mirror of
https://github.com/freebsd/freebsd-src.git
synced 2024-12-05 03:39:02 +00:00
b8ba871bd9
files, curses, db, regex etc that we already have). The other glue will follow shortly. Obtained from: Keith Bostic <bostic@bostic.com>
335 lines
7.7 KiB
C
335 lines
7.7 KiB
C
/*-
|
|
* Copyright (c) 1993, 1994
|
|
* The Regents of the University of California. All rights reserved.
|
|
* Copyright (c) 1993, 1994, 1995, 1996
|
|
* Keith Bostic. All rights reserved.
|
|
*
|
|
* See the LICENSE file for redistribution information.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#ifndef lint
|
|
static const char sccsid[] = "@(#)cl_read.c 10.15 (Berkeley) 9/24/96";
|
|
#endif /* not lint */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/queue.h>
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
#include <sys/select.h>
|
|
#endif
|
|
#include <sys/time.h>
|
|
|
|
#include <bitstring.h>
|
|
#include <curses.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
|
|
#include "../common/common.h"
|
|
#include "../ex/script.h"
|
|
#include "cl.h"
|
|
|
|
static input_t cl_read __P((SCR *,
|
|
u_int32_t, CHAR_T *, size_t, int *, struct timeval *));
|
|
static int cl_resize __P((SCR *, size_t, size_t));
|
|
|
|
/*
|
|
* cl_event --
|
|
* Return a single event.
|
|
*
|
|
* PUBLIC: int cl_event __P((SCR *, EVENT *, u_int32_t, int));
|
|
*/
|
|
int
|
|
cl_event(sp, evp, flags, ms)
|
|
SCR *sp;
|
|
EVENT *evp;
|
|
u_int32_t flags;
|
|
int ms;
|
|
{
|
|
struct timeval t, *tp;
|
|
CL_PRIVATE *clp;
|
|
size_t lines, columns;
|
|
int changed, nr;
|
|
|
|
/*
|
|
* Queue signal based events. We never clear SIGHUP or SIGTERM events,
|
|
* so that we just keep returning them until the editor dies.
|
|
*/
|
|
clp = CLP(sp);
|
|
retest: if (LF_ISSET(EC_INTERRUPT) || F_ISSET(clp, CL_SIGINT)) {
|
|
if (F_ISSET(clp, CL_SIGINT)) {
|
|
F_CLR(clp, CL_SIGINT);
|
|
evp->e_event = E_INTERRUPT;
|
|
} else
|
|
evp->e_event = E_TIMEOUT;
|
|
return (0);
|
|
}
|
|
if (F_ISSET(clp, CL_SIGHUP | CL_SIGTERM | CL_SIGWINCH)) {
|
|
if (F_ISSET(clp, CL_SIGHUP)) {
|
|
evp->e_event = E_SIGHUP;
|
|
return (0);
|
|
}
|
|
if (F_ISSET(clp, CL_SIGTERM)) {
|
|
evp->e_event = E_SIGTERM;
|
|
return (0);
|
|
}
|
|
if (F_ISSET(clp, CL_SIGWINCH)) {
|
|
F_CLR(clp, CL_SIGWINCH);
|
|
if (cl_ssize(sp, 1, &lines, &columns, &changed))
|
|
return (1);
|
|
if (changed) {
|
|
(void)cl_resize(sp, lines, columns);
|
|
evp->e_event = E_WRESIZE;
|
|
return (0);
|
|
}
|
|
/* No real change, ignore the signal. */
|
|
}
|
|
}
|
|
|
|
/* Set timer. */
|
|
if (ms == 0)
|
|
tp = NULL;
|
|
else {
|
|
t.tv_sec = ms / 1000;
|
|
t.tv_usec = (ms % 1000) * 1000;
|
|
tp = &t;
|
|
}
|
|
|
|
/* Read input characters. */
|
|
switch (cl_read(sp, LF_ISSET(EC_QUOTED | EC_RAW),
|
|
clp->ibuf, sizeof(clp->ibuf), &nr, tp)) {
|
|
case INP_OK:
|
|
evp->e_csp = clp->ibuf;
|
|
evp->e_len = nr;
|
|
evp->e_event = E_STRING;
|
|
break;
|
|
case INP_EOF:
|
|
evp->e_event = E_EOF;
|
|
break;
|
|
case INP_ERR:
|
|
evp->e_event = E_ERR;
|
|
break;
|
|
case INP_INTR:
|
|
goto retest;
|
|
case INP_TIMEOUT:
|
|
evp->e_event = E_TIMEOUT;
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* cl_read --
|
|
* Read characters from the input.
|
|
*/
|
|
static input_t
|
|
cl_read(sp, flags, bp, blen, nrp, tp)
|
|
SCR *sp;
|
|
u_int32_t flags;
|
|
CHAR_T *bp;
|
|
size_t blen;
|
|
int *nrp;
|
|
struct timeval *tp;
|
|
{
|
|
struct termios term1, term2;
|
|
struct timeval poll;
|
|
CL_PRIVATE *clp;
|
|
GS *gp;
|
|
SCR *tsp;
|
|
fd_set rdfd;
|
|
input_t rval;
|
|
int maxfd, nr, term_reset;
|
|
|
|
gp = sp->gp;
|
|
clp = CLP(sp);
|
|
term_reset = 0;
|
|
|
|
/*
|
|
* 1: A read from a file or a pipe. In this case, the reads
|
|
* never timeout regardless. This means that we can hang
|
|
* when trying to complete a map, but we're going to hang
|
|
* on the next read anyway.
|
|
*/
|
|
if (!F_ISSET(clp, CL_STDIN_TTY)) {
|
|
switch (nr = read(STDIN_FILENO, bp, blen)) {
|
|
case 0:
|
|
return (INP_EOF);
|
|
case -1:
|
|
goto err;
|
|
default:
|
|
*nrp = nr;
|
|
return (INP_OK);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
/*
|
|
* 2: A read with an associated timeout, e.g., trying to complete
|
|
* a map sequence. If input exists, we fall into #3.
|
|
*/
|
|
FD_ZERO(&rdfd);
|
|
poll.tv_sec = 0;
|
|
poll.tv_usec = 0;
|
|
if (tp != NULL) {
|
|
FD_SET(STDIN_FILENO, &rdfd);
|
|
switch (select(STDIN_FILENO + 1,
|
|
&rdfd, NULL, NULL, tp == NULL ? &poll : tp)) {
|
|
case 0:
|
|
return (INP_TIMEOUT);
|
|
case -1:
|
|
goto err;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The user can enter a key in the editor to quote a character. If we
|
|
* get here and the next key is supposed to be quoted, do what we can.
|
|
* Reset the tty so that the user can enter a ^C, ^Q, ^S. There's an
|
|
* obvious race here, when the key has already been entered, but there's
|
|
* nothing that we can do to fix that problem.
|
|
*
|
|
* The editor can ask for the next literal character even thought it's
|
|
* generally running in line-at-a-time mode. Do what we can.
|
|
*/
|
|
if (LF_ISSET(EC_QUOTED | EC_RAW) && !tcgetattr(STDIN_FILENO, &term1)) {
|
|
term_reset = 1;
|
|
if (LF_ISSET(EC_QUOTED)) {
|
|
term2 = term1;
|
|
term2.c_lflag &= ~ISIG;
|
|
term2.c_iflag &= ~(IXON | IXOFF);
|
|
(void)tcsetattr(STDIN_FILENO,
|
|
TCSASOFT | TCSADRAIN, &term2);
|
|
} else
|
|
(void)tcsetattr(STDIN_FILENO,
|
|
TCSASOFT | TCSADRAIN, &clp->vi_enter);
|
|
}
|
|
|
|
/*
|
|
* 3: Wait for input.
|
|
*
|
|
* Select on the command input and scripting window file descriptors.
|
|
* It's ugly that we wait on scripting file descriptors here, but it's
|
|
* the only way to keep from locking out scripting windows.
|
|
*/
|
|
if (F_ISSET(gp, G_SCRWIN)) {
|
|
loop: FD_ZERO(&rdfd);
|
|
FD_SET(STDIN_FILENO, &rdfd);
|
|
maxfd = STDIN_FILENO;
|
|
for (tsp = gp->dq.cqh_first;
|
|
tsp != (void *)&gp->dq; tsp = tsp->q.cqe_next)
|
|
if (F_ISSET(sp, SC_SCRIPT)) {
|
|
FD_SET(sp->script->sh_master, &rdfd);
|
|
if (sp->script->sh_master > maxfd)
|
|
maxfd = sp->script->sh_master;
|
|
}
|
|
switch (select(maxfd + 1, &rdfd, NULL, NULL, NULL)) {
|
|
case 0:
|
|
abort();
|
|
case -1:
|
|
goto err;
|
|
default:
|
|
break;
|
|
}
|
|
if (!FD_ISSET(STDIN_FILENO, &rdfd)) {
|
|
if (sscr_input(sp))
|
|
return (INP_ERR);
|
|
goto loop;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 4: Read the input.
|
|
*
|
|
* !!!
|
|
* What's going on here is some scary stuff. Ex runs the terminal in
|
|
* canonical mode. So, the <newline> character terminating a line of
|
|
* input is returned in the buffer, but a trailing <EOF> character is
|
|
* not similarly included. As ex uses 0<EOF> and ^<EOF> as autoindent
|
|
* commands, it has to see the trailing <EOF> characters to determine
|
|
* the difference between the user entering "0ab" and "0<EOF>ab". We
|
|
* leave an extra slot in the buffer, so that we can add a trailing
|
|
* <EOF> character if the buffer isn't terminated by a <newline>. We
|
|
* lose if the buffer is too small for the line and exactly N characters
|
|
* are entered followed by an <EOF> character.
|
|
*/
|
|
#define ONE_FOR_EOF 1
|
|
switch (nr = read(STDIN_FILENO, bp, blen - ONE_FOR_EOF)) {
|
|
case 0: /* EOF. */
|
|
/*
|
|
* ^D in canonical mode returns a read of 0, i.e. EOF. EOF is
|
|
* a valid command, but we don't want to loop forever because
|
|
* the terminal driver is returning EOF because the user has
|
|
* disconnected. The editor will almost certainly try to write
|
|
* something before this fires, which should kill us, but You
|
|
* Never Know.
|
|
*/
|
|
if (++clp->eof_count < 50) {
|
|
bp[0] = clp->orig.c_cc[VEOF];
|
|
*nrp = 1;
|
|
rval = INP_OK;
|
|
|
|
} else
|
|
rval = INP_EOF;
|
|
break;
|
|
case -1: /* Error or interrupt. */
|
|
err: if (errno == EINTR)
|
|
rval = INP_INTR;
|
|
else {
|
|
rval = INP_ERR;
|
|
msgq(sp, M_SYSERR, "input");
|
|
}
|
|
break;
|
|
default: /* Input characters. */
|
|
if (F_ISSET(sp, SC_EX) && bp[nr - 1] != '\n')
|
|
bp[nr++] = clp->orig.c_cc[VEOF];
|
|
*nrp = nr;
|
|
clp->eof_count = 0;
|
|
rval = INP_OK;
|
|
break;
|
|
}
|
|
|
|
/* Restore the terminal state if it was modified. */
|
|
if (term_reset)
|
|
(void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &term1);
|
|
return (rval);
|
|
}
|
|
|
|
/*
|
|
* cl_resize --
|
|
* Reset the options for a resize event.
|
|
*/
|
|
static int
|
|
cl_resize(sp, lines, columns)
|
|
SCR *sp;
|
|
size_t lines, columns;
|
|
{
|
|
ARGS *argv[2], a, b;
|
|
char b1[1024];
|
|
|
|
a.bp = b1;
|
|
b.bp = NULL;
|
|
a.len = b.len = 0;
|
|
argv[0] = &a;
|
|
argv[1] = &b;
|
|
|
|
(void)snprintf(b1, sizeof(b1), "lines=%lu", (u_long)lines);
|
|
a.len = strlen(b1);
|
|
if (opts_set(sp, argv, NULL))
|
|
return (1);
|
|
(void)snprintf(b1, sizeof(b1), "columns=%lu", (u_long)columns);
|
|
a.len = strlen(b1);
|
|
if (opts_set(sp, argv, NULL))
|
|
return (1);
|
|
return (0);
|
|
}
|