sh.lex.c revision 100616 
1/* $Header: /src/pub/tcsh/sh.lex.c,v 3.56 2002/07/08 20:57:32 christos Exp $ */
2/*
3 * sh.lex.c: Lexical analysis into tokens
4 */
5/*-
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33#include "sh.h"
34
35RCSID("$Id: sh.lex.c,v 3.56 2002/07/08 20:57:32 christos Exp $")
36
37#include "ed.h"
38/* #define DEBUG_INP */
39/* #define DEBUG_SEEK */
40
41/*
42 * C shell
43 */
44
45/*
46 * These lexical routines read input and form lists of words.
47 * There is some involved processing here, because of the complications
48 * of input buffering, and especially because of history substitution.
49 */
50static	Char		*word		__P((void));
51static	int	 	 getC1		__P((int));
52static	void	 	 getdol		__P((void));
53static	void	 	 getexcl	__P((int));
54static	struct Hist 	*findev		__P((Char *, bool));
55static	void	 	 setexclp	__P((Char *));
56static	int	 	 bgetc		__P((void));
57static	void		 balloc		__P((int));
58static	void	 	 bfree		__P((void));
59static	struct wordent	*gethent	__P((int));
60static	int	 	 matchs		__P((Char *, Char *));
61static	int	 	 getsel		__P((int *, int *, int));
62static	struct wordent	*getsub		__P((struct wordent *));
63static	Char 		*subword	__P((Char *, int, bool *));
64static	struct wordent	*dosub		__P((int, struct wordent *, bool));
65
66/*
67 * Peekc is a peek character for getC, peekread for readc.
68 * There is a subtlety here in many places... history routines
69 * will read ahead and then insert stuff into the input stream.
70 * If they push back a character then they must push it behind
71 * the text substituted by the history substitution.  On the other
72 * hand in several places we need 2 peek characters.  To make this
73 * all work, the history routines read with getC, and make use both
74 * of ungetC and unreadc.  The key observation is that the state
75 * of getC at the call of a history reference is such that calls
76 * to getC from the history routines will always yield calls of
77 * readc, unless this peeking is involved.  That is to say that during
78 * getexcl the variables lap, exclp, and exclnxt are all zero.
79 *
80 * Getdol invokes history substitution, hence the extra peek, peekd,
81 * which it can ungetD to be before history substitutions.
82 */
83static Char peekc = 0, peekd = 0;
84static Char peekread = 0;
85
86/* (Tail of) current word from ! subst */
87static Char *exclp = NULL;
88
89/* The rest of the ! subst words */
90static struct wordent *exclnxt = NULL;
91
92/* Count of remaining words in ! subst */
93static int exclc = 0;
94
95/* "Globp" for alias resubstitution */
96int aret = TCSH_F_SEEK;
97
98/*
99 * Labuf implements a general buffer for lookahead during lexical operations.
100 * Text which is to be placed in the input stream can be stuck here.
101 * We stick parsed ahead $ constructs during initial input,
102 * process id's from `$$', and modified variable values (from qualifiers
103 * during expansion in sh.dol.c) here.
104 */
105static Char labuf[BUFSIZE];
106
107/*
108 * Lex returns to its caller not only a wordlist (as a "var" parameter)
109 * but also whether a history substitution occurred.  This is used in
110 * the main (process) routine to determine whether to echo, and also
111 * when called by the alias routine to determine whether to keep the
112 * argument list.
113 */
114static bool hadhist = 0;
115
116/*
117 * Avoid alias expansion recursion via \!#
118 */
119int     hleft;
120
121Char    histline[BUFSIZE + 2];	/* last line input */
122
123 /* The +2 is to fool hp's optimizer */
124bool    histvalid = 0;		/* is histline valid */
125static Char *histlinep = NULL;	/* current pointer into histline */
126
127static Char getCtmp;
128
129#define getC(f)		(((getCtmp = peekc) != '\0') ? (peekc = 0, getCtmp) : getC1(f))
130#define	ungetC(c)	peekc = (Char) c
131#define	ungetD(c)	peekd = (Char) c
132
133/* Use Htime to store timestamps picked up from history file for enthist()
134 * if reading saved history (sg)
135 */
136time_t Htime = (time_t)0;
137static time_t a2time_t __P((Char *));
138
139/*
140 * for history event processing
141 * in the command 'echo !?foo?:1 !$' we want the !$ to expand from the line
142 * 'foo' was found instead of the last command
143 */
144static int uselastevent = 1;
145
146int
147lex(hp)
148    struct wordent *hp;
149{
150    struct wordent *wdp;
151    int     c;
152
153
154    uselastevent = 1;
155    histvalid = 0;
156    histlinep = histline;
157    *histlinep = '\0';
158
159    btell(&lineloc);
160    hp->next = hp->prev = hp;
161    hp->word = STRNULL;
162    hadhist = 0;
163    do
164	c = readc(0);
165    while (c == ' ' || c == '\t');
166    if (c == HISTSUB && intty)
167	/* ^lef^rit	from tty is short !:s^lef^rit */
168	getexcl(c);
169    else
170	unreadc(c);
171    wdp = hp;
172    /*
173     * The following loop is written so that the links needed by freelex will
174     * be ready and rarin to go even if it is interrupted.
175     */
176    do {
177	struct wordent *new;
178
179	new = (struct wordent *) xmalloc((size_t) sizeof(*wdp));
180	new->word = STRNULL;
181	new->prev = wdp;
182	new->next = hp;
183	wdp->next = new;
184	hp->prev = new;
185	wdp = new;
186	wdp->word = word();
187    } while (wdp->word[0] != '\n');
188    if (histlinep < histline + BUFSIZE) {
189	*histlinep = '\0';
190	if (histlinep > histline && histlinep[-1] == '\n')
191	    histlinep[-1] = '\0';
192	histvalid = 1;
193    }
194    else {
195	histline[BUFSIZE - 1] = '\0';
196    }
197
198    return (hadhist);
199}
200
201static time_t
202a2time_t(word)
203    Char *word;
204{
205    /* Attempt to distinguish timestamps from other possible entries.
206     * Format: "+NNNNNNNNNN" (10 digits, left padded with ascii '0') */
207
208    time_t ret;
209    Char *s;
210    int ct;
211
212    if (!word || *(s = word) != '+')
213	return (time_t)0;
214
215    for (++s, ret = 0, ct = 0; *s; ++s, ++ct)
216    {
217	if (!isdigit((unsigned char)*s))
218	    return (time_t)0;
219	ret = ret * 10 + (time_t)((unsigned char)*s - '0');
220    }
221
222    if (ct != 10)
223	return (time_t)0;
224
225    return ret;
226}
227
228void
229prlex(sp0)
230    struct wordent *sp0;
231{
232    struct wordent *sp = sp0->next;
233
234    for (;;) {
235	xprintf("%S", sp->word);
236	sp = sp->next;
237	if (sp == sp0)
238	    break;
239	if (sp->word[0] != '\n')
240	    xputchar(' ');
241    }
242}
243
244void
245copylex(hp, fp)
246    struct wordent *hp;
247    struct wordent *fp;
248{
249    struct wordent *wdp;
250
251    wdp = hp;
252    fp = fp->next;
253    do {
254	struct wordent *new;
255
256	new = (struct wordent *) xmalloc((size_t) sizeof(*wdp));
257	new->word = STRNULL;
258	new->prev = wdp;
259	new->next = hp;
260	wdp->next = new;
261	hp->prev = new;
262	wdp = new;
263	wdp->word = Strsave(fp->word);
264	fp = fp->next;
265    } while (wdp->word[0] != '\n');
266}
267
268void
269freelex(vp)
270    struct wordent *vp;
271{
272    struct wordent *fp;
273
274    while (vp->next != vp) {
275	fp = vp->next;
276	vp->next = fp->next;
277	if (fp->word != STRNULL)
278	    xfree((ptr_t) fp->word);
279	xfree((ptr_t) fp);
280    }
281    vp->prev = vp;
282}
283
284static Char *
285word()
286{
287    Char c, c1;
288    Char *wp;
289    Char    wbuf[BUFSIZE];
290    Char    hbuf[12];
291    int	    h;
292    bool dolflg;
293    int i;
294#if defined(DSPMBYTE)
295    int mbytepos = 1;
296#endif /* DSPMBYTE */
297
298    wp = wbuf;
299    i = BUFSIZE - 4;
300loop:
301    while ((c = getC(DOALL)) == ' ' || c == '\t')
302	continue;
303    if (cmap(c, _META | _ESC))
304	switch (c) {
305	case '&':
306	case '|':
307	case '<':
308	case '>':
309	    *wp++ = c;
310	    c1 = getC(DOALL);
311	    if (c1 == c)
312		*wp++ = c1;
313	    else
314		ungetC(c1);
315	    goto ret;
316
317	case '#':
318	    if (intty)
319		break;
320	    c = 0;
321	    h = 0;
322	    do {
323		c1 = c;
324		c = getC(0);
325		if (h < 12)
326		    hbuf[h++] = c;
327	    } while (c != '\n');
328	    hbuf[11] = '\0';
329	    Htime = a2time_t(hbuf);
330	    if (c1 == '\\')
331		goto loop;
332	    /*FALLTHROUGH*/
333
334	case ';':
335	case '(':
336	case ')':
337	case '\n':
338	    *wp++ = c;
339	    goto ret;
340
341	case '\\':
342	    c = getC(0);
343	    if (c == '\n') {
344		if (onelflg == 1)
345		    onelflg = 2;
346		goto loop;
347	    }
348	    if (c != HIST)
349		*wp++ = '\\', --i;
350	    c |= QUOTE;
351	default:
352	    break;
353	}
354    c1 = 0;
355    dolflg = DOALL;
356    for (;;) {
357#if defined(DSPMBYTE)
358        if (mbytepos == 2)
359	    mbytepos = 1;
360	else if (mbytepos == 1 && Ismbyte1(c) && 2 <= i)
361	    mbytepos = 2;
362	else
363#endif /* DSPMBYTE */
364	if (c1) {
365	    if (c == c1) {
366		c1 = 0;
367		dolflg = DOALL;
368	    }
369	    else if (c == '\\') {
370		c = getC(0);
371/*
372 * PWP: this is dumb, but how all of the other shells work.  If \ quotes
373 * a character OUTSIDE of a set of ''s, why shouldn't it quote EVERY
374 * following character INSIDE a set of ''s.
375 *
376 * Actually, all I really want to be able to say is 'foo\'bar' --> foo'bar
377 */
378		if (c == HIST)
379		    c |= QUOTE;
380		else {
381		    if (bslash_quote &&
382			((c == '\'') || (c == '"') ||
383			 (c == '\\'))) {
384			c |= QUOTE;
385		    }
386		    else {
387			if (c == '\n')
388			    /*
389			     * if (c1 == '`') c = ' '; else
390			     */
391			    c |= QUOTE;
392			ungetC(c);
393			c = '\\';
394		    }
395		}
396	    }
397	    else if (c == '\n') {
398		seterror(ERR_UNMATCHED, c1);
399		ungetC(c);
400		break;
401	    }
402	}
403	else if (cmap(c, _META | _QF | _QB | _ESC)) {
404	    if (c == '\\') {
405		c = getC(0);
406		if (c == '\n') {
407		    if (onelflg == 1)
408			onelflg = 2;
409		    break;
410		}
411		if (c != HIST)
412		    *wp++ = '\\', --i;
413		c |= QUOTE;
414	    }
415	    else if (cmap(c, _QF | _QB)) {	/* '"` */
416		c1 = c;
417		dolflg = c == '"' ? DOALL : DOEXCL;
418	    }
419	    else if (c != '#' || !intty) {
420		ungetC(c);
421		break;
422	    }
423	}
424	if (--i > 0) {
425	    *wp++ = c;
426	    c = getC(dolflg);
427	}
428	else {
429	    seterror(ERR_WTOOLONG);
430	    wp = &wbuf[1];
431	    break;
432	}
433    }
434ret:
435    *wp = 0;
436    return (Strsave(wbuf));
437}
438
439static int
440getC1(flag)
441    int flag;
442{
443    Char c;
444
445    for (;;) {
446	if ((c = peekc) != 0) {
447	    peekc = 0;
448	    return (c);
449	}
450	if (lap) {
451	    if ((c = *lap++) == 0)
452		lap = 0;
453	    else {
454		if (cmap(c, _META | _QF | _QB))
455		    c |= QUOTE;
456		return (c);
457	    }
458	}
459	if ((c = peekd) != 0) {
460	    peekd = 0;
461	    return (c);
462	}
463	if (exclp) {
464	    if ((c = *exclp++) != 0)
465		return (c);
466	    if (exclnxt && --exclc >= 0) {
467		exclnxt = exclnxt->next;
468		setexclp(exclnxt->word);
469		return (' ');
470	    }
471	    exclp = 0;
472	    exclnxt = 0;
473	    /* this will throw away the dummy history entries */
474	    savehist(NULL, 0);
475
476	}
477	if (exclnxt) {
478	    exclnxt = exclnxt->next;
479	    if (--exclc < 0)
480		exclnxt = 0;
481	    else
482		setexclp(exclnxt->word);
483	    continue;
484	}
485	c = readc(0);
486	if (c == '$' && (flag & DODOL)) {
487	    getdol();
488	    continue;
489	}
490	if (c == HIST && (flag & DOEXCL)) {
491	    getexcl(0);
492	    continue;
493	}
494	break;
495    }
496    return (c);
497}
498
499static void
500getdol()
501{
502    Char *np, *ep;
503    Char    name[4 * MAXVARLEN + 1];
504    int c;
505    int     sc;
506    bool    special = 0, toolong;
507
508    np = name, *np++ = '$';
509    c = sc = getC(DOEXCL);
510    if (any("\t \n", c)) {
511	ungetD(c);
512	ungetC('$' | QUOTE);
513	return;
514    }
515    if (c == '{')
516	*np++ = (Char) c, c = getC(DOEXCL);
517    if (c == '#' || c == '?' || c == '%')
518	special++, *np++ = (Char) c, c = getC(DOEXCL);
519    *np++ = (Char) c;
520    switch (c) {
521
522    case '<':
523    case '$':
524    case '!':
525	if (special)
526	    seterror(ERR_SPDOLLT);
527	*np = 0;
528	addla(name);
529	return;
530
531    case '\n':
532	ungetD(c);
533	np--;
534	if (!special)
535	    seterror(ERR_NEWLINE);
536	*np = 0;
537	addla(name);
538	return;
539
540    case '*':
541	if (special)
542	    seterror(ERR_SPSTAR);
543	*np = 0;
544	addla(name);
545	return;
546
547    default:
548	toolong = 0;
549	if (Isdigit(c)) {
550#ifdef notdef
551	    /* let $?0 pass for now */
552	    if (special) {
553		seterror(ERR_DIGIT);
554		*np = 0;
555		addla(name);
556		return;
557	    }
558#endif
559	    /* we know that np < &name[4] */
560	    ep = &np[MAXVARLEN];
561	    while ((c = getC(DOEXCL)) != 0) {
562		if (!Isdigit(c))
563		    break;
564		if (np < ep)
565		    *np++ = (Char) c;
566		else
567		    toolong = 1;
568	    }
569	}
570	else if (letter(c)) {
571	    /* we know that np < &name[4] */
572	    ep = &np[MAXVARLEN];
573	    toolong = 0;
574	    while ((c = getC(DOEXCL)) != 0) {
575		/* Bugfix for ${v123x} from Chris Torek, DAS DEC-90. */
576		if (!letter(c) && !Isdigit(c))
577		    break;
578		if (np < ep)
579		    *np++ = (Char) c;
580		else
581		    toolong = 1;
582	    }
583	}
584	else {
585	    if (!special)
586		seterror(ERR_VARILL);
587	    else {
588		ungetD(c);
589		--np;
590	    }
591	    *np = 0;
592	    addla(name);
593	    return;
594	}
595	if (toolong) {
596	    seterror(ERR_VARTOOLONG);
597	    *np = 0;
598	    addla(name);
599	    return;
600	}
601	break;
602    }
603    if (c == '[') {
604	*np++ = (Char) c;
605	/*
606	 * Name up to here is a max of MAXVARLEN + 8.
607	 */
608	ep = &np[2 * MAXVARLEN + 8];
609	do {
610	    /*
611	     * Michael Greim: Allow $ expansion to take place in selector
612	     * expressions. (limits the number of characters returned)
613	     */
614	    c = getC(DOEXCL | DODOL);
615	    if (c == '\n') {
616		ungetD(c);
617		np--;
618		seterror(ERR_NLINDEX);
619		*np = 0;
620		addla(name);
621		return;
622	    }
623	    if (np < ep)
624		*np++ = (Char) c;
625	} while (c != ']');
626	*np = '\0';
627	if (np >= ep) {
628	    seterror(ERR_SELOVFL);
629	    addla(name);
630	    return;
631	}
632	c = getC(DOEXCL);
633    }
634    /*
635     * Name up to here is a max of 2 * MAXVARLEN + 8.
636     */
637    if (c == ':') {
638	/*
639	 * if the :g modifier is followed by a newline, then error right away!
640	 * -strike
641	 */
642
643	int     gmodflag = 0, amodflag = 0;
644
645#ifndef COMPAT
646	do {
647#endif /* COMPAT */
648	    *np++ = (Char) c, c = getC(DOEXCL);
649	    if (c == 'g' || c == 'a') {
650		if (c == 'g')
651		    gmodflag++;
652		else
653		    amodflag++;
654		*np++ = (Char) c; c = getC(DOEXCL);
655	    }
656	    if ((c == 'g' && !gmodflag) || (c == 'a' && !amodflag)) {
657		if (c == 'g')
658		    gmodflag++;
659		else
660		    amodflag++;
661		*np++ = (Char) c; c = getC(DOEXCL);
662	    }
663	    *np++ = (Char) c;
664	    /* scan s// [eichin:19910926.0512EST] */
665	    if (c == 's') {
666		int delimcnt = 2;
667		int delim = getC(0);
668		*np++ = (Char) delim;
669
670		if (!delim || letter(delim)
671		    || Isdigit(delim) || any(" \t\n", delim)) {
672		    seterror(ERR_BADSUBST);
673		    break;
674		}
675		while ((c = getC(0)) != (-1)) {
676		    *np++ = (Char) c;
677		    if(c == delim) delimcnt--;
678		    if(!delimcnt) break;
679		}
680		if(delimcnt) {
681		    seterror(ERR_BADSUBST);
682		    break;
683		}
684		c = 's';
685	    }
686	    if (!any("htrqxesul", c)) {
687		if ((amodflag || gmodflag) && c == '\n')
688		    stderror(ERR_VARSYN);	/* strike */
689		seterror(ERR_BADMOD, c);
690		*np = 0;
691		addla(name);
692		return;
693	    }
694#ifndef COMPAT
695	}
696	while ((c = getC(DOEXCL)) == ':');
697	ungetD(c);
698#endif /* COMPAT */
699    }
700    else
701	ungetD(c);
702    if (sc == '{') {
703	c = getC(DOEXCL);
704	if (c != '}') {
705	    ungetD(c);
706	    seterror(ERR_MISSING, '}');
707	    *np = 0;
708	    addla(name);
709	    return;
710	}
711	*np++ = (Char) c;
712    }
713    *np = 0;
714    addla(name);
715    return;
716}
717
718void
719addla(cp)
720    Char   *cp;
721{
722    Char    buf[BUFSIZE];
723
724    if (Strlen(cp) + (lap ? Strlen(lap) : 0) >=
725	(sizeof(labuf) - 4) / sizeof(Char)) {
726	seterror(ERR_EXPOVFL);
727	return;
728    }
729    if (lap)
730	(void) Strcpy(buf, lap);
731    (void) Strcpy(labuf, cp);
732    if (lap)
733	(void) Strcat(labuf, buf);
734    lap = labuf;
735}
736
737static Char lhsb[32];
738static Char slhs[32];
739static Char rhsb[64];
740static int quesarg;
741
742static void
743getexcl(sc)
744    int    sc;
745{
746    struct wordent *hp, *ip;
747    int     left, right, dol;
748    int c;
749
750    if (sc == 0) {
751	sc = getC(0);
752	if (sc != '{') {
753	    ungetC(sc);
754	    sc = 0;
755	}
756    }
757    quesarg = -1;
758
759    if (uselastevent) {
760	uselastevent = 0;
761	lastev = eventno;
762    }
763    else
764	lastev = eventno;
765    hp = gethent(sc);
766    if (hp == 0)
767	return;
768    hadhist = 1;
769    dol = 0;
770    if (hp == alhistp)
771	for (ip = hp->next->next; ip != alhistt; ip = ip->next)
772	    dol++;
773    else
774	for (ip = hp->next->next; ip != hp->prev; ip = ip->next)
775	    dol++;
776    left = 0, right = dol;
777    if (sc == HISTSUB) {
778	ungetC('s'), unreadc(HISTSUB), c = ':';
779	goto subst;
780    }
781    c = getC(0);
782    if (!any(":^$*-%", c))
783	goto subst;
784    left = right = -1;
785    if (c == ':') {
786	c = getC(0);
787	unreadc(c);
788	if (letter(c) || c == '&') {
789	    c = ':';
790	    left = 0, right = dol;
791	    goto subst;
792	}
793    }
794    else
795	ungetC(c);
796    if (!getsel(&left, &right, dol))
797	return;
798    c = getC(0);
799    if (c == '*')
800	ungetC(c), c = '-';
801    if (c == '-') {
802	if (!getsel(&left, &right, dol))
803	    return;
804	c = getC(0);
805    }
806subst:
807    exclc = right - left + 1;
808    while (--left >= 0)
809	hp = hp->next;
810    if (sc == HISTSUB || c == ':') {
811	do {
812	    hp = getsub(hp);
813	    c = getC(0);
814	} while (c == ':');
815    }
816    unreadc(c);
817    if (sc == '{') {
818	c = getC(0);
819	if (c != '}')
820	    seterror(ERR_BADBANG);
821    }
822    exclnxt = hp;
823}
824
825static struct wordent *
826getsub(en)
827    struct wordent *en;
828{
829    Char *cp;
830    int     delim;
831    int c;
832    int     sc;
833    bool global;
834    Char    orhsb[sizeof(rhsb) / sizeof(Char)];
835
836#ifndef COMPAT
837    do {
838#endif /* COMPAT */
839	exclnxt = 0;
840	global = 0;
841	sc = c = getC(0);
842	if (c == 'g' || c == 'a') {
843	    global |= (c == 'g') ? 1 : 2;
844	    sc = c = getC(0);
845	}
846	if (((c =='g') && !(global & 1)) || ((c == 'a') && !(global & 2))) {
847	    global |= (c == 'g') ? 1 : 2;
848	    sc = c = getC(0);
849	}
850
851	switch (c) {
852	case 'p':
853	    justpr++;
854	    return (en);
855
856	case 'x':
857	case 'q':
858	    global |= 1;
859	    /*FALLTHROUGH*/
860
861	case 'h':
862	case 'r':
863	case 't':
864	case 'e':
865	case 'u':
866	case 'l':
867	    break;
868
869	case '&':
870	    if (slhs[0] == 0) {
871		seterror(ERR_NOSUBST);
872		return (en);
873	    }
874	    (void) Strcpy(lhsb, slhs);
875	    break;
876
877#ifdef notdef
878	case '~':
879	    if (lhsb[0] == 0)
880		goto badlhs;
881	    break;
882#endif
883
884	case 's':
885	    delim = getC(0);
886	    if (letter(delim) || Isdigit(delim) || any(" \t\n", delim)) {
887		unreadc(delim);
888		lhsb[0] = 0;
889		seterror(ERR_BADSUBST);
890		return (en);
891	    }
892	    cp = lhsb;
893	    for (;;) {
894		c = getC(0);
895		if (c == '\n') {
896		    unreadc(c);
897		    break;
898		}
899		if (c == delim)
900		    break;
901		if (cp > &lhsb[sizeof(lhsb) / sizeof(Char) - 2]) {
902		    lhsb[0] = 0;
903		    seterror(ERR_BADSUBST);
904		    return (en);
905		}
906		if (c == '\\') {
907		    c = getC(0);
908		    if (c != delim && c != '\\')
909			*cp++ = '\\';
910		}
911		*cp++ = (Char) c;
912	    }
913	    if (cp != lhsb)
914		*cp++ = 0;
915	    else if (lhsb[0] == 0) {
916		seterror(ERR_LHS);
917		return (en);
918	    }
919	    cp = rhsb;
920	    (void) Strcpy(orhsb, cp);
921	    for (;;) {
922		c = getC(0);
923		if (c == '\n') {
924		    unreadc(c);
925		    break;
926		}
927		if (c == delim)
928		    break;
929#ifdef notdef
930		if (c == '~') {
931		    if (&cp[Strlen(orhsb)] > &rhsb[sizeof(rhsb) /
932						   sizeof(Char) - 2])
933			goto toorhs;
934		    (void) Strcpy(cp, orhsb);
935		    cp = Strend(cp);
936		    continue;
937		}
938#endif
939		if (cp > &rhsb[sizeof(rhsb) / sizeof(Char) - 2]) {
940		    seterror(ERR_RHSLONG);
941		    return (en);
942		}
943		if (c == '\\') {
944		    c = getC(0);
945		    if (c != delim /* && c != '~' */ )
946			*cp++ = '\\';
947		}
948		*cp++ = (Char) c;
949	    }
950	    *cp++ = 0;
951	    break;
952
953	default:
954	    if (c == '\n')
955		unreadc(c);
956	    seterror(ERR_BADBANGMOD, c);
957	    return (en);
958	}
959	(void) Strcpy(slhs, lhsb);
960	if (exclc)
961	    en = dosub(sc, en, global);
962#ifndef COMPAT
963    }
964    while ((c = getC(0)) == ':');
965    unreadc(c);
966#endif /* COMPAT */
967    return (en);
968}
969
970/*
971 *
972 * From Beto Appleton (beto@aixwiz.austin.ibm.com)
973 *
974 * when using history substitution, and the variable
975 * 'history' is set to a value higher than 1000,
976 * the shell might either freeze (hang) or core-dump.
977 * We raise the limit to 50000000
978 */
979
980#define HIST_PURGE -50000000
981static struct wordent *
982dosub(sc, en, global)
983    int     sc;
984    struct wordent *en;
985    bool global;
986{
987    struct wordent lexi;
988    bool    didsub = 0, didone = 0;
989    struct wordent *hp = &lexi;
990    struct wordent *wdp;
991    int i = exclc;
992    struct Hist *hst;
993
994    wdp = hp;
995    while (--i >= 0) {
996	struct wordent *new =
997		(struct wordent *) xcalloc(1, sizeof *wdp);
998
999	new->word = 0;
1000	new->prev = wdp;
1001	new->next = hp;
1002	wdp->next = new;
1003	wdp = new;
1004	en = en->next;
1005	if (en->word) {
1006	    Char *tword, *otword;
1007
1008	    if ((global & 1) || didsub == 0) {
1009		tword = subword(en->word, sc, &didone);
1010		if (didone)
1011		    didsub = 1;
1012		if (global & 2) {
1013		    while (didone && tword != STRNULL) {
1014			otword = tword;
1015			tword = subword(otword, sc, &didone);
1016			if (Strcmp(tword, otword) == 0) {
1017			    xfree((ptr_t) otword);
1018			    break;
1019			}
1020			else
1021			    xfree((ptr_t) otword);
1022		    }
1023		}
1024	    }
1025	    else
1026		tword = Strsave(en->word);
1027	    wdp->word = tword;
1028	}
1029    }
1030    if (didsub == 0)
1031	seterror(ERR_MODFAIL);
1032    hp->prev = wdp;
1033    /*
1034     * ANSI mode HP/UX compiler chokes on
1035     * return &enthist(HIST_PURGE, &lexi, 0)->Hlex;
1036     */
1037    hst = enthist(HIST_PURGE, &lexi, 0, 0);
1038    return &(hst->Hlex);
1039}
1040
1041static Char *
1042subword(cp, type, adid)
1043    Char   *cp;
1044    int     type;
1045    bool   *adid;
1046{
1047    Char    wbuf[BUFSIZE];
1048    Char *wp, *mp, *np;
1049    int i;
1050
1051    *adid = 0;
1052    switch (type) {
1053
1054    case 'r':
1055    case 'e':
1056    case 'h':
1057    case 't':
1058    case 'q':
1059    case 'x':
1060    case 'u':
1061    case 'l':
1062	wp = domod(cp, type);
1063	if (wp == 0)
1064	    return (Strsave(cp));
1065	*adid = 1;
1066	return (wp);
1067
1068    default:
1069	wp = wbuf;
1070	i = BUFSIZE - 4;
1071	for (mp = cp; *mp; mp++)
1072	    if (matchs(mp, lhsb)) {
1073		for (np = cp; np < mp;)
1074		    *wp++ = *np++, --i;
1075		for (np = rhsb; *np; np++)
1076		    switch (*np) {
1077
1078		    case '\\':
1079			if (np[1] == '&')
1080			    np++;
1081			/* fall into ... */
1082
1083		    default:
1084			if (--i < 0) {
1085			    seterror(ERR_SUBOVFL);
1086			    return (STRNULL);
1087			}
1088			*wp++ = *np;
1089			continue;
1090
1091		    case '&':
1092			i -= Strlen(lhsb);
1093			if (i < 0) {
1094			    seterror(ERR_SUBOVFL);
1095			    return (STRNULL);
1096			}
1097			*wp = 0;
1098			(void) Strcat(wp, lhsb);
1099			wp = Strend(wp);
1100			continue;
1101		    }
1102		mp += Strlen(lhsb);
1103		i -= Strlen(mp);
1104		if (i < 0) {
1105		    seterror(ERR_SUBOVFL);
1106		    return (STRNULL);
1107		}
1108		*wp = 0;
1109		(void) Strcat(wp, mp);
1110		*adid = 1;
1111		return (Strsave(wbuf));
1112	    }
1113	return (Strsave(cp));
1114    }
1115}
1116
1117Char   *
1118domod(cp, type)
1119    Char   *cp;
1120    int     type;
1121{
1122    Char *wp, *xp;
1123    int c;
1124
1125    switch (type) {
1126
1127    case 'x':
1128    case 'q':
1129	wp = Strsave(cp);
1130	for (xp = wp; (c = *xp) != 0; xp++)
1131	    if ((c != ' ' && c != '\t') || type == 'q')
1132		*xp |= QUOTE;
1133	return (wp);
1134
1135    case 'l':
1136	wp = Strsave(cp);
1137	for (cp = wp; *cp; cp++)
1138	    if (Isupper(*cp)) {
1139		*cp = Tolower(*cp);
1140		return wp;
1141	    }
1142	return wp;
1143
1144    case 'u':
1145	wp = Strsave(cp);
1146	for (cp = wp; *cp; cp++)
1147	    if (Islower(*cp)) {
1148		*cp = Toupper(*cp);
1149		return wp;
1150	    }
1151	return wp;
1152
1153    case 'h':
1154    case 't':
1155	if (!any(short2str(cp), '/'))
1156	    return (type == 't' ? Strsave(cp) : 0);
1157	wp = Strend(cp);
1158	while (*--wp != '/')
1159	    continue;
1160	if (type == 'h')
1161	    xp = Strsave(cp), xp[wp - cp] = 0;
1162	else
1163	    xp = Strsave(wp + 1);
1164	return (xp);
1165
1166    case 'e':
1167    case 'r':
1168	wp = Strend(cp);
1169	for (wp--; wp >= cp && *wp != '/'; wp--)
1170	    if (*wp == '.') {
1171		if (type == 'e')
1172		    xp = Strsave(wp + 1);
1173		else
1174		    xp = Strsave(cp), xp[wp - cp] = 0;
1175		return (xp);
1176	    }
1177	return (Strsave(type == 'e' ? STRNULL : cp));
1178    default:
1179	break;
1180    }
1181    return (0);
1182}
1183
1184static int
1185matchs(str, pat)
1186    Char *str, *pat;
1187{
1188    while (*str && *pat && *str == *pat)
1189	str++, pat++;
1190    return (*pat == 0);
1191}
1192
1193static int
1194getsel(al, ar, dol)
1195    int *al, *ar;
1196    int     dol;
1197{
1198    int c = getC(0);
1199    int i;
1200    bool    first = *al < 0;
1201
1202    switch (c) {
1203
1204    case '%':
1205	if (quesarg == -1) {
1206	    seterror(ERR_BADBANGARG);
1207	    return (0);
1208	}
1209	if (*al < 0)
1210	    *al = quesarg;
1211	*ar = quesarg;
1212	break;
1213
1214    case '-':
1215	if (*al < 0) {
1216	    *al = 0;
1217	    *ar = dol - 1;
1218	    unreadc(c);
1219	}
1220	return (1);
1221
1222    case '^':
1223	if (*al < 0)
1224	    *al = 1;
1225	*ar = 1;
1226	break;
1227
1228    case '$':
1229	if (*al < 0)
1230	    *al = dol;
1231	*ar = dol;
1232	break;
1233
1234    case '*':
1235	if (*al < 0)
1236	    *al = 1;
1237	*ar = dol;
1238	if (*ar < *al) {
1239	    *ar = 0;
1240	    *al = 1;
1241	    return (1);
1242	}
1243	break;
1244
1245    default:
1246	if (Isdigit(c)) {
1247	    i = 0;
1248	    while (Isdigit(c)) {
1249		i = i * 10 + c - '0';
1250		c = getC(0);
1251	    }
1252	    if (i < 0)
1253		i = dol + 1;
1254	    if (*al < 0)
1255		*al = i;
1256	    *ar = i;
1257	}
1258	else if (*al < 0)
1259	    *al = 0, *ar = dol;
1260	else
1261	    *ar = dol - 1;
1262	unreadc(c);
1263	break;
1264    }
1265    if (first) {
1266	c = getC(0);
1267	unreadc(c);
1268	if (any("-$*", c))
1269	    return (1);
1270    }
1271    if (*al > *ar || *ar > dol) {
1272	seterror(ERR_BADBANGARG);
1273	return (0);
1274    }
1275    return (1);
1276
1277}
1278
1279static struct wordent *
1280gethent(sc)
1281    int     sc;
1282{
1283    struct Hist *hp;
1284    Char *np;
1285    int c;
1286    int     event;
1287    bool    back = 0;
1288
1289    c = sc == HISTSUB ? HIST : getC(0);
1290    if (c == HIST) {
1291	if (alhistp)
1292	    return (alhistp);
1293	event = eventno;
1294    }
1295    else
1296	switch (c) {
1297
1298	case ':':
1299	case '^':
1300	case '$':
1301	case '*':
1302	case '%':
1303	    ungetC(c);
1304	    if (lastev == eventno && alhistp)
1305		return (alhistp);
1306	    event = lastev;
1307	    break;
1308
1309	case '#':		/* !# is command being typed in (mrh) */
1310	    if (--hleft == 0) {
1311		seterror(ERR_HISTLOOP);
1312		return (0);
1313	    }
1314	    else
1315		return (&paraml);
1316	    /* NOTREACHED */
1317
1318	case '-':
1319	    back = 1;
1320	    c = getC(0);
1321	    /* FALLSTHROUGH */
1322
1323	default:
1324	    if (any("(=~", c)) {
1325		unreadc(c);
1326		ungetC(HIST);
1327		return (0);
1328	    }
1329	    np = lhsb;
1330	    event = 0;
1331	    while (!cmap(c, _ESC | _META | _QF | _QB) && !any("^*-%${}:#", c)) {
1332		if (event != -1 && Isdigit(c))
1333		    event = event * 10 + c - '0';
1334		else
1335		    event = -1;
1336		if (np < &lhsb[sizeof(lhsb) / sizeof(Char) - 2])
1337		    *np++ = (Char) c;
1338		c = getC(0);
1339	    }
1340	    unreadc(c);
1341	    if (np == lhsb) {
1342		ungetC(HIST);
1343		return (0);
1344	    }
1345	    *np++ = 0;
1346	    if (event != -1) {
1347		/*
1348		 * History had only digits
1349		 */
1350		if (back)
1351		    event = eventno + (alhistp == 0) - (event ? event : 0);
1352		break;
1353	    }
1354	    if (back) {
1355		event = sizeof(lhsb) / sizeof(lhsb[0]);
1356		np = &lhsb[--event];
1357		*np-- = '\0';
1358		for (event--; np > lhsb; *np-- = lhsb[--event])
1359		    continue;
1360		*np = '-';
1361	    }
1362	    hp = findev(lhsb, 0);
1363	    if (hp)
1364		lastev = hp->Hnum;
1365	    return (&hp->Hlex);
1366
1367	case '?':
1368	    np = lhsb;
1369	    for (;;) {
1370		c = getC(0);
1371		if (c == '\n') {
1372		    unreadc(c);
1373		    break;
1374		}
1375		if (c == '?')
1376		    break;
1377		if (np < &lhsb[sizeof(lhsb) / sizeof(Char) - 2])
1378		    *np++ = (Char) c;
1379	    }
1380	    if (np == lhsb) {
1381		if (lhsb[0] == 0) {
1382		    seterror(ERR_NOSEARCH);
1383		    return (0);
1384		}
1385	    }
1386	    else
1387		*np++ = 0;
1388	    hp = findev(lhsb, 1);
1389	    if (hp)
1390		lastev = hp->Hnum;
1391	    return (&hp->Hlex);
1392	}
1393
1394    for (hp = Histlist.Hnext; hp; hp = hp->Hnext)
1395	if (hp->Hnum == event) {
1396	    hp->Href = eventno;
1397	    lastev = hp->Hnum;
1398	    return (&hp->Hlex);
1399	}
1400    np = putn(event);
1401    seterror(ERR_NOEVENT, short2str(np));
1402    return (0);
1403}
1404
1405static struct Hist *
1406findev(cp, anyarg)
1407    Char   *cp;
1408    bool    anyarg;
1409{
1410    struct Hist *hp;
1411
1412    for (hp = Histlist.Hnext; hp; hp = hp->Hnext) {
1413	Char   *dp;
1414	Char *p, *q;
1415	struct wordent *lp = hp->Hlex.next;
1416	int     argno = 0;
1417
1418	/*
1419	 * The entries added by alias substitution don't have a newline but do
1420	 * have a negative event number. Savehist() trims off these entries,
1421	 * but it happens before alias expansion, too early to delete those
1422	 * from the previous command.
1423	 */
1424	if (hp->Hnum < 0)
1425	    continue;
1426	if (lp->word[0] == '\n')
1427	    continue;
1428	if (!anyarg) {
1429	    p = cp;
1430	    q = lp->word;
1431	    do
1432		if (!*p)
1433		    return (hp);
1434	    while (*p++ == *q++);
1435	    continue;
1436	}
1437	do {
1438	    for (dp = lp->word; *dp; dp++) {
1439		p = cp;
1440		q = dp;
1441		do
1442		    if (!*p) {
1443			quesarg = argno;
1444			return (hp);
1445		    }
1446		while (*p++ == *q++);
1447	    }
1448	    lp = lp->next;
1449	    argno++;
1450	} while (lp->word[0] != '\n');
1451    }
1452    seterror(ERR_NOEVENT, short2str(cp));
1453    return (0);
1454}
1455
1456
1457static void
1458setexclp(cp)
1459    Char *cp;
1460{
1461    if (cp && cp[0] == '\n')
1462	return;
1463    exclp = cp;
1464}
1465
1466void
1467unreadc(c)
1468    int    c;
1469{
1470    peekread = (Char) c;
1471}
1472
1473int
1474readc(wanteof)
1475    bool    wanteof;
1476{
1477    int c;
1478    static  int sincereal;	/* Number of real EOFs we've seen */
1479    Char *ptr;			/* For STRignoreeof */
1480    int numeof = 0;		/* Value of STRignoreeof */
1481
1482#ifdef DEBUG_INP
1483    xprintf("readc\n");
1484#endif
1485    if ((c = peekread) != 0) {
1486	peekread = 0;
1487	return (c);
1488    }
1489
1490    /* Compute the value of EOFs */
1491    if ((ptr = varval(STRignoreeof)) != STRNULL) {
1492	while (*ptr) {
1493	    if (!Isdigit(*ptr)) {
1494		numeof = 0;
1495		break;
1496	    }
1497	    numeof = numeof * 10 + *ptr++ - '0';
1498	}
1499	if (numeof != 0)
1500	    numeof++;
1501    }
1502    if (numeof < 0) numeof = 26;	/* Sanity check */
1503
1504top:
1505    aret = TCSH_F_SEEK;
1506    if (alvecp) {
1507	arun = 1;
1508#ifdef DEBUG_INP
1509	xprintf("alvecp %c\n", *alvecp & 0xff);
1510#endif
1511	aret = TCSH_A_SEEK;
1512	if ((c = *alvecp++) != 0)
1513	    return (c);
1514	if (alvec && *alvec) {
1515		alvecp = *alvec++;
1516		return (' ');
1517	}
1518	else {
1519	    alvecp = NULL;
1520	    aret = TCSH_F_SEEK;
1521	    return('\n');
1522	}
1523    }
1524    if (alvec) {
1525	arun = 1;
1526	if ((alvecp = *alvec) != 0) {
1527	    alvec++;
1528	    goto top;
1529	}
1530	/* Infinite source! */
1531	return ('\n');
1532    }
1533    arun = 0;
1534    if (evalp) {
1535	aret = TCSH_E_SEEK;
1536	if ((c = *evalp++) != 0)
1537	    return (c);
1538	if (evalvec && *evalvec) {
1539	    evalp = *evalvec++;
1540	    return (' ');
1541	}
1542	aret = TCSH_F_SEEK;
1543	evalp = 0;
1544    }
1545    if (evalvec) {
1546	if (evalvec == INVPPTR) {
1547	    doneinp = 1;
1548	    reset();
1549	}
1550	if ((evalp = *evalvec) != 0) {
1551	    evalvec++;
1552	    goto top;
1553	}
1554	evalvec = INVPPTR;
1555	return ('\n');
1556    }
1557    do {
1558	if (arginp == INVPTR || onelflg == 1) {
1559	    if (wanteof)
1560		return (-1);
1561	    exitstat();
1562	}
1563	if (arginp) {
1564	    if ((c = *arginp++) == 0) {
1565		arginp = INVPTR;
1566		return ('\n');
1567	    }
1568	    return (c);
1569	}
1570#ifdef BSDJOBS
1571reread:
1572#endif /* BSDJOBS */
1573	c = bgetc();
1574	if (c < 0) {
1575#ifndef WINNT_NATIVE
1576# ifndef POSIX
1577#  ifdef TERMIO
1578	    struct termio tty;
1579#  else /* SGTTYB */
1580	    struct sgttyb tty;
1581#  endif /* TERMIO */
1582# else /* POSIX */
1583	    struct termios tty;
1584# endif /* POSIX */
1585#endif /* !WINNT_NATIVE */
1586	    if (wanteof)
1587		return (-1);
1588	    /* was isatty but raw with ignoreeof yields problems */
1589#ifndef WINNT_NATIVE
1590# ifndef POSIX
1591#  ifdef TERMIO
1592	    if (ioctl(SHIN, TCGETA, (ioctl_t) & tty) == 0 &&
1593		(tty.c_lflag & ICANON))
1594#  else /* GSTTYB */
1595	    if (ioctl(SHIN, TIOCGETP, (ioctl_t) & tty) == 0 &&
1596		(tty.sg_flags & RAW) == 0)
1597#  endif /* TERMIO */
1598# else /* POSIX */
1599	    if (tcgetattr(SHIN, &tty) == 0 &&
1600		(tty.c_lflag & ICANON))
1601# endif /* POSIX */
1602#else /* WINNT_NATIVE */
1603	    if (isatty(SHIN))
1604#endif /* !WINNT_NATIVE */
1605	    {
1606#ifdef BSDJOBS
1607		int     ctpgrp;
1608#endif /* BSDJOBS */
1609
1610		if (numeof != 0 && ++sincereal >= numeof)	/* Too many EOFs?  Bye! */
1611		    goto oops;
1612#ifdef BSDJOBS
1613		if (tpgrp != -1 &&
1614		    (ctpgrp = tcgetpgrp(FSHTTY)) != -1 &&
1615		    tpgrp != ctpgrp) {
1616		    (void) tcsetpgrp(FSHTTY, tpgrp);
1617# ifdef _SEQUENT_
1618		    if (ctpgrp)
1619# endif /* _SEQUENT */
1620		    (void) killpg((pid_t) ctpgrp, SIGHUP);
1621# ifdef notdef
1622		    /*
1623		     * With the walking process group fix, this message
1624		     * is now obsolete. As the foreground process group
1625		     * changes, the shell needs to adjust. Well too bad.
1626		     */
1627		    xprintf(CGETS(16, 1, "Reset tty pgrp from %d to %d\n"),
1628			    ctpgrp, tpgrp);
1629# endif /* notdef */
1630		    goto reread;
1631		}
1632#endif /* BSDJOBS */
1633		/* What follows is complicated EOF handling -- sterling@netcom.com */
1634		/* First, we check to see if we have ignoreeof set */
1635		if (adrof(STRignoreeof)) {
1636			/* If so, we check for any stopped jobs only on the first EOF */
1637			if ((sincereal == 1) && (chkstop == 0)) {
1638				panystop(1);
1639			}
1640		} else {
1641			/* If we don't have ignoreeof set, always check for stopped jobs */
1642			if (chkstop == 0) {
1643				panystop(1);
1644			}
1645		}
1646		/* At this point, if there were stopped jobs, we would have already
1647		 * called reset().  If we got this far, assume we can print an
1648		 * exit/logout message if we ignoreeof, or just exit.
1649		 */
1650		if (adrof(STRignoreeof)) {
1651			/* If so, tell the user to use exit or logout */
1652		    if (loginsh) {
1653				xprintf(CGETS(16, 2,
1654					"\nUse \"logout\" to logout.\n"));
1655		   	} else {
1656				xprintf(CGETS(16, 3,
1657					"\nUse \"exit\" to leave %s.\n"),
1658					progname);
1659			}
1660			reset();
1661		} else {
1662			/* If we don't have ignoreeof set, just fall through */
1663			;	/* EMPTY */
1664		}
1665	    }
1666    oops:
1667	    doneinp = 1;
1668	    reset();
1669	}
1670	sincereal = 0;
1671	if (c == '\n' && onelflg)
1672	    onelflg--;
1673    } while (c == 0);
1674    if (histlinep < histline + BUFSIZE)
1675	*histlinep++ = (Char) c;
1676    return (c);
1677}
1678
1679static void
1680balloc(buf)
1681    int buf;
1682{
1683    Char **nfbuf;
1684
1685    while (buf >= fblocks) {
1686	nfbuf = (Char **) xcalloc((size_t) (fblocks + 2),
1687			  sizeof(Char **));
1688	if (fbuf) {
1689	    (void) blkcpy(nfbuf, fbuf);
1690	    xfree((ptr_t) fbuf);
1691	}
1692	fbuf = nfbuf;
1693	fbuf[fblocks] = (Char *) xcalloc(BUFSIZE, sizeof(Char));
1694	fblocks++;
1695    }
1696}
1697
1698static int
1699bgetc()
1700{
1701    int c, off, buf;
1702    int numleft = 0, roomleft;
1703    char    tbuf[BUFSIZE + 1];
1704
1705    if (cantell) {
1706	if (fseekp < fbobp || fseekp > feobp) {
1707	    fbobp = feobp = fseekp;
1708	    (void) lseek(SHIN, fseekp, L_SET);
1709	}
1710	if (fseekp == feobp) {
1711	    int     i;
1712
1713	    fbobp = feobp;
1714	    do
1715		c = read(SHIN, tbuf, BUFSIZE);
1716	    while (c < 0 && errno == EINTR);
1717#ifdef convex
1718	    if (c < 0)
1719		stderror(ERR_SYSTEM, progname, strerror(errno));
1720#endif /* convex */
1721	    if (c <= 0)
1722		return (-1);
1723	    for (i = 0; i < c; i++)
1724		fbuf[0][i] = (unsigned char) tbuf[i];
1725	    feobp += c;
1726	}
1727#ifndef WINNT_NATIVE
1728	c = fbuf[0][fseekp - fbobp];
1729	fseekp++;
1730#else
1731	do {
1732	    c = fbuf[0][fseekp - fbobp];
1733	    fseekp++;
1734	} while(c == '\r');
1735#endif /* !WINNT_NATIVE */
1736	return (c);
1737    }
1738
1739    while (fseekp >= feobp) {
1740	if ((editing
1741#if defined(FILEC) && defined(TIOCSTI)
1742	    || filec
1743#endif /* FILEC && TIOCSTI */
1744	    ) && intty) {		/* then use twenex routine */
1745	    fseekp = feobp;		/* where else? */
1746#if defined(FILEC) && defined(TIOCSTI)
1747	    if (!editing)
1748		c = numleft = tenex(InputBuf, BUFSIZE);
1749	    else
1750#endif /* FILEC && TIOCSTI */
1751	    c = numleft = Inputl();	/* PWP: get a line */
1752	    while (numleft > 0) {
1753		off = (int) feobp % BUFSIZE;
1754		buf = (int) feobp / BUFSIZE;
1755		balloc(buf);
1756		roomleft = BUFSIZE - off;
1757		if (roomleft > numleft)
1758		    roomleft = numleft;
1759		(void) memmove((ptr_t) (fbuf[buf] + off),
1760		    (ptr_t) (InputBuf + c - numleft),
1761		    (size_t) (roomleft * sizeof(Char)));
1762		numleft -= roomleft;
1763		feobp += roomleft;
1764	    }
1765	} else {
1766	    off = (int) feobp % BUFSIZE;
1767	    buf = (int) feobp / BUFSIZE;
1768	    balloc(buf);
1769	    roomleft = BUFSIZE - off;
1770	    c = read(SHIN, tbuf, (size_t) roomleft);
1771	    if (c > 0) {
1772		int     i;
1773		Char   *ptr = fbuf[buf] + off;
1774
1775		for (i = 0; i < c; i++)
1776		    ptr[i] = (unsigned char) tbuf[i];
1777		feobp += c;
1778	    }
1779	}
1780	if (c == 0 || (c < 0 && fixio(SHIN, errno) == -1))
1781	    return (-1);
1782    }
1783#ifndef WINNT_NATIVE
1784    c = fbuf[(int) fseekp / BUFSIZE][(int) fseekp % BUFSIZE];
1785    fseekp++;
1786#else
1787    do {
1788	c = fbuf[(int) fseekp / BUFSIZE][(int) fseekp % BUFSIZE];
1789	fseekp++;
1790    } while(c == '\r');
1791#endif /* !WINNT_NATIVE */
1792    return (c);
1793}
1794
1795static void
1796bfree()
1797{
1798    int sb, i;
1799
1800    if (cantell)
1801	return;
1802    if (whyles)
1803	return;
1804    sb = (int) (fseekp - 1) / BUFSIZE;
1805    if (sb > 0) {
1806	for (i = 0; i < sb; i++)
1807	    xfree((ptr_t) fbuf[i]);
1808	(void) blkcpy(fbuf, &fbuf[sb]);
1809	fseekp -= BUFSIZE * sb;
1810	feobp -= BUFSIZE * sb;
1811	fblocks -= sb;
1812    }
1813}
1814
1815void
1816bseek(l)
1817    struct Ain   *l;
1818{
1819    switch (aret = l->type) {
1820    case TCSH_E_SEEK:
1821	evalvec = l->a_seek;
1822	evalp = l->c_seek;
1823#ifdef DEBUG_SEEK
1824	xprintf(CGETS(16, 4, "seek to eval %x %x\n"), evalvec, evalp);
1825#endif
1826	return;
1827    case TCSH_A_SEEK:
1828	alvec = l->a_seek;
1829	alvecp = l->c_seek;
1830#ifdef DEBUG_SEEK
1831	xprintf(CGETS(16, 5, "seek to alias %x %x\n"), alvec, alvecp);
1832#endif
1833	return;
1834    case TCSH_F_SEEK:
1835#ifdef DEBUG_SEEK
1836	xprintf(CGETS(16, 6, "seek to file %x\n"), fseekp);
1837#endif
1838	fseekp = l->f_seek;
1839	return;
1840    default:
1841	xprintf(CGETS(16, 7, "Bad seek type %d\n"), aret);
1842	abort();
1843    }
1844}
1845
1846/* any similarity to bell telephone is purely accidental */
1847void
1848btell(l)
1849struct Ain *l;
1850{
1851    switch (l->type = aret) {
1852    case TCSH_E_SEEK:
1853	l->a_seek = evalvec;
1854	l->c_seek = evalp;
1855#ifdef DEBUG_SEEK
1856	xprintf(CGETS(16, 8, "tell eval %x %x\n"), evalvec, evalp);
1857#endif
1858	return;
1859    case TCSH_A_SEEK:
1860	l->a_seek = alvec;
1861	l->c_seek = alvecp;
1862#ifdef DEBUG_SEEK
1863	xprintf(CGETS(16, 9, "tell alias %x %x\n"), alvec, alvecp);
1864#endif
1865	return;
1866    case TCSH_F_SEEK:
1867	/*SUPPRESS 112*/
1868	l->f_seek = fseekp;
1869	l->a_seek = NULL;
1870#ifdef DEBUG_SEEK
1871	xprintf(CGETS(16, 10, "tell file %x\n"), fseekp);
1872#endif
1873	return;
1874    default:
1875	xprintf(CGETS(16, 7, "Bad seek type %d\n"), aret);
1876	abort();
1877    }
1878}
1879
1880void
1881btoeof()
1882{
1883    (void) lseek(SHIN, (off_t) 0, L_XTND);
1884    aret = TCSH_F_SEEK;
1885    fseekp = feobp;
1886    alvec = NULL;
1887    alvecp = NULL;
1888    evalvec = NULL;
1889    evalp = NULL;
1890    wfree();
1891    bfree();
1892}
1893
1894void
1895settell()
1896{
1897    off_t x;
1898    cantell = 0;
1899    if (arginp || onelflg || intty)
1900	return;
1901    if ((x = lseek(SHIN, (off_t) 0, L_INCR)) == -1)
1902	return;
1903    fbuf = (Char **) xcalloc(2, sizeof(Char **));
1904    fblocks = 1;
1905    fbuf[0] = (Char *) xcalloc(BUFSIZE, sizeof(Char));
1906    fseekp = fbobp = feobp = x;
1907    cantell = 1;
1908}
1909