[unix-history] / usr / src / cmd / osh.c

/*
 */

#include <setjmp.h>
#define	INTR	2
#define	QUIT	3
#define LINSIZ 1000
#define ARGSIZ 50
#define TRESIZ 100

#define QUOTE 0200
#define FAND 1
#define FCAT 2
#define FPIN 4
#define FPOU 8
#define FPAR 16
#define FINT 32
#define FPRS 64
#define TCOM 1
#define TPAR 2
#define TFIL 3
#define TLST 4
#define DTYP 0
#define DLEF 1
#define DRIT 2
#define DFLG 3
#define DSPR 4
#define DCOM 5
#define	ENOMEM	12
#define	ENOEXEC 8

int errval;
char	*dolp;
char	pidp[6];
char	**dolv;
jmp_buf	jmpbuf;
int	dolc;
char	*promp;
char	*linep;
char	*elinep;
char	**argp;
char	**eargp;
int	*treep;
int	*treeend;
char	peekc;
char	gflg;
char	error;
char	uid;
char	setintr;
char	*arginp;
int	onelflg;
int	stoperr;

#define	NSIG	16
char	*mesg[NSIG] {
	0,
	"Hangup",
	0,
	"Quit",
	"Illegal instruction",
	"Trace/BPT trap",
	"IOT trap",
	"EMT trap",
	"Floating exception",
	"Killed",
	"Bus error",
	"Memory fault",
	"Bad system call",
	0,
	"Alarm clock",
	"Terminated",
};

char	line[LINSIZ];
char	*args[ARGSIZ];
int	trebuf[TRESIZ];

main(c, av)
int c;
char **av;
{
	register f;
	register char *acname, **v;

	for(f=3; f<15; f++)
		close(f);
	dolc = getpid();
	for(f=4; f>=0; f--) {
		dolc = dolc/10;
		pidp[f] = dolc%10 + '0';
	}
	v = av;
	acname = "<none>";
	promp = "% ";
	if((uid = getuid()) == 0)
		promp = "# ";
	if(c>1 && v[1][0]=='-' && v[1][1]=='e') {
		++stoperr;
		v[1] = v[0];
		++v;
		--c;
	}
	if(c > 1) {
		promp = 0;
		if (*v[1]=='-') {
			**v = '-';
			if (v[1][1]=='c' && c>2)
				arginp = v[2];
			else if (v[1][1]=='t')
				onelflg = 2;
		} else {
			close(0);
			f = open(v[1], 0);
			if(f < 0) {
				prs(v[1]);
				err(": cannot open",255);
			}
		}
	}
	if(**v == '-') {
		signal(QUIT, 1);
		f = signal(INTR, 1);
		if ((arginp==0&&onelflg==0) || (f&01)==0)
			setintr++;
	}
	dolv = v+1;
	dolc = c-1;

loop:
	if(promp != 0)
		prs(promp);
	peekc = getc();
	main1();
	goto loop;
}

main1()
{
	register char  *cp;
	register *t;

	argp = args;
	eargp = args+ARGSIZ-5;
	linep = line;
	elinep = line+LINSIZ-5;
	error = 0;
	gflg = 0;
	do {
		cp = linep;
		word();
	} while(*cp != '\n');
	treep = trebuf;
	treeend = &trebuf[TRESIZ];
	if(gflg == 0) {
		if(error == 0) {
			setjmp(jmpbuf);
			if (error)
				return;
			t = syntax(args, argp);
		}
		if(error != 0)
			err("syntax error",255); else
			execute(t);
	}
}

word()
{
	register char c, c1;

	*argp++ = linep;

loop:
	switch(c = getc()) {

	case ' ':
	case '\t':
		goto loop;

	case '\'':
	case '"':
		c1 = c;
		while((c=readc()) != c1) {
			if(c == '\n') {
				error++;
				peekc = c;
				return;
			}
			*linep++ = c|QUOTE;
		}
		goto pack;

	case '&':
	case ';':
	case '<':
	case '>':
	case '(':
	case ')':
	case '|':
	case '^':
	case '\n':
		*linep++ = c;
		*linep++ = '\0';
		return;
	}

	peekc = c;

pack:
	for(;;) {
		c = getc();
		if(any(c, " '\"\t;&<>()|^\n")) {
			peekc = c;
			if(any(c, "\"'"))
				goto loop;
			*linep++ = '\0';
			return;
		}
		*linep++ = c;
	}
}

tree(n)
int n;
{
	register *t;

	t = treep;
	treep =+ n;
	if (treep>treeend) {
		prs("Command line overflow\n");
		error++;
		longjmp(jmpbuf, 1);
	}
	return(t);
}

getc()
{
	register char c;

	if(peekc) {
		c = peekc;
		peekc = 0;
		return(c);
	}
	if(argp > eargp) {
		argp =- 10;
		while((c=getc()) != '\n');
		argp =+ 10;
		err("Too many args",255);
		gflg++;
		return(c);
	}
	if(linep > elinep) {
		linep =- 10;
		while((c=getc()) != '\n');
		linep =+ 10;
		err("Too many characters",255);
		gflg++;
		return(c);
	}
getd:
	if(dolp) {
		c = *dolp++;
		if(c != '\0')
			return(c);
		dolp = 0;
	}
	c = readc();
	if(c == '\\') {
		c = readc();
		if(c == '\n')
			return(' ');
		return(c|QUOTE);
	}
	if(c == '$') {
		c = readc();
		if(c>='0' && c<='9') {
			if(c-'0' < dolc)
				dolp = dolv[c-'0'];
			goto getd;
		}
		if(c == '$') {
			dolp = pidp;
			goto getd;
		}
	}
	return(c&0177);
}

readc()
{
	int rdstat;
	char cc;
	register c;

	if (arginp) {
		if (arginp == 1)
			exit(errval);
		if ((c = *arginp++) == 0) {
			arginp = 1;
			c = '\n';
		}
		return(c);
	}
	if (onelflg==1)
		exit(255);
	if((rdstat = read(0, &cc, 1)) != 1)
		if(rdstat==0) exit(errval); /* end of file*/
		else exit(255); /* error */
	if (cc=='\n' && onelflg)
		onelflg--;
	return(cc);
}

/*
 * syntax
 *	empty
 *	syn1
 */

syntax(p1, p2)
char **p1, **p2;
{

	while(p1 != p2) {
		if(any(**p1, ";&\n"))
			p1++; else
			return(syn1(p1, p2));
	}
	return(0);
}

/*
 * syn1
 *	syn2
 *	syn2 & syntax
 *	syn2 ; syntax
 */

syn1(p1, p2)
char **p1, **p2;
{
	register char **p;
	register *t, *t1;
	int l;

	l = 0;
	for(p=p1; p!=p2; p++)
	switch(**p) {

	case '(':
		l++;
		continue;

	case ')':
		l--;
		if(l < 0)
			error++;
		continue;

	case '&':
	case ';':
	case '\n':
		if(l == 0) {
			l = **p;
			t = tree(4);
			t[DTYP] = TLST;
			t[DLEF] = syn2(p1, p);
			t[DFLG] = 0;
			if(l == '&') {
				t1 = t[DLEF];
				t1[DFLG] =| FAND|FPRS|FINT;
			}
			t[DRIT] = syntax(p+1, p2);
			return(t);
		}
	}
	if(l == 0)
		return(syn2(p1, p2));
	error++;
	return(0);
}

/*
 * syn2
 *	syn3
 *	syn3 | syn2
 */

syn2(p1, p2)
char **p1, **p2;
{
	register char **p;
	register int l, *t;

	l = 0;
	for(p=p1; p!=p2; p++)
	switch(**p) {

	case '(':
		l++;
		continue;

	case ')':
		l--;
		continue;

	case '|':
	case '^':
		if(l == 0) {
			t = tree(4);
			t[DTYP] = TFIL;
			t[DLEF] = syn3(p1, p);
			t[DRIT] = syn2(p+1, p2);
			t[DFLG] = 0;
			return(t);
		}
	}
	return(syn3(p1, p2));
}

/*
 * syn3
 *	( syn1 ) [ < in  ] [ > out ]
 *	word word* [ < in ] [ > out ]
 */

syn3(p1, p2)
char **p1, **p2;
{
	register char **p;
	char **lp, **rp;
	register *t;
	int n, l, i, o, c, flg;

	flg = 0;
	if(**p2 == ')')
		flg =| FPAR;
	lp = 0;
	rp = 0;
	i = 0;
	o = 0;
	n = 0;
	l = 0;
	for(p=p1; p!=p2; p++)
	switch(c = **p) {

	case '(':
		if(l == 0) {
			if(lp != 0)
				error++;
			lp = p+1;
		}
		l++;
		continue;

	case ')':
		l--;
		if(l == 0)
			rp = p;
		continue;

	case '>':
		p++;
		if(p!=p2 && **p=='>')
			flg =| FCAT; else
			p--;

	case '<':
		if(l == 0) {
			p++;
			if(p == p2) {
				error++;
				p--;
			}
			if(any(**p, "<>("))
				error++;
			if(c == '<') {
				if(i != 0)
					error++;
				i = *p;
				continue;
			}
			if(o != 0)
				error++;
			o = *p;
		}
		continue;

	default:
		if(l == 0)
			p1[n++] = *p;
	}
	if(lp != 0) {
		if(n != 0)
			error++;
		t = tree(5);
		t[DTYP] = TPAR;
		t[DSPR] = syn1(lp, rp);
		goto out;
	}
	if(n == 0)
		error++;
	p1[n++] = 0;
	t = tree(n+5);
	t[DTYP] = TCOM;
	for(l=0; l<n; l++)
		t[l+DCOM] = p1[l];
out:
	t[DFLG] = flg;
	t[DLEF] = i;
	t[DRIT] = o;
	return(t);
}

scan(at, f)
int *at;
int (*f)();
{
	register char *p, c;
	register *t;

	t = at+DCOM;
	while(p = *t++)
		while(c = *p)
			*p++ = (*f)(c);
}

tglob(c)
int c;
{

	if(any(c, "[?*"))
		gflg = 1;
	return(c);
}

trim(c)
int c;
{

	return(c&0177);
}

execute(t, pf1, pf2)
int *t, *pf1, *pf2;
{
	int i, f, pv[2];
	register *t1;
	register char *cp1, *cp2;
	extern errno;

	if(t != 0)
	switch(t[DTYP]) {

	case TCOM:
		cp1 = t[DCOM];
		if(equal(cp1, "chdir")) {
			if(t[DCOM+1] != 0) {
				if(chdir(t[DCOM+1]) < 0)
					err("chdir: bad directory",255);
			} else
				err("chdir: arg count",255);
			return;
		}
		if(equal(cp1, "shift")) {
			if(dolc < 1) {
				prs("shift: no args\n");
				return;
			}
			dolv[1] = dolv[0];
			dolv++;
			dolc--;
			return;
		}
		if(equal(cp1, "login")) {
			if(promp != 0) {
				execv("/bin/login", t+DCOM);
			}
			prs("login: cannot execute\n");
			return;
		}
		if(equal(cp1, "newgrp")) {
			if(promp != 0) {
				execv("/bin/newgrp", t+DCOM);
			}
			prs("newgrp: cannot execute\n");
			return;
		}
		if(equal(cp1, "wait")) {
			pwait(-1, 0);
			return;
		}
		if(equal(cp1, ":"))
			return;

	case TPAR:
		f = t[DFLG];
		i = 0;
		if((f&FPAR) == 0)
			i = fork();
		if(i == -1) {
			err("try again",255);
			return;
		}
		if(i != 0) {
			if((f&FPIN) != 0) {
				close(pf1[0]);
				close(pf1[1]);
			}
			if((f&FPRS) != 0) {
				prn(i);
				prs("\n");
			}
			if((f&FAND) != 0)
				return;
			if((f&FPOU) == 0)
				pwait(i, t);
			return;
		}
		if(t[DLEF] != 0) {
			close(0);
			i = open(t[DLEF], 0);
			if(i < 0) {
				prs(t[DLEF]);
				err(": cannot open",255);
				exit(255);
			}
		}
		if(t[DRIT] != 0) {
			if((f&FCAT) != 0) {
				i = open(t[DRIT], 1);
				if(i >= 0) {
					lseek(i, 0L, 2);
					goto f1;
				}
			}
			i = creat(t[DRIT], 0666);
			if(i < 0) {
				prs(t[DRIT]);
				err(": cannot create",255);
				exit(255);
			}
		f1:
			close(1);
			dup(i);
			close(i);
		}
		if((f&FPIN) != 0) {
			close(0);
			dup(pf1[0]);
			close(pf1[0]);
			close(pf1[1]);
		}
		if((f&FPOU) != 0) {
			close(1);
			dup(pf2[1]);
			close(pf2[0]);
			close(pf2[1]);
		}
		if((f&FINT)!=0 && t[DLEF]==0 && (f&FPIN)==0) {
			close(0);
			open("/dev/null", 0);
		}
		if((f&FINT) == 0 && setintr) {
			signal(INTR, 0);
			signal(QUIT, 0);
		}
		if(t[DTYP] == TPAR) {
			if(t1 = t[DSPR])
				t1[DFLG] =| f&FINT;
			execute(t1);
			exit(255);
		}
		gflg = 0;
		scan(t, tglob);
		if(gflg) {
			t[DSPR] = "/etc/glob";
			execv(t[DSPR], t+DSPR);
			prs("glob: cannot execute\n");
			exit(255);
		}
		scan(t, trim);
		*linep = 0;
		texec(t[DCOM], t);
		cp1 = linep;
		cp2 = "/usr/bin/";
		while(*cp1 = *cp2++)
			cp1++;
		cp2 = t[DCOM];
		while(*cp1++ = *cp2++);
		texec(linep+4, t);
		texec(linep, t);
		prs(t[DCOM]);
		err(": not found",255);
		exit(255);

	case TFIL:
		f = t[DFLG];
		pipe(pv);
		t1 = t[DLEF];
		t1[DFLG] =| FPOU | (f&(FPIN|FINT|FPRS));
		execute(t1, pf1, pv);
		t1 = t[DRIT];
		t1[DFLG] =| FPIN | (f&(FPOU|FINT|FAND|FPRS));
		execute(t1, pv, pf2);
		return;

	case TLST:
		f = t[DFLG]&FINT;
		if(t1 = t[DLEF])
			t1[DFLG] =| f;
		execute(t1);
		if(t1 = t[DRIT])
			t1[DFLG] =| f;
		execute(t1);
		return;

	}
}

texec(f, at)
int *at;
{
	extern errno;
	register int *t;

	t = at;
	execv(f, t+DCOM);
	if (errno==ENOEXEC) {
		if (*linep)
			t[DCOM] = linep;
		t[DSPR] = "/usr/bin/osh";
		execv(t[DSPR], t+DSPR);
		prs("No shell!\n");
		exit(255);
	}
	if (errno==ENOMEM) {
		prs(t[DCOM]);
		err(": too large",255);
		exit(255);
	}
}

err(s, exitno)
char *s;
int exitno;
{

	prs(s);
	prs("\n");
	if(promp == 0) {
		lseek(0, 0L, 2);
		exit(exitno);
	}
}

prs(as)
char *as;
{
	register char *s;

	s = as;
	while(*s)
		putc(*s++);
}

putc(c)
{
	char cc;

	cc = c;
	write(2, &cc, 1);
}

prn(n)
int n;
{
	register a;

	if (a = n/10)
		prn(a);
	putc(n%10 + '0');
}

any(c, as)
int c;
char *as;
{
	register char *s;

	s = as;
	while(*s)
		if(*s++ == c)
			return(1);
	return(0);
}

equal(as1, as2)
char *as1, *as2;
{
	register char *s1, *s2;

	s1 = as1;
	s2 = as2;
	while(*s1++ == *s2)
		if(*s2++ == '\0')
			return(1);
	return(0);
}

pwait(i, t)
int i, *t;
{
	register p, e;
	int s;

	if(i != 0)
	for(;;) {
		p = wait(&s);
		if(p == -1)
			break;
		e = s&0177;
		if (e>=NSIG || mesg[e]) {
			if(p != i) {
				prn(p);
				prs(": ");
			}
			if (e < NSIG)
				prs(mesg[e]);
			else {
				prs("Signal ");
				prn(e);
			}
			if(s&0200)
				prs(" -- Core dumped");
		}
		if (e || s&&stoperr)
			err("", (s>>8)|e );
		errval =| (s>>8);
	}
}
Commit	Line	Data
88f62f26 KT	1	/*
	2	*/
	3
	4	#include <setjmp.h>
	5	#define INTR 2
	6	#define QUIT 3
	7	#define LINSIZ 1000
	8	#define ARGSIZ 50
	9	#define TRESIZ 100
	10
	11	#define QUOTE 0200
	12	#define FAND 1
	13	#define FCAT 2
	14	#define FPIN 4
	15	#define FPOU 8
	16	#define FPAR 16
	17	#define FINT 32
	18	#define FPRS 64
	19	#define TCOM 1
	20	#define TPAR 2
	21	#define TFIL 3
	22	#define TLST 4
	23	#define DTYP 0
	24	#define DLEF 1
	25	#define DRIT 2
	26	#define DFLG 3
	27	#define DSPR 4
	28	#define DCOM 5
	29	#define ENOMEM 12
	30	#define ENOEXEC 8
	31
	32	int errval;
	33	char *dolp;
	34	char pidp[6];
	35	char **dolv;
	36	jmp_buf jmpbuf;
	37	int dolc;
	38	char *promp;
	39	char *linep;
	40	char *elinep;
	41	char **argp;
	42	char **eargp;
	43	int *treep;
	44	int *treeend;
	45	char peekc;
	46	char gflg;
	47	char error;
	48	char uid;
	49	char setintr;
	50	char *arginp;
	51	int onelflg;
	52	int stoperr;
	53
	54	#define NSIG 16
	55	char *mesg[NSIG] {
	56	0,
	57	"Hangup",
	58	0,
	59	"Quit",
	60	"Illegal instruction",
	61	"Trace/BPT trap",
	62	"IOT trap",
	63	"EMT trap",
	64	"Floating exception",
65	"Killed",
66	"Bus error",
67	"Memory fault",
68	"Bad system call",
69	0,
70	"Alarm clock",
71	"Terminated",
72	};
73
74	char line[LINSIZ];
75	char *args[ARGSIZ];
76	int trebuf[TRESIZ];
77
78	main(c, av)
79	int c;
80	char **av;
81	{
82	register f;
83	register char acname, *v;
84
85	for(f=3; f<15; f++)
86	close(f);
87	dolc = getpid();
88	for(f=4; f>=0; f--) {
89	dolc = dolc/10;
90	pidp[f] = dolc%10 + '0';
91	}
92	v = av;
93	acname = "<none>";
94	promp = "% ";
95	if((uid = getuid()) == 0)
96	promp = "# ";
97	if(c>1 && v[1][0]=='-' && v[1][1]=='e') {
98	++stoperr;
99	v[1] = v[0];
100	++v;
101	--c;
102	}
103	if(c > 1) {
104	promp = 0;
105	if (*v[1]=='-') {
106	**v = '-';
107	if (v[1][1]=='c' && c>2)
108	arginp = v[2];
109	else if (v[1][1]=='t')
110	onelflg = 2;
111	} else {
112	close(0);
113	f = open(v[1], 0);
114	if(f < 0) {
115	prs(v[1]);
116	err(": cannot open",255);
117	}
118	}
119	}
120	if(**v == '-') {
121	signal(QUIT, 1);
122	f = signal(INTR, 1);
123	if ((arginp==0&&onelflg==0) \|\| (f&01)==0)
124	setintr++;
125	}
126	dolv = v+1;
127	dolc = c-1;
128
129	loop:
130	if(promp != 0)
131	prs(promp);
132	peekc = getc();
133	main1();
134	goto loop;
135	}
136
137	main1()
138	{
139	register char *cp;
140	register *t;
141
142	argp = args;
143	eargp = args+ARGSIZ-5;
144	linep = line;
145	elinep = line+LINSIZ-5;
146	error = 0;
147	gflg = 0;
148	do {
149	cp = linep;
150	word();
151	} while(*cp != '\n');
152	treep = trebuf;
153	treeend = &trebuf[TRESIZ];
154	if(gflg == 0) {
155	if(error == 0) {
156	setjmp(jmpbuf);
157	if (error)
158	return;
159	t = syntax(args, argp);
160	}
161	if(error != 0)
162	err("syntax error",255); else
163	execute(t);
164	}
165	}
166
167	word()
168	{
169	register char c, c1;
170
171	*argp++ = linep;
172
173	loop:
174	switch(c = getc()) {
175
176	case ' ':
177	case '\t':
178	goto loop;
179
180	case '\'':
181	case '"':
182	c1 = c;
183	while((c=readc()) != c1) {
184	if(c == '\n') {
185	error++;
186	peekc = c;
187	return;
188	}
189	*linep++ = c\|QUOTE;
190	}
191	goto pack;
192
193	case '&':
194	case ';':
195	case '<':
196	case '>':
197	case '(':
198	case ')':
199	case '\|':
200	case '^':
201	case '\n':
202	*linep++ = c;
203	*linep++ = '\0';
204	return;
205	}
206
207	peekc = c;
208
209	pack:
210	for(;;) {
211	c = getc();
212	if(any(c, " '\"\t;&<>()\|^\n")) {
213	peekc = c;
214	if(any(c, "\"'"))
215	goto loop;
216	*linep++ = '\0';
217	return;
218	}
219	*linep++ = c;
220	}
221	}
222
223	tree(n)
224	int n;
225	{
226	register *t;
227
228	t = treep;
229	treep =+ n;
230	if (treep>treeend) {
231	prs("Command line overflow\n");
232	error++;
233	longjmp(jmpbuf, 1);
234	}
235	return(t);
236	}
237
238	getc()
239	{
240	register char c;
241
242	if(peekc) {
243	c = peekc;
244	peekc = 0;
245	return(c);
246	}
247	if(argp > eargp) {
248	argp =- 10;
249	while((c=getc()) != '\n');
250	argp =+ 10;
251	err("Too many args",255);
252	gflg++;
253	return(c);
254	}
255	if(linep > elinep) {
256	linep =- 10;
257	while((c=getc()) != '\n');
258	linep =+ 10;
259	err("Too many characters",255);
260	gflg++;
261	return(c);
262	}
263	getd:
264	if(dolp) {
265	c = *dolp++;
266	if(c != '\0')
267	return(c);
268	dolp = 0;
269	}
270	c = readc();
271	if(c == '\\') {
272	c = readc();
273	if(c == '\n')
274	return(' ');
275	return(c\|QUOTE);
276	}
277	if(c == '$') {
278	c = readc();
279	if(c>='0' && c<='9') {
280	if(c-'0' < dolc)
281	dolp = dolv[c-'0'];
282	goto getd;
283	}
284	if(c == '$') {
285	dolp = pidp;
286	goto getd;
287	}
288	}
289	return(c&0177);
290	}
291
292	readc()
293	{
294	int rdstat;
295	char cc;
296	register c;
297
298	if (arginp) {
299	if (arginp == 1)
300	exit(errval);
301	if ((c = *arginp++) == 0) {
302	arginp = 1;
303	c = '\n';
304	}
305	return(c);
306	}
307	if (onelflg==1)
308	exit(255);
309	if((rdstat = read(0, &cc, 1)) != 1)
310	if(rdstat==0) exit(errval); /* end of file*/
311	else exit(255); /* error */
312	if (cc=='\n' && onelflg)
313	onelflg--;
314	return(cc);
315	}
316
317	/*
318	* syntax
319	* empty
320	* syn1
321	*/
322
323	syntax(p1, p2)
324	char p1, p2;
325	{
326
327	while(p1 != p2) {
328	if(any(**p1, ";&\n"))
329	p1++; else
330	return(syn1(p1, p2));
331	}
332	return(0);
333	}
334
335	/*
336	* syn1
337	* syn2
338	* syn2 & syntax
339	* syn2 ; syntax
340	*/
341
342	syn1(p1, p2)
343	char p1, p2;
344	{
345	register char **p;
346	register t, t1;
347	int l;
348
349	l = 0;
350	for(p=p1; p!=p2; p++)
351	switch(**p) {
352
353	case '(':
354	l++;
355	continue;
356
357	case ')':
358	l--;
359	if(l < 0)
360	error++;
361	continue;
362
363	case '&':
364	case ';':
365	case '\n':
366	if(l == 0) {
367	l = **p;
368	t = tree(4);
369	t[DTYP] = TLST;
370	t[DLEF] = syn2(p1, p);
371	t[DFLG] = 0;
372	if(l == '&') {
373	t1 = t[DLEF];
374	t1[DFLG] =\| FAND\|FPRS\|FINT;
375	}
376	t[DRIT] = syntax(p+1, p2);
377	return(t);
378	}
379	}
380	if(l == 0)
381	return(syn2(p1, p2));
382	error++;
383	return(0);
384	}
385
386	/*
387	* syn2
388	* syn3
389	* syn3 \| syn2
390	*/
391
392	syn2(p1, p2)
393	char p1, p2;
394	{
395	register char **p;
396	register int l, *t;
397
398	l = 0;
399	for(p=p1; p!=p2; p++)
400	switch(**p) {
401
402	case '(':
403	l++;
404	continue;
405
406	case ')':
407	l--;
408	continue;
409
410	case '\|':
411	case '^':
412	if(l == 0) {
413	t = tree(4);
414	t[DTYP] = TFIL;
415	t[DLEF] = syn3(p1, p);
416	t[DRIT] = syn2(p+1, p2);
417	t[DFLG] = 0;
418	return(t);
419	}
420	}
421	return(syn3(p1, p2));
422	}
423
424	/*
425	* syn3
426	* ( syn1 ) [ < in ] [ > out ]
427	* word word* [ < in ] [ > out ]
428	*/
429
430	syn3(p1, p2)
431	char p1, p2;
432	{
433	register char **p;
434	char lp, rp;
435	register *t;
436	int n, l, i, o, c, flg;
437
438	flg = 0;
439	if(**p2 == ')')
440	flg =\| FPAR;
441	lp = 0;
442	rp = 0;
443	i = 0;
444	o = 0;
445	n = 0;
446	l = 0;
447	for(p=p1; p!=p2; p++)
448	switch(c = **p) {
449
450	case '(':
451	if(l == 0) {
452	if(lp != 0)
453	error++;
454	lp = p+1;
455	}
456	l++;
457	continue;
458
459	case ')':
460	l--;
461	if(l == 0)
462	rp = p;
463	continue;
464
465	case '>':
466	p++;
467	if(p!=p2 && **p=='>')
468	flg =\| FCAT; else
469	p--;
470
471	case '<':
472	if(l == 0) {
473	p++;
474	if(p == p2) {
475	error++;
476	p--;
477	}
478	if(any(**p, "<>("))
479	error++;
480	if(c == '<') {
481	if(i != 0)
482	error++;
483	i = *p;
484	continue;
485	}
486	if(o != 0)
487	error++;
488	o = *p;
489	}
490	continue;
491
492	default:
493	if(l == 0)
494	p1[n++] = *p;
495	}
496	if(lp != 0) {
497	if(n != 0)
498	error++;
499	t = tree(5);
500	t[DTYP] = TPAR;
501	t[DSPR] = syn1(lp, rp);
502	goto out;
503	}
504	if(n == 0)
505	error++;
506	p1[n++] = 0;
507	t = tree(n+5);
508	t[DTYP] = TCOM;
509	for(l=0; l<n; l++)
510	t[l+DCOM] = p1[l];
511	out:
512	t[DFLG] = flg;
513	t[DLEF] = i;
514	t[DRIT] = o;
515	return(t);
516	}
517
518	scan(at, f)
519	int *at;
520	int (*f)();
521	{
522	register char *p, c;
523	register *t;
524
525	t = at+DCOM;
526	while(p = *t++)
527	while(c = *p)
528	p++ = (f)(c);
529	}
530
531	tglob(c)
532	int c;
533	{
534
535	if(any(c, "[?*"))
536	gflg = 1;
537	return(c);
538	}
539
540	trim(c)
541	int c;
542	{
543
544	return(c&0177);
545	}
546
547	execute(t, pf1, pf2)
548	int t, pf1, *pf2;
549	{
550	int i, f, pv[2];
551	register *t1;
552	register char cp1, cp2;
553	extern errno;
554
555	if(t != 0)
556	switch(t[DTYP]) {
557
558	case TCOM:
559	cp1 = t[DCOM];
560	if(equal(cp1, "chdir")) {
561	if(t[DCOM+1] != 0) {
562	if(chdir(t[DCOM+1]) < 0)
563	err("chdir: bad directory",255);
564	} else
565	err("chdir: arg count",255);
566	return;
567	}
568	if(equal(cp1, "shift")) {
569	if(dolc < 1) {
570	prs("shift: no args\n");
571	return;
572	}
573	dolv[1] = dolv[0];
574	dolv++;
575	dolc--;
576	return;
577	}
578	if(equal(cp1, "login")) {
579	if(promp != 0) {
580	execv("/bin/login", t+DCOM);
581	}
582	prs("login: cannot execute\n");
583	return;
584	}
585	if(equal(cp1, "newgrp")) {
586	if(promp != 0) {
587	execv("/bin/newgrp", t+DCOM);
588	}
589	prs("newgrp: cannot execute\n");
590	return;
591	}
592	if(equal(cp1, "wait")) {
593	pwait(-1, 0);
594	return;
595	}
596	if(equal(cp1, ":"))
597	return;
598
599	case TPAR:
600	f = t[DFLG];
601	i = 0;
602	if((f&FPAR) == 0)
603	i = fork();
604	if(i == -1) {
605	err("try again",255);
606	return;
607	}
608	if(i != 0) {
609	if((f&FPIN) != 0) {
610	close(pf1[0]);
611	close(pf1[1]);
612	}
613	if((f&FPRS) != 0) {
614	prn(i);
615	prs("\n");
616	}
617	if((f&FAND) != 0)
618	return;
619	if((f&FPOU) == 0)
620	pwait(i, t);
621	return;
622	}
623	if(t[DLEF] != 0) {
624	close(0);
625	i = open(t[DLEF], 0);
626	if(i < 0) {
627	prs(t[DLEF]);
628	err(": cannot open",255);
629	exit(255);
630	}
631	}
632	if(t[DRIT] != 0) {
633	if((f&FCAT) != 0) {
634	i = open(t[DRIT], 1);
635	if(i >= 0) {
636	lseek(i, 0L, 2);
637	goto f1;
638	}
639	}
640	i = creat(t[DRIT], 0666);
641	if(i < 0) {
642	prs(t[DRIT]);
643	err(": cannot create",255);
644	exit(255);
645	}
646	f1:
647	close(1);
648	dup(i);
649	close(i);
650	}
651	if((f&FPIN) != 0) {
652	close(0);
653	dup(pf1[0]);
654	close(pf1[0]);
655	close(pf1[1]);
656	}
657	if((f&FPOU) != 0) {
658	close(1);
659	dup(pf2[1]);
660	close(pf2[0]);
661	close(pf2[1]);
662	}
663	if((f&FINT)!=0 && t[DLEF]==0 && (f&FPIN)==0) {
664	close(0);
665	open("/dev/null", 0);
666	}
667	if((f&FINT) == 0 && setintr) {
668	signal(INTR, 0);
669	signal(QUIT, 0);
670	}
671	if(t[DTYP] == TPAR) {
672	if(t1 = t[DSPR])
673	t1[DFLG] =\| f&FINT;
674	execute(t1);
675	exit(255);
676	}
677	gflg = 0;
678	scan(t, tglob);
679	if(gflg) {
680	t[DSPR] = "/etc/glob";
681	execv(t[DSPR], t+DSPR);
682	prs("glob: cannot execute\n");
683	exit(255);
684	}
685	scan(t, trim);
686	*linep = 0;
687	texec(t[DCOM], t);
688	cp1 = linep;
689	cp2 = "/usr/bin/";
690	while(cp1 = cp2++)
691	cp1++;
692	cp2 = t[DCOM];
693	while(cp1++ = cp2++);
694	texec(linep+4, t);
695	texec(linep, t);
696	prs(t[DCOM]);
697	err(": not found",255);
698	exit(255);
699
700	case TFIL:
701	f = t[DFLG];
702	pipe(pv);
703	t1 = t[DLEF];
704	t1[DFLG] =\| FPOU \| (f&(FPIN\|FINT\|FPRS));
705	execute(t1, pf1, pv);
706	t1 = t[DRIT];
707	t1[DFLG] =\| FPIN \| (f&(FPOU\|FINT\|FAND\|FPRS));
708	execute(t1, pv, pf2);
709	return;
710
711	case TLST:
712	f = t[DFLG]&FINT;
713	if(t1 = t[DLEF])
714	t1[DFLG] =\| f;
715	execute(t1);
716	if(t1 = t[DRIT])
717	t1[DFLG] =\| f;
718	execute(t1);
719	return;
720
721	}
722	}
723
724	texec(f, at)
725	int *at;
726	{
727	extern errno;
728	register int *t;
729
730	t = at;
731	execv(f, t+DCOM);
732	if (errno==ENOEXEC) {
733	if (*linep)
734	t[DCOM] = linep;
735	t[DSPR] = "/usr/bin/osh";
736	execv(t[DSPR], t+DSPR);
737	prs("No shell!\n");
738	exit(255);
739	}
740	if (errno==ENOMEM) {
741	prs(t[DCOM]);
742	err(": too large",255);
743	exit(255);
744	}
745	}
746
747	err(s, exitno)
748	char *s;
749	int exitno;
750	{
751
752	prs(s);
753	prs("\n");
754	if(promp == 0) {
755	lseek(0, 0L, 2);
756	exit(exitno);
757	}
758	}
759
760	prs(as)
761	char *as;
762	{
763	register char *s;
764
765	s = as;
766	while(*s)
767	putc(*s++);
768	}
769
770	putc(c)
771	{
772	char cc;
773
774	cc = c;
775	write(2, &cc, 1);
776	}
777
778	prn(n)
779	int n;
780	{
781	register a;
782
783	if (a = n/10)
784	prn(a);
785	putc(n%10 + '0');
786	}
787
788	any(c, as)
789	int c;
790	char *as;
791	{
792	register char *s;
793
794	s = as;
795	while(*s)
796	if(*s++ == c)
797	return(1);
798	return(0);
799	}
800
801	equal(as1, as2)
802	char as1, as2;
803	{
804	register char s1, s2;
805
806	s1 = as1;
807	s2 = as2;
808	while(s1++ == s2)
809	if(*s2++ == '\0')
810	return(1);
811	return(0);
812	}
813
814	pwait(i, t)
815	int i, *t;
816	{
817	register p, e;
818	int s;
819
820	if(i != 0)
821	for(;;) {
822	p = wait(&s);
823	if(p == -1)
824	break;
825	e = s&0177;
826	if (e>=NSIG \|\| mesg[e]) {
827	if(p != i) {
828	prn(p);
829	prs(": ");
830	}
831	if (e < NSIG)
832	prs(mesg[e]);
833	else {
834	prs("Signal ");
835	prn(e);
836	}
837	if(s&0200)
838	prs(" -- Core dumped");
839	}
840	if (e \|\| s&&stoperr)
841	err("", (s>>8)\|e );
842	errval =\| (s>>8);
843	}
844	}