4.4BSD/usr/src/usr.bin/ex/ex_vget.c
/*-
* Copyright (c) 1980, 1993
* The Regents of the University of California. All rights reserved.
*
* This module is believed to contain source code proprietary to AT&T.
* Use and redistribution is subject to the Berkeley Software License
* Agreement and your Software Agreement with AT&T (Western Electric).
*/
#ifndef lint
static char sccsid[] = "@(#)ex_vget.c 8.1 (Berkeley) 6/9/93";
#endif /* not lint */
#include "ex.h"
#include "ex_tty.h"
#include "ex_vis.h"
/*
* Input routines for open/visual.
* We handle upper case only terminals in visual and reading from the
* echo area here as well as notification on large changes
* which appears in the echo area.
*/
/*
* Return the key.
*/
ungetkey(c)
int c; /* mjm: char --> int */
{
if (Peek_key != ATTN)
Peek_key = c;
}
/*
* Return a keystroke, but never a ^@.
*/
getkey()
{
register int c; /* mjm: char --> int */
do {
c = getbr();
if (c==0)
beep();
} while (c == 0);
return (c);
}
/*
* Tell whether next keystroke would be a ^@.
*/
peekbr()
{
Peek_key = getbr();
return (Peek_key == 0);
}
short precbksl;
jmp_buf readbuf;
int doingread = 0;
/*
* Get a keystroke, including a ^@.
* If an key was returned with ungetkey, that
* comes back first. Next comes unread input (e.g.
* from repeating commands with .), and finally new
* keystrokes.
*
* The hard work here is in mapping of \ escaped
* characters on upper case only terminals.
*/
getbr()
{
char ch;
register int c, d;
register char *colp;
#define BEEHIVE
#ifdef BEEHIVE
static char Peek2key;
#endif
extern short slevel, ttyindes;
getATTN:
if (Peek_key) {
c = Peek_key;
Peek_key = 0;
return (c);
}
#ifdef BEEHIVE
if (Peek2key) {
c = Peek2key;
Peek2key = 0;
return (c);
}
#endif
if (vglobp) {
if (*vglobp)
return (lastvgk = *vglobp++);
lastvgk = 0;
return (ESCAPE);
}
if (vmacp) {
if (*vmacp)
return(*vmacp++);
/* End of a macro or set of nested macros */
vmacp = 0;
if (inopen == -1) /* don't screw up undo for esc esc */
vundkind = VMANY;
inopen = 1; /* restore old setting now that macro done */
vch_mac = VC_NOTINMAC;
}
flusho();
again:
if (setjmp(readbuf))
goto getATTN;
doingread = 1;
#ifndef vms
c = read(slevel == 0 ? 0 : ttyindes, &ch, 1);
#else
c = vms_read(slevel == 0 ? 0 : ttyindes, &ch, 1);
#endif
doingread = 0;
if (c != 1) {
if (errno == EINTR)
goto getATTN;
error("Input read error");
}
c = ch & TRIM;
#ifdef BEEHIVE
if (XB && slevel==0 && c == ESCAPE) {
if (read(0, &Peek2key, 1) != 1)
goto getATTN;
Peek2key &= TRIM;
switch (Peek2key) {
case 'C': /* SPOW mode sometimes sends \EC for space */
c = ' ';
Peek2key = 0;
break;
case 'q': /* f2 -> ^C */
c = CTRL('c');
Peek2key = 0;
break;
case 'p': /* f1 -> esc */
Peek2key = 0;
break;
}
}
#endif
#ifdef UCVISUAL
/*
* The algorithm here is that of the UNIX kernel.
* See the description in the programmers manual.
*/
if (UPPERCASE) {
if (isupper(c))
c = tolower(c);
if (c == '\\') {
if (precbksl < 2)
precbksl++;
if (precbksl == 1)
goto again;
} else if (precbksl) {
d = 0;
if (islower(c))
d = toupper(c);
else {
colp = "({)}!|^~'~";
while (d = *colp++)
if (d == c) {
d = *colp++;
break;
} else
colp++;
}
if (precbksl == 2) {
if (!d) {
Peek_key = c;
precbksl = 0;
c = '\\';
}
} else if (d)
c = d;
else {
Peek_key = c;
precbksl = 0;
c = '\\';
}
}
if (c != '\\')
precbksl = 0;
}
#endif
#ifdef TRACE
if (trace) {
if (!techoin) {
tfixnl();
techoin = 1;
fprintf(trace, "*** Input: ");
}
tracec(c);
}
#endif
lastvgk = 0;
return (c);
}
/*
* Get a key, but if a delete, quit or attention
* is typed return 0 so we will abort a partial command.
*/
getesc()
{
register int c;
c = getkey();
switch (c) {
case CTRL('v'):
case CTRL('q'):
c = getkey();
return (c);
case ATTN:
case QUIT:
ungetkey(c);
return (0);
case ESCAPE:
return (0);
}
return (c);
}
/*
* Peek at the next keystroke.
*/
peekkey()
{
Peek_key = getkey();
return (Peek_key);
}
/*
* Read a line from the echo area, with single character prompt c.
* A return value of 1 means the user blewit or blewit away.
*/
readecho(c)
char c;
{
register char *sc = cursor;
register int (*OP)();
bool waste;
register int OPeek;
if (WBOT == WECHO)
vclean();
else
vclrech(0);
splitw++;
vgoto(WECHO, 0);
ex_putchar(c);
vclreol();
vgoto(WECHO, 1);
cursor = linebuf; linebuf[0] = 0; genbuf[0] = c;
if (peekbr()) {
if (!INS[0] || (INS[0] & (QUOTE|TRIM)) == OVERBUF)
goto blewit;
vglobp = INS;
}
OP = Pline; Pline = normline;
ignore(vgetline(0, genbuf + 1, &waste, c));
if (Outchar == termchar)
ex_putchar('\n');
vscrap();
Pline = OP;
if (Peek_key != ATTN && Peek_key != QUIT && Peek_key != CTRL('h')) {
cursor = sc;
vclreol();
return (0);
}
blewit:
OPeek = Peek_key==CTRL('h') ? 0 : Peek_key; Peek_key = 0;
splitw = 0;
vclean();
vshow(dot, NOLINE);
vnline(sc);
Peek_key = OPeek;
return (1);
}
/*
* A complete command has been defined for
* the purposes of repeat, so copy it from
* the working to the previous command buffer.
*/
setLAST()
{
if (vglobp || vmacp)
return;
lastreg = vreg;
lasthad = Xhadcnt;
lastcnt = Xcnt;
*lastcp = 0;
CP(lastcmd, workcmd);
}
/*
* Gather up some more text from an insert.
* If the insertion buffer oveflows, then destroy
* the repeatability of the insert.
*/
addtext(cp)
char *cp;
{
if (vglobp)
return;
addto(INS, cp);
if ((INS[0] & (QUOTE|TRIM)) == OVERBUF)
lastcmd[0] = 0;
}
setDEL()
{
ex_setBUF(DEL);
}
/*
* Put text from cursor upto wcursor in BUF.
*/
ex_setBUF(BUF)
register char *BUF;
{
register int c;
register char *wp = wcursor;
c = *wp;
*wp = 0;
BUF[0] = 0;
addto(BUF, cursor);
*wp = c;
}
addto(buf, str)
register char *buf, *str;
{
if ((buf[0] & (QUOTE|TRIM)) == OVERBUF)
return;
if (strlen(buf) + strlen(str) + 1 >= VBSIZE) {
buf[0] = OVERBUF;
return;
}
ignore(strcat(buf, str));
}
/*
* Note a change affecting a lot of lines, or non-visible
* lines. If the parameter must is set, then we only want
* to do this for open modes now; return and save for later
* notification in visual.
*/
noteit(must)
bool must;
{
register int sdl = destline, sdc = destcol;
if (notecnt < 2 || !must && state == VISUAL)
return (0);
splitw++;
if (WBOT == WECHO)
vmoveitup(1, 1);
vigoto(WECHO, 0);
ex_printf("%d %sline", notecnt, notesgn);
if (notecnt > 1)
ex_putchar('s');
if (*notenam) {
ex_printf(" %s", notenam);
if (*(strend(notenam) - 1) != 'e')
ex_putchar('e');
ex_putchar('d');
}
vclreol();
notecnt = 0;
if (state != VISUAL)
vcnt = vcline = 0;
splitw = 0;
if (state == ONEOPEN || state == CRTOPEN)
vup1();
destline = sdl; destcol = sdc;
return (1);
}
/*
* Rrrrringgggggg.
* If possible, use flash (VB).
*/
beep()
{
if (VB)
vputp(VB, 0);
else
vputc(CTRL('g'));
}
/*
* Map the command input character c,
* for keypads and labelled keys which do cursor
* motions. I.e. on an adm3a we might map ^K to ^P.
* DM1520 for example has a lot of mappable characters.
*/
map(c,maps)
register int c;
register struct maps *maps;
{
register int d;
register char *p, *q;
char b[10]; /* Assumption: no keypad sends string longer than 10 */
/*
* Mapping for special keys on the terminal only.
* BUG: if there's a long sequence and it matches
* some chars and then misses, we lose some chars.
*
* For this to work, some conditions must be met.
* 1) Keypad sends SHORT (2 or 3 char) strings
* 2) All strings sent are same length & similar
* 3) The user is unlikely to type the first few chars of
* one of these strings very fast.
* Note: some code has been fixed up since the above was laid out,
* so conditions 1 & 2 are probably not required anymore.
* However, this hasn't been tested with any first char
* that means anything else except escape.
*/
#ifdef MDEBUG
if (trace)
fprintf(trace,"map(%c): ",c);
#endif
/*
* If c==0, the char came from getesc typing escape. Pass it through
* unchanged. 0 messes up the following code anyway.
*/
if (c==0)
return(0);
b[0] = c;
b[1] = 0;
for (d=0; maps[d].mapto; d++) {
#ifdef MDEBUG
if (trace)
fprintf(trace,"\ntry '%s', ",maps[d].cap);
#endif
if (p = maps[d].cap) {
for (q=b; *p; p++, q++) {
#ifdef MDEBUG
if (trace)
fprintf(trace,"q->b[%d], ",q-b);
#endif
if (*q==0) {
/*
* Is there another char waiting?
*
* This test is oversimplified, but
* should work mostly. It handles the
* case where we get an ESCAPE that
* wasn't part of a keypad string.
*/
if ((c=='#' ? peekkey() : fastpeekkey()) == 0) {
#ifdef MDEBUG
if (trace)
fprintf(trace,"fpk=0: will return '%c'",c);
#endif
/*
* Nothing waiting. Push back
* what we peeked at & return
* failure (c).
*
* We want to be able to undo
* commands, but it's nonsense
* to undo part of an insertion
* so if in input mode don't.
*/
#ifdef MDEBUG
if (trace)
fprintf(trace, "Call macpush, b %d %d %d\n", b[0], b[1], b[2]);
#endif
macpush(&b[1],maps == arrows);
#ifdef MDEBUG
if (trace)
fprintf(trace, "return %d\n", c);
#endif
return(c);
}
*q = getkey();
q[1] = 0;
}
if (*p != *q)
goto contin;
}
macpush(maps[d].mapto,maps == arrows);
c = getkey();
#ifdef MDEBUG
if (trace)
fprintf(trace,"Success: push(%s), return %c",maps[d].mapto, c);
#endif
return(c); /* first char of map string */
contin:;
}
}
#ifdef MDEBUG
if (trace)
fprintf(trace,"Fail: push(%s), return %c", &b[1], c);
#endif
macpush(&b[1],0);
return(c);
}
/*
* Push st onto the front of vmacp. This is tricky because we have to
* worry about where vmacp was previously pointing. We also have to
* check for overflow (which is typically from a recursive macro)
* Finally we have to set a flag so the whole thing can be undone.
* canundo is 1 iff we want to be able to undo the macro. This
* is false for, for example, pushing back lookahead from fastpeekkey(),
* since otherwise two fast escapes can clobber our undo.
*/
macpush(st, canundo)
char *st;
int canundo;
{
char tmpbuf[BUFSIZ];
if (st==0 || *st==0)
return;
#ifdef MDEBUG
if (trace)
fprintf(trace, "macpush(%s), canundo=%d\n",st,canundo);
#endif
if ((vmacp ? strlen(vmacp) : 0) + strlen(st) > BUFSIZ)
error("Macro too long@ - maybe recursive?");
if (vmacp) {
strcpy(tmpbuf, vmacp);
if (!FIXUNDO)
canundo = 0; /* can't undo inside a macro anyway */
}
strcpy(vmacbuf, st);
if (vmacp)
strcat(vmacbuf, tmpbuf);
vmacp = vmacbuf;
/* arrange to be able to undo the whole macro */
if (canundo) {
#ifdef notdef
otchng = tchng;
vsave();
saveall();
inopen = -1; /* no need to save since it had to be 1 or -1 before */
vundkind = VMANY;
#endif
vch_mac = VC_NOCHANGE;
}
}
#ifdef TRACE
visdump(s)
char *s;
{
register int i;
if (!trace) return;
fprintf(trace, "\n%s: basWTOP=%d, basWLINES=%d, WTOP=%d, WBOT=%d, WLINES=%d, WCOLS=%d, WECHO=%d\n",
s, basWTOP, basWLINES, WTOP, WBOT, WLINES, WCOLS, WECHO);
fprintf(trace, " vcnt=%d, vcline=%d, cursor=%d, wcursor=%d, wdot=%d\n",
vcnt, vcline, cursor-linebuf, wcursor-linebuf, wdot-zero);
for (i=0; i<TUBELINES; i++)
if (vtube[i] && *vtube[i])
fprintf(trace, "%d: '%s'\n", i, vtube[i]);
tvliny();
}
vudump(s)
char *s;
{
register line *p;
char savelb[1024];
if (!trace) return;
fprintf(trace, "\n%s: undkind=%d, vundkind=%d, unddel=%d, undap1=%d, undap2=%d,\n",
s, undkind, vundkind, lineno(unddel), lineno(undap1), lineno(undap2));
fprintf(trace, " undadot=%d, dot=%d, dol=%d, unddol=%d, truedol=%d\n",
lineno(undadot), lineno(dot), lineno(dol), lineno(unddol), lineno(truedol));
fprintf(trace, " [\n");
CP(savelb, linebuf);
fprintf(trace, "linebuf = '%s'\n", linebuf);
for (p=zero+1; p<=truedol; p++) {
fprintf(trace, "%o ", *p);
getline(*p);
fprintf(trace, "'%s'\n", linebuf);
}
fprintf(trace, "]\n");
CP(linebuf, savelb);
}
#endif
/*
* Get a count from the keyed input stream.
* A zero count is indistinguishable from no count.
*/
vgetcnt()
{
register int c, cnt;
cnt = 0;
for (;;) {
c = getkey();
if (!isdigit(c))
break;
cnt *= 10, cnt += c - '0';
}
ungetkey(c);
Xhadcnt = 1;
Xcnt = cnt;
return(cnt);
}
/*
* fastpeekkey is just like peekkey but insists the character come in
* fast (within 1 second). This will succeed if it is the 2nd char of
* a machine generated sequence (such as a function pad from an escape
* flavor terminal) but fail for a human hitting escape then waiting.
*/
fastpeekkey()
{
void trapalarm();
sig_t Oint;
register int c;
/*
* If the user has set notimeout, we wait forever for a key.
* If we are in a macro we do too, but since it's already
* buffered internally it will return immediately.
* In other cases we force this to die in 1 second.
* This is pretty reliable (VMUNIX rounds it to .5 - 1.5 secs,
* but UNIX truncates it to 0 - 1 secs) but due to system delays
* there are times when arrow keys or very fast typing get counted
* as separate. notimeout is provided for people who dislike such
* nondeterminism.
*/
#ifdef MDEBUG
if (trace)
fprintf(trace,"\nfastpeekkey: ");
#endif
Oint = signal(SIGINT, trapalarm);
CATCH
if (value(TIMEOUT) && inopen >= 0) {
signal(SIGALRM, trapalarm);
#ifdef MDEBUG
alarm(10);
if (trace)
fprintf(trace, "set alarm ");
#else
alarm(1);
#endif
}
c = peekkey();
alarm(0);
#ifdef MDEBUG
if (trace)
fprintf(trace,"[OK]");
#endif
ONERR
c = 0;
#ifdef MDEBUG
if (trace)
fprintf(trace,"[TIMEOUT]");
#endif
ENDCATCH
#ifdef MDEBUG
if (trace)
fprintf(trace,"[fpk:%o]",c);
#endif
signal(SIGINT,Oint);
return(c);
}
void
trapalarm() {
alarm(0);
if (vcatch)
longjmp(vreslab,1);
}