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