[unix-history] / usr / src / cmd / sh / xec.c

#
/*
 * UNIX shell
 *
 * S. R. Bourne
 * Bell Telephone Laboratories
 *
 */

#include	"defs.h"
#include	"sym.h"

LOCAL INT	parent;

SYSTAB		commands;


/* ========	command execution	========*/


execute(argt, execflg, pf1, pf2)
	TREPTR		argt;
	INT		*pf1, *pf2;
{
	/* `stakbot' is preserved by this routine */
	REG TREPTR	t;
	STKPTR		sav=savstak();

	sigchk();

	IF (t=argt) ANDF execbrk==0
	THEN	REG INT		treeflgs;
		INT		oldexit, type;
		REG STRING	*com;

		treeflgs = t->tretyp; type = treeflgs&COMMSK;
		oldexit=exitval; exitval=0;

		SWITCH type IN

		case TCOM:
			BEGIN
			STRING		a1;
			INT		argn, internal;
			ARGPTR		schain=gchain;
			IOPTR		io=t->treio;
			gchain=0;
			argn = getarg(t);
			com=scan(argn);
			a1=com[1]; gchain=schain;

			IF (internal=syslook(com[0],commands)) ORF argn==0
			THEN	setlist(t->comset, 0);
			FI

			IF argn ANDF (flags&noexec)==0
			THEN	/* print command if execpr */
				IF flags&execpr
				THEN	argn=0;	prs(execpmsg);
					WHILE com[argn]!=ENDARGS
					DO prs(com[argn++]); blank() OD
					newline();
				FI

				SWITCH internal IN

				case SYSDOT:
					IF a1
					THEN	REG INT		f;
	
						IF (f=pathopen(getpath(a1), a1)) < 0
						THEN failed(a1,notfound);
						ELSE execexp(0,f);
						FI
					FI
					break;
	
				case SYSTIMES:
					{
					L_INT	t[4]; times(t);
					prt(t[2]); blank(); prt(t[3]); newline();
					}
					break;
	
				case SYSEXIT:
					exitsh(a1?stoi(a1):oldexit);
	
				case SYSNULL:
					io=0;
					break;
	
				case SYSCONT:
					execbrk = -loopcnt; break;
	
				case SYSBREAK:
					IF (execbrk=loopcnt) ANDF a1
					THEN breakcnt=stoi(a1);
					FI
					break;
	
				case SYSTRAP:
					IF a1
					THEN	BOOL	clear;
						IF (clear=digit(*a1))==0
						THEN	++com;
						FI
						WHILE *++com
						DO INT	i;
						   IF (i=stoi(*com))>=MAXTRAP ORF i<MINTRAP
						   THEN	failed(*com,badtrap);
						   ELIF clear
						   THEN	clrsig(i);
						   ELSE	replace(&trapcom[i],a1);
							IF *a1
							THEN	getsig(i);
							ELSE	ignsig(i);
							FI
						   FI
						OD
					ELSE	/* print out current traps */
						INT		i;
	
						FOR i=0; i<MAXTRAP; i++
						DO IF trapcom[i]
						   THEN	prn(i); prs(colon); prs(trapcom[i]); newline();
						   FI
						OD
					FI
					break;
	
				case SYSEXEC:
					com++;
					initio(io); ioset=0; io=0;
					IF a1==0 THEN break FI
	
				case SYSLOGIN:
					flags |= forked;
					oldsigs(); execa(com); done();
	
				case SYSCD:
					IF flags&rshflg
					THEN	failed(com[0],restricted);
					ELIF (a1==0 ANDF (a1=homenod.namval)==0) ORF chdir(a1)<0
					THEN	failed(a1,baddir);
					FI
					break;
	
				case SYSSHFT:
					IF dolc<1
					THEN	error(badshift);
					ELSE	dolv++; dolc--;
					FI
					assnum(&dolladr, dolc);
					break;
	
				case SYSWAIT:
					await(-1);
					break;
	
				case SYSREAD:
					exitval=readvar(&com[1]);
					break;

/*
				case SYSTST:
					exitval=testcmd(com);
					break;
*/

				case SYSSET:
					IF a1
					THEN	INT	argc;
						argc = options(argn,com);
						IF argc>1
						THEN	setargs(com+argn-argc);
						FI
					ELIF t->comset==0
					THEN	/*scan name chain and print*/
						namscan(printnam);
					FI
					break;
	
				case SYSRDONLY:
					exitval=N_RDONLY;
				case SYSXPORT:
					IF exitval==0 THEN exitval=N_EXPORT; FI
	
					IF a1
					THEN	WHILE *++com
						DO attrib(lookup(*com), exitval) OD
					ELSE	namscan(printflg);
					FI
					exitval=0;
					break;
	
				case SYSEVAL:
					IF a1
					THEN	execexp(a1,&com[2]);
					FI
					break;

                                case SYSUMASK:
                                        if (a1) {
                                                int c, i
                                                i = 0;
                                                while ((c = *a1++) >= '0' &&
                                                        c <= '7')
                                                        i = (i << 3) + c - '0';
                                                umask(i);
                                        } else {
                                                int i, j;
                                                umask(i = umask(0));
                                                prc('0');
                                                for (j = 6; j >= 0; j -= 3)
                                                        prc(((i>>j)&07) + '0');
                                                newline();
                                        }
                                        break;
	
				default:
					internal=builtin(argn,com);
	
				ENDSW

				IF internal
				THEN	IF io THEN error(illegal) FI
					chktrap();
					break;
				FI
			ELIF t->treio==0
			THEN	break;
			FI
			END
	
		case TFORK:
			IF execflg ANDF (treeflgs&(FAMP|FPOU))==0
			THEN	parent=0;
			ELSE	WHILE (parent=fork()) == -1
				DO sigchk(); alarm(10); pause() OD
			FI

			IF parent
			THEN	/* This is the parent branch of fork;    */
				/* it may or may not wait for the child. */
				IF treeflgs&FPRS ANDF flags&ttyflg
				THEN	prn(parent); newline();
				FI
				IF treeflgs&FPCL THEN closepipe(pf1) FI
				IF (treeflgs&(FAMP|FPOU))==0
				THEN	await(parent);
				ELIF (treeflgs&FAMP)==0
				THEN	post(parent);
				ELSE	assnum(&pcsadr, parent);
				FI

				chktrap();
				break;


			ELSE	/* this is the forked branch (child) of execute */
				flags |= forked; iotemp=0;
				postclr();
				settmp();

				/* Turn off INTR and QUIT if `FINT'  */
				/* Reset ramaining signals to parent */
				/* except for those `lost' by trap   */
				oldsigs();
				IF treeflgs&FINT
				THEN	signal(INTR,1); signal(QUIT,1);
				FI

				/* pipe in or out */
				IF treeflgs&FPIN
				THEN	rename(pf1[INPIPE],0);
					close(pf1[OTPIPE]);
				FI
				IF treeflgs&FPOU
				THEN	rename(pf2[OTPIPE],1);
					close(pf2[INPIPE]);
				FI

				/* default std input for & */
				IF treeflgs&FINT ANDF ioset==0
				THEN	rename(chkopen(devnull),0);
				FI

				/* io redirection */
				initio(t->treio);
				IF type!=TCOM
				THEN	execute(t->forktre,1);
				ELIF com[0]!=ENDARGS
				THEN	setlist(t->comset,N_EXPORT);
					execa(com);
				FI
				done();
			FI

		case TPAR:
			rename(dup(2),output);
			execute(t->partre,execflg);
			done();

		case TFIL:
			BEGIN
			   INT pv[2]; chkpipe(pv);
			   IF execute(t->lstlef, 0, pf1, pv)==0
			   THEN	execute(t->lstrit, execflg, pv, pf2);
			   ELSE	closepipe(pv);
			   FI
			END
			break;

		case TLST:
			execute(t->lstlef,0);
			execute(t->lstrit,execflg);
			break;

		case TAND:
			IF execute(t->lstlef,0)==0
			THEN	execute(t->lstrit,execflg);
			FI
			break;

		case TORF:
			IF execute(t->lstlef,0)!=0
			THEN	execute(t->lstrit,execflg);
			FI
			break;

		case TFOR:
			BEGIN
			   NAMPTR	n = lookup(t->fornam);
			   STRING	*args;
			   DOLPTR	argsav=0;

			   IF t->forlst==0
			   THEN    args=dolv+1;
				   argsav=useargs();
			   ELSE	   ARGPTR	schain=gchain;
				   gchain=0;
				   trim((args=scan(getarg(t->forlst)))[0]);
				   gchain=schain;
			   FI
			   loopcnt++;
			   WHILE *args!=ENDARGS ANDF execbrk==0
			   DO	assign(n,*args++);
				execute(t->fortre,0);
				IF execbrk<0 THEN execbrk=0 FI
			   OD
			   IF breakcnt THEN breakcnt-- FI
			   execbrk=breakcnt; loopcnt--;
			   argfor=freeargs(argsav);
			END
			break;

		case TWH:
		case TUN:
			BEGIN
			   INT		i=0;

			   loopcnt++;
			   WHILE execbrk==0 ANDF (execute(t->whtre,0)==0)==(type==TWH)
			   DO i=execute(t->dotre,0);
			      IF execbrk<0 THEN execbrk=0 FI
			   OD
			   IF breakcnt THEN breakcnt-- FI
			   execbrk=breakcnt; loopcnt--; exitval=i;
			END
			break;

		case TIF:
			IF execute(t->iftre,0)==0
			THEN	execute(t->thtre,execflg);
			ELSE	execute(t->eltre,execflg);
			FI
			break;

		case TSW:
			BEGIN
			   REG STRING	r = mactrim(t->swarg);
			   t=t->swlst;
			   WHILE t
			   DO	ARGPTR		rex=t->regptr;
				WHILE rex
				DO	REG STRING	s;
					IF gmatch(r,s=macro(rex->argval)) ORF (trim(s), eq(r,s))
					THEN	execute(t->regcom,0);
						t=0; break;
					ELSE	rex=rex->argnxt;
					FI
				OD
				IF t THEN t=t->regnxt FI
			   OD
			END
			break;
		ENDSW
		exitset();
	FI

	sigchk();
	tdystak(sav);
	return(exitval);
}


execexp(s,f)
	STRING		s;
	UFD		f;
{
	FILEBLK		fb;
	push(&fb);
	IF s
	THEN	estabf(s); fb.feval=f;
	ELIF f>=0
	THEN	initf(f);
	FI
	execute(cmd(NL, NLFLG|MTFLG),0);
	pop();
}
Commit	Line	Data
862515b8 TL	1	#
	2	/*
	3	* UNIX shell
	4	*
	5	* S. R. Bourne
	6	* Bell Telephone Laboratories
	7	*
	8	*/
	9
	10	#include "defs.h"
	11	#include "sym.h"
	12
	13	LOCAL INT parent;
	14
	15	SYSTAB commands;
	16
	17
	18
	19	/* ======== command execution ========*/
	20
	21
	22	execute(argt, execflg, pf1, pf2)
	23	TREPTR argt;
	24	INT pf1, pf2;
	25	{
	26	/* `stakbot' is preserved by this routine */
	27	REG TREPTR t;
	28	STKPTR sav=savstak();
	29
	30	sigchk();
	31
	32	IF (t=argt) ANDF execbrk==0
	33	THEN REG INT treeflgs;
	34	INT oldexit, type;
	35	REG STRING *com;
	36
	37	treeflgs = t->tretyp; type = treeflgs&COMMSK;
	38	oldexit=exitval; exitval=0;
	39
	40	SWITCH type IN
	41
	42	case TCOM:
	43	BEGIN
	44	STRING a1;
	45	INT argn, internal;
	46	ARGPTR schain=gchain;
	47	IOPTR io=t->treio;
	48	gchain=0;
	49	argn = getarg(t);
	50	com=scan(argn);
	51	a1=com[1]; gchain=schain;
	52
	53	IF (internal=syslook(com[0],commands)) ORF argn==0
	54	THEN setlist(t->comset, 0);
	55	FI
	56
	57	IF argn ANDF (flags&noexec)==0
	58	THEN /* print command if execpr */
	59	IF flags&execpr
	60	THEN argn=0; prs(execpmsg);
	61	WHILE com[argn]!=ENDARGS
	62	DO prs(com[argn++]); blank() OD
	63	newline();
	64	FI
65
66	SWITCH internal IN
67
68	case SYSDOT:
69	IF a1
70	THEN REG INT f;
71
72	IF (f=pathopen(getpath(a1), a1)) < 0
73	THEN failed(a1,notfound);
74	ELSE execexp(0,f);
75	FI
76	FI
77	break;
78
79	case SYSTIMES:
80	{
81	L_INT t[4]; times(t);
82	prt(t[2]); blank(); prt(t[3]); newline();
83	}
84	break;
85
86	case SYSEXIT:
87	exitsh(a1?stoi(a1):oldexit);
88
89	case SYSNULL:
90	io=0;
91	break;
92
93	case SYSCONT:
94	execbrk = -loopcnt; break;
95
96	case SYSBREAK:
97	IF (execbrk=loopcnt) ANDF a1
98	THEN breakcnt=stoi(a1);
99	FI
100	break;
101
102	case SYSTRAP:
103	IF a1
104	THEN BOOL clear;
105	IF (clear=digit(*a1))==0
106	THEN ++com;
107	FI
108	WHILE *++com
109	DO INT i;
110	IF (i=stoi(*com))>=MAXTRAP ORF i<MINTRAP
111	THEN failed(*com,badtrap);
112	ELIF clear
113	THEN clrsig(i);
114	ELSE replace(&trapcom[i],a1);
115	IF *a1
116	THEN getsig(i);
117	ELSE ignsig(i);
118	FI
119	FI
120	OD
121	ELSE /* print out current traps */
122	INT i;
123
124	FOR i=0; i<MAXTRAP; i++
125	DO IF trapcom[i]
126	THEN prn(i); prs(colon); prs(trapcom[i]); newline();
127	FI
128	OD
129	FI
130	break;
131
132	case SYSEXEC:
133	com++;
134	initio(io); ioset=0; io=0;
135	IF a1==0 THEN break FI
136
137	case SYSLOGIN:
138	flags \|= forked;
139	oldsigs(); execa(com); done();
140
141	case SYSCD:
142	IF flags&rshflg
143	THEN failed(com[0],restricted);
144	ELIF (a1==0 ANDF (a1=homenod.namval)==0) ORF chdir(a1)<0
145	THEN failed(a1,baddir);
146	FI
147	break;
148
149	case SYSSHFT:
150	IF dolc<1
151	THEN error(badshift);
152	ELSE dolv++; dolc--;
153	FI
154	assnum(&dolladr, dolc);
155	break;
156
157	case SYSWAIT:
158	await(-1);
159	break;
160
161	case SYSREAD:
162	exitval=readvar(&com[1]);
163	break;
164
165	/*
166	case SYSTST:
167	exitval=testcmd(com);
168	break;
169	*/
170
171	case SYSSET:
172	IF a1
173	THEN INT argc;
174	argc = options(argn,com);
175	IF argc>1
176	THEN setargs(com+argn-argc);
177	FI
178	ELIF t->comset==0
179	THEN /scan name chain and print/
180	namscan(printnam);
181	FI
182	break;
183
184	case SYSRDONLY:
185	exitval=N_RDONLY;
186	case SYSXPORT:
187	IF exitval==0 THEN exitval=N_EXPORT; FI
188
189	IF a1
190	THEN WHILE *++com
191	DO attrib(lookup(*com), exitval) OD
192	ELSE namscan(printflg);
193	FI
194	exitval=0;
195	break;
196
197	case SYSEVAL:
198	IF a1
199	THEN execexp(a1,&com[2]);
200	FI
201	break;
202
203	case SYSUMASK:
204	if (a1) {
205	int c, i
206	i = 0;
207	while ((c = *a1++) >= '0' &&
208	c <= '7')
209	i = (i << 3) + c - '0';
210	umask(i);
211	} else {
212	int i, j;
213	umask(i = umask(0));
214	prc('0');
215	for (j = 6; j >= 0; j -= 3)
216	prc(((i>>j)&07) + '0');
217	newline();
218	}
219	break;
220
221	default:
222	internal=builtin(argn,com);
223
224	ENDSW
225
226	IF internal
227	THEN IF io THEN error(illegal) FI
228	chktrap();
229	break;
230	FI
231	ELIF t->treio==0
232	THEN break;
233	FI
234	END
235
236	case TFORK:
237	IF execflg ANDF (treeflgs&(FAMP\|FPOU))==0
238	THEN parent=0;
239	ELSE WHILE (parent=fork()) == -1
240	DO sigchk(); alarm(10); pause() OD
241	FI
242
243	IF parent
244	THEN /* This is the parent branch of fork; */
245	/* it may or may not wait for the child. */
246	IF treeflgs&FPRS ANDF flags&ttyflg
247	THEN prn(parent); newline();
248	FI
249	IF treeflgs&FPCL THEN closepipe(pf1) FI
250	IF (treeflgs&(FAMP\|FPOU))==0
251	THEN await(parent);
252	ELIF (treeflgs&FAMP)==0
253	THEN post(parent);
254	ELSE assnum(&pcsadr, parent);
255	FI
256
257	chktrap();
258	break;
259
260
261	ELSE /* this is the forked branch (child) of execute */
262	flags \|= forked; iotemp=0;
263	postclr();
264	settmp();
265
266	/* Turn off INTR and QUIT if `FINT' */
267	/* Reset ramaining signals to parent */
268	/* except for those `lost' by trap */
269	oldsigs();
270	IF treeflgs&FINT
271	THEN signal(INTR,1); signal(QUIT,1);
272	FI
273
274	/* pipe in or out */
275	IF treeflgs&FPIN
276	THEN rename(pf1[INPIPE],0);
277	close(pf1[OTPIPE]);
278	FI
279	IF treeflgs&FPOU
280	THEN rename(pf2[OTPIPE],1);
281	close(pf2[INPIPE]);
282	FI
283
284	/* default std input for & */
285	IF treeflgs&FINT ANDF ioset==0
286	THEN rename(chkopen(devnull),0);
287	FI
288
289	/* io redirection */
290	initio(t->treio);
291	IF type!=TCOM
292	THEN execute(t->forktre,1);
293	ELIF com[0]!=ENDARGS
294	THEN setlist(t->comset,N_EXPORT);
295	execa(com);
296	FI
297	done();
298	FI
299
300	case TPAR:
301	rename(dup(2),output);
302	execute(t->partre,execflg);
303	done();
304
305	case TFIL:
306	BEGIN
307	INT pv[2]; chkpipe(pv);
308	IF execute(t->lstlef, 0, pf1, pv)==0
309	THEN execute(t->lstrit, execflg, pv, pf2);
310	ELSE closepipe(pv);
311	FI
312	END
313	break;
314
315	case TLST:
316	execute(t->lstlef,0);
317	execute(t->lstrit,execflg);
318	break;
319
320	case TAND:
321	IF execute(t->lstlef,0)==0
322	THEN execute(t->lstrit,execflg);
323	FI
324	break;
325
326	case TORF:
327	IF execute(t->lstlef,0)!=0
328	THEN execute(t->lstrit,execflg);
329	FI
330	break;
331
332	case TFOR:
333	BEGIN
334	NAMPTR n = lookup(t->fornam);
335	STRING *args;
336	DOLPTR argsav=0;
337
338	IF t->forlst==0
339	THEN args=dolv+1;
340	argsav=useargs();
341	ELSE ARGPTR schain=gchain;
342	gchain=0;
343	trim((args=scan(getarg(t->forlst)))[0]);
344	gchain=schain;
345	FI
346	loopcnt++;
347	WHILE *args!=ENDARGS ANDF execbrk==0
348	DO assign(n,*args++);
349	execute(t->fortre,0);
350	IF execbrk<0 THEN execbrk=0 FI
351	OD
352	IF breakcnt THEN breakcnt-- FI
353	execbrk=breakcnt; loopcnt--;
354	argfor=freeargs(argsav);
355	END
356	break;
357
358	case TWH:
359	case TUN:
360	BEGIN
361	INT i=0;
362
363	loopcnt++;
364	WHILE execbrk==0 ANDF (execute(t->whtre,0)==0)==(type==TWH)
365	DO i=execute(t->dotre,0);
366	IF execbrk<0 THEN execbrk=0 FI
367	OD
368	IF breakcnt THEN breakcnt-- FI
369	execbrk=breakcnt; loopcnt--; exitval=i;
370	END
371	break;
372
373	case TIF:
374	IF execute(t->iftre,0)==0
375	THEN execute(t->thtre,execflg);
376	ELSE execute(t->eltre,execflg);
377	FI
378	break;
379
380	case TSW:
381	BEGIN
382	REG STRING r = mactrim(t->swarg);
383	t=t->swlst;
384	WHILE t
385	DO ARGPTR rex=t->regptr;
386	WHILE rex
387	DO REG STRING s;
388	IF gmatch(r,s=macro(rex->argval)) ORF (trim(s), eq(r,s))
389	THEN execute(t->regcom,0);
390	t=0; break;
391	ELSE rex=rex->argnxt;
392	FI
393	OD
394	IF t THEN t=t->regnxt FI
395	OD
396	END
397	break;
398	ENDSW
399	exitset();
400	FI
401
402	sigchk();
403	tdystak(sav);
404	return(exitval);
405	}
406
407
408	execexp(s,f)
409	STRING s;
410	UFD f;
411	{
412	FILEBLK fb;
413	push(&fb);
414	IF s
415	THEN estabf(s); fb.feval=f;
416	ELIF f>=0
417	THEN initf(f);
418	FI
419	execute(cmd(NL, NLFLG\|MTFLG),0);
420	pop();
421	}