contrib/nvi/cl/cl_read.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[] = "@(#)cl_read.c     10.15 (Berkeley) 9/24/96";
  14 #endif /* not lint */
  15
  16 #include <sys/types.h>
  17 #include <sys/queue.h>
  18 #ifdef HAVE_SYS_SELECT_H
  19 #include <sys/select.h>
  20 #endif
  21 #include <sys/time.h>
  22
  23 #include <bitstring.h>
  24 #include <curses.h>
  25 #include <errno.h>
  26 #include <fcntl.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 "../ex/script.h"
  36 #include "cl.h"
  37
  38 static input_t  cl_read __P((SCR *,
  39     u_int32_t, CHAR_T *, size_t, int *, struct timeval *));
  40 static int      cl_resize __P((SCR *, size_t, size_t));
  41
  42 /*
  43  * cl_event --
  44  *      Return a single event.
  45  *
  46  * PUBLIC: int cl_event __P((SCR *, EVENT *, u_int32_t, int));
  47  */
  48 int
  49 cl_event(sp, evp, flags, ms)
  50         SCR *sp;
  51         EVENT *evp;
  52         u_int32_t flags;
  53         int ms;
  54 {
  55         struct timeval t, *tp;
  56         CL_PRIVATE *clp;
  57         size_t lines, columns;
  58         int changed, nr;
  59
  60         /*
  61          * Queue signal based events.  We never clear SIGHUP or SIGTERM events,
  62          * so that we just keep returning them until the editor dies.
  63          */
  64         clp = CLP(sp);
  65 retest: if (LF_ISSET(EC_INTERRUPT) || F_ISSET(clp, CL_SIGINT)) {
  66                 if (F_ISSET(clp, CL_SIGINT)) {
  67                         F_CLR(clp, CL_SIGINT);
  68                         evp->e_event = E_INTERRUPT;
  69                 } else
  70                         evp->e_event = E_TIMEOUT;
  71                 return (0);
  72         }
  73         if (F_ISSET(clp, CL_SIGHUP | CL_SIGTERM | CL_SIGWINCH)) {
  74                 if (F_ISSET(clp, CL_SIGHUP)) {
  75                         evp->e_event = E_SIGHUP;
  76                         return (0);
  77                 }
  78                 if (F_ISSET(clp, CL_SIGTERM)) {
  79                         evp->e_event = E_SIGTERM;
  80                         return (0);
  81                 }
  82                 if (F_ISSET(clp, CL_SIGWINCH)) {
  83                         F_CLR(clp, CL_SIGWINCH);
  84                         if (cl_ssize(sp, 1, &lines, &columns, &changed))
  85                                 return (1);
  86                         if (changed) {
  87                                 (void)cl_resize(sp, lines, columns);
  88                                 evp->e_event = E_WRESIZE;
  89                                 return (0);
  90                         }
  91                         /* No real change, ignore the signal. */
  92                 }
  93         }
  94
  95         /* Set timer. */
  96         if (ms == 0)
  97                 tp = NULL;
  98         else {
  99                 t.tv_sec = ms / 1000;
 100                 t.tv_usec = (ms % 1000) * 1000;
 101                 tp = &t;
 102         }
 103
 104         /* Read input characters. */
 105         switch (cl_read(sp, LF_ISSET(EC_QUOTED | EC_RAW),
 106             clp->ibuf, sizeof(clp->ibuf), &nr, tp)) {
 107         case INP_OK:
 108                 evp->e_csp = clp->ibuf;
 109                 evp->e_len = nr;
 110                 evp->e_event = E_STRING;
 111                 break;
 112         case INP_EOF:
 113                 evp->e_event = E_EOF;
 114                 break;
 115         case INP_ERR:
 116                 evp->e_event = E_ERR;
 117                 break;
 118         case INP_INTR:
 119                 goto retest;
 120         case INP_TIMEOUT:
 121                 evp->e_event = E_TIMEOUT;
 122                 break;
 123         default:
 124                 abort();
 125         }
 126         return (0);
 127 }
 128
 129 /*
 130  * cl_read --
 131  *      Read characters from the input.
 132  */
 133 static input_t
 134 cl_read(sp, flags, bp, blen, nrp, tp)
 135         SCR *sp;
 136         u_int32_t flags;
 137         CHAR_T *bp;
 138         size_t blen;
 139         int *nrp;
 140         struct timeval *tp;
 141 {
 142         struct termios term1, term2;
 143         struct timeval poll;
 144         CL_PRIVATE *clp;
 145         GS *gp;
 146         SCR *tsp;
 147         fd_set rdfd;
 148         input_t rval;
 149         int maxfd, nr, term_reset;
 150
 151         gp = sp->gp;
 152         clp = CLP(sp);
 153         term_reset = 0;
 154
 155         /*
 156          * 1: A read from a file or a pipe.  In this case, the reads
 157          *    never timeout regardless.  This means that we can hang
 158          *    when trying to complete a map, but we're going to hang
 159          *    on the next read anyway.
 160          */
 161         if (!F_ISSET(clp, CL_STDIN_TTY)) {
 162                 switch (nr = read(STDIN_FILENO, bp, blen)) {
 163                 case 0:
 164                         return (INP_EOF);
 165                 case -1:
 166                         goto err;
 167                 default:
 168                         *nrp = nr;
 169                         return (INP_OK);
 170                 }
 171                 /* NOTREACHED */
 172         }
 173
 174         /*
 175          * 2: A read with an associated timeout, e.g., trying to complete
 176          *    a map sequence.  If input exists, we fall into #3.
 177          */
 178         FD_ZERO(&rdfd);
 179         poll.tv_sec = 0;
 180         poll.tv_usec = 0;
 181         if (tp != NULL) {
 182                 FD_SET(STDIN_FILENO, &rdfd);
 183                 switch (select(STDIN_FILENO + 1,
 184                     &rdfd, NULL, NULL, tp == NULL ? &poll : tp)) {
 185                 case 0:
 186                         return (INP_TIMEOUT);
 187                 case -1:
 188                         goto err;
 189                 default:
 190                         break;
 191                 }
 192         }
 193
 194         /*
 195          * The user can enter a key in the editor to quote a character.  If we
 196          * get here and the next key is supposed to be quoted, do what we can.
 197          * Reset the tty so that the user can enter a ^C, ^Q, ^S.  There's an
 198          * obvious race here, when the key has already been entered, but there's
 199          * nothing that we can do to fix that problem.
 200          *
 201          * The editor can ask for the next literal character even thought it's
 202          * generally running in line-at-a-time mode.  Do what we can.
 203          */
 204         if (LF_ISSET(EC_QUOTED | EC_RAW) && !tcgetattr(STDIN_FILENO, &term1)) {
 205                 term_reset = 1;
 206                 if (LF_ISSET(EC_QUOTED)) {
 207                         term2 = term1;
 208                         term2.c_lflag &= ~ISIG;
 209                         term2.c_iflag &= ~(IXON | IXOFF);
 210                         (void)tcsetattr(STDIN_FILENO,
 211                             TCSASOFT | TCSADRAIN, &term2);
 212                 } else
 213                         (void)tcsetattr(STDIN_FILENO,
 214                             TCSASOFT | TCSADRAIN, &clp->vi_enter);
 215         }
 216
 217         /*
 218          * 3: Wait for input.
 219          *
 220          * Select on the command input and scripting window file descriptors.
 221          * It's ugly that we wait on scripting file descriptors here, but it's
 222          * the only way to keep from locking out scripting windows.
 223          */
 224         if (F_ISSET(gp, G_SCRWIN)) {
 225 loop:           FD_ZERO(&rdfd);
 226                 FD_SET(STDIN_FILENO, &rdfd);
 227                 maxfd = STDIN_FILENO;
 228                 for (tsp = gp->dq.cqh_first;
 229                     tsp != (void *)&gp->dq; tsp = tsp->q.cqe_next)
 230                         if (F_ISSET(sp, SC_SCRIPT)) {
 231                                 FD_SET(sp->script->sh_master, &rdfd);
 232                                 if (sp->script->sh_master > maxfd)
 233                                         maxfd = sp->script->sh_master;
 234                         }
 235                 switch (select(maxfd + 1, &rdfd, NULL, NULL, NULL)) {
 236                 case 0:
 237                         abort();
 238                 case -1:
 239                         goto err;
 240                 default:
 241                         break;
 242                 }
 243                 if (!FD_ISSET(STDIN_FILENO, &rdfd)) {
 244                         if (sscr_input(sp))
 245                                 return (INP_ERR);
 246                         goto loop;
 247                 }
 248         }
 249
 250         /*
 251          * 4: Read the input.
 252          *
 253          * !!!
 254          * What's going on here is some scary stuff.  Ex runs the terminal in
 255          * canonical mode.  So, the <newline> character terminating a line of
 256          * input is returned in the buffer, but a trailing <EOF> character is
 257          * not similarly included.  As ex uses 0<EOF> and ^<EOF> as autoindent
 258          * commands, it has to see the trailing <EOF> characters to determine
 259          * the difference between the user entering "0ab" and "0<EOF>ab".  We
 260          * leave an extra slot in the buffer, so that we can add a trailing
 261          * <EOF> character if the buffer isn't terminated by a <newline>.  We
 262          * lose if the buffer is too small for the line and exactly N characters
 263          * are entered followed by an <EOF> character.
 264          */
 265 #define ONE_FOR_EOF     1
 266         switch (nr = read(STDIN_FILENO, bp, blen - ONE_FOR_EOF)) {
 267         case  0:                                /* EOF. */
 268                 /*
 269                  * ^D in canonical mode returns a read of 0, i.e. EOF.  EOF is
 270                  * a valid command, but we don't want to loop forever because
 271                  * the terminal driver is returning EOF because the user has
 272                  * disconnected. The editor will almost certainly try to write
 273                  * something before this fires, which should kill us, but You
 274                  * Never Know.
 275                  */
 276                 if (++clp->eof_count < 50) {
 277                         bp[0] = clp->orig.c_cc[VEOF];
 278                         *nrp = 1;
 279                         rval = INP_OK;
 280
 281                 } else
 282                         rval = INP_EOF;
 283                 break;
 284         case -1:                                /* Error or interrupt. */
 285 err:            if (errno == EINTR)
 286                         rval = INP_INTR;
 287                 else {
 288                         rval = INP_ERR;
 289                         msgq(sp, M_SYSERR, "input");
 290                 }
 291                 break;
 292         default:                                /* Input characters. */
 293                 if (F_ISSET(sp, SC_EX) && bp[nr - 1] != '\n')
 294                         bp[nr++] = clp->orig.c_cc[VEOF];
 295                 *nrp = nr;
 296                 clp->eof_count = 0;
 297                 rval = INP_OK;
 298                 break;
 299         }
 300
 301         /* Restore the terminal state if it was modified. */
 302         if (term_reset)
 303                 (void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &term1);
 304         return (rval);
 305 }
 306
 307 /*
 308  * cl_resize --
 309  *      Reset the options for a resize event.
 310  */
 311 static int
 312 cl_resize(sp, lines, columns)
 313         SCR *sp;
 314         size_t lines, columns;
 315 {
 316         ARGS *argv[2], a, b;
 317         char b1[1024];
 318
 319         a.bp = b1;
 320         b.bp = NULL;
 321         a.len = b.len = 0;
 322         argv[0] = &a;
 323         argv[1] = &b;
 324
 325         (void)snprintf(b1, sizeof(b1), "lines=%lu", (u_long)lines);
 326         a.len = strlen(b1);
 327         if (opts_set(sp, argv, NULL))
 328                 return (1);
 329         (void)snprintf(b1, sizeof(b1), "columns=%lu", (u_long)columns);
 330         a.len = strlen(b1);
 331         if (opts_set(sp, argv, NULL))
 332                 return (1);
 333         return (0);
 334 }