cmd/csh/sh.lex.c

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley Software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#include <unistd.h>	/* for lseek prototype */
#include "sh.h"
#include "sh.tconst.h"
#include <sys/filio.h>
#include <sys/ttold.h>
#define	RAW 	O_RAW
/*
 * C shell
 */

bool	justpr;
static int lastev;
int	onelflg;
tchar	**alvec;
struct wordent *alhistp;
struct wordent *alhistt;
struct wordent paraml;

/*
 * These lexical routines read input and form lists of words.
 * There is some involved processing here, because of the complications
 * of input buffering, and especially because of history substitution.
 */

tchar	*word(void);
tchar	getC1(int);
tchar	*subword(tchar *, int, bool *);
void	getdol(void);
void	addla(tchar *);
void	getexcl(tchar);
void	noev(tchar *);
void	setexclp(tchar *);
void	unreadc(tchar);
int	readc(bool);
struct wordent	*dosub(int, struct wordent *, bool);
struct Hist	*findev(tchar *, bool);
struct wordent	*gethent(int);
struct wordent	*getsub(struct wordent *);

/*
 * Peekc is a peek characer for getC, peekread for readc.
 * There is a subtlety here in many places... history routines
 * will read ahead and then insert stuff into the input stream.
 * If they push back a character then they must push it behind
 * the text substituted by the history substitution.  On the other
 * hand in several places we need 2 peek characters.  To make this
 * all work, the history routines read with getC, and make use both
 * of ungetC and unreadc.  The key observation is that the state
 * of getC at the call of a history reference is such that calls
 * to getC from the history routines will always yield calls of
 * readc, unless this peeking is involved.  That is to say that during
 * getexcl the variables lap, exclp, and exclnxt are all zero.
 *
 * Getdol invokes history substitution, hence the extra peek, peekd,
 * which it can ungetD to be before history substitutions.
 */
tchar peekc, peekd;
tchar peekread;

tchar *exclp;			/* (Tail of) current word from ! subst */
struct	wordent *exclnxt;	/* The rest of the ! subst words */
int	exclc;			/* Count of remainig words in ! subst */
tchar *alvecp;		/* "Globp" for alias resubstitution */

/*
 * Lex returns to its caller not only a wordlist (as a "var" parameter)
 * but also whether a history substitution occurred.  This is used in
 * the main (process) routine to determine whether to echo, and also
 * when called by the alias routine to determine whether to keep the
 * argument list.
 */
bool	hadhist;

tchar getCtmp;
#define	getC(f)		((getCtmp = peekc) ? (peekc = 0, getCtmp) : getC1(f))
#define	ungetC(c)	peekc = c
#define	ungetD(c)	peekd = c

bool
lex(struct wordent *hp)
{
	struct wordent *wdp;
	int c;

#ifdef TRACE
	tprintf("TRACE- lex()\n");
#endif
	lineloc = btell();
	hp->next = hp->prev = hp;
	hp->word = S_ /* "" */;
	alvecp = 0, hadhist = 0;
	do
		c = readc(0);
	while (issp(c));
	/* make sure history is enabled */
	if (HIST && c == HISTSUB && intty)
		/* ^lef^rit	from tty is short !:s^lef^rit */
		getexcl(c);
	else
		unreadc(c);
	wdp = hp;
	/*
	 * The following loop is written so that the links needed
	 * by freelex will be ready and rarin to go even if it is
	 * interrupted.
	 */
	do {
		struct wordent *new = (struct wordent *)xalloc(sizeof *wdp);

		new->word = 0;
		new->prev = wdp;
		new->next = hp;
		wdp->next = new;
		wdp = new;
		wdp->word = word();
	} while (wdp->word[0] != '\n');
#ifdef TRACE
	tprintf("Exiting lex()\n");
#endif
	hp->prev = wdp;
	return (hadhist);
}

void
prlex(struct wordent *sp0)
{
	struct wordent *sp = sp0->next;

#ifdef TRACE
	tprintf("TRACE- prlex()\n");
#endif
	for (;;) {
		printf("%t", sp->word);
		sp = sp->next;
		if (sp == sp0)
			break;
		if (sp->word[0] != '\n')
			Putchar(' ');
	}
}

void
copylex(struct wordent *hp, struct wordent *fp)
{
	struct wordent *wdp;

#ifdef TRACE
	tprintf("TRACE- copylex()\n");
#endif
	wdp = hp;
	fp = fp->next;
	do {
		struct wordent *new = (struct wordent *)xalloc(sizeof *wdp);

		new->prev = wdp;
		new->next = hp;
		wdp->next = new;
		wdp = new;
		wdp->word = savestr(fp->word);
		fp = fp->next;
	} while (wdp->word[0] != '\n');
	hp->prev = wdp;
}

void
freelex(struct wordent *vp)
{
	struct wordent *fp;

#ifdef TRACE
	tprintf("TRACE- freelex()\n");
#endif
	while (vp->next != vp) {
		fp = vp->next;
		vp->next = fp->next;
		xfree(fp->word);
		xfree(fp);
	}
	vp->prev = vp;
}

tchar *
word(void)
{
	tchar c, c1;
	tchar *wp;
	tchar wbuf[BUFSIZ];
	bool dolflg;
	int i;

#ifdef TRACE
	tprintf("TRACE- word()\n");
#endif
	wp = wbuf;
	i = BUFSIZ - 4;
loop:
	while (issp(c = getC(DOALL)))
		;
	if (cmap(c, _META|_ESC)||isauxsp(c))
		switch (c) {
		case '&':
		case '|':
		case '<':
		case '>':
			*wp++ = c;
			c1 = getC(DOALL);
			if (c1 == c)
				*wp++ = c1;
			else
				ungetC(c1);
			goto ret;

		case '#':
			if (intty)
				break;
			c = 0;
			do {
				c1 = c;
				c = getC(0);
			} while (c != '\n');
			if (c1 == '\\')
				goto loop;
			/* fall into ... */

		case ';':
		case '(':
		case ')':
		case '\n':
			*wp++ = c;
			goto ret;

		case '\\':
			c = getC(0);
			if (c == '\n') {
				if (onelflg == 1)
					onelflg = 2;
				goto loop;
			}
			if (c != HIST)
				*wp++ = '\\', --i;
			c |= QUOTE;
		}
	c1 = 0;
	dolflg = DOALL;
	for (;;) {
		if (c1) {
			if (c == c1) {
				c1 = 0;
				dolflg = DOALL;
			} else if (c == '\\') {
				c = getC(0);
				if (c == HIST)
					c |= QUOTE;
				else {
					if (c == '\n')
#if 0
						if (c1 == '`')
							c = ' ';
						else
#endif
							c |= QUOTE;
					ungetC(c);
					c = '\\';
				}
			} else if (c == '\n') {
				seterrc(gettext("Unmatched "), c1);
				ungetC(c);
				break;
			}
		} else if (cmap(c, _META|_Q|_Q1|_ESC)||isauxsp(c)) {
			if (c == '\\') {
				c = getC(0);
				if (c == '\n') {
					if (onelflg == 1)
						onelflg = 2;
					break;
				}
				if (c != HIST)
					*wp++ = '\\', --i;
				c |= QUOTE;
			} else if (cmap(c, _Q|_Q1)) {		/* '"` */
				c1 = c;
				dolflg = c == '"' ? DOALL : DOEXCL;
			} else if (c != '#' || !intty) {
				ungetC(c);
				break;
			}
		}
		if (--i > 0) {
			*wp++ = c;
			c = getC(dolflg);
		} else {
			seterr("Word too long");
			wp = &wbuf[1];
			break;
		}
	}
ret:
	*wp = 0;
#ifdef TRACE
	tprintf("word() returning:%t\n", wbuf);
#endif
	return (savestr(wbuf));
}

tchar
getC1(int flag)
{
	tchar c;

top:
	if (c = peekc) {
		peekc = 0;
		return (c);
	}
	if (lap) {
		if ((c = *lap++) == 0)
			lap = 0;
		else {
			/*
			 * don't quote things if there was an error (err!=0)
			 * the input is original, not from a substitution and
			 * therefore should not be quoted
			 */
			if (!err_msg && cmap(c, _META|_Q|_Q1)||isauxsp(c))
				c |= QUOTE;
			return (c);
		}
	}
	if (c = peekd) {
		peekd = 0;
		return (c);
	}
	if (exclp) {
		if (c = *exclp++)
			return (c);
		if (exclnxt && --exclc >= 0) {
			exclnxt = exclnxt->next;
			setexclp(exclnxt->word);
			return (' ');
		}
		exclp = 0;
		exclnxt = 0;
	}
	if (exclnxt) {
		exclnxt = exclnxt->next;
		if (--exclc < 0)
			exclnxt = 0;
		else
			setexclp(exclnxt->word);
		goto top;
	}
	c = readc(0);
	if (c == '$' && (flag & DODOL)) {
		getdol();
		goto top;
	}
	if (c == HIST && (flag & DOEXCL)) {
		getexcl(0);
		goto top;
	}
	return (c);
}

void
getdol(void)
{
	tchar *np, *p;
	tchar name[MAX_VREF_LEN];
	int c;
	int sc;
	bool special = 0;

#ifdef TRACE
	tprintf("TRACE- getdol()\n");
#endif
	np = name, *np++ = '$';
	c = sc = getC(DOEXCL);
	if (isspnl(c)) {
		ungetD(c);
		ungetC('$' | QUOTE);
		return;
	}
	if (c == '{')
		*np++ = c, c = getC(DOEXCL);
	if (c == '#' || c == '?')
		special++, *np++ = c, c = getC(DOEXCL);
	*np++ = c;
	switch (c) {

	case '<':
	case '$':
	case '*':
		if (special)
			goto vsyn;
		goto ret;

	case '\n':
		ungetD(c);
		np--;
		goto vsyn;

	default:
		p = np;
		if (digit(c)) {
			/* make sure the variable names are MAX_VAR_LEN chars or less */
			while (digit(c = getC(DOEXCL)) && (np - p) < MAX_VAR_LEN) {
				*np++ = c;
			}
		} else if (letter(c)) {
			while ((letter(c = getC(DOEXCL)) || digit(c)) &&
				(np - p) < MAX_VAR_LEN) {
				*np++ = c;
			}
		}
		else
			goto vsyn;

		if ((np - p) > MAX_VAR_LEN)
		{
			seterr("Variable name too long");
			goto ret;
		}
	}
	if (c == '[') {
		*np++ = c;
		do {
			c = getC(DOEXCL);
			if (c == '\n') {
				ungetD(c);
				np--;
				goto vsyn;
			}
			/* need to leave space for possible modifiers */
			if (np >= &name[MAX_VREF_LEN - 8])
			{
				seterr("Variable reference too long");
				goto ret;
			}
			*np++ = c;
		} while (c != ']');
		c = getC(DOEXCL);
	}
	if (c == ':') {
		*np++ = c, c = getC(DOEXCL);
		if (c == 'g')
			*np++ = c, c = getC(DOEXCL);
		*np++ = c;
		if (!any(c, S_htrqxe))
			goto vsyn;
	} else
		ungetD(c);
	if (sc == '{') {
		c = getC(DOEXCL);
		if (c != '}') {
			ungetC(c);
			goto vsyn;
		}
		*np++ = c;
	}
ret:
	*np = 0;
	addla(name);
	return;

vsyn:
	seterr("Variable syntax");
	goto ret;
}

void
addla(tchar *cp)
{
	tchar *buf;
	static tchar *labuf = NULL;
	int len = 0;

#ifdef TRACE
	tprintf("TRACE- addla()\n");
#endif
	if (lap) {
		len = strlen_(lap);
		buf = xalloc((len+1) * sizeof (tchar));
		(void) strcpy_(buf, lap);
	}
	len += strlen_(cp);

	/* len+5 is allow 4 additional charecters just to be safe */
	labuf = xrealloc(labuf, (len+5) * sizeof (tchar));
	(void) strcpy_(labuf, cp);
	if (lap) {
		(void) strcat_(labuf, buf);
		xfree(buf);
	}
	lap = labuf;
}

tchar	lhsb[256];
tchar	slhs[256];
tchar	rhsb[512];
int	quesarg;

void
getexcl(tchar sc)
{
	struct wordent *hp, *ip;
	int left, right, dol;
	int c;

#ifdef TRACE
	tprintf("TRACE- getexcl()\n");
#endif
	if (sc == 0) {
		sc = getC(0);
		if (sc != '{') {
			ungetC(sc);
			sc = 0;
		}
	}
	quesarg = -1;
	lastev = eventno;
	hp = gethent(sc);
	if (hp == 0)
		return;
	hadhist = 1;
	dol = 0;
	if (hp == alhistp)
		for (ip = hp->next->next; ip != alhistt; ip = ip->next)
			dol++;
	else
		for (ip = hp->next->next; ip != hp->prev; ip = ip->next)
			dol++;
	left = 0, right = dol;
	if (sc == HISTSUB) {
		ungetC('s'), unreadc(HISTSUB), c = ':';
		goto subst;
	}
	c = getC(0);
	/* if (!any(c, ":^$*-%")) */	/* change needed for char -> tchar */
	if (! (c == ':' || c == '^' || c == '$' || c == '*' ||
	    c == '-' || c == '%'))
		goto subst;
	left = right = -1;
	if (c == ':') {
		c = getC(0);
		unreadc(c);
		if (letter(c) || c == '&') {
			c = ':';
			left = 0, right = dol;
			goto subst;
		}
	} else
		ungetC(c);
	if (!getsel(&left, &right, dol))
		return;
	c = getC(0);
	if (c == '*')
		ungetC(c), c = '-';
	if (c == '-') {
		if (!getsel(&left, &right, dol))
			return;
		c = getC(0);
	}
subst:
	exclc = right - left + 1;
	while (--left >= 0)
		hp = hp->next;
	if (sc == HISTSUB || c == ':') {
		do {
			hp = getsub(hp);
			c = getC(0);
		} while (c == ':');
	}
	unreadc(c);
	if (sc == '{') {
		c = getC(0);
		if (c != '}')
			seterr("Bad ! form");
	}
	exclnxt = hp;
}

struct wordent *
getsub(struct wordent *en)
{
	tchar *cp;
	int delim;
	int c;
	int sc;
	bool global = 0;
	tchar orhsb[(sizeof rhsb)/(sizeof rhsb[0])];

#ifdef TRACE
	tprintf("TRACE- getsub()\n");
#endif
	exclnxt = 0;
	sc = c = getC(0);
	if (c == 'g')
		global++, c = getC(0);
	switch (c) {

	case 'p':
		justpr++;
		goto ret;

	case 'x':
	case 'q':
		global++;
		/* fall into ... */

	case 'h':
	case 'r':
	case 't':
	case 'e':
		break;

	case '&':
		if (slhs[0] == 0) {
			seterr("No prev sub");
			goto ret;
		}
		(void) strcpy_(lhsb, slhs);
		break;

#if 0
	case '~':
		if (lhsb[0] == 0)
			goto badlhs;
		break;
#endif

	case 's':
		delim = getC(0);
		if (alnum(delim) || isspnl(delim)) {
			unreadc(delim);
bads:
			lhsb[0] = 0;
			seterr("Bad substitute");
			goto ret;
		}
		cp = lhsb;
		for (;;) {
			c = getC(0);
			if (c == '\n') {
				unreadc(c);
				break;
			}
			if (c == delim)
				break;
			if (cp > &lhsb[(sizeof lhsb)/(sizeof lhsb[0]) - 2])
				goto bads;
			if (c == '\\') {
				c = getC(0);
				if (c != delim && c != '\\')
					*cp++ = '\\';
			}
			*cp++ = c;
		}
		if (cp != lhsb)
			*cp++ = 0;
		else if (lhsb[0] == 0) {
/* badlhs: */
			seterr("No prev lhs");
			goto ret;
		}
		cp = rhsb;
		(void) strcpy_(orhsb, cp);
		for (;;) {
			c = getC(0);
			if (c == '\n') {
				unreadc(c);
				break;
			}
			if (c == delim)
				break;
#if 0
			if (c == '~') {
				if (&cp[strlen_(orhsb)]
				> &rhsb[(sizeof rhsb)/(sizeof rhsb[0]) - 2])
					goto toorhs;
				(void) strcpy_(cp, orhsb);
				cp = strend(cp);
				continue;
			}
#endif
			if (cp > &rhsb[(sizeof rhsb)/(sizeof rhsb[0]) - 2]) {
/* toorhs: */
				seterr("Rhs too long");
				goto ret;
			}
			if (c == '\\') {
				c = getC(0);
				if (c != delim /* && c != '~' */)
					*cp++ = '\\';
			}
			*cp++ = c;
		}
		*cp++ = 0;
		break;

	default:
		if (c == '\n')
			unreadc(c);
		seterrc(gettext("Bad ! modifier: "), c);
		goto ret;
	}
	(void) strcpy_(slhs, lhsb);
	if (exclc)
		en = dosub(sc, en, global);
ret:
	return (en);
}

struct wordent *
dosub(int sc, struct wordent *en, bool global)
{
	struct wordent lex;
	bool didsub = 0;
	struct wordent *hp = &lex;
	struct wordent *wdp;
	int i = exclc;

#ifdef TRACE
	tprintf("TRACE- dosub()\n");
#endif
	wdp = hp;
	while (--i >= 0) {
		struct wordent *new = (struct wordent *)xcalloc(1, sizeof *wdp);

		new->prev = wdp;
		new->next = hp;
		wdp->next = new;
		wdp = new;
		en = en->next;
		wdp->word = global || didsub == 0 ?
		    subword(en->word, sc, &didsub) : savestr(en->word);
	}
	if (didsub == 0)
		seterr("Modifier failed");
	hp->prev = wdp;
	return (&enthist(-1000, &lex, 0)->Hlex);
}

tchar *
subword(tchar *cp, int type, bool *adid)
{
	tchar wbuf[BUFSIZ];
	tchar *wp, *mp, *np;
	int i;

#ifdef TRACE
	tprintf("TRACE- subword()\n");
#endif
	switch (type) {

	case 'r':
	case 'e':
	case 'h':
	case 't':
	case 'q':
	case 'x':
		wp = domod(cp, type);
		if (wp == 0)
			return (savestr(cp));
		*adid = 1;
		return (wp);

	default:
		wp = wbuf;
		i = BUFSIZ - 4;
		for (mp = cp; *mp; mp++)
			if (matchs(mp, lhsb)) {
				for (np = cp; np < mp; )
					*wp++ = *np++, --i;
				for (np = rhsb; *np; np++) switch (*np) {

				case '\\':
					if (np[1] == '&')
						np++;
					/* fall into ... */

				default:
					if (--i < 0)
						goto ovflo;
					*wp++ = *np;
					continue;

				case '&':
					i -= strlen_(lhsb);
					if (i < 0)
						goto ovflo;
					*wp = 0;
					(void) strcat_(wp, lhsb);
					wp = strend(wp);
					continue;
				}
				mp += strlen_(lhsb);
				i -= strlen_(mp);
				if (i < 0) {
ovflo:
					seterr("Subst buf ovflo");
					return (S_ /* "" */);
				}
				*wp = 0;
				(void) strcat_(wp, mp);
				*adid = 1;
				return (savestr(wbuf));
			}
		return (savestr(cp));
	}
}

tchar *
domod(tchar *cp, int type)
{
	tchar *wp, *xp;
	int c;

#ifdef TRACE
	tprintf("TRACE- domod()\n");
#endif
	switch (type) {

	case 'x':
	case 'q':
		wp = savestr(cp);
		for (xp = wp; c = *xp; xp++)
			if (!issp(c) || type == 'q')
				*xp |= QUOTE;
		return (wp);

	case 'h':
	case 't':
		if (!any('/', cp))
			return (type == 't' ? savestr(cp) : 0);
		wp = strend(cp);
		while (*--wp != '/')
			continue;
		if (type == 'h')
			xp = savestr(cp), xp[wp - cp] = 0;
		else
			xp = savestr(wp + 1);
		return (xp);

	case 'e':
	case 'r':
		wp = strend(cp);
		for (wp--; wp >= cp && *wp != '/'; wp--)
			if (*wp == '.') {
				if (type == 'e')
					xp = savestr(wp + 1);
				else
					xp = savestr(cp), xp[wp - cp] = 0;
				return (xp);
			}
		return (savestr(type == 'e' ? S_ /* "" */ : cp));
	}
	return (0);
}

int
matchs(tchar *str, tchar *pat)
{

#ifdef TRACE
	tprintf("TRACE- matchs()\n");
#endif
	while (*str && *pat && *str == *pat)
		str++, pat++;
	return (*pat == 0);
}

int
getsel(int *al, int *ar, int dol)
{
	int c = getC(0);
	int i;
	bool first = *al < 0;

#ifdef TRACE
	tprintf("TRACE- getsel()\n");
#endif
	switch (c) {

	case '%':
		if (quesarg == -1)
			goto bad;
		if (*al < 0)
			*al = quesarg;
		*ar = quesarg;
		break;

	case '-':
		if (*al < 0) {
			*al = 0;
			*ar = dol - 1;
			unreadc(c);
		}
		return (1);

	case '^':
		if (*al < 0)
			*al = 1;
		*ar = 1;
		break;

	case '$':
		if (*al < 0)
			*al = dol;
		*ar = dol;
		break;

	case '*':
		if (*al < 0)
			*al = 1;
		*ar = dol;
		if (*ar < *al) {
			*ar = 0;
			*al = 1;
			return (1);
		}
		break;

	default:
		if (digit(c)) {
			i = 0;
			while (digit(c)) {
				i = i * 10 + c - '0';
				c = getC(0);
			}
			if (i < 0)
				i = dol + 1;
			if (*al < 0)
				*al = i;
			*ar = i;
		} else
			if (*al < 0)
				*al = 0, *ar = dol;
			else
				*ar = dol - 1;
		unreadc(c);
		break;
	}
	if (first) {
		c = getC(0);
		unreadc(c);
		/* if (any(c, "-$*")) */	/* char -> tchar */
		if (c == '-' || c == '$' || c == '*')
			return (1);
	}
	if (*al > *ar || *ar > dol) {
bad:
		seterr("Bad ! arg selector");
		return (0);
	}
	return (1);

}

struct wordent *
gethent(int sc)
{
	struct Hist *hp;
	tchar *np;
	int c;
	int event;
	bool back = 0;

#ifdef TRACE
	tprintf("TRACE- gethent()\n");
#endif
	c = sc == HISTSUB ? HIST : getC(0);
	if (c == HIST) {
		if (alhistp)
			return (alhistp);
		event = eventno;
		goto skip;
	}
	switch (c) {

	case ':':
	case '^':
	case '$':
	case '*':
	case '%':
		ungetC(c);
		if (lastev == eventno && alhistp)
			return (alhistp);
		event = lastev;
		break;

	case '-':
		back = 1;
		c = getC(0);
		goto number;

	case '#':			/* !# is command being typed in (mrh) */
		return (&paraml);

	default:
		/* if (any(c, "(=~")) { */
		if (c == '(' || c == '=' || c == '~') {
			unreadc(c);
			ungetC(HIST);
			return (0);
		}
		if (digit(c))
			goto number;
		np = lhsb;
		/* while (!any(c, ": \t\\\n}")) { */
		while (! (c == ':' || c == '\\' || isspnl(c) || c == '}')) {
			if (np < &lhsb[(sizeof lhsb)/(sizeof lhsb[0]) - 2])
				*np++ = c;
			c = getC(0);
		}
		unreadc(c);
		if (np == lhsb) {
			ungetC(HIST);
			return (0);
		}
		*np++ = 0;
		hp = findev(lhsb, 0);
		if (hp)
			lastev = hp->Hnum;
		return (&hp->Hlex);

	case '?':
		np = lhsb;
		for (;;) {
			c = getC(0);
			if (c == '\n') {
				unreadc(c);
				break;
			}
			if (c == '?')
				break;
			if (np < &lhsb[(sizeof lhsb)/(sizeof lhsb[0]) - 2])
				*np++ = c;
		}
		if (np == lhsb) {
			if (lhsb[0] == 0) {
				seterr("No prev search");
				return (0);
			}
		} else
			*np++ = 0;
		hp = findev(lhsb, 1);
		if (hp)
			lastev = hp->Hnum;
		return (&hp->Hlex);

	number:
		event = 0;
		while (digit(c)) {
			event = event * 10 + c - '0';
			c = getC(0);
		}
		if (back)
			event = eventno + (alhistp == 0) - (event ? event : 0);
		unreadc(c);
		break;
	}
skip:
	for (hp = Histlist.Hnext; hp; hp = hp->Hnext)
		if (hp->Hnum == event) {
			hp->Href = eventno;
			lastev = hp->Hnum;
			return (&hp->Hlex);
		}
	np = putn(event);
	noev(np);
	return (0);
}

struct Hist *
findev(tchar *cp, bool anyarg)
{
	struct Hist *hp;

#ifdef TRACE
	tprintf("TRACE- findev()\n");
#endif
	for (hp = Histlist.Hnext; hp; hp = hp->Hnext) {
		tchar *dp;
		tchar *p, *q;
		struct wordent *lp = hp->Hlex.next;
		int argno = 0;

		if (lp->word[0] == '\n')
			continue;
		if (!anyarg) {
			p = cp;
			q = lp->word;
			do
				if (!*p)
					return (hp);
			while (*p++ == *q++);
			continue;
		}
		do {
			for (dp = lp->word; *dp; dp++) {
				p = cp;
				q = dp;
				do
					if (!*p) {
						quesarg = argno;
						return (hp);
					}
				while (*p++ == *q++);
			}
			lp = lp->next;
			argno++;
		} while (lp->word[0] != '\n');
	}
	noev(cp);
	return (0);
}

void
noev(tchar *cp)
{

#ifdef TRACE
	tprintf("TRACE- noev()\n");
#endif
	seterr2(cp, ": Event not found");
}

void
setexclp(tchar *cp)
{

#ifdef TRACE
	tprintf("TRACE- setexclp()\n");
#endif
	if (cp && cp[0] == '\n')
		return;
	exclp = cp;
}

void
unreadc(tchar c)
{

	peekread = c;
}

int
readc(bool wanteof)
{
	int c;
	static int sincereal;

	if (c = peekread) {
		peekread = 0;
		return (c);
	}
top:
	if (alvecp) {
		if (c = *alvecp++)
			return (c);
		if (*alvec) {
			alvecp = *alvec++;
			return (' ');
		}
	}
	if (alvec) {
		if (alvecp = *alvec) {
			alvec++;
			goto top;
		}
		/* Infinite source! */
		return ('\n');
	}
	if (evalp) {
		if (c = *evalp++)
			return (c);
		if (*evalvec) {
			evalp = *evalvec++;
			return (' ');
		}
		evalp = 0;
	}
	if (evalvec) {
		if (evalvec ==  (tchar **)1) {
			doneinp = 1;
			reset();
		}
		if (evalp = *evalvec) {
			evalvec++;
			goto top;
		}
		evalvec =  (tchar **)1;
		return ('\n');
	}
	do {
		if (arginp ==  (tchar *) 1 || onelflg == 1) {
			if (wanteof)
				return (-1);
			exitstat();
		}
		if (arginp) {
			if ((c = *arginp++) == 0) {
				arginp =  (tchar *) 1;
				return ('\n');
			}
			return (c);
		}
reread:
		c = bgetc();
		if (c < 0) {
			struct sgttyb tty;

			if (wanteof)
				return (-1);
			/* was isatty but raw with ignoreeof yields problems */
			if (ioctl(SHIN, TIOCGETP,  (char *)&tty) == 0 &&
			    (tty.sg_flags & RAW) == 0) {
				/* was 'short' for FILEC */
				int ctpgrp;

				if (++sincereal > 25)
					goto oops;
				if (tpgrp != -1 &&
				    ioctl(FSHTTY, TIOCGPGRP, (char *)&ctpgrp) == 0 &&
				    tpgrp != ctpgrp) {
					(void) ioctl(FSHTTY, TIOCSPGRP,
						(char *)&tpgrp);
					(void) killpg(ctpgrp, SIGHUP);
printf("Reset tty pgrp from %d to %d\n", ctpgrp, tpgrp);
					goto reread;
				}
				if (adrof(S_ignoreeof /* "ignoreeof" */)) {
					if (loginsh)
				printf("\nUse \"logout\" to logout.\n");
					else
				printf("\nUse \"exit\" to leave csh.\n");
					reset();
				}
				if (chkstop == 0) {
					panystop(1);
				}
			}
oops:
			doneinp = 1;
			reset();
		}
		sincereal = 0;
		if (c == '\n' && onelflg)
			onelflg--;
	} while (c == 0);
	return (c);
}

static void
expand_fbuf(void)
{
	tchar **nfbuf =
	    (tchar **)xcalloc((unsigned)(fblocks + 2), sizeof (tchar **));

	if (fbuf) {
		(void) blkcpy(nfbuf, fbuf);
		xfree((char *)fbuf);
	}
	fbuf = nfbuf;
	fbuf[fblocks] = (tchar *)xcalloc(BUFSIZ + MB_LEN_MAX,
		sizeof (tchar));
	fblocks++;
}

int
bgetc(void)
{
	int buf, off, c;
#ifdef FILEC
	tchar ttyline[BUFSIZ + MB_LEN_MAX]; /* read_() can return extra bytes */
	int roomleft;
#endif

#ifdef TELL
	if (cantell) {
		if (fseekp < fbobp || fseekp > feobp) {
			fbobp = feobp = fseekp;
			(void) lseek(SHIN, fseekp, 0);
		}
		if (fseekp == feobp) {
			fbobp = feobp;
			do
				c = read_(SHIN, fbuf[0], BUFSIZ);
			while (c < 0 && errno == EINTR);
			if (c <= 0)
				return (-1);
			feobp += c;
		}
		c = fbuf[0][fseekp - fbobp];
		fseekp++;
		return (c);
	}
#endif
again:
	buf = (int)fseekp / BUFSIZ;
	if (buf >= fblocks) {
		expand_fbuf();
		goto again;
	}
	if (fseekp >= feobp) {
		buf = (int)feobp / BUFSIZ;
		off = (int)feobp % BUFSIZ;
#ifndef FILEC
		for (;;) {
			c = read_(SHIN, fbuf[buf] + off, BUFSIZ - off);
#else
		roomleft = BUFSIZ - off;
		for (;;) {
			if (filec && intty) {
				c = tenex(ttyline, BUFSIZ);
				if (c > roomleft) {
					expand_fbuf();
					copy(fbuf[buf] + off, ttyline,
					    roomleft * sizeof (tchar));
					copy(fbuf[buf + 1], ttyline + roomleft,
					    (c - roomleft) * sizeof (tchar));
				} else if (c > 0) {
					copy(fbuf[buf] + off, ttyline,
						c * sizeof (tchar));
				}
			} else {
				c = read_(SHIN, fbuf[buf] + off, roomleft);
				if (c > roomleft) {
					expand_fbuf();
					copy(fbuf[buf + 1],
					    fbuf[buf] + off + roomleft,
					    (c - roomleft) * sizeof (tchar));
				}
			}
#endif
			if (c >= 0)
				break;
			if (errno == EWOULDBLOCK) {
				int off = 0;

				(void) ioctl(SHIN, FIONBIO,  (char *)&off);
			} else if (errno != EINTR)
				break;
		}
		if (c <= 0)
			return (-1);
		feobp += c;
#ifndef FILEC
		goto again;
#else
		if (filec && !intty)
			goto again;
#endif
	}
	c = fbuf[buf][(int)fseekp % BUFSIZ];
	fseekp++;
	return (c);
}

void
bfree(void)
{
	int sb, i;

#ifdef TELL
	if (cantell)
		return;
#endif
	if (whyles)
		return;
	sb = (int)(fseekp - 1) / BUFSIZ;
	if (sb > 0) {
		for (i = 0; i < sb; i++)
			xfree(fbuf[i]);
		(void) blkcpy(fbuf, &fbuf[sb]);
		fseekp -= BUFSIZ * sb;
		feobp -= BUFSIZ * sb;
		fblocks -= sb;
	}
}

void
bseek(off_t l)
{
	struct whyle *wp;

	fseekp = l;
#ifdef TELL
	if (!cantell) {
#endif
		if (!whyles)
			return;
		for (wp = whyles; wp->w_next; wp = wp->w_next)
			continue;
		if (wp->w_start > l)
			l = wp->w_start;
#ifdef TELL
	}
#endif
}

/* any similarity to bell telephone is purely accidental */
#ifndef btell
off_t
btell(void)
{

	return (fseekp);
}
#endif

void
btoeof(void)
{

	(void) lseek(SHIN, (off_t)0, 2);
	fseekp = feobp;
	wfree();
	bfree();
}

#ifdef TELL
void
settell(void)
{

	cantell = 0;
	if (arginp || onelflg || intty)
		return;
	if (lseek(SHIN, (off_t)0, 1) < 0 || errno == ESPIPE)
		return;
	fbuf = (tchar **)xcalloc(2, sizeof (tchar **));
	fblocks = 1;
	fbuf[0] = (tchar *)xcalloc(BUFSIZ + MB_LEN_MAX, sizeof (tchar));
	fseekp = fbobp = feobp = lseek(SHIN, (off_t)0, 1);
	cantell = 1;
}
#endif