Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: MondoRescue/branches/stable/mindi-busybox/shell/msh.c@ 821

Visit:

Last change on this file since 821 was 821, checked in by Bruno Cornec, 18 years ago
Addition of busybox 1.2.1 as a mindi-busybox new package This should avoid delivering binary files in mindi not built there (Fedora and Debian are quite serious about that)
File size: 102.0 KB

Line
1	/* vi: set sw=4 ts=4: */
2	/*
3	* Minix shell port for busybox
4	*
5	* This version of the Minix shell was adapted for use in busybox
6	* by Erik Andersen <andersen@codepoet.org>
7	*
8	* - backtick expansion did not work properly
9	* Jonas Holmberg <jonas.holmberg@axis.com>
10	* Robert Schwebel <r.schwebel@pengutronix.de>
11	* Erik Andersen <andersen@codepoet.org>
12	*
13	* This program is free software; you can redistribute it and/or modify
14	* it under the terms of the GNU General Public License as published by
15	* the Free Software Foundation; either version 2 of the License, or
16	* (at your option) any later version.
17	*
18	* This program is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21	* General Public License for more details.
22	*
23	* You should have received a copy of the GNU General Public License
24	* along with this program; if not, write to the Free Software
25	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26	*
27	* Original copyright notice is retained at the end of this file.
28	*/
29
30	#include "busybox.h"
31	#include <ctype.h>
32	#include <dirent.h>
33	#include <errno.h>
34	#include <fcntl.h>
35	#include <limits.h>
36	#include <setjmp.h>
37	#include <signal.h>
38	#include <stddef.h>
39	#include <stdio.h>
40	#include <stdlib.h>
41	#include <string.h>
42	#include <time.h>
43	#include <unistd.h>
44	#include <sys/stat.h>
45	#include <sys/times.h>
46	#include <sys/types.h>
47	#include <sys/wait.h>
48
49	#include "cmdedit.h"
50
51
52	/* Conditional use of "register" keyword */
53	#define REGISTER register
54
55
56	/#define MSHDEBUG 1/
57
58	#ifdef MSHDEBUG
59	int mshdbg = MSHDEBUG;
60
61	#define DBGPRINTF(x) if(mshdbg>0)printf x
62	#define DBGPRINTF0(x) if(mshdbg>0)printf x
63	#define DBGPRINTF1(x) if(mshdbg>1)printf x
64	#define DBGPRINTF2(x) if(mshdbg>2)printf x
65	#define DBGPRINTF3(x) if(mshdbg>3)printf x
66	#define DBGPRINTF4(x) if(mshdbg>4)printf x
67	#define DBGPRINTF5(x) if(mshdbg>5)printf x
68	#define DBGPRINTF6(x) if(mshdbg>6)printf x
69	#define DBGPRINTF7(x) if(mshdbg>7)printf x
70	#define DBGPRINTF8(x) if(mshdbg>8)printf x
71	#define DBGPRINTF9(x) if(mshdbg>9)printf x
72
73	int mshdbg_rc = 0;
74
75	#define RCPRINTF(x) if(mshdbg_rc)printf x
76
77	#else
78
79	#define DBGPRINTF(x)
80	#define DBGPRINTF0(x)
81	#define DBGPRINTF1(x)
82	#define DBGPRINTF2(x)
83	#define DBGPRINTF3(x)
84	#define DBGPRINTF4(x)
85	#define DBGPRINTF5(x)
86	#define DBGPRINTF6(x)
87	#define DBGPRINTF7(x)
88	#define DBGPRINTF8(x)
89	#define DBGPRINTF9(x)
90
91	#define RCPRINTF(x)
92
93	#endif /* MSHDEBUG */
94
95
96	#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
97	# define DEFAULT_ROOT_PROMPT "\\u:\\w> "
98	# define DEFAULT_USER_PROMPT "\\u:\\w$ "
99	#else
100	# define DEFAULT_ROOT_PROMPT "# "
101	# define DEFAULT_USER_PROMPT "$ "
102	#endif
103
104
105	/* -------- sh.h -------- */
106	/*
107	* shell
108	*/
109
110	#define LINELIM 2100
111	#define NPUSH 8 /* limit to input nesting */
112
113	#undef NOFILE
114	#define NOFILE 20 /* Number of open files */
115	#define NUFILE 10 /* Number of user-accessible files */
116	#define FDBASE 10 /* First file usable by Shell */
117
118	/*
119	* values returned by wait
120	*/
121	#define WAITSIG(s) ((s)&0177)
122	#define WAITVAL(s) (((s)>>8)&0377)
123	#define WAITCORE(s) (((s)&0200)!=0)
124
125	/*
126	* library and system definitions
127	*/
128	typedef void xint; /* base type of jmp_buf, for not broken compilers */
129
130	/*
131	* shell components
132	*/
133
134	#define QUOTE 0200
135
136	#define NOBLOCK ((struct op *)NULL)
137	#define NOWORD ((char *)NULL)
138	#define NOWORDS ((char **)NULL)
139	#define NOPIPE ((int *)NULL)
140
141	/*
142	* Description of a command or an operation on commands.
143	* Might eventually use a union.
144	*/
145	struct op {
146	int type; /* operation type, see below */
147	char *words; / arguments to a command */
148	struct ioword *ioact; / IO actions (eg, < > >>) */
149	struct op *left;
150	struct op *right;
151	char str; / identifier for case and for */
152	};
153
154	#define TCOM 1 /* command */
155	#define TPAREN 2 /* (c-list) */
156	#define TPIPE 3 /* a \| b */
157	#define TLIST 4 /* a [&;] b */
158	#define TOR 5 /* \|\| */
159	#define TAND 6 /* && */
160	#define TFOR 7
161	#define TDO 8
162	#define TCASE 9
163	#define TIF 10
164	#define TWHILE 11
165	#define TUNTIL 12
166	#define TELIF 13
167	#define TPAT 14 /* pattern in case */
168	#define TBRACE 15 /* {c-list} */
169	#define TASYNC 16 /* c & */
170	/* Added to support "." file expansion */
171	#define TDOT 17
172
173	/* Strings for names to make debug easier */
174	#ifdef MSHDEBUG
175	static char *T_CMD_NAMES[] = {
176	"PLACEHOLDER",
177	"TCOM",
178	"TPAREN",
179	"TPIPE",
180	"TLIST",
181	"TOR",
182	"TAND",
183	"TFOR",
184	"TDO",
185	"TCASE",
186	"TIF",
187	"TWHILE",
188	"TUNTIL",
189	"TELIF",
190	"TPAT",
191	"TBRACE",
192	"TASYNC",
193	"TDOT",
194	};
195	#endif
196
197	/*
198	* actions determining the environment of a process
199	*/
200	#define BIT(i) (1<<(i))
201	#define FEXEC BIT(0) /* execute without forking */
202
203	#if 0 /* Original value */
204	#define AREASIZE (65000)
205	#else
206	#define AREASIZE (90000)
207	#endif
208
209	/*
210	* flags to control evaluation of words
211	*/
212	#define DOSUB 1 /* interpret $, `, and quotes */
213	#define DOBLANK 2 /* perform blank interpretation */
214	#define DOGLOB 4 /* interpret [?* */
215	#define DOKEY 8 /* move words with `=' to 2nd arg. list */
216	#define DOTRIM 16 /* trim resulting string */
217
218	#define DOALL (DOSUB\|DOBLANK\|DOGLOB\|DOKEY\|DOTRIM)
219
220
221	/* PROTOTYPES */
222	static int newfile(char *s);
223	static char findeq(char cp);
224	static char cclass(char p, int sub);
225	static void initarea(void);
226	extern int msh_main(int argc, char **argv);
227
228
229	struct brkcon {
230	jmp_buf brkpt;
231	struct brkcon *nextlev;
232	};
233
234
235	/*
236	* redirection
237	*/
238	struct ioword {
239	short io_unit; /* unit affected */
240	short io_flag; /* action (below) */
241	char io_name; / file name */
242	};
243
244	#define IOREAD 1 /* < */
245	#define IOHERE 2 /* << (here file) */
246	#define IOWRITE 4 /* > */
247	#define IOCAT 8 /* >> */
248	#define IOXHERE 16 /* ${}, ` in << */
249	#define IODUP 32 /* >&digit */
250	#define IOCLOSE 64 /* >&- */
251
252	#define IODEFAULT (-1) /* token for default IO unit */
253
254
255
256	/*
257	* parsing & execution environment
258	*/
259	static struct env {
260	char *linep;
261	struct io *iobase;
262	struct io *iop;
263	xint errpt; / void * */
264	int iofd;
265	struct env *oenv;
266	} e;
267
268	/*
269	* flags:
270	* -e: quit on error
271	* -k: look for name=value everywhere on command line
272	* -n: no execution
273	* -t: exit after reading and executing one command
274	* -v: echo as read
275	* -x: trace
276	* -u: unset variables net diagnostic
277	*/
278	static char *flag;
279
280	static char null; / null value for variable */
281	static int intr; /* interrupt pending */
282
283	static char *trap[_NSIG + 1];
284	static char ourtrap[_NSIG + 1];
285	static int trapset; /* trap pending */
286
287	static int heedint; /* heed interrupt signals */
288
289	static int yynerrs; /* yacc */
290
291	static char line[LINELIM];
292	static char *elinep;
293
294
295	/*
296	* other functions
297	*/
298	static int (inbuilt(char s)) (struct op *);
299
300	static char rexecve(char c, char v, char envp);
301	static char *space(int n);
302	static char strsave(char s, int a);
303	static char evalstr(char cp, int f);
304	static char *putn(int n);
305	static char *itoa(int n);
306	static char unquote(char as);
307	static struct var lookup(char n);
308	static int rlookup(char *n);
309	static struct wdblock glob(char cp, struct wdblock *wb);
310	static int my_getc(int ec);
311	static int subgetc(char ec, int quoted);
312	static char *makenv(int all, struct wdblock wb);
313	static char eval(char ap, int f);
314	static int setstatus(int s);
315	static int waitfor(int lastpid, int canintr);
316
317	static void onintr(int s); /* SIGINT handler */
318
319	static int newenv(int f);
320	static void quitenv(void);
321	static void err(char *s);
322	static int anys(char s1, char s2);
323	static int any(int c, char *s);
324	static void next(int f);
325	static void setdash(void);
326	static void onecommand(void);
327	static void runtrap(int i);
328	static int gmatch(char s, char p);
329
330
331	/*
332	* error handling
333	*/
334	static void leave(void); /* abort shell (or fail in subshell) */
335	static void fail(void); /* fail but return to process next command */
336	static void warn(char *s);
337	static void sig(int i); /* default signal handler */
338
339
340
341	/* -------- area stuff -------- */
342
343	#define REGSIZE sizeof(struct region)
344	#define GROWBY (256)
345	/* #define SHRINKBY (64) */
346	#undef SHRINKBY
347	#define FREE (32767)
348	#define BUSY (0)
349	#define ALIGN (sizeof(int)-1)
350
351
352	struct region {
353	struct region *next;
354	int area;
355	};
356
357
358
359	/* -------- grammar stuff -------- */
360	typedef union {
361	char *cp;
362	char **wp;
363	int i;
364	struct op *o;
365	} YYSTYPE;
366
367	#define WORD 256
368	#define LOGAND 257
369	#define LOGOR 258
370	#define BREAK 259
371	#define IF 260
372	#define THEN 261
373	#define ELSE 262
374	#define ELIF 263
375	#define FI 264
376	#define CASE 265
377	#define ESAC 266
378	#define FOR 267
379	#define WHILE 268
380	#define UNTIL 269
381	#define DO 270
382	#define DONE 271
383	#define IN 272
384	/* Added for "." file expansion */
385	#define DOT 273
386
387	#define YYERRCODE 300
388
389	/* flags to yylex */
390	#define CONTIN 01 /* skip new lines to complete command */
391
392	#define SYNTAXERR zzerr()
393
394	static struct op *pipeline(int cf);
395	static struct op *andor(void);
396	static struct op *c_list(void);
397	static int synio(int cf);
398	static void musthave(int c, int cf);
399	static struct op *simple(void);
400	static struct op *nested(int type, int mark);
401	static struct op *command(int cf);
402	static struct op *dogroup(int onlydone);
403	static struct op *thenpart(void);
404	static struct op *elsepart(void);
405	static struct op *caselist(void);
406	static struct op *casepart(void);
407	static char **pattern(void);
408	static char **wordlist(void);
409	static struct op list(struct op t1, struct op *t2);
410	static struct op block(int type, struct op t1, struct op t2, char *wp);
411	static struct op *newtp(void);
412	static struct op namelist(struct op t);
413	static char **copyw(void);
414	static void word(char *cp);
415	static struct ioword **copyio(void);
416	static struct ioword io(int u, int f, char cp);
417	static void zzerr(void);
418	static void yyerror(char *s);
419	static int yylex(int cf);
420	static int collect(int c, int c1);
421	static int dual(int c);
422	static void diag(int ec);
423	static char *tree(unsigned size);
424
425	/* -------- var.h -------- */
426
427	struct var {
428	char *value;
429	char *name;
430	struct var *next;
431	char status;
432	};
433
434	#define COPYV 1 /* flag to setval, suggesting copy */
435	#define RONLY 01 /* variable is read-only */
436	#define EXPORT 02 /* variable is to be exported */
437	#define GETCELL 04 /* name & value space was got with getcell */
438
439	static int yyparse(void);
440	static struct var lookup(char n);
441	static void setval(struct var vp, char val);
442	static void nameval(struct var vp, char val, char *name);
443	static void export(struct var *vp);
444	static void ronly(struct var *vp);
445	static int isassign(char *s);
446	static int checkname(char *cp);
447	static int assign(char *s, int cf);
448	static void putvlist(int f, int out);
449	static int eqname(char n1, char n2);
450
451	static int execute(struct op t, int pin, int *pout, int act);
452
453
454	/* -------- io.h -------- */
455	/* io buffer */
456	struct iobuf {
457	unsigned id; /* buffer id */
458	char buf[512]; /* buffer */
459	char bufp; / pointer into buffer */
460	char ebufp; / pointer to end of buffer */
461	};
462
463	/* possible arguments to an IO function */
464	struct ioarg {
465	char *aword;
466	char **awordlist;
467	int afile; /* file descriptor */
468	unsigned afid; /* buffer id */
469	long afpos; /* file position */
470	struct iobuf afbuf; / buffer for this file */
471	};
472
473	//static struct ioarg ioargstack[NPUSH];
474	#define AFID_NOBUF (~0)
475	#define AFID_ID 0
476
477	/* an input generator's state */
478	struct io {
479	int (iofn) (struct ioarg , struct io *);
480	struct ioarg *argp;
481	int peekc;
482	char prev; /* previous character read by readc() */
483	char nlcount; /* for `'s */
484	char xchar; /* for `'s */
485	char task; /* reason for pushed IO */
486	};
487
488	//static struct io iostack[NPUSH];
489	#define XOTHER 0 /* none of the below */
490	#define XDOLL 1 /* expanding ${} */
491	#define XGRAVE 2 /* expanding `'s */
492	#define XIO 3 /* file IO */
493
494	/* in substitution */
495	#define INSUB() (e.iop->task == XGRAVE \|\| e.iop->task == XDOLL)
496
497
498	/*
499	* input generators for IO structure
500	*/
501	static int nlchar(struct ioarg *ap);
502	static int strchar(struct ioarg *ap);
503	static int qstrchar(struct ioarg *ap);
504	static int filechar(struct ioarg *ap);
505	static int herechar(struct ioarg *ap);
506	static int linechar(struct ioarg *ap);
507	static int gravechar(struct ioarg ap, struct io iop);
508	static int qgravechar(struct ioarg ap, struct io iop);
509	static int dolchar(struct ioarg *ap);
510	static int wdchar(struct ioarg *ap);
511	static void scraphere(void);
512	static void freehere(int area);
513	static void gethere(void);
514	static void markhere(char s, struct ioword iop);
515	static int herein(char *hname, int xdoll);
516	static int run(struct ioarg argp, int (f) (struct ioarg *));
517
518
519	/*
520	* IO functions
521	*/
522	static int eofc(void);
523	static int readc(void);
524	static void unget(int c);
525	static void ioecho(char c);
526	static void prs(const char *s);
527	static void prn(unsigned u);
528	static void closef(int i);
529	static void closeall(void);
530
531
532	/*
533	* IO control
534	*/
535	static void pushio(struct ioarg argp, int (f) (struct ioarg *));
536	static int remap(int fd);
537	static int openpipe(int *pv);
538	static void closepipe(int *pv);
539	static struct io setbase(struct io ip);
540
541	#define PUSHIO(what,arg,gen) ((temparg.what = (arg)),pushio(&temparg,(gen)))
542	#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
543
544	/* -------- word.h -------- */
545
546	#define NSTART 16 /* default number of words to allow for initially */
547
548	struct wdblock {
549	short w_bsize;
550	short w_nword;
551	/* bounds are arbitrary */
552	char *w_words[1];
553	};
554
555	static struct wdblock addword(char wd, struct wdblock *wb);
556	static struct wdblock *newword(int nw);
557	static char *getwords(struct wdblock wb);
558
559	/* -------- area.h -------- */
560
561	/*
562	* storage allocation
563	*/
564	static char *getcell(unsigned nbytes);
565	static void garbage(void);
566	static void setarea(char *cp, int a);
567	static int getarea(char *cp);
568	static void freearea(int a);
569	static void freecell(char *cp);
570	static int areanum; /* current allocation area */
571
572	#define NEW(type) (type *)getcell(sizeof(type))
573	#define DELETE(obj) freecell((char *)obj)
574
575
576	/* -------- misc stuff -------- */
577
578	static int forkexec(struct op t, int pin, int pout, int act, char *wp);
579	static int iosetup(struct ioword *iop, int pipein, int pipeout);
580	static void echo(char **wp);
581	static struct op *find1case(struct op t, char *w);
582	static struct op findcase(struct op t, char *w);
583	static void brkset(struct brkcon *bc);
584	static int dolabel(struct op *t);
585	static int dohelp(struct op *t);
586	static int dochdir(struct op *t);
587	static int doshift(struct op *t);
588	static int dologin(struct op *t);
589	static int doumask(struct op *t);
590	static int doexec(struct op *t);
591	static int dodot(struct op *t);
592	static int dowait(struct op *t);
593	static int doread(struct op *t);
594	static int doeval(struct op *t);
595	static int dotrap(struct op *t);
596	static int getsig(char *s);
597	static void setsig(int n, sighandler_t f);
598	static int getn(char *as);
599	static int dobreak(struct op *t);
600	static int docontinue(struct op *t);
601	static int brkcontin(char *cp, int val);
602	static int doexit(struct op *t);
603	static int doexport(struct op *t);
604	static int doreadonly(struct op *t);
605	static void rdexp(char *wp, void (f) (struct var *), int key);
606	static void badid(char *s);
607	static int doset(struct op *t);
608	static void varput(char *s, int out);
609	static int dotimes(struct op *t);
610	static int expand(char cp, struct wdblock *wbp, int f);
611	static char *blank(int f);
612	static int dollar(int quoted);
613	static int grave(int quoted);
614	static void globname(char we, char pp);
615	static char generate(char start1, char end1, char middle, char *end);
616	static int anyspcl(struct wdblock *wb);
617	static int xstrcmp(char p1, char p2);
618	static void glob0(char *a0, unsigned int a1, int a2,
619	int (a3) (char , char *));
620	static void glob1(char base, char lim);
621	static void glob2(char i, char j);
622	static void glob3(char i, char j, char *k);
623	static void readhere(char *name, char s, int ec);
624	static void pushio(struct ioarg argp, int (f) (struct ioarg *));
625	static int xxchar(struct ioarg *ap);
626
627	struct here {
628	char *h_tag;
629	int h_dosub;
630	struct ioword *h_iop;
631	struct here *h_next;
632	};
633
634	static const char * const signame[] = {
635	"Signal 0",
636	"Hangup",
637	(char ) NULL, / interrupt */
638	"Quit",
639	"Illegal instruction",
640	"Trace/BPT trap",
641	"Abort",
642	"Bus error",
643	"Floating Point Exception",
644	"Killed",
645	"SIGUSR1",
646	"SIGSEGV",
647	"SIGUSR2",
648	(char ) NULL, / broken pipe */
649	"Alarm clock",
650	"Terminated",
651	};
652
653	#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))
654
655	struct res {
656	const char *r_name;
657	int r_val;
658	};
659	static const struct res restab[] = {
660	{"for", FOR},
661	{"case", CASE},
662	{"esac", ESAC},
663	{"while", WHILE},
664	{"do", DO},
665	{"done", DONE},
666	{"if", IF},
667	{"in", IN},
668	{"then", THEN},
669	{"else", ELSE},
670	{"elif", ELIF},
671	{"until", UNTIL},
672	{"fi", FI},
673	{";;", BREAK},
674	{"\|\|", LOGOR},
675	{"&&", LOGAND},
676	{"{", '{'},
677	{"}", '}'},
678	{".", DOT},
679	{0, 0},
680	};
681
682
683	struct builtincmd {
684	const char *name;
685	int (builtinfunc) (struct op t);
686	};
687	static const struct builtincmd builtincmds[] = {
688	{".", dodot},
689	{":", dolabel},
690	{"break", dobreak},
691	{"cd", dochdir},
692	{"continue", docontinue},
693	{"eval", doeval},
694	{"exec", doexec},
695	{"exit", doexit},
696	{"export", doexport},
697	{"help", dohelp},
698	{"login", dologin},
699	{"newgrp", dologin},
700	{"read", doread},
701	{"readonly", doreadonly},
702	{"set", doset},
703	{"shift", doshift},
704	{"times", dotimes},
705	{"trap", dotrap},
706	{"umask", doumask},
707	{"wait", dowait},
708	{0, 0}
709	};
710
711	static struct op scantree(struct op );
712	static struct op *dowholefile(int, int);
713
714	/* Globals */
715	extern char *environ; / environment pointer */
716
717	static char **dolv;
718	static int dolc;
719	static int exstat;
720	static char gflg;
721	static int interactive; /* Is this an interactive shell */
722	static int execflg;
723	static int multiline; /* \n changed to ; */
724	static struct op outtree; / result from parser */
725	static xint *failpt;
726	static xint *errpt;
727	static struct brkcon *brklist;
728	static int isbreak;
729	static struct wdblock *wdlist;
730	static struct wdblock *iolist;
731	static char *trap[_NSIG + 1];
732	static char ourtrap[_NSIG + 1];
733	static int trapset; /* trap pending */
734	static int yynerrs; /* yacc */
735	static char line[LINELIM];
736
737	#ifdef MSHDEBUG
738	static struct var *mshdbg_var;
739	#endif
740	static struct var vlist; / dictionary */
741	static struct var homedir; / home directory */
742	static struct var prompt; / main prompt */
743	static struct var cprompt; / continuation prompt */
744	static struct var path; / search path for commands */
745	static struct var shell; / shell to interpret command files */
746	static struct var ifs; / field separators */
747
748	static int areanum; /* current allocation area */
749	static int intr;
750	static int inparse;
751	static char flags['z' - 'a' + 1];
752	static char *flag = flags - 'a';
753	static char *null = "";
754	static int heedint = 1;
755	static void (*qflag) (int) = SIG_IGN;
756	static int startl;
757	static int peeksym;
758	static int nlseen;
759	static int iounit = IODEFAULT;
760	static YYSTYPE yylval;
761	static char *elinep = line + sizeof(line) - 5;
762
763	static struct ioarg temparg = { 0, 0, 0, AFID_NOBUF, 0 }; /* temporary for PUSHIO */
764	static struct ioarg ioargstack[NPUSH];
765	static struct io iostack[NPUSH];
766	static struct iobuf sharedbuf = { AFID_NOBUF };
767	static struct iobuf mainbuf = { AFID_NOBUF };
768	static unsigned bufid = AFID_ID; /* buffer id counter */
769
770	static struct here inhere; / list of hear docs while parsing */
771	static struct here acthere; / list of active here documents */
772	static struct region areabot; / bottom of area */
773	static struct region areatop; / top of area */
774	static struct region areanxt; / starting point of scan */
775	static void *brktop;
776	static void *brkaddr;
777
778	static struct env e = {
779	line, /* linep: char ptr */
780	iostack, /* iobase: struct io ptr */
781	iostack - 1, /* iop: struct io ptr */
782	(xint ) NULL, / errpt: void ptr for errors? */
783	FDBASE, /* iofd: file desc */
784	(struct env ) NULL / oenv: struct env ptr */
785	};
786
787	#ifdef MSHDEBUG
788	void print_t(struct op *t);
789	void print_t(struct op *t)
790	{
791	DBGPRINTF(("T: t=%p, type %s, words=%p, IOword=%p\n", t,
792	T_CMD_NAMES[t->type], t->words, t->ioact));
793
794	if (t->words) {
795	DBGPRINTF(("T: W1: %s", t->words[0]));
796	}
797
798	return;
799	}
800
801	void print_tree(struct op *head);
802	void print_tree(struct op *head)
803	{
804	if (head == NULL) {
805	DBGPRINTF(("PRINT_TREE: no tree\n"));
806	return;
807	}
808
809	DBGPRINTF(("NODE: %p, left %p, right %p\n", head, head->left,
810	head->right));
811
812	if (head->left)
813	print_tree(head->left);
814
815	if (head->right)
816	print_tree(head->right);
817
818	return;
819	}
820	#endif /* MSHDEBUG */
821
822
823	#ifdef CONFIG_FEATURE_COMMAND_EDITING
824	static char *current_prompt;
825	#endif
826
827	/* -------- sh.c -------- */
828	/*
829	* shell
830	*/
831
832
833	int msh_main(int argc, char **argv)
834	{
835	REGISTER int f;
836	REGISTER char *s;
837	int cflag;
838	char name, *ap;
839	int (iof) (struct ioarg );
840
841	DBGPRINTF(("MSH_MAIN: argc %d, environ %p\n", argc, environ));
842
843	initarea();
844	if ((ap = environ) != NULL) {
845	while (*ap)
846	assign(*ap++, !COPYV);
847	for (ap = environ; *ap;)
848	export(lookup(*ap++));
849	}
850	closeall();
851	areanum = 1;
852
853	shell = lookup("SHELL");
854	if (shell->value == null)
855	setval(shell, (char *)DEFAULT_SHELL);
856	export(shell);
857
858	homedir = lookup("HOME");
859	if (homedir->value == null)
860	setval(homedir, "/");
861	export(homedir);
862
863	setval(lookup("$"), putn(getpid()));
864
865	path = lookup("PATH");
866	if (path->value == null) {
867	if (geteuid() == 0)
868	setval(path, "/sbin:/bin:/usr/sbin:/usr/bin");
869	else
870	setval(path, "/bin:/usr/bin");
871	}
872	export(path);
873
874	ifs = lookup("IFS");
875	if (ifs->value == null)
876	setval(ifs, " \t\n");
877
878	#ifdef MSHDEBUG
879	mshdbg_var = lookup("MSHDEBUG");
880	if (mshdbg_var->value == null)
881	setval(mshdbg_var, "0");
882	#endif
883
884	prompt = lookup("PS1");
885	#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
886	if (prompt->value == null)
887	#endif
888	setval(prompt, DEFAULT_USER_PROMPT);
889	if (geteuid() == 0) {
890	setval(prompt, DEFAULT_ROOT_PROMPT);
891	prompt->status &= ~EXPORT;
892	}
893	cprompt = lookup("PS2");
894	#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
895	if (cprompt->value == null)
896	#endif
897	setval(cprompt, "> ");
898
899	iof = filechar;
900	cflag = 0;
901	name = *argv++;
902	if (--argc >= 1) {
903	if (argv[0][0] == '-' && argv[0][1] != '\0') {
904	for (s = argv[0] + 1; *s; s++)
905	switch (*s) {
906	case 'c':
907	prompt->status &= ~EXPORT;
908	cprompt->status &= ~EXPORT;
909	setval(prompt, "");
910	setval(cprompt, "");
911	cflag = 1;
912	if (--argc > 0)
913	PUSHIO(aword, *++argv, iof = nlchar);
914	break;
915
916	case 'q':
917	qflag = SIG_DFL;
918	break;
919
920	case 's':
921	/* standard input */
922	break;
923
924	case 't':
925	prompt->status &= ~EXPORT;
926	setval(prompt, "");
927	iof = linechar;
928	break;
929
930	case 'i':
931	interactive++;
932	default:
933	if (s >= 'a' && s <= 'z')
934	flag[(int) *s]++;
935	}
936	} else {
937	argv--;
938	argc++;
939	}
940
941	if (iof == filechar && --argc > 0) {
942	setval(prompt, "");
943	setval(cprompt, "");
944	prompt->status &= ~EXPORT;
945	cprompt->status &= ~EXPORT;
946
947	/* Shell is non-interactive, activate printf-based debug */
948	#ifdef MSHDEBUG
949	mshdbg = (int) (((char) (mshdbg_var->value[0])) - '0');
950	if (mshdbg < 0)
951	mshdbg = 0;
952	#endif
953	DBGPRINTF(("MSH_MAIN: calling newfile()\n"));
954
955	if (newfile(name = *++argv))
956	exit(1); /* Exit on error */
957	}
958	}
959
960	setdash();
961
962	/* This won't be true if PUSHIO has been called, say from newfile() above */
963	if (e.iop < iostack) {
964	PUSHIO(afile, 0, iof);
965	if (isatty(0) && isatty(1) && !cflag) {
966	interactive++;
967	#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
968	#ifdef MSHDEBUG
969	printf("\n\n%s Built-in shell (msh with debug)\n", BB_BANNER);
970	#else
971	printf("\n\n%s Built-in shell (msh)\n", BB_BANNER);
972	#endif
973	printf("Enter 'help' for a list of built-in commands.\n\n");
974	#endif
975	}
976	}
977
978	signal(SIGQUIT, qflag);
979	if (name && name[0] == '-') {
980	interactive++;
981	if ((f = open(".profile", 0)) >= 0)
982	next(remap(f));
983	if ((f = open("/etc/profile", 0)) >= 0)
984	next(remap(f));
985	}
986	if (interactive)
987	signal(SIGTERM, sig);
988
989	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
990	signal(SIGINT, onintr);
991	dolv = argv;
992	dolc = argc;
993	dolv[0] = name;
994	if (dolc > 1) {
995	for (ap = ++argv; --argc > 0;) {
996	if (assign(ap = argv++, !COPYV)) {
997	dolc--; /* keyword */
998	} else {
999	ap++;
1000	}
1001	}
1002	}
1003	setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
1004
1005	DBGPRINTF(("MSH_MAIN: begin FOR loop, interactive %d, e.iop %p, iostack %p\n", interactive, e.iop, iostack));
1006
1007	for (;;) {
1008	if (interactive && e.iop <= iostack) {
1009	#ifdef CONFIG_FEATURE_COMMAND_EDITING
1010	current_prompt = prompt->value;
1011	#else
1012	prs(prompt->value);
1013	#endif
1014	}
1015	onecommand();
1016	/* Ensure that getenv("PATH") stays current */
1017	setenv("PATH", path->value, 1);
1018	}
1019
1020	DBGPRINTF(("MSH_MAIN: returning.\n"));
1021	}
1022
1023	static void setdash(void)
1024	{
1025	REGISTER char *cp;
1026	REGISTER int c;
1027	char m['z' - 'a' + 1];
1028
1029	cp = m;
1030	for (c = 'a'; c <= 'z'; c++)
1031	if (flag[(int) c])
1032	*cp++ = c;
1033	*cp = 0;
1034	setval(lookup("-"), m);
1035	}
1036
1037	static int newfile(REGISTER char *s)
1038	{
1039	REGISTER int f;
1040
1041	DBGPRINTF7(("NEWFILE: opening %s\n", s));
1042
1043	if (strcmp(s, "-") != 0) {
1044	DBGPRINTF(("NEWFILE: s is %s\n", s));
1045	f = open(s, 0);
1046	if (f < 0) {
1047	prs(s);
1048	err(": cannot open");
1049	return (1);
1050	}
1051	} else
1052	f = 0;
1053
1054	next(remap(f));
1055	return (0);
1056	}
1057
1058
1059	struct op scantree(struct op head)
1060	{
1061	struct op *dotnode;
1062
1063	if (head == NULL)
1064	return (NULL);
1065
1066	if (head->left != NULL) {
1067	dotnode = scantree(head->left);
1068	if (dotnode)
1069	return (dotnode);
1070	}
1071
1072	if (head->right != NULL) {
1073	dotnode = scantree(head->right);
1074	if (dotnode)
1075	return (dotnode);
1076	}
1077
1078	if (head->words == NULL)
1079	return (NULL);
1080
1081	DBGPRINTF5(("SCANTREE: checking node %p\n", head));
1082
1083	if ((head->type != TDOT) && (strcmp(".", head->words[0]) == 0)) {
1084	DBGPRINTF5(("SCANTREE: dot found in node %p\n", head));
1085	return (head);
1086	}
1087
1088	return (NULL);
1089	}
1090
1091
1092	static void onecommand(void)
1093	{
1094	REGISTER int i;
1095	jmp_buf m1;
1096
1097	DBGPRINTF(("ONECOMMAND: enter, outtree=%p\n", outtree));
1098
1099	while (e.oenv)
1100	quitenv();
1101
1102	areanum = 1;
1103	freehere(areanum);
1104	freearea(areanum);
1105	garbage();
1106	wdlist = 0;
1107	iolist = 0;
1108	e.errpt = 0;
1109	e.linep = line;
1110	yynerrs = 0;
1111	multiline = 0;
1112	inparse = 1;
1113	intr = 0;
1114	execflg = 0;
1115
1116	setjmp(failpt = m1); /* Bruce Evans' fix */
1117	if (setjmp(failpt = m1) \|\| yyparse() \|\| intr) {
1118
1119	DBGPRINTF(("ONECOMMAND: this is not good.\n"));
1120
1121	while (e.oenv)
1122	quitenv();
1123	scraphere();
1124	if (!interactive && intr)
1125	leave();
1126	inparse = 0;
1127	intr = 0;
1128	return;
1129	}
1130
1131	inparse = 0;
1132	brklist = 0;
1133	intr = 0;
1134	execflg = 0;
1135
1136	if (!flag['n']) {
1137	DBGPRINTF(("ONECOMMAND: calling execute, t=outtree=%p\n",
1138	outtree));
1139	execute(outtree, NOPIPE, NOPIPE, 0);
1140	}
1141
1142	if (!interactive && intr) {
1143	execflg = 0;
1144	leave();
1145	}
1146
1147	if ((i = trapset) != 0) {
1148	trapset = 0;
1149	runtrap(i);
1150	}
1151	}
1152
1153	static void fail(void)
1154	{
1155	longjmp(failpt, 1);
1156	/* NOTREACHED */
1157	}
1158
1159	static void leave(void)
1160	{
1161	DBGPRINTF(("LEAVE: leave called!\n"));
1162
1163	if (execflg)
1164	fail();
1165	scraphere();
1166	freehere(1);
1167	runtrap(0);
1168	_exit(exstat);
1169	/* NOTREACHED */
1170	}
1171
1172	static void warn(REGISTER char *s)
1173	{
1174	if (*s) {
1175	prs(s);
1176	exstat = -1;
1177	}
1178	prs("\n");
1179	if (flag['e'])
1180	leave();
1181	}
1182
1183	static void err(char *s)
1184	{
1185	warn(s);
1186	if (flag['n'])
1187	return;
1188	if (!interactive)
1189	leave();
1190	if (e.errpt)
1191	longjmp(e.errpt, 1);
1192	closeall();
1193	e.iop = e.iobase = iostack;
1194	}
1195
1196	static int newenv(int f)
1197	{
1198	REGISTER struct env *ep;
1199
1200	DBGPRINTF(("NEWENV: f=%d (indicates quitenv and return)\n", f));
1201
1202	if (f) {
1203	quitenv();
1204	return (1);
1205	}
1206
1207	ep = (struct env ) space(sizeof(ep));
1208	if (ep == NULL) {
1209	while (e.oenv)
1210	quitenv();
1211	fail();
1212	}
1213	*ep = e;
1214	e.oenv = ep;
1215	e.errpt = errpt;
1216
1217	return (0);
1218	}
1219
1220	static void quitenv(void)
1221	{
1222	REGISTER struct env *ep;
1223	REGISTER int fd;
1224
1225	DBGPRINTF(("QUITENV: e.oenv=%p\n", e.oenv));
1226
1227	if ((ep = e.oenv) != NULL) {
1228	fd = e.iofd;
1229	e = *ep;
1230	/* should close `'d files */
1231	DELETE(ep);
1232	while (--fd >= e.iofd)
1233	close(fd);
1234	}
1235	}
1236
1237	/*
1238	* Is any character from s1 in s2?
1239	*/
1240	static int anys(REGISTER char s1, REGISTER char s2)
1241	{
1242	while (*s1)
1243	if (any(*s1++, s2))
1244	return (1);
1245	return (0);
1246	}
1247
1248	/*
1249	* Is character c in s?
1250	*/
1251	static int any(REGISTER int c, REGISTER char *s)
1252	{
1253	while (*s)
1254	if (*s++ == c)
1255	return (1);
1256	return (0);
1257	}
1258
1259	static char *putn(REGISTER int n)
1260	{
1261	return (itoa(n));
1262	}
1263
1264	static char *itoa(REGISTER int n)
1265	{
1266	static char s[20];
1267
1268	snprintf(s, sizeof(s), "%u", n);
1269	return (s);
1270	}
1271
1272
1273	static void next(int f)
1274	{
1275	PUSHIO(afile, f, filechar);
1276	}
1277
1278	static void onintr(int s) /* ANSI C requires a parameter */
1279	{
1280	signal(SIGINT, onintr);
1281	intr = 1;
1282	if (interactive) {
1283	if (inparse) {
1284	prs("\n");
1285	fail();
1286	}
1287	} else if (heedint) {
1288	execflg = 0;
1289	leave();
1290	}
1291	}
1292
1293	static char *space(int n)
1294	{
1295	REGISTER char *cp;
1296
1297	if ((cp = getcell(n)) == 0)
1298	err("out of string space");
1299	return (cp);
1300	}
1301
1302	static char strsave(REGISTER char s, int a)
1303	{
1304	REGISTER char cp, xp;
1305
1306	if ((cp = space(strlen(s) + 1)) != NULL) {
1307	setarea((char *) cp, a);
1308	for (xp = cp; (xp++ = s++) != '\0';);
1309	return (cp);
1310	}
1311	return ("");
1312	}
1313
1314	/*
1315	* trap handling
1316	*/
1317	static void sig(REGISTER int i)
1318	{
1319	trapset = i;
1320	signal(i, sig);
1321	}
1322
1323	static void runtrap(int i)
1324	{
1325	char *trapstr;
1326
1327	if ((trapstr = trap[i]) == NULL)
1328	return;
1329
1330	if (i == 0)
1331	trap[i] = 0;
1332
1333	RUN(aword, trapstr, nlchar);
1334	}
1335
1336	/* -------- var.c -------- */
1337
1338	/*
1339	* Find the given name in the dictionary
1340	* and return its value. If the name was
1341	* not previously there, enter it now and
1342	* return a null value.
1343	*/
1344	static struct var lookup(REGISTER char n)
1345	{
1346	REGISTER struct var *vp;
1347	REGISTER char *cp;
1348	REGISTER int c;
1349	static struct var dummy;
1350
1351	if (isdigit(*n)) {
1352	dummy.name = n;
1353	for (c = 0; isdigit(*n) && c < 1000; n++)
1354	c = c * 10 + *n - '0';
1355	dummy.status = RONLY;
1356	dummy.value = c <= dolc ? dolv[c] : null;
1357	return (&dummy);
1358	}
1359	for (vp = vlist; vp; vp = vp->next)
1360	if (eqname(vp->name, n))
1361	return (vp);
1362	cp = findeq(n);
1363	vp = (struct var ) space(sizeof(vp));
1364	if (vp == 0 \|\| (vp->name = space((int) (cp - n) + 2)) == 0) {
1365	dummy.name = dummy.value = "";
1366	return (&dummy);
1367	}
1368	for (cp = vp->name; (cp = n++) && *cp != '='; cp++);
1369	if (*cp == 0)
1370	*cp = '=';
1371	*++cp = 0;
1372	setarea((char *) vp, 0);
1373	setarea((char *) vp->name, 0);
1374	vp->value = null;
1375	vp->next = vlist;
1376	vp->status = GETCELL;
1377	vlist = vp;
1378	return (vp);
1379	}
1380
1381	/*
1382	* give variable at `vp' the value `val'.
1383	*/
1384	static void setval(struct var vp, char val)
1385	{
1386	nameval(vp, val, (char *) NULL);
1387	}
1388
1389	/*
1390	* if name is not NULL, it must be
1391	* a prefix of the space `val',
1392	* and end with `='.
1393	* this is all so that exporting
1394	* values is reasonably painless.
1395	*/
1396	static void nameval(REGISTER struct var vp, char val, char *name)
1397	{
1398	REGISTER char cp, xp;
1399	char *nv;
1400	int fl;
1401
1402	if (vp->status & RONLY) {
1403	for (xp = vp->name; xp && xp != '=';)
1404	putc(*xp++, stderr);
1405	err(" is read-only");
1406	return;
1407	}
1408	fl = 0;
1409	if (name == NULL) {
1410	xp = space(strlen(vp->name) + strlen(val) + 2);
1411	if (xp == 0)
1412	return;
1413	/* make string: name=value */
1414	setarea((char *) xp, 0);
1415	name = xp;
1416	for (cp = vp->name; (xp = cp++) && *xp != '='; xp++);
1417	if (*xp++ == 0)
1418	xp[-1] = '=';
1419	nv = xp;
1420	for (cp = val; (xp++ = cp++) != '\0';);
1421	val = nv;
1422	fl = GETCELL;
1423	}
1424	if (vp->status & GETCELL)
1425	freecell(vp->name); /* form new string `name=value' */
1426	vp->name = name;
1427	vp->value = val;
1428	vp->status \|= fl;
1429	}
1430
1431	static void export(struct var *vp)
1432	{
1433	vp->status \|= EXPORT;
1434	}
1435
1436	static void ronly(struct var *vp)
1437	{
1438	if (isalpha(vp->name[0]) \|\| vp->name[0] == '_') /* not an internal symbol */
1439	vp->status \|= RONLY;
1440	}
1441
1442	static int isassign(REGISTER char *s)
1443	{
1444	DBGPRINTF7(("ISASSIGN: enter, s=%s\n", s));
1445
1446	if (!isalpha((int) s) && s != '_')
1447	return (0);
1448	for (; *s != '='; s++)
1449	if (s == 0 \|\| (!isalnum(s) && *s != '_'))
1450	return (0);
1451
1452	return (1);
1453	}
1454
1455	static int assign(REGISTER char *s, int cf)
1456	{
1457	REGISTER char *cp;
1458	struct var *vp;
1459
1460	DBGPRINTF7(("ASSIGN: enter, s=%s, cf=%d\n", s, cf));
1461
1462	if (!isalpha(s) && s != '_')
1463	return (0);
1464	for (cp = s; *cp != '='; cp++)
1465	if (cp == 0 \|\| (!isalnum(cp) && *cp != '_'))
1466	return (0);
1467	vp = lookup(s);
1468	nameval(vp, ++cp, cf == COPYV ? (char *) NULL : s);
1469	if (cf != COPYV)
1470	vp->status &= ~GETCELL;
1471	return (1);
1472	}
1473
1474	static int checkname(REGISTER char *cp)
1475	{
1476	DBGPRINTF7(("CHECKNAME: enter, cp=%s\n", cp));
1477
1478	if (!isalpha(cp++) && (cp - 1) != '_')
1479	return (0);
1480	while (*cp)
1481	if (!isalnum(cp++) && (cp - 1) != '_')
1482	return (0);
1483	return (1);
1484	}
1485
1486	static void putvlist(REGISTER int f, REGISTER int out)
1487	{
1488	REGISTER struct var *vp;
1489
1490	for (vp = vlist; vp; vp = vp->next)
1491	if (vp->status & f && (isalpha(vp->name) \|\| vp->name == '_')) {
1492	if (vp->status & EXPORT)
1493	write(out, "export ", 7);
1494	if (vp->status & RONLY)
1495	write(out, "readonly ", 9);
1496	write(out, vp->name, (int) (findeq(vp->name) - vp->name));
1497	write(out, "\n", 1);
1498	}
1499	}
1500
1501	static int eqname(REGISTER char n1, REGISTER char n2)
1502	{
1503	for (; n1 != '=' && n1 != 0; n1++)
1504	if (n2++ != n1)
1505	return (0);
1506	return (n2 == 0 \|\| n2 == '=');
1507	}
1508
1509	static char findeq(REGISTER char cp)
1510	{
1511	while (cp != '\0' && cp != '=')
1512	cp++;
1513	return (cp);
1514	}
1515
1516	/* -------- gmatch.c -------- */
1517	/*
1518	* int gmatch(string, pattern)
1519	* char string, pattern;
1520	*
1521	* Match a pattern as in sh(1).
1522	*/
1523
1524	#define CMASK 0377
1525	#define QUOTE 0200
1526	#define QMASK (CMASK&~QUOTE)
1527	#define NOT '!' /* might use ^ */
1528
1529	static int gmatch(REGISTER char s, REGISTER char p)
1530	{
1531	REGISTER int sc, pc;
1532
1533	if (s == NULL \|\| p == NULL)
1534	return (0);
1535	while ((pc = *p++ & CMASK) != '\0') {
1536	sc = *s++ & QMASK;
1537	switch (pc) {
1538	case '[':
1539	if ((p = cclass(p, sc)) == NULL)
1540	return (0);
1541	break;
1542
1543	case '?':
1544	if (sc == 0)
1545	return (0);
1546	break;
1547
1548	case '*':
1549	s--;
1550	do {
1551	if (*p == '\0' \|\| gmatch(s, p))
1552	return (1);
1553	} while (*s++ != '\0');
1554	return (0);
1555
1556	default:
1557	if (sc != (pc & ~QUOTE))
1558	return (0);
1559	}
1560	}
1561	return (*s == 0);
1562	}
1563
1564	static char cclass(REGISTER char p, REGISTER int sub)
1565	{
1566	REGISTER int c, d, not, found;
1567
1568	if ((not = *p == NOT) != 0)
1569	p++;
1570	found = not;
1571	do {
1572	if (*p == '\0')
1573	return ((char *) NULL);
1574	c = *p & CMASK;
1575	if (p[1] == '-' && p[2] != ']') {
1576	d = p[2] & CMASK;
1577	p++;
1578	} else
1579	d = c;
1580	if (c == sub \|\| (c <= sub && sub <= d))
1581	found = !not;
1582	} while (*++p != ']');
1583	return (found ? p + 1 : (char *) NULL);
1584	}
1585
1586
1587	/* -------- area.c -------- */
1588
1589	/*
1590	* All memory between (char )areabot and (char )(areatop+1) is
1591	* exclusively administered by the area management routines.
1592	* It is assumed that sbrk() and brk() manipulate the high end.
1593	*/
1594
1595	#define sbrk(X) ({ void * __q = (void *)-1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})
1596
1597	static void initarea(void)
1598	{
1599	brkaddr = xmalloc(AREASIZE);
1600	brktop = brkaddr + AREASIZE;
1601
1602	while ((long) sbrk(0) & ALIGN)
1603	sbrk(1);
1604	areabot = (struct region *) sbrk(REGSIZE);
1605
1606	areabot->next = areabot;
1607	areabot->area = BUSY;
1608	areatop = areabot;
1609	areanxt = areabot;
1610	}
1611
1612	char *getcell(unsigned nbytes)
1613	{
1614	REGISTER int nregio;
1615	REGISTER struct region p, q;
1616	REGISTER int i;
1617
1618	if (nbytes == 0) {
1619	puts("getcell(0)");
1620	abort();
1621	}
1622	/* silly and defeats the algorithm */
1623	/*
1624	* round upwards and add administration area
1625	*/
1626	nregio = (nbytes + (REGSIZE - 1)) / REGSIZE + 1;
1627	for (p = areanxt;;) {
1628	if (p->area > areanum) {
1629	/*
1630	* merge free cells
1631	*/
1632	while ((q = p->next)->area > areanum && q != areanxt)
1633	p->next = q->next;
1634	/*
1635	* exit loop if cell big enough
1636	*/
1637	if (q >= p + nregio)
1638	goto found;
1639	}
1640	p = p->next;
1641	if (p == areanxt)
1642	break;
1643	}
1644	i = nregio >= GROWBY ? nregio : GROWBY;
1645	p = (struct region ) sbrk(i REGSIZE);
1646	if (p == (struct region *) -1)
1647	return ((char *) NULL);
1648	p--;
1649	if (p != areatop) {
1650	puts("not contig");
1651	abort(); /* allocated areas are contiguous */
1652	}
1653	q = p + i;
1654	p->next = q;
1655	p->area = FREE;
1656	q->next = areabot;
1657	q->area = BUSY;
1658	areatop = q;
1659	found:
1660	/*
1661	* we found a FREE area big enough, pointed to by 'p', and up to 'q'
1662	*/
1663	areanxt = p + nregio;
1664	if (areanxt < q) {
1665	/*
1666	* split into requested area and rest
1667	*/
1668	if (areanxt + 1 > q) {
1669	puts("OOM");
1670	abort(); /* insufficient space left for admin */
1671	}
1672	areanxt->next = q;
1673	areanxt->area = FREE;
1674	p->next = areanxt;
1675	}
1676	p->area = areanum;
1677	return ((char *) (p + 1));
1678	}
1679
1680	static void freecell(char *cp)
1681	{
1682	REGISTER struct region *p;
1683
1684	if ((p = (struct region *) cp) != NULL) {
1685	p--;
1686	if (p < areanxt)
1687	areanxt = p;
1688	p->area = FREE;
1689	}
1690	}
1691
1692	static void freearea(REGISTER int a)
1693	{
1694	REGISTER struct region p, top;
1695
1696	top = areatop;
1697	for (p = areabot; p != top; p = p->next)
1698	if (p->area >= a)
1699	p->area = FREE;
1700	}
1701
1702	static void setarea(char *cp, int a)
1703	{
1704	REGISTER struct region *p;
1705
1706	if ((p = (struct region *) cp) != NULL)
1707	(p - 1)->area = a;
1708	}
1709
1710	int getarea(char *cp)
1711	{
1712	return ((struct region *) cp - 1)->area;
1713	}
1714
1715	static void garbage(void)
1716	{
1717	REGISTER struct region p, q, *top;
1718
1719	top = areatop;
1720	for (p = areabot; p != top; p = p->next) {
1721	if (p->area > areanum) {
1722	while ((q = p->next)->area > areanum)
1723	p->next = q->next;
1724	areanxt = p;
1725	}
1726	}
1727	#ifdef SHRINKBY
1728	if (areatop >= q + SHRINKBY && q->area > areanum) {
1729	brk((char *) (q + 1));
1730	q->next = areabot;
1731	q->area = BUSY;
1732	areatop = q;
1733	}
1734	#endif
1735	}
1736
1737	/* -------- csyn.c -------- */
1738	/*
1739	* shell: syntax (C version)
1740	*/
1741
1742	int yyparse(void)
1743	{
1744	DBGPRINTF7(("YYPARSE: enter...\n"));
1745
1746	startl = 1;
1747	peeksym = 0;
1748	yynerrs = 0;
1749	outtree = c_list();
1750	musthave('\n', 0);
1751	return (yynerrs != 0);
1752	}
1753
1754	static struct op *pipeline(int cf)
1755	{
1756	REGISTER struct op t, p;
1757	REGISTER int c;
1758
1759	DBGPRINTF7(("PIPELINE: enter, cf=%d\n", cf));
1760
1761	t = command(cf);
1762
1763	DBGPRINTF9(("PIPELINE: t=%p\n", t));
1764
1765	if (t != NULL) {
1766	while ((c = yylex(0)) == '\|') {
1767	if ((p = command(CONTIN)) == NULL) {
1768	DBGPRINTF8(("PIPELINE: error!\n"));
1769	SYNTAXERR;
1770	}
1771
1772	if (t->type != TPAREN && t->type != TCOM) {
1773	/* shell statement */
1774	t = block(TPAREN, t, NOBLOCK, NOWORDS);
1775	}
1776
1777	t = block(TPIPE, t, p, NOWORDS);
1778	}
1779	peeksym = c;
1780	}
1781
1782	DBGPRINTF7(("PIPELINE: returning t=%p\n", t));
1783	return (t);
1784	}
1785
1786	static struct op *andor(void)
1787	{
1788	REGISTER struct op t, p;
1789	REGISTER int c;
1790
1791	DBGPRINTF7(("ANDOR: enter...\n"));
1792
1793	t = pipeline(0);
1794
1795	DBGPRINTF9(("ANDOR: t=%p\n", t));
1796
1797	if (t != NULL) {
1798	while ((c = yylex(0)) == LOGAND \|\| c == LOGOR) {
1799	if ((p = pipeline(CONTIN)) == NULL) {
1800	DBGPRINTF8(("ANDOR: error!\n"));
1801	SYNTAXERR;
1802	}
1803
1804	t = block(c == LOGAND ? TAND : TOR, t, p, NOWORDS);
1805	} /* WHILE */
1806
1807	peeksym = c;
1808	}
1809
1810	DBGPRINTF7(("ANDOR: returning t=%p\n", t));
1811	return (t);
1812	}
1813
1814	static struct op *c_list(void)
1815	{
1816	REGISTER struct op t, p;
1817	REGISTER int c;
1818
1819	DBGPRINTF7(("C_LIST: enter...\n"));
1820
1821	t = andor();
1822
1823	if (t != NULL) {
1824	if ((peeksym = yylex(0)) == '&')
1825	t = block(TASYNC, t, NOBLOCK, NOWORDS);
1826
1827	while ((c = yylex(0)) == ';' \|\| c == '&'
1828	\|\| (multiline && c == '\n')) {
1829
1830	if ((p = andor()) == NULL)
1831	return (t);
1832
1833	if ((peeksym = yylex(0)) == '&')
1834	p = block(TASYNC, p, NOBLOCK, NOWORDS);
1835
1836	t = list(t, p);
1837	} /* WHILE */
1838
1839	peeksym = c;
1840	}
1841	/* IF */
1842	DBGPRINTF7(("C_LIST: returning t=%p\n", t));
1843	return (t);
1844	}
1845
1846	static int synio(int cf)
1847	{
1848	REGISTER struct ioword *iop;
1849	REGISTER int i;
1850	REGISTER int c;
1851
1852	DBGPRINTF7(("SYNIO: enter, cf=%d\n", cf));
1853
1854	if ((c = yylex(cf)) != '<' && c != '>') {
1855	peeksym = c;
1856	return (0);
1857	}
1858
1859	i = yylval.i;
1860	musthave(WORD, 0);
1861	iop = io(iounit, i, yylval.cp);
1862	iounit = IODEFAULT;
1863
1864	if (i & IOHERE)
1865	markhere(yylval.cp, iop);
1866
1867	DBGPRINTF7(("SYNIO: returning 1\n"));
1868	return (1);
1869	}
1870
1871	static void musthave(int c, int cf)
1872	{
1873	if ((peeksym = yylex(cf)) != c) {
1874	DBGPRINTF7(("MUSTHAVE: error!\n"));
1875	SYNTAXERR;
1876	}
1877
1878	peeksym = 0;
1879	}
1880
1881	static struct op *simple(void)
1882	{
1883	REGISTER struct op *t;
1884
1885	t = NULL;
1886	for (;;) {
1887	switch (peeksym = yylex(0)) {
1888	case '<':
1889	case '>':
1890	(void) synio(0);
1891	break;
1892
1893	case WORD:
1894	if (t == NULL) {
1895	t = newtp();
1896	t->type = TCOM;
1897	}
1898	peeksym = 0;
1899	word(yylval.cp);
1900	break;
1901
1902	default:
1903	return (t);
1904	}
1905	}
1906	}
1907
1908	static struct op *nested(int type, int mark)
1909	{
1910	REGISTER struct op *t;
1911
1912	DBGPRINTF3(("NESTED: enter, type=%d, mark=%d\n", type, mark));
1913
1914	multiline++;
1915	t = c_list();
1916	musthave(mark, 0);
1917	multiline--;
1918	return (block(type, t, NOBLOCK, NOWORDS));
1919	}
1920
1921	static struct op *command(int cf)
1922	{
1923	REGISTER struct op *t;
1924	struct wdblock *iosave;
1925	REGISTER int c;
1926
1927	DBGPRINTF(("COMMAND: enter, cf=%d\n", cf));
1928
1929	iosave = iolist;
1930	iolist = NULL;
1931
1932	if (multiline)
1933	cf \|= CONTIN;
1934
1935	while (synio(cf))
1936	cf = 0;
1937
1938	c = yylex(cf);
1939
1940	switch (c) {
1941	default:
1942	peeksym = c;
1943	if ((t = simple()) == NULL) {
1944	if (iolist == NULL)
1945	return ((struct op *) NULL);
1946	t = newtp();
1947	t->type = TCOM;
1948	}
1949	break;
1950
1951	case '(':
1952	t = nested(TPAREN, ')');
1953	break;
1954
1955	case '{':
1956	t = nested(TBRACE, '}');
1957	break;
1958
1959	case FOR:
1960	t = newtp();
1961	t->type = TFOR;
1962	musthave(WORD, 0);
1963	startl = 1;
1964	t->str = yylval.cp;
1965	multiline++;
1966	t->words = wordlist();
1967	if ((c = yylex(0)) != '\n' && c != ';')
1968	peeksym = c;
1969	t->left = dogroup(0);
1970	multiline--;
1971	break;
1972
1973	case WHILE:
1974	case UNTIL:
1975	multiline++;
1976	t = newtp();
1977	t->type = c == WHILE ? TWHILE : TUNTIL;
1978	t->left = c_list();
1979	t->right = dogroup(1);
1980	t->words = NULL;
1981	multiline--;
1982	break;
1983
1984	case CASE:
1985	t = newtp();
1986	t->type = TCASE;
1987	musthave(WORD, 0);
1988	t->str = yylval.cp;
1989	startl++;
1990	multiline++;
1991	musthave(IN, CONTIN);
1992	startl++;
1993
1994	t->left = caselist();
1995
1996	musthave(ESAC, 0);
1997	multiline--;
1998	break;
1999
2000	case IF:
2001	multiline++;
2002	t = newtp();
2003	t->type = TIF;
2004	t->left = c_list();
2005	t->right = thenpart();
2006	musthave(FI, 0);
2007	multiline--;
2008	break;
2009
2010	case DOT:
2011	t = newtp();
2012	t->type = TDOT;
2013
2014	musthave(WORD, 0); /* gets name of file */
2015	DBGPRINTF7(("COMMAND: DOT clause, yylval.cp is %s\n", yylval.cp));
2016
2017	word(yylval.cp); /* add word to wdlist */
2018	word(NOWORD); /* terminate wdlist */
2019	t->words = copyw(); /* dup wdlist */
2020	break;
2021
2022	}
2023
2024	while (synio(0));
2025
2026	t = namelist(t);
2027	iolist = iosave;
2028
2029	DBGPRINTF(("COMMAND: returning %p\n", t));
2030
2031	return (t);
2032	}
2033
2034	static struct op *dowholefile(int type, int mark)
2035	{
2036	REGISTER struct op *t;
2037
2038	DBGPRINTF(("DOWHOLEFILE: enter, type=%d, mark=%d\n", type, mark));
2039
2040	multiline++;
2041	t = c_list();
2042	multiline--;
2043	t = block(type, t, NOBLOCK, NOWORDS);
2044	DBGPRINTF(("DOWHOLEFILE: return t=%p\n", t));
2045	return (t);
2046	}
2047
2048	static struct op *dogroup(int onlydone)
2049	{
2050	REGISTER int c;
2051	REGISTER struct op *mylist;
2052
2053	c = yylex(CONTIN);
2054	if (c == DONE && onlydone)
2055	return ((struct op *) NULL);
2056	if (c != DO)
2057	SYNTAXERR;
2058	mylist = c_list();
2059	musthave(DONE, 0);
2060	return (mylist);
2061	}
2062
2063	static struct op *thenpart(void)
2064	{
2065	REGISTER int c;
2066	REGISTER struct op *t;
2067
2068	if ((c = yylex(0)) != THEN) {
2069	peeksym = c;
2070	return ((struct op *) NULL);
2071	}
2072	t = newtp();
2073	t->type = 0;
2074	t->left = c_list();
2075	if (t->left == NULL)
2076	SYNTAXERR;
2077	t->right = elsepart();
2078	return (t);
2079	}
2080
2081	static struct op *elsepart(void)
2082	{
2083	REGISTER int c;
2084	REGISTER struct op *t;
2085
2086	switch (c = yylex(0)) {
2087	case ELSE:
2088	if ((t = c_list()) == NULL)
2089	SYNTAXERR;
2090	return (t);
2091
2092	case ELIF:
2093	t = newtp();
2094	t->type = TELIF;
2095	t->left = c_list();
2096	t->right = thenpart();
2097	return (t);
2098
2099	default:
2100	peeksym = c;
2101	return ((struct op *) NULL);
2102	}
2103	}
2104
2105	static struct op *caselist(void)
2106	{
2107	REGISTER struct op *t;
2108
2109	t = NULL;
2110	while ((peeksym = yylex(CONTIN)) != ESAC) {
2111	DBGPRINTF(("CASELIST, doing yylex, peeksym=%d\n", peeksym));
2112	t = list(t, casepart());
2113	}
2114
2115	DBGPRINTF(("CASELIST, returning t=%p\n", t));
2116	return (t);
2117	}
2118
2119	static struct op *casepart(void)
2120	{
2121	REGISTER struct op *t;
2122
2123	DBGPRINTF7(("CASEPART: enter...\n"));
2124
2125	t = newtp();
2126	t->type = TPAT;
2127	t->words = pattern();
2128	musthave(')', 0);
2129	t->left = c_list();
2130	if ((peeksym = yylex(CONTIN)) != ESAC)
2131	musthave(BREAK, CONTIN);
2132
2133	DBGPRINTF7(("CASEPART: made newtp(TPAT, t=%p)\n", t));
2134
2135	return (t);
2136	}
2137
2138	static char **pattern(void)
2139	{
2140	REGISTER int c, cf;
2141
2142	cf = CONTIN;
2143	do {
2144	musthave(WORD, cf);
2145	word(yylval.cp);
2146	cf = 0;
2147	} while ((c = yylex(0)) == '\|');
2148	peeksym = c;
2149	word(NOWORD);
2150
2151	return (copyw());
2152	}
2153
2154	static char **wordlist(void)
2155	{
2156	REGISTER int c;
2157
2158	if ((c = yylex(0)) != IN) {
2159	peeksym = c;
2160	return ((char **) NULL);
2161	}
2162	startl = 0;
2163	while ((c = yylex(0)) == WORD)
2164	word(yylval.cp);
2165	word(NOWORD);
2166	peeksym = c;
2167	return (copyw());
2168	}
2169
2170	/*
2171	* supporting functions
2172	*/
2173	static struct op list(REGISTER struct op t1, REGISTER struct op *t2)
2174	{
2175	DBGPRINTF7(("LIST: enter, t1=%p, t2=%p\n", t1, t2));
2176
2177	if (t1 == NULL)
2178	return (t2);
2179	if (t2 == NULL)
2180	return (t1);
2181
2182	return (block(TLIST, t1, t2, NOWORDS));
2183	}
2184
2185	static struct op block(int type, struct op t1, struct op t2, char *wp)
2186	{
2187	REGISTER struct op *t;
2188
2189	DBGPRINTF7(("BLOCK: enter, type=%d (%s)\n", type, T_CMD_NAMES[type]));
2190
2191	t = newtp();
2192	t->type = type;
2193	t->left = t1;
2194	t->right = t2;
2195	t->words = wp;
2196
2197	DBGPRINTF7(("BLOCK: inserted %p between %p and %p\n", t, t1,
2198	t2));
2199
2200	return (t);
2201	}
2202
2203	/* See if given string is a shell multiline (FOR, IF, etc) */
2204	static int rlookup(REGISTER char *n)
2205	{
2206	REGISTER const struct res *rp;
2207
2208	DBGPRINTF7(("RLOOKUP: enter, n is %s\n", n));
2209
2210	for (rp = restab; rp->r_name; rp++)
2211	if (strcmp(rp->r_name, n) == 0) {
2212	DBGPRINTF7(("RLOOKUP: match, returning %d\n", rp->r_val));
2213	return (rp->r_val); /* Return numeric code for shell multiline */
2214	}
2215
2216	DBGPRINTF7(("RLOOKUP: NO match, returning 0\n"));
2217	return (0); /* Not a shell multiline */
2218	}
2219
2220	static struct op *newtp(void)
2221	{
2222	REGISTER struct op *t;
2223
2224	t = (struct op ) tree(sizeof(t));
2225	t->type = 0;
2226	t->words = NULL;
2227	t->ioact = NULL;
2228	t->left = NULL;
2229	t->right = NULL;
2230	t->str = NULL;
2231
2232	DBGPRINTF3(("NEWTP: allocated %p\n", t));
2233
2234	return (t);
2235	}
2236
2237	static struct op namelist(REGISTER struct op t)
2238	{
2239
2240	DBGPRINTF7(("NAMELIST: enter, t=%p, type %s, iolist=%p\n", t,
2241	T_CMD_NAMES[t->type], iolist));
2242
2243	if (iolist) {
2244	iolist = addword((char *) NULL, iolist);
2245	t->ioact = copyio();
2246	} else
2247	t->ioact = NULL;
2248
2249	if (t->type != TCOM) {
2250	if (t->type != TPAREN && t->ioact != NULL) {
2251	t = block(TPAREN, t, NOBLOCK, NOWORDS);
2252	t->ioact = t->left->ioact;
2253	t->left->ioact = NULL;
2254	}
2255	return (t);
2256	}
2257
2258	word(NOWORD);
2259	t->words = copyw();
2260
2261
2262	return (t);
2263	}
2264
2265	static char **copyw(void)
2266	{
2267	REGISTER char **wd;
2268
2269	wd = getwords(wdlist);
2270	wdlist = 0;
2271	return (wd);
2272	}
2273
2274	static void word(char *cp)
2275	{
2276	wdlist = addword(cp, wdlist);
2277	}
2278
2279	static struct ioword **copyio(void)
2280	{
2281	REGISTER struct ioword **iop;
2282
2283	iop = (struct ioword **) getwords(iolist);
2284	iolist = 0;
2285	return (iop);
2286	}
2287
2288	static struct ioword io(int u, int f, char cp)
2289	{
2290	REGISTER struct ioword *iop;
2291
2292	iop = (struct ioword ) tree(sizeof(iop));
2293	iop->io_unit = u;
2294	iop->io_flag = f;
2295	iop->io_name = cp;
2296	iolist = addword((char *) iop, iolist);
2297	return (iop);
2298	}
2299
2300	static void zzerr(void)
2301	{
2302	yyerror("syntax error");
2303	}
2304
2305	static void yyerror(char *s)
2306	{
2307	yynerrs++;
2308	if (interactive && e.iop <= iostack) {
2309	multiline = 0;
2310	while (eofc() == 0 && yylex(0) != '\n');
2311	}
2312	err(s);
2313	fail();
2314	}
2315
2316	static int yylex(int cf)
2317	{
2318	REGISTER int c, c1;
2319	int atstart;
2320
2321	if ((c = peeksym) > 0) {
2322	peeksym = 0;
2323	if (c == '\n')
2324	startl = 1;
2325	return (c);
2326	}
2327
2328
2329	nlseen = 0;
2330	atstart = startl;
2331	startl = 0;
2332	yylval.i = 0;
2333	e.linep = line;
2334
2335	/* MALAMO */
2336	line[LINELIM - 1] = '\0';
2337
2338	loop:
2339	while ((c = my_getc(0)) == ' ' \|\| c == '\t') /* Skip whitespace */
2340	;
2341
2342	switch (c) {
2343	default:
2344	if (any(c, "0123456789")) {
2345	unget(c1 = my_getc(0));
2346	if (c1 == '<' \|\| c1 == '>') {
2347	iounit = c - '0';
2348	goto loop;
2349	}
2350	*e.linep++ = c;
2351	c = c1;
2352	}
2353	break;
2354
2355	case '#': /* Comment, skip to next newline or End-of-string */
2356	while ((c = my_getc(0)) != 0 && c != '\n');
2357	unget(c);
2358	goto loop;
2359
2360	case 0:
2361	DBGPRINTF5(("YYLEX: return 0, c=%d\n", c));
2362	return (c);
2363
2364	case '$':
2365	DBGPRINTF9(("YYLEX: found $\n"));
2366	*e.linep++ = c;
2367	if ((c = my_getc(0)) == '{') {
2368	if ((c = collect(c, '}')) != '\0')
2369	return (c);
2370	goto pack;
2371	}
2372	break;
2373
2374	case '`':
2375	case '\'':
2376	case '"':
2377	if ((c = collect(c, c)) != '\0')
2378	return (c);
2379	goto pack;
2380
2381	case '\|':
2382	case '&':
2383	case ';':
2384	startl = 1;
2385	/* If more chars process them, else return NULL char */
2386	if ((c1 = dual(c)) != '\0')
2387	return (c1);
2388	else
2389	return (c);
2390
2391	case '^':
2392	startl = 1;
2393	return ('\|');
2394	case '>':
2395	case '<':
2396	diag(c);
2397	return (c);
2398
2399	case '\n':
2400	nlseen++;
2401	gethere();
2402	startl = 1;
2403	if (multiline \|\| cf & CONTIN) {
2404	if (interactive && e.iop <= iostack) {
2405	#ifdef CONFIG_FEATURE_COMMAND_EDITING
2406	current_prompt = cprompt->value;
2407	#else
2408	prs(cprompt->value);
2409	#endif
2410	}
2411	if (cf & CONTIN)
2412	goto loop;
2413	}
2414	return (c);
2415
2416	case '(':
2417	case ')':
2418	startl = 1;
2419	return (c);
2420	}
2421
2422	unget(c);
2423
2424	pack:
2425	while ((c = my_getc(0)) != 0 && !any(c, "`$ '\"\t;&<>()\|^\n")) {
2426	if (e.linep >= elinep)
2427	err("word too long");
2428	else
2429	*e.linep++ = c;
2430	};
2431
2432	unget(c);
2433
2434	if (any(c, "\"'`$"))
2435	goto loop;
2436
2437	*e.linep++ = '\0';
2438
2439	if (atstart && (c = rlookup(line)) != 0) {
2440	startl = 1;
2441	return (c);
2442	}
2443
2444	yylval.cp = strsave(line, areanum);
2445	return (WORD);
2446	}
2447
2448
2449	static int collect(REGISTER int c, REGISTER int c1)
2450	{
2451	char s[2];
2452
2453	DBGPRINTF8(("COLLECT: enter, c=%d, c1=%d\n", c, c1));
2454
2455	*e.linep++ = c;
2456	while ((c = my_getc(c1)) != c1) {
2457	if (c == 0) {
2458	unget(c);
2459	s[0] = c1;
2460	s[1] = 0;
2461	prs("no closing ");
2462	yyerror(s);
2463	return (YYERRCODE);
2464	}
2465	if (interactive && c == '\n' && e.iop <= iostack) {
2466	#ifdef CONFIG_FEATURE_COMMAND_EDITING
2467	current_prompt = cprompt->value;
2468	#else
2469	prs(cprompt->value);
2470	#endif
2471	}
2472	*e.linep++ = c;
2473	}
2474
2475	*e.linep++ = c;
2476
2477	DBGPRINTF8(("COLLECT: return 0, line is %s\n", line));
2478
2479	return (0);
2480	}
2481
2482	/* "multiline commands" helper func */
2483	/* see if next 2 chars form a shell multiline */
2484	static int dual(REGISTER int c)
2485	{
2486	char s[3];
2487	REGISTER char *cp = s;
2488
2489	DBGPRINTF8(("DUAL: enter, c=%d\n", c));
2490
2491	cp++ = c; / c is the given "peek" char */
2492	cp++ = my_getc(0); / get next char of input */
2493	cp = 0; / add EOS marker */
2494
2495	c = rlookup(s); /* see if 2 chars form a shell multiline */
2496	if (c == 0)
2497	unget(--cp); / String is not a shell multiline, put peek char back */
2498
2499	return (c); /* String is multiline, return numeric multiline (restab) code */
2500	}
2501
2502	static void diag(REGISTER int ec)
2503	{
2504	REGISTER int c;
2505
2506	DBGPRINTF8(("DIAG: enter, ec=%d\n", ec));
2507
2508	c = my_getc(0);
2509	if (c == '>' \|\| c == '<') {
2510	if (c != ec)
2511	zzerr();
2512	yylval.i = ec == '>' ? IOWRITE \| IOCAT : IOHERE;
2513	c = my_getc(0);
2514	} else
2515	yylval.i = ec == '>' ? IOWRITE : IOREAD;
2516	if (c != '&' \|\| yylval.i == IOHERE)
2517	unget(c);
2518	else
2519	yylval.i \|= IODUP;
2520	}
2521
2522	static char *tree(unsigned size)
2523	{
2524	REGISTER char *t;
2525
2526	if ((t = getcell(size)) == NULL) {
2527	DBGPRINTF2(("TREE: getcell(%d) failed!\n", size));
2528	prs("command line too complicated\n");
2529	fail();
2530	/* NOTREACHED */
2531	}
2532	return (t);
2533	}
2534
2535	/* VARARGS1 */
2536	/* ARGSUSED */
2537
2538	/* -------- exec.c -------- */
2539
2540	/*
2541	* execute tree
2542	*/
2543
2544
2545	static int execute(REGISTER struct op t, int pin, int *pout, int act)
2546	{
2547	REGISTER struct op *t1;
2548	volatile int i, rv, a;
2549	char cp, wp, *wp2;
2550	struct var *vp;
2551	struct op *outtree_save;
2552	struct brkcon bc;
2553
2554	#if __GNUC__
2555	/* Avoid longjmp clobbering */
2556	(void) &wp;
2557	#endif
2558
2559	if (t == NULL) {
2560	DBGPRINTF4(("EXECUTE: enter, t==null, returning.\n"));
2561	return (0);
2562	}
2563
2564	DBGPRINTF(("EXECUTE: t=%p, t->type=%d (%s), t->words is %s\n", t,
2565	t->type, T_CMD_NAMES[t->type],
2566	((t->words == NULL) ? "NULL" : t->words[0])));
2567
2568	rv = 0;
2569	a = areanum++;
2570	wp = (wp2 = t->words) != NULL
2571	? eval(wp2, t->type == TCOM ? DOALL : DOALL & ~DOKEY)
2572	: NULL;
2573
2574	/* Hard to know how many words there are, be careful of garbage pointer values */
2575	/* They are likely to cause "PCI bus fault" errors */
2576	#if 0
2577	DBGPRINTF(("EXECUTE: t->left=%p, t->right=%p, t->words[1] is %s\n",
2578	t->left, t->right,
2579	((t->words[1] == NULL) ? "NULL" : t->words[1])));
2580	DBGPRINTF7(("EXECUTE: t->words[2] is %s, t->words[3] is %s\n",
2581	((t->words[2] == NULL) ? "NULL" : t->words[2]),
2582	((t->words[3] == NULL) ? "NULL" : t->words[3])));
2583	#endif
2584
2585
2586	switch (t->type) {
2587	case TDOT:
2588	DBGPRINTF3(("EXECUTE: TDOT\n"));
2589
2590	outtree_save = outtree;
2591
2592	newfile(evalstr(t->words[0], DOALL));
2593
2594	t->left = dowholefile(TLIST, 0);
2595	t->right = NULL;
2596
2597	outtree = outtree_save;
2598
2599	if (t->left)
2600	rv = execute(t->left, pin, pout, 0);
2601	if (t->right)
2602	rv = execute(t->right, pin, pout, 0);
2603	break;
2604
2605	case TPAREN:
2606	rv = execute(t->left, pin, pout, 0);
2607	break;
2608
2609	case TCOM:
2610	{
2611	rv = forkexec(t, pin, pout, act, wp);
2612	}
2613	break;
2614
2615	case TPIPE:
2616	{
2617	int pv[2];
2618
2619	if ((rv = openpipe(pv)) < 0)
2620	break;
2621	pv[0] = remap(pv[0]);
2622	pv[1] = remap(pv[1]);
2623	(void) execute(t->left, pin, pv, 0);
2624	rv = execute(t->right, pv, pout, 0);
2625	}
2626	break;
2627
2628	case TLIST:
2629	(void) execute(t->left, pin, pout, 0);
2630	rv = execute(t->right, pin, pout, 0);
2631	break;
2632
2633	case TASYNC:
2634	{
2635	int hinteractive = interactive;
2636
2637	DBGPRINTF7(("EXECUTE: TASYNC clause, calling vfork()...\n"));
2638
2639	i = vfork();
2640	if (i != 0) {
2641	interactive = hinteractive;
2642	if (i != -1) {
2643	setval(lookup("!"), putn(i));
2644	if (pin != NULL)
2645	closepipe(pin);
2646	if (interactive) {
2647	prs(putn(i));
2648	prs("\n");
2649	}
2650	} else
2651	rv = -1;
2652	setstatus(rv);
2653	} else {
2654	signal(SIGINT, SIG_IGN);
2655	signal(SIGQUIT, SIG_IGN);
2656	if (interactive)
2657	signal(SIGTERM, SIG_DFL);
2658	interactive = 0;
2659	if (pin == NULL) {
2660	close(0);
2661	open(bb_dev_null, 0);
2662	}
2663	_exit(execute(t->left, pin, pout, FEXEC));
2664	}
2665	}
2666	break;
2667
2668	case TOR:
2669	case TAND:
2670	rv = execute(t->left, pin, pout, 0);
2671	if ((t1 = t->right) != NULL && (rv == 0) == (t->type == TAND))
2672	rv = execute(t1, pin, pout, 0);
2673	break;
2674
2675	case TFOR:
2676	if (wp == NULL) {
2677	wp = dolv + 1;
2678	if ((i = dolc) < 0)
2679	i = 0;
2680	} else {
2681	i = -1;
2682	while (*wp++ != NULL);
2683	}
2684	vp = lookup(t->str);
2685	while (setjmp(bc.brkpt))
2686	if (isbreak)
2687	goto broken;
2688	brkset(&bc);
2689	for (t1 = t->left; i-- && *wp != NULL;) {
2690	setval(vp, *wp++);
2691	rv = execute(t1, pin, pout, 0);
2692	}
2693	brklist = brklist->nextlev;
2694	break;
2695
2696	case TWHILE:
2697	case TUNTIL:
2698	while (setjmp(bc.brkpt))
2699	if (isbreak)
2700	goto broken;
2701	brkset(&bc);
2702	t1 = t->left;
2703	while ((execute(t1, pin, pout, 0) == 0) == (t->type == TWHILE))
2704	rv = execute(t->right, pin, pout, 0);
2705	brklist = brklist->nextlev;
2706	break;
2707
2708	case TIF:
2709	case TELIF:
2710	if (t->right != NULL) {
2711	rv = !execute(t->left, pin, pout, 0) ?
2712	execute(t->right->left, pin, pout, 0) :
2713	execute(t->right->right, pin, pout, 0);
2714	}
2715	break;
2716
2717	case TCASE:
2718	if ((cp = evalstr(t->str, DOSUB \| DOTRIM)) == 0)
2719	cp = "";
2720
2721	DBGPRINTF7(("EXECUTE: TCASE, t->str is %s, cp is %s\n",
2722	((t->str == NULL) ? "NULL" : t->str),
2723	((cp == NULL) ? "NULL" : cp)));
2724
2725	if ((t1 = findcase(t->left, cp)) != NULL) {
2726	DBGPRINTF7(("EXECUTE: TCASE, calling execute(t=%p, t1=%p)...\n", t, t1));
2727	rv = execute(t1, pin, pout, 0);
2728	DBGPRINTF7(("EXECUTE: TCASE, back from execute(t=%p, t1=%p)...\n", t, t1));
2729	}
2730	break;
2731
2732	case TBRACE:
2733	/*
2734	if (iopp = t->ioact)
2735	while (*iopp)
2736	if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
2737	rv = -1;
2738	break;
2739	}
2740	*/
2741	if (rv >= 0 && (t1 = t->left))
2742	rv = execute(t1, pin, pout, 0);
2743	break;
2744
2745	};
2746
2747	broken:
2748	t->words = wp2;
2749	isbreak = 0;
2750	freehere(areanum);
2751	freearea(areanum);
2752	areanum = a;
2753	if (interactive && intr) {
2754	closeall();
2755	fail();
2756	}
2757
2758	if ((i = trapset) != 0) {
2759	trapset = 0;
2760	runtrap(i);
2761	}
2762
2763	DBGPRINTF(("EXECUTE: returning from t=%p, rv=%d\n", t, rv));
2764	return (rv);
2765	}
2766
2767	static int
2768	forkexec(REGISTER struct op t, int pin, int pout, int act, char *wp)
2769	{
2770	pid_t newpid;
2771	int i, rv;
2772	int (shcom) (struct op ) = NULL;
2773	REGISTER int f;
2774	char *cp = NULL;
2775	struct ioword **iopp;
2776	int resetsig;
2777	char **owp;
2778	int forked = 0;
2779
2780	int *hpin = pin;
2781	int *hpout = pout;
2782	char *hwp;
2783	int hinteractive;
2784	int hintr;
2785	struct brkcon *hbrklist;
2786	int hexecflg;
2787
2788	#if __GNUC__
2789	/* Avoid longjmp clobbering */
2790	(void) &pin;
2791	(void) &pout;
2792	(void) &wp;
2793	(void) &shcom;
2794	(void) &cp;
2795	(void) &resetsig;
2796	(void) &owp;
2797	#endif
2798
2799	DBGPRINTF(("FORKEXEC: t=%p, pin %p, pout %p, act %d\n", t, pin,
2800	pout, act));
2801	DBGPRINTF7(("FORKEXEC: t->words is %s\n",
2802	((t->words == NULL) ? "NULL" : t->words[0])));
2803
2804	/* Hard to know how many words there are, be careful of garbage pointer values */
2805	/* They are likely to cause "PCI bus fault" errors */
2806	#if 0
2807	DBGPRINTF7(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
2808	((t->words == NULL) ? "NULL" : t->words[0]),
2809	((t->words == NULL) ? "NULL" : t->words[1])));
2810	DBGPRINTF7(("FORKEXEC: wp is %s, wp[1] is %s\n",
2811	((wp == NULL) ? "NULL" : wp[0]),
2812	((wp[1] == NULL) ? "NULL" : wp[1])));
2813	DBGPRINTF7(("FORKEXEC: wp2 is %s, wp[3] is %s\n",
2814	((wp[2] == NULL) ? "NULL" : wp[2]),
2815	((wp[3] == NULL) ? "NULL" : wp[3])));
2816	#endif
2817
2818
2819	owp = wp;
2820	resetsig = 0;
2821	rv = -1; /* system-detected error */
2822	if (t->type == TCOM) {
2823	while ((cp = *wp++) != NULL);
2824	cp = *wp;
2825
2826	/* strip all initial assignments */
2827	/* not correct wrt PATH=yyy command etc */
2828	if (flag['x']) {
2829	DBGPRINTF9(("FORKEXEC: echo'ing, cp=%p, wp=%p, owp=%p\n",
2830	cp, wp, owp));
2831	echo(cp ? wp : owp);
2832	}
2833	#if 0
2834	DBGPRINTF9(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
2835	((t->words == NULL) ? "NULL" : t->words[0]),
2836	((t->words == NULL) ? "NULL" : t->words[1])));
2837	DBGPRINTF9(("FORKEXEC: wp is %s, wp[1] is %s\n",
2838	((wp == NULL) ? "NULL" : wp[0]),
2839	((wp == NULL) ? "NULL" : wp[1])));
2840	#endif
2841
2842	if (cp == NULL && t->ioact == NULL) {
2843	while ((cp = *owp++) != NULL && assign(cp, COPYV));
2844	DBGPRINTF(("FORKEXEC: returning setstatus()\n"));
2845	return (setstatus(0));
2846	} else if (cp != NULL) {
2847	shcom = inbuilt(cp);
2848	}
2849	}
2850
2851	t->words = wp;
2852	f = act;
2853
2854	#if 0
2855	DBGPRINTF3(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
2856	((t->words == NULL) ? "NULL" : t->words[0]),
2857	((t->words == NULL) ? "NULL" : t->words[1])));
2858	#endif
2859	DBGPRINTF(("FORKEXEC: shcom %p, f&FEXEC 0x%x, owp %p\n", shcom,
2860	f & FEXEC, owp));
2861
2862	if (shcom == NULL && (f & FEXEC) == 0) {
2863	/* Save values in case the child process alters them */
2864	hpin = pin;
2865	hpout = pout;
2866	hwp = *wp;
2867	hinteractive = interactive;
2868	hintr = intr;
2869	hbrklist = brklist;
2870	hexecflg = execflg;
2871
2872	DBGPRINTF3(("FORKEXEC: calling vfork()...\n"));
2873
2874	newpid = vfork();
2875
2876	if (newpid == -1) {
2877	DBGPRINTF(("FORKEXEC: ERROR, unable to vfork()!\n"));
2878	return (-1);
2879	}
2880
2881
2882	if (newpid > 0) { /* Parent */
2883
2884	/* Restore values */
2885	pin = hpin;
2886	pout = hpout;
2887	*wp = hwp;
2888	interactive = hinteractive;
2889	intr = hintr;
2890	brklist = hbrklist;
2891	execflg = hexecflg;
2892
2893	/* moved up
2894	if (i == -1)
2895	return(rv);
2896	*/
2897
2898	if (pin != NULL)
2899	closepipe(pin);
2900
2901	return (pout == NULL ? setstatus(waitfor(newpid, 0)) : 0);
2902	}
2903
2904	/* Must be the child process, pid should be 0 */
2905	DBGPRINTF(("FORKEXEC: child process, shcom=%p\n", shcom));
2906
2907	if (interactive) {
2908	signal(SIGINT, SIG_IGN);
2909	signal(SIGQUIT, SIG_IGN);
2910	resetsig = 1;
2911	}
2912	interactive = 0;
2913	intr = 0;
2914	forked = 1;
2915	brklist = 0;
2916	execflg = 0;
2917	}
2918
2919
2920	if (owp != NULL)
2921	while ((cp = *owp++) != NULL && assign(cp, COPYV))
2922	if (shcom == NULL)
2923	export(lookup(cp));
2924
2925	#ifdef COMPIPE
2926	if ((pin != NULL \|\| pout != NULL) && shcom != NULL && shcom != doexec) {
2927	err("piping to/from shell builtins not yet done");
2928	if (forked)
2929	_exit(-1);
2930	return (-1);
2931	}
2932	#endif
2933
2934	if (pin != NULL) {
2935	dup2(pin[0], 0);
2936	closepipe(pin);
2937	}
2938	if (pout != NULL) {
2939	dup2(pout[1], 1);
2940	closepipe(pout);
2941	}
2942
2943	if ((iopp = t->ioact) != NULL) {
2944	if (shcom != NULL && shcom != doexec) {
2945	prs(cp);
2946	err(": cannot redirect shell command");
2947	if (forked)
2948	_exit(-1);
2949	return (-1);
2950	}
2951	while (*iopp)
2952	if (iosetup(*iopp++, pin != NULL, pout != NULL)) {
2953	if (forked)
2954	_exit(rv);
2955	return (rv);
2956	}
2957	}
2958
2959	if (shcom) {
2960	i = setstatus((*shcom) (t));
2961	if (forked)
2962	_exit(i);
2963	DBGPRINTF(("FORKEXEC: returning i=%d\n", i));
2964	return (i);
2965	}
2966
2967	/* should use FIOCEXCL */
2968	for (i = FDBASE; i < NOFILE; i++)
2969	close(i);
2970	if (resetsig) {
2971	signal(SIGINT, SIG_DFL);
2972	signal(SIGQUIT, SIG_DFL);
2973	}
2974
2975	if (t->type == TPAREN)
2976	_exit(execute(t->left, NOPIPE, NOPIPE, FEXEC));
2977	if (wp[0] == NULL)
2978	_exit(0);
2979
2980	cp = rexecve(wp[0], wp, makenv(0, NULL));
2981	prs(wp[0]);
2982	prs(": ");
2983	err(cp);
2984	if (!execflg)
2985	trap[0] = NULL;
2986
2987	DBGPRINTF(("FORKEXEC: calling leave(), pid=%d\n", newpid));
2988
2989	leave();
2990	/* NOTREACHED */
2991	_exit(1);
2992	}
2993
2994	/*
2995	* 0< 1> are ignored as required
2996	* within pipelines.
2997	*/
2998	static int iosetup(REGISTER struct ioword *iop, int pipein, int pipeout)
2999	{
3000	REGISTER int u = -1;
3001	char cp = NULL, msg;
3002
3003	DBGPRINTF(("IOSETUP: iop %p, pipein %i, pipeout %i\n", iop,
3004	pipein, pipeout));
3005
3006	if (iop->io_unit == IODEFAULT) /* take default */
3007	iop->io_unit = iop->io_flag & (IOREAD \| IOHERE) ? 0 : 1;
3008
3009	if (pipein && iop->io_unit == 0)
3010	return (0);
3011
3012	if (pipeout && iop->io_unit == 1)
3013	return (0);
3014
3015	msg = iop->io_flag & (IOREAD \| IOHERE) ? "open" : "create";
3016	if ((iop->io_flag & IOHERE) == 0) {
3017	cp = iop->io_name;
3018	if ((cp = evalstr(cp, DOSUB \| DOTRIM)) == NULL)
3019	return (1);
3020	}
3021
3022	if (iop->io_flag & IODUP) {
3023	if (cp[1] \|\| (!isdigit(cp) && cp != '-')) {
3024	prs(cp);
3025	err(": illegal >& argument");
3026	return (1);
3027	}
3028	if (*cp == '-')
3029	iop->io_flag = IOCLOSE;
3030	iop->io_flag &= ~(IOREAD \| IOWRITE);
3031	}
3032	switch (iop->io_flag) {
3033	case IOREAD:
3034	u = open(cp, 0);
3035	break;
3036
3037	case IOHERE:
3038	case IOHERE \| IOXHERE:
3039	u = herein(iop->io_name, iop->io_flag & IOXHERE);
3040	cp = "here file";
3041	break;
3042
3043	case IOWRITE \| IOCAT:
3044	if ((u = open(cp, 1)) >= 0) {
3045	lseek(u, (long) 0, 2);
3046	break;
3047	}
3048	case IOWRITE:
3049	u = creat(cp, 0666);
3050	break;
3051
3052	case IODUP:
3053	u = dup2(*cp - '0', iop->io_unit);
3054	break;
3055
3056	case IOCLOSE:
3057	close(iop->io_unit);
3058	return (0);
3059	}
3060	if (u < 0) {
3061	prs(cp);
3062	prs(": cannot ");
3063	warn(msg);
3064	return (1);
3065	} else {
3066	if (u != iop->io_unit) {
3067	dup2(u, iop->io_unit);
3068	close(u);
3069	}
3070	}
3071	return (0);
3072	}
3073
3074	static void echo(REGISTER char **wp)
3075	{
3076	REGISTER int i;
3077
3078	prs("+");
3079	for (i = 0; wp[i]; i++) {
3080	if (i)
3081	prs(" ");
3082	prs(wp[i]);
3083	}
3084	prs("\n");
3085	}
3086
3087	static struct op *find1case(struct op t, char *w)
3088	{
3089	REGISTER struct op *t1;
3090	struct op **tp;
3091	REGISTER char *wp, cp;
3092
3093
3094	if (t == NULL) {
3095	DBGPRINTF3(("FIND1CASE: enter, t==NULL, returning.\n"));
3096	return ((struct op **) NULL);
3097	}
3098
3099	DBGPRINTF3(("FIND1CASE: enter, t->type=%d (%s)\n", t->type,
3100	T_CMD_NAMES[t->type]));
3101
3102	if (t->type == TLIST) {
3103	if ((tp = find1case(t->left, w)) != NULL) {
3104	DBGPRINTF3(("FIND1CASE: found one to the left, returning tp=%p\n", tp));
3105	return (tp);
3106	}
3107	t1 = t->right; /* TPAT */
3108	} else
3109	t1 = t;
3110
3111	for (wp = t1->words; *wp;)
3112	if ((cp = evalstr(*wp++, DOSUB)) && gmatch(w, cp)) {
3113	DBGPRINTF3(("FIND1CASE: returning &t1->left= %p.\n",
3114	&t1->left));
3115	return (&t1->left);
3116	}
3117
3118	DBGPRINTF(("FIND1CASE: returning NULL\n"));
3119	return ((struct op **) NULL);
3120	}
3121
3122	static struct op findcase(struct op t, char *w)
3123	{
3124	REGISTER struct op **tp;
3125
3126	return ((tp = find1case(t, w)) != NULL ? tp : (struct op ) NULL);
3127	}
3128
3129	/*
3130	* Enter a new loop level (marked for break/continue).
3131	*/
3132	static void brkset(struct brkcon *bc)
3133	{
3134	bc->nextlev = brklist;
3135	brklist = bc;
3136	}
3137
3138	/*
3139	* Wait for the last process created.
3140	* Print a message for each process found
3141	* that was killed by a signal.
3142	* Ignore interrupt signals while waiting
3143	* unless `canintr' is true.
3144	*/
3145	static int waitfor(REGISTER int lastpid, int canintr)
3146	{
3147	REGISTER int pid, rv;
3148	int s;
3149	int oheedint = heedint;
3150
3151	heedint = 0;
3152	rv = 0;
3153	do {
3154	pid = wait(&s);
3155	if (pid == -1) {
3156	if (errno != EINTR \|\| canintr)
3157	break;
3158	} else {
3159	if ((rv = WAITSIG(s)) != 0) {
3160	if (rv < NSIGNAL) {
3161	if (signame[rv] != NULL) {
3162	if (pid != lastpid) {
3163	prn(pid);
3164	prs(": ");
3165	}
3166	prs(signame[rv]);
3167	}
3168	} else {
3169	if (pid != lastpid) {
3170	prn(pid);
3171	prs(": ");
3172	}
3173	prs("Signal ");
3174	prn(rv);
3175	prs(" ");
3176	}
3177	if (WAITCORE(s))
3178	prs(" - core dumped");
3179	if (rv >= NSIGNAL \|\| signame[rv])
3180	prs("\n");
3181	rv = -1;
3182	} else
3183	rv = WAITVAL(s);
3184	}
3185	} while (pid != lastpid);
3186	heedint = oheedint;
3187	if (intr) {
3188	if (interactive) {
3189	if (canintr)
3190	intr = 0;
3191	} else {
3192	if (exstat == 0)
3193	exstat = rv;
3194	onintr(0);
3195	}
3196	}
3197	return (rv);
3198	}
3199
3200	static int setstatus(REGISTER int s)
3201	{
3202	exstat = s;
3203	setval(lookup("?"), putn(s));
3204	return (s);
3205	}
3206
3207	/*
3208	* PATH-searching interface to execve.
3209	* If getenv("PATH") were kept up-to-date,
3210	* execvp might be used.
3211	*/
3212	static char rexecve(char c, char v, char envp)
3213	{
3214	REGISTER int i;
3215	REGISTER char sp, tp;
3216	int eacces = 0, asis = 0;
3217
3218	#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3219	char *name = c;
3220
3221	optind = 1;
3222	if (find_applet_by_name(name)) {
3223	/* We have to exec here since we vforked. Running
3224	* run_applet_by_name() won't work and bad things
3225	* will happen. */
3226	execve(CONFIG_BUSYBOX_EXEC_PATH, v, envp);
3227	}
3228	#endif
3229
3230	DBGPRINTF(("REXECVE: c=%p, v=%p, envp=%p\n", c, v, envp));
3231
3232	sp = any('/', c) ? "" : path->value;
3233	asis = *sp == '\0';
3234	while (asis \|\| *sp != '\0') {
3235	asis = 0;
3236	tp = e.linep;
3237	for (; *sp != '\0'; tp++)
3238	if ((tp = sp++) == ':') {
3239	asis = *sp == '\0';
3240	break;
3241	}
3242	if (tp != e.linep)
3243	*tp++ = '/';
3244	for (i = 0; (*tp++ = c[i++]) != '\0';);
3245
3246	DBGPRINTF3(("REXECVE: e.linep is %s\n", e.linep));
3247
3248	execve(e.linep, v, envp);
3249
3250	switch (errno) {
3251	case ENOEXEC:
3252	*v = e.linep;
3253	tp = *--v;
3254	*v = e.linep;
3255	execve(DEFAULT_SHELL, v, envp);
3256	*v = tp;
3257	return ("no Shell");
3258
3259	case ENOMEM:
3260	return ((char *) bb_msg_memory_exhausted);
3261
3262	case E2BIG:
3263	return ("argument list too long");
3264
3265	case EACCES:
3266	eacces++;
3267	break;
3268	}
3269	}
3270	return (errno == ENOENT ? "not found" : "cannot execute");
3271	}
3272
3273	/*
3274	* Run the command produced by generator `f'
3275	* applied to stream `arg'.
3276	*/
3277	static int run(struct ioarg argp, int (f) (struct ioarg *))
3278	{
3279	struct op *otree;
3280	struct wdblock *swdlist;
3281	struct wdblock *siolist;
3282	jmp_buf ev, rt;
3283	xint *ofail;
3284	int rv;
3285
3286	#if __GNUC__
3287	/* Avoid longjmp clobbering */
3288	(void) &rv;
3289	#endif
3290
3291	DBGPRINTF(("RUN: enter, areanum %d, outtree %p, failpt %p\n",
3292	areanum, outtree, failpt));
3293
3294	areanum++;
3295	swdlist = wdlist;
3296	siolist = iolist;
3297	otree = outtree;
3298	ofail = failpt;
3299	rv = -1;
3300
3301	if (newenv(setjmp(errpt = ev)) == 0) {
3302	wdlist = 0;
3303	iolist = 0;
3304	pushio(argp, f);
3305	e.iobase = e.iop;
3306	yynerrs = 0;
3307	if (setjmp(failpt = rt) == 0 && yyparse() == 0)
3308	rv = execute(outtree, NOPIPE, NOPIPE, 0);
3309	quitenv();
3310	} else {
3311	DBGPRINTF(("RUN: error from newenv()!\n"));
3312	}
3313
3314	wdlist = swdlist;
3315	iolist = siolist;
3316	failpt = ofail;
3317	outtree = otree;
3318	freearea(areanum--);
3319
3320	return (rv);
3321	}
3322
3323	/* -------- do.c -------- */
3324
3325	/*
3326	* built-in commands: doX
3327	*/
3328
3329	static int dohelp(struct op *t)
3330	{
3331	int col;
3332	const struct builtincmd *x;
3333
3334	printf("\nBuilt-in commands:\n");
3335	printf("-------------------\n");
3336
3337	for (col = 0, x = builtincmds; x->builtinfunc != NULL; x++) {
3338	if (!x->name)
3339	continue;
3340	col += printf("%s%s", ((col == 0) ? "\t" : " "), x->name);
3341	if (col > 60) {
3342	printf("\n");
3343	col = 0;
3344	}
3345	}
3346	#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3347	{
3348	int i;
3349	const struct BB_applet *applet;
3350	extern const struct BB_applet applets[];
3351	extern const size_t NUM_APPLETS;
3352
3353	for (i = 0, applet = applets; i < NUM_APPLETS; applet++, i++) {
3354	if (!applet->name)
3355	continue;
3356
3357	col += printf("%s%s", ((col == 0) ? "\t" : " "), applet->name);
3358	if (col > 60) {
3359	printf("\n");
3360	col = 0;
3361	}
3362	}
3363	}
3364	#endif
3365	printf("\n\n");
3366	return EXIT_SUCCESS;
3367	}
3368
3369
3370
3371	static int dolabel(struct op *t)
3372	{
3373	return (0);
3374	}
3375
3376	static int dochdir(REGISTER struct op *t)
3377	{
3378	REGISTER char cp, er;
3379
3380	if ((cp = t->words[1]) == NULL && (cp = homedir->value) == NULL)
3381	er = ": no home directory";
3382	else if (chdir(cp) < 0)
3383	er = ": bad directory";
3384	else
3385	return (0);
3386	prs(cp != NULL ? cp : "cd");
3387	err(er);
3388	return (1);
3389	}
3390
3391	static int doshift(REGISTER struct op *t)
3392	{
3393	REGISTER int n;
3394
3395	n = t->words[1] ? getn(t->words[1]) : 1;
3396	if (dolc < n) {
3397	err("nothing to shift");
3398	return (1);
3399	}
3400	dolv[n] = dolv[0];
3401	dolv += n;
3402	dolc -= n;
3403	setval(lookup("#"), putn(dolc));
3404	return (0);
3405	}
3406
3407	/*
3408	* execute login and newgrp directly
3409	*/
3410	static int dologin(struct op *t)
3411	{
3412	REGISTER char *cp;
3413
3414	if (interactive) {
3415	signal(SIGINT, SIG_DFL);
3416	signal(SIGQUIT, SIG_DFL);
3417	}
3418	cp = rexecve(t->words[0], t->words, makenv(0, NULL));
3419	prs(t->words[0]);
3420	prs(": ");
3421	err(cp);
3422	return (1);
3423	}
3424
3425	static int doumask(REGISTER struct op *t)
3426	{
3427	REGISTER int i, n;
3428	REGISTER char *cp;
3429
3430	if ((cp = t->words[1]) == NULL) {
3431	i = umask(0);
3432	umask(i);
3433	for (n = 3 * 4; (n -= 3) >= 0;)
3434	putc('0' + ((i >> n) & 07), stderr);
3435	putc('\n', stderr);
3436	} else {
3437	for (n = 0; cp >= '0' && cp <= '9'; cp++)
3438	n = n * 8 + (*cp - '0');
3439	umask(n);
3440	}
3441	return (0);
3442	}
3443
3444	static int doexec(REGISTER struct op *t)
3445	{
3446	REGISTER int i;
3447	jmp_buf ex;
3448	xint *ofail;
3449
3450	t->ioact = NULL;
3451	for (i = 0; (t->words[i] = t->words[i + 1]) != NULL; i++);
3452	if (i == 0)
3453	return (1);
3454	execflg = 1;
3455	ofail = failpt;
3456	if (setjmp(failpt = ex) == 0)
3457	execute(t, NOPIPE, NOPIPE, FEXEC);
3458	failpt = ofail;
3459	execflg = 0;
3460	return (1);
3461	}
3462
3463	static int dodot(struct op *t)
3464	{
3465	REGISTER int i;
3466	REGISTER char sp, tp;
3467	char *cp;
3468	int maltmp;
3469
3470	DBGPRINTF(("DODOT: enter, t=%p, tleft %p, tright %p, e.linep is %s\n", t, t->left, t->right, ((e.linep == NULL) ? "NULL" : e.linep)));
3471
3472	if ((cp = t->words[1]) == NULL) {
3473	DBGPRINTF(("DODOT: bad args, ret 0\n"));
3474	return (0);
3475	} else {
3476	DBGPRINTF(("DODOT: cp is %s\n", cp));
3477	}
3478
3479	sp = any('/', cp) ? ":" : path->value;
3480
3481	DBGPRINTF(("DODOT: sp is %s, e.linep is %s\n",
3482	((sp == NULL) ? "NULL" : sp),
3483	((e.linep == NULL) ? "NULL" : e.linep)));
3484
3485	while (*sp) {
3486	tp = e.linep;
3487	while (sp && (tp = *sp++) != ':')
3488	tp++;
3489	if (tp != e.linep)
3490	*tp++ = '/';
3491
3492	for (i = 0; (*tp++ = cp[i++]) != '\0';);
3493
3494	/* Original code */
3495	if ((i = open(e.linep, 0)) >= 0) {
3496	exstat = 0;
3497	maltmp = remap(i);
3498	DBGPRINTF(("DODOT: remap=%d, exstat=%d, e.iofd %d, i %d, e.linep is %s\n", maltmp, exstat, e.iofd, i, e.linep));
3499
3500	next(maltmp); /* Basically a PUSHIO */
3501
3502	DBGPRINTF(("DODOT: returning exstat=%d\n", exstat));
3503
3504	return (exstat);
3505	}
3506
3507	} /* While */
3508
3509	prs(cp);
3510	err(": not found");
3511
3512	return (-1);
3513	}
3514
3515	static int dowait(struct op *t)
3516	{
3517	REGISTER int i;
3518	REGISTER char *cp;
3519
3520	if ((cp = t->words[1]) != NULL) {
3521	i = getn(cp);
3522	if (i == 0)
3523	return (0);
3524	} else
3525	i = -1;
3526	setstatus(waitfor(i, 1));
3527	return (0);
3528	}
3529
3530	static int doread(struct op *t)
3531	{
3532	REGISTER char cp, *wp;
3533	REGISTER int nb = 0;
3534	REGISTER int nl = 0;
3535
3536	if (t->words[1] == NULL) {
3537	err("Usage: read name ...");
3538	return (1);
3539	}
3540	for (wp = t->words + 1; *wp; wp++) {
3541	for (cp = e.linep; !nl && cp < elinep - 1; cp++)
3542	if ((nb = read(0, cp, sizeof(cp))) != sizeof(cp) \|\|
3543	(nl = (cp == '\n')) \|\| (wp[1] && any(cp, ifs->value)))
3544	break;
3545	*cp = 0;
3546	if (nb <= 0)
3547	break;
3548	setval(lookup(*wp), e.linep);
3549	}
3550	return (nb <= 0);
3551	}
3552
3553	static int doeval(REGISTER struct op *t)
3554	{
3555	return (RUN(awordlist, t->words + 1, wdchar));
3556	}
3557
3558	static int dotrap(REGISTER struct op *t)
3559	{
3560	REGISTER int n, i;
3561	REGISTER int resetsig;
3562
3563	if (t->words[1] == NULL) {
3564	for (i = 0; i <= _NSIG; i++)
3565	if (trap[i]) {
3566	prn(i);
3567	prs(": ");
3568	prs(trap[i]);
3569	prs("\n");
3570	}
3571	return (0);
3572	}
3573	resetsig = isdigit(*t->words[1]);
3574	for (i = resetsig ? 1 : 2; t->words[i] != NULL; ++i) {
3575	n = getsig(t->words[i]);
3576	freecell(trap[n]);
3577	trap[n] = 0;
3578	if (!resetsig) {
3579	if (*t->words[1] != '\0') {
3580	trap[n] = strsave(t->words[1], 0);
3581	setsig(n, sig);
3582	} else
3583	setsig(n, SIG_IGN);
3584	} else {
3585	if (interactive)
3586	if (n == SIGINT)
3587	setsig(n, onintr);
3588	else
3589	setsig(n, n == SIGQUIT ? SIG_IGN : SIG_DFL);
3590	else
3591	setsig(n, SIG_DFL);
3592	}
3593	}
3594	return (0);
3595	}
3596
3597	static int getsig(char *s)
3598	{
3599	REGISTER int n;
3600
3601	if ((n = getn(s)) < 0 \|\| n > _NSIG) {
3602	err("trap: bad signal number");
3603	n = 0;
3604	}
3605	return (n);
3606	}
3607
3608	static void setsig(REGISTER int n, sighandler_t f)
3609	{
3610	if (n == 0)
3611	return;
3612	if (signal(n, SIG_IGN) != SIG_IGN \|\| ourtrap[n]) {
3613	ourtrap[n] = 1;
3614	signal(n, f);
3615	}
3616	}
3617
3618	static int getn(char *as)
3619	{
3620	REGISTER char *s;
3621	REGISTER int n, m;
3622
3623	s = as;
3624	m = 1;
3625	if (*s == '-') {
3626	m = -1;
3627	s++;
3628	}
3629	for (n = 0; isdigit(*s); s++)
3630	n = (n * 10) + (*s - '0');
3631	if (*s) {
3632	prs(as);
3633	err(": bad number");
3634	}
3635	return (n * m);
3636	}
3637
3638	static int dobreak(struct op *t)
3639	{
3640	return (brkcontin(t->words[1], 1));
3641	}
3642
3643	static int docontinue(struct op *t)
3644	{
3645	return (brkcontin(t->words[1], 0));
3646	}
3647
3648	static int brkcontin(REGISTER char *cp, int val)
3649	{
3650	REGISTER struct brkcon *bc;
3651	REGISTER int nl;
3652
3653	nl = cp == NULL ? 1 : getn(cp);
3654	if (nl <= 0)
3655	nl = 999;
3656	do {
3657	if ((bc = brklist) == NULL)
3658	break;
3659	brklist = bc->nextlev;
3660	} while (--nl);
3661	if (nl) {
3662	err("bad break/continue level");
3663	return (1);
3664	}
3665	isbreak = val;
3666	longjmp(bc->brkpt, 1);
3667	/* NOTREACHED */
3668	}
3669
3670	static int doexit(struct op *t)
3671	{
3672	REGISTER char *cp;
3673
3674	execflg = 0;
3675	if ((cp = t->words[1]) != NULL)
3676	setstatus(getn(cp));
3677
3678	DBGPRINTF(("DOEXIT: calling leave(), t=%p\n", t));
3679
3680	leave();
3681	/* NOTREACHED */
3682	return (0);
3683	}
3684
3685	static int doexport(struct op *t)
3686	{
3687	rdexp(t->words + 1, export, EXPORT);
3688	return (0);
3689	}
3690
3691	static int doreadonly(struct op *t)
3692	{
3693	rdexp(t->words + 1, ronly, RONLY);
3694	return (0);
3695	}
3696
3697	static void rdexp(char *wp, void (f) (struct var *), int key)
3698	{
3699	DBGPRINTF6(("RDEXP: enter, wp=%p, func=%p, key=%d\n", wp, f, key));
3700	DBGPRINTF6(("RDEXP: wp=%s\n", wp));
3701
3702	if (*wp != NULL) {
3703	for (; *wp != NULL; wp++) {
3704	if (isassign(*wp)) {
3705	char *cp;
3706
3707	assign(*wp, COPYV);
3708	for (cp = wp; cp != '='; cp++);
3709	*cp = '\0';
3710	}
3711	if (checkname(*wp))
3712	(f) (lookup(wp));
3713	else
3714	badid(*wp);
3715	}
3716	} else
3717	putvlist(key, 1);
3718	}
3719
3720	static void badid(REGISTER char *s)
3721	{
3722	prs(s);
3723	err(": bad identifier");
3724	}
3725
3726	static int doset(REGISTER struct op *t)
3727	{
3728	REGISTER struct var *vp;
3729	REGISTER char *cp;
3730	REGISTER int n;
3731
3732	if ((cp = t->words[1]) == NULL) {
3733	for (vp = vlist; vp; vp = vp->next)
3734	varput(vp->name, 1);
3735	return (0);
3736	}
3737	if (*cp == '-') {
3738	/* bad: t->words++; */
3739	for (n = 0; (t->words[n] = t->words[n + 1]) != NULL; n++);
3740	if (*++cp == 0)
3741	flag['x'] = flag['v'] = 0;
3742	else
3743	for (; *cp; cp++)
3744	switch (*cp) {
3745	case 'e':
3746	if (!interactive)
3747	flag['e']++;
3748	break;
3749
3750	default:
3751	if (cp >= 'a' && cp <= 'z')
3752	flag[(int) *cp]++;
3753	break;
3754	}
3755	setdash();
3756	}
3757	if (t->words[1]) {
3758	t->words[0] = dolv[0];
3759	for (n = 1; t->words[n]; n++)
3760	setarea((char *) t->words[n], 0);
3761	dolc = n - 1;
3762	dolv = t->words;
3763	setval(lookup("#"), putn(dolc));
3764	setarea((char *) (dolv - 1), 0);
3765	}
3766	return (0);
3767	}
3768
3769	static void varput(REGISTER char *s, int out)
3770	{
3771	if (isalnum(s) \|\| s == '_') {
3772	write(out, s, strlen(s));
3773	write(out, "\n", 1);
3774	}
3775	}
3776
3777
3778	/*
3779	* Copyright (c) 1999 Herbert Xu <herbert@debian.org>
3780	* This file contains code for the times builtin.
3781	*/
3782	static int dotimes(struct op *t)
3783	{
3784	struct tms buf;
3785	long int clk_tck = sysconf(_SC_CLK_TCK);
3786
3787	times(&buf);
3788	printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
3789	(int) (buf.tms_utime / clk_tck / 60),
3790	((double) buf.tms_utime) / clk_tck,
3791	(int) (buf.tms_stime / clk_tck / 60),
3792	((double) buf.tms_stime) / clk_tck,
3793	(int) (buf.tms_cutime / clk_tck / 60),
3794	((double) buf.tms_cutime) / clk_tck,
3795	(int) (buf.tms_cstime / clk_tck / 60),
3796	((double) buf.tms_cstime) / clk_tck);
3797	return 0;
3798	}
3799
3800
3801	static int (inbuilt(char s)) (struct op *) {
3802	const struct builtincmd *bp;
3803
3804	for (bp = builtincmds; bp->name != NULL; bp++)
3805	if (strcmp(bp->name, s) == 0)
3806	return (bp->builtinfunc);
3807
3808	return (NULL);
3809	}
3810
3811	/* -------- eval.c -------- */
3812
3813	/*
3814	* ${}
3815	* `command`
3816	* blank interpretation
3817	* quoting
3818	* glob
3819	*/
3820
3821	static char eval(char ap, int f)
3822	{
3823	struct wdblock *wb;
3824	char **wp;
3825	char **wf;
3826	jmp_buf ev;
3827
3828	#if __GNUC__
3829	/* Avoid longjmp clobbering */
3830	(void) &wp;
3831	(void) ≈
3832	#endif
3833
3834	DBGPRINTF4(("EVAL: enter, f=%d\n", f));
3835
3836	wp = NULL;
3837	wb = NULL;
3838	wf = NULL;
3839	if (newenv(setjmp(errpt = ev)) == 0) {
3840	while (ap && isassign(ap))
3841	expand(*ap++, &wb, f & ~DOGLOB);
3842	if (flag['k']) {
3843	for (wf = ap; *wf; wf++) {
3844	if (isassign(*wf))
3845	expand(*wf, &wb, f & ~DOGLOB);
3846	}
3847	}
3848	for (wb = addword((char ) 0, wb); ap; ap++) {
3849	if (!flag['k'] \|\| !isassign(*ap))
3850	expand(*ap, &wb, f & ~DOKEY);
3851	}
3852	wb = addword((char *) 0, wb);
3853	wp = getwords(wb);
3854	quitenv();
3855	} else
3856	gflg = 1;
3857
3858	return (gflg ? (char **) NULL : wp);
3859	}
3860
3861	/*
3862	* Make the exported environment from the exported
3863	* names in the dictionary. Keyword assignments
3864	* will already have been done.
3865	*/
3866	static char *makenv(int all, struct wdblock wb)
3867	{
3868	REGISTER struct var *vp;
3869
3870	DBGPRINTF5(("MAKENV: enter, all=%d\n", all));
3871
3872	for (vp = vlist; vp; vp = vp->next)
3873	if (all \|\| vp->status & EXPORT)
3874	wb = addword(vp->name, wb);
3875	wb = addword((char *) 0, wb);
3876	return (getwords(wb));
3877	}
3878
3879	static char evalstr(REGISTER char cp, int f)
3880	{
3881	struct wdblock *wb;
3882
3883	DBGPRINTF6(("EVALSTR: enter, cp=%p, f=%d\n", cp, f));
3884
3885	wb = NULL;
3886	if (expand(cp, &wb, f)) {
3887	if (wb == NULL \|\| wb->w_nword == 0
3888	\|\| (cp = wb->w_words[0]) == NULL)
3889	cp = "";
3890	DELETE(wb);
3891	} else
3892	cp = NULL;
3893	return (cp);
3894	}
3895
3896	static int expand(char cp, REGISTER struct wdblock *wbp, int f)
3897	{
3898	jmp_buf ev;
3899
3900	#if __GNUC__
3901	/* Avoid longjmp clobbering */
3902	(void) &cp;
3903	#endif
3904
3905	DBGPRINTF3(("EXPAND: enter, f=%d\n", f));
3906
3907	gflg = 0;
3908
3909	if (cp == NULL)
3910	return (0);
3911
3912	if (!anys("$`'\"", cp) &&
3913	!anys(ifs->value, cp) && ((f & DOGLOB) == 0 \|\| !anys("[*?", cp))) {
3914	cp = strsave(cp, areanum);
3915	if (f & DOTRIM)
3916	unquote(cp);
3917	wbp = addword(cp, wbp);
3918	return (1);
3919	}
3920	if (newenv(setjmp(errpt = ev)) == 0) {
3921	PUSHIO(aword, cp, strchar);
3922	e.iobase = e.iop;
3923	while ((cp = blank(f)) && gflg == 0) {
3924	e.linep = cp;
3925	cp = strsave(cp, areanum);
3926	if ((f & DOGLOB) == 0) {
3927	if (f & DOTRIM)
3928	unquote(cp);
3929	wbp = addword(cp, wbp);
3930	} else
3931	wbp = glob(cp, wbp);
3932	}
3933	quitenv();
3934	} else
3935	gflg = 1;
3936	return (gflg == 0);
3937	}
3938
3939	/*
3940	* Blank interpretation and quoting
3941	*/
3942	static char *blank(int f)
3943	{
3944	REGISTER int c, c1;
3945	REGISTER char *sp;
3946	int scanequals, foundequals;
3947
3948	DBGPRINTF3(("BLANK: enter, f=%d\n", f));
3949
3950	sp = e.linep;
3951	scanequals = f & DOKEY;
3952	foundequals = 0;
3953
3954	loop:
3955	switch (c = subgetc('"', foundequals)) {
3956	case 0:
3957	if (sp == e.linep)
3958	return (0);
3959	*e.linep++ = 0;
3960	return (sp);
3961
3962	default:
3963	if (f & DOBLANK && any(c, ifs->value))
3964	goto loop;
3965	break;
3966
3967	case '"':
3968	case '\'':
3969	scanequals = 0;
3970	if (INSUB())
3971	break;
3972	for (c1 = c; (c = subgetc(c1, 1)) != c1;) {
3973	if (c == 0)
3974	break;
3975	if (c == '\'' \|\| !any(c, "$`\""))
3976	c \|= QUOTE;
3977	*e.linep++ = c;
3978	}
3979	c = 0;
3980	}
3981	unget(c);
3982	if (!isalpha(c) && c != '_')
3983	scanequals = 0;
3984	for (;;) {
3985	c = subgetc('"', foundequals);
3986	if (c == 0 \|\|
3987	f & (DOBLANK && any(c, ifs->value)) \|\|
3988	(!INSUB() && any(c, "\"'"))) {
3989	scanequals = 0;
3990	unget(c);
3991	if (any(c, "\"'"))
3992	goto loop;
3993	break;
3994	}
3995	if (scanequals) {
3996	if (c == '=') {
3997	foundequals = 1;
3998	scanequals = 0;
3999	} else if (!isalnum(c) && c != '_')
4000	scanequals = 0;
4001	}
4002	*e.linep++ = c;
4003	}
4004	*e.linep++ = 0;
4005	return (sp);
4006	}
4007
4008	/*
4009	* Get characters, substituting for ` and $
4010	*/
4011	static int subgetc(REGISTER char ec, int quoted)
4012	{
4013	REGISTER char c;
4014
4015	DBGPRINTF3(("SUBGETC: enter, quoted=%d\n", quoted));
4016
4017	again:
4018	c = my_getc(ec);
4019	if (!INSUB() && ec != '\'') {
4020	if (c == '`') {
4021	if (grave(quoted) == 0)
4022	return (0);
4023	e.iop->task = XGRAVE;
4024	goto again;
4025	}
4026	if (c == '$' && (c = dollar(quoted)) == 0) {
4027	e.iop->task = XDOLL;
4028	goto again;
4029	}
4030	}
4031	return (c);
4032	}
4033
4034	/*
4035	* Prepare to generate the string returned by ${} substitution.
4036	*/
4037	static int dollar(int quoted)
4038	{
4039	int otask;
4040	struct io *oiop;
4041	char *dolp;
4042	REGISTER char s, c, cp = NULL;
4043	struct var *vp;
4044
4045	DBGPRINTF3(("DOLLAR: enter, quoted=%d\n", quoted));
4046
4047	c = readc();
4048	s = e.linep;
4049	if (c != '{') {
4050	*e.linep++ = c;
4051	if (isalpha(c) \|\| c == '_') {
4052	while ((c = readc()) != 0 && (isalnum(c) \|\| c == '_'))
4053	if (e.linep < elinep)
4054	*e.linep++ = c;
4055	unget(c);
4056	}
4057	c = 0;
4058	} else {
4059	oiop = e.iop;
4060	otask = e.iop->task;
4061
4062	e.iop->task = XOTHER;
4063	while ((c = subgetc('"', 0)) != 0 && c != '}' && c != '\n')
4064	if (e.linep < elinep)
4065	*e.linep++ = c;
4066	if (oiop == e.iop)
4067	e.iop->task = otask;
4068	if (c != '}') {
4069	err("unclosed ${");
4070	gflg++;
4071	return (c);
4072	}
4073	}
4074	if (e.linep >= elinep) {
4075	err("string in ${} too long");
4076	gflg++;
4077	e.linep -= 10;
4078	}
4079	*e.linep = 0;
4080	if (*s)
4081	for (cp = s + 1; *cp; cp++)
4082	if (any(*cp, "=-+?")) {
4083	c = *cp;
4084	*cp++ = 0;
4085	break;
4086	}
4087	if (s[1] == 0 && (s == '' \|\| *s == '@')) {
4088	if (dolc > 1) {
4089	/* currently this does not distinguish $* and $@ */
4090	/* should check dollar */
4091	e.linep = s;
4092	PUSHIO(awordlist, dolv + 1, dolchar);
4093	return (0);
4094	} else { /* trap the nasty ${=} */
4095	s[0] = '1';
4096	s[1] = 0;
4097	}
4098	}
4099	vp = lookup(s);
4100	if ((dolp = vp->value) == null) {
4101	switch (c) {
4102	case '=':
4103	if (isdigit(*s)) {
4104	err("cannot use ${...=...} with $n");
4105	gflg++;
4106	break;
4107	}
4108	setval(vp, cp);
4109	dolp = vp->value;
4110	break;
4111
4112	case '-':
4113	dolp = strsave(cp, areanum);
4114	break;
4115
4116	case '?':
4117	if (*cp == 0) {
4118	prs("missing value for ");
4119	err(s);
4120	} else
4121	err(cp);
4122	gflg++;
4123	break;
4124	}
4125	} else if (c == '+')
4126	dolp = strsave(cp, areanum);
4127	if (flag['u'] && dolp == null) {
4128	prs("unset variable: ");
4129	err(s);
4130	gflg++;
4131	}
4132	e.linep = s;
4133	PUSHIO(aword, dolp, quoted ? qstrchar : strchar);
4134	return (0);
4135	}
4136
4137	/*
4138	* Run the command in `...` and read its output.
4139	*/
4140
4141	static int grave(int quoted)
4142	{
4143	char *cp;
4144	REGISTER int i;
4145	int j;
4146	int pf[2];
4147	static char child_cmd[LINELIM];
4148	char *src;
4149	char *dest;
4150	int count;
4151	int ignore;
4152	int ignore_once;
4153	char *argument_list[4];
4154	struct wdblock *wb = NULL;
4155
4156	#if __GNUC__
4157	/* Avoid longjmp clobbering */
4158	(void) &cp;
4159	#endif
4160
4161	for (cp = e.iop->argp->aword; *cp != '`'; cp++)
4162	if (*cp == 0) {
4163	err("no closing `");
4164	return (0);
4165	}
4166
4167	/* string copy with dollar expansion */
4168	src = e.iop->argp->aword;
4169	dest = child_cmd;
4170	count = 0;
4171	ignore = 0;
4172	ignore_once = 0;
4173	while ((*src != '`') && (count < LINELIM)) {
4174	if (*src == '\'')
4175	ignore = !ignore;
4176	if (*src == '\\')
4177	ignore_once = 1;
4178	if (*src == '$' && !ignore && !ignore_once) {
4179	struct var *vp;
4180	char var_name[LINELIM];
4181	char alt_value[LINELIM];
4182	int var_index = 0;
4183	int alt_index = 0;
4184	char operator = 0;
4185	int braces = 0;
4186	char *value;
4187
4188	src++;
4189	if (*src == '{') {
4190	braces = 1;
4191	src++;
4192	}
4193
4194	var_name[var_index++] = *src++;
4195	while (isalnum(src) \|\| src=='_')
4196	var_name[var_index++] = *src++;
4197	var_name[var_index] = 0;
4198
4199	if (braces) {
4200	switch (*src) {
4201	case '}':
4202	break;
4203	case '-':
4204	case '=':
4205	case '+':
4206	case '?':
4207	operator = * src;
4208	break;
4209	default:
4210	err("unclosed ${\n");
4211	return (0);
4212	}
4213	if (operator) {
4214	src++;
4215	while (src && (src != '}')) {
4216	alt_value[alt_index++] = *src++;
4217	}
4218	alt_value[alt_index] = 0;
4219	if (*src != '}') {
4220	err("unclosed ${\n");
4221	return (0);
4222	}
4223	}
4224	src++;
4225	}
4226
4227	if (isalpha(*var_name)) {
4228	/* let subshell handle it instead */
4229
4230	char *namep = var_name;
4231
4232	*dest++ = '$';
4233	if (braces)
4234	*dest++ = '{';
4235	while (*namep)
4236	dest++ = namep++;
4237	if (operator) {
4238	char *altp = alt_value;
4239	*dest++ = operator;
4240	while (*altp)
4241	dest++ = altp++;
4242	}
4243	if (braces)
4244	*dest++ = '}';
4245
4246	wb = addword(lookup(var_name)->name, wb);
4247	} else {
4248	/* expand */
4249
4250	vp = lookup(var_name);
4251	if (vp->value != null)
4252	value = (operator == '+') ?
4253	alt_value : vp->value;
4254	else if (operator == '?') {
4255	err(alt_value);
4256	return (0);
4257	} else if (alt_index && (operator != '+')) {
4258	value = alt_value;
4259	if (operator == '=')
4260	setval(vp, value);
4261	} else
4262	continue;
4263
4264	while (*value && (count < LINELIM)) {
4265	dest++ = value++;
4266	count++;
4267	}
4268	}
4269	} else {
4270	dest++ = src++;
4271	count++;
4272	ignore_once = 0;
4273	}
4274	}
4275	*dest = '\0';
4276
4277	if (openpipe(pf) < 0)
4278	return (0);
4279
4280	while ((i = vfork()) == -1 && errno == EAGAIN);
4281
4282	DBGPRINTF3(("GRAVE: i is %p\n", io));
4283
4284	if (i < 0) {
4285	closepipe(pf);
4286	err((char *) bb_msg_memory_exhausted);
4287	return (0);
4288	}
4289	if (i != 0) {
4290	waitpid(i, NULL, 0);
4291	e.iop->argp->aword = ++cp;
4292	close(pf[1]);
4293	PUSHIO(afile, remap(pf[0]),
4294	(int ()(struct ioarg )) ((quoted) ? qgravechar :
4295	gravechar));
4296	return (1);
4297	}
4298	/* allow trapped signals */
4299	/* XXX - Maybe this signal stuff should go as well? */
4300	for (j = 0; j <= _NSIG; j++)
4301	if (ourtrap[j] && signal(j, SIG_IGN) != SIG_IGN)
4302	signal(j, SIG_DFL);
4303
4304	dup2(pf[1], 1);
4305	closepipe(pf);
4306
4307	argument_list[0] = (char *) DEFAULT_SHELL;
4308	argument_list[1] = "-c";
4309	argument_list[2] = child_cmd;
4310	argument_list[3] = 0;
4311
4312	cp = rexecve(argument_list[0], argument_list, makenv(1, wb));
4313	prs(argument_list[0]);
4314	prs(": ");
4315	err(cp);
4316	_exit(1);
4317	}
4318
4319
4320	static char unquote(REGISTER char as)
4321	{
4322	REGISTER char *s;
4323
4324	if ((s = as) != NULL)
4325	while (*s)
4326	*s++ &= ~QUOTE;
4327	return (as);
4328	}
4329
4330	/* -------- glob.c -------- */
4331
4332	/*
4333	* glob
4334	*/
4335
4336	#define scopy(x) strsave((x), areanum)
4337	#define BLKSIZ 512
4338	#define NDENT ((BLKSIZ+sizeof(struct dirent)-1)/sizeof(struct dirent))
4339
4340	static struct wdblock cl, nl;
4341	static char spcl[] = "[?*";
4342
4343	static struct wdblock glob(char cp, struct wdblock *wb)
4344	{
4345	REGISTER int i;
4346	REGISTER char *pp;
4347
4348	if (cp == 0)
4349	return (wb);
4350	i = 0;
4351	for (pp = cp; *pp; pp++)
4352	if (any(*pp, spcl))
4353	i++;
4354	else if (!any(*pp & ~QUOTE, spcl))
4355	*pp &= ~QUOTE;
4356	if (i != 0) {
4357	for (cl = addword(scopy(cp), (struct wdblock *) 0); anyspcl(cl);
4358	cl = nl) {
4359	nl = newword(cl->w_nword * 2);
4360	for (i = 0; i < cl->w_nword; i++) { /* for each argument */
4361	for (pp = cl->w_words[i]; *pp; pp++)
4362	if (any(*pp, spcl)) {
4363	globname(cl->w_words[i], pp);
4364	break;
4365	}
4366	if (*pp == '\0')
4367	nl = addword(scopy(cl->w_words[i]), nl);
4368	}
4369	for (i = 0; i < cl->w_nword; i++)
4370	DELETE(cl->w_words[i]);
4371	DELETE(cl);
4372	}
4373	for (i = 0; i < cl->w_nword; i++)
4374	unquote(cl->w_words[i]);
4375	glob0((char ) cl->w_words, cl->w_nword, sizeof(char ), xstrcmp);
4376	if (cl->w_nword) {
4377	for (i = 0; i < cl->w_nword; i++)
4378	wb = addword(cl->w_words[i], wb);
4379	DELETE(cl);
4380	return (wb);
4381	}
4382	}
4383	wb = addword(unquote(cp), wb);
4384	return (wb);
4385	}
4386
4387	static void globname(char we, REGISTER char pp)
4388	{
4389	REGISTER char np, cp;
4390	char name, gp, *dp;
4391	int k;
4392	DIR *dirp;
4393	struct dirent *de;
4394	char dname[NAME_MAX + 1];
4395	struct stat dbuf;
4396
4397	for (np = we; np != pp; pp--)
4398	if (pp[-1] == '/')
4399	break;
4400	for (dp = cp = space((int) (pp - np) + 3); np < pp;)
4401	cp++ = np++;
4402	*cp++ = '.';
4403	*cp = '\0';
4404	for (gp = cp = space(strlen(pp) + 1); np && np != '/';)
4405	cp++ = np++;
4406	*cp = '\0';
4407	dirp = opendir(dp);
4408	if (dirp == 0) {
4409	DELETE(dp);
4410	DELETE(gp);
4411	return;
4412	}
4413	dname[NAME_MAX] = '\0';
4414	while ((de = readdir(dirp)) != NULL) {
4415	/* XXX Hmmm... What this could be? (abial) */
4416	/*
4417	if (ent[j].d_ino == 0)
4418	continue;
4419	*/
4420	strncpy(dname, de->d_name, NAME_MAX);
4421	if (dname[0] == '.')
4422	if (*gp != '.')
4423	continue;
4424	for (k = 0; k < NAME_MAX; k++)
4425	if (any(dname[k], spcl))
4426	dname[k] \|= QUOTE;
4427	if (gmatch(dname, gp)) {
4428	name = generate(we, pp, dname, np);
4429	if (*np && !anys(np, spcl)) {
4430	if (stat(name, &dbuf)) {
4431	DELETE(name);
4432	continue;
4433	}
4434	}
4435	nl = addword(name, nl);
4436	}
4437	}
4438	closedir(dirp);
4439	DELETE(dp);
4440	DELETE(gp);
4441	}
4442
4443	/*
4444	* generate a pathname as below.
4445	* start..end1 / middle end
4446	* the slashes come for free
4447	*/
4448	static char generate(char start1, REGISTER char end1, char middle, char *end)
4449	{
4450	char *p;
4451	REGISTER char op, xp;
4452
4453	p = op =
4454	space((int) (end1 - start1) + strlen(middle) + strlen(end) + 2);
4455	for (xp = start1; xp != end1;)
4456	op++ = xp++;
4457	for (xp = middle; (op++ = xp++) != '\0';);
4458	op--;
4459	for (xp = end; (op++ = xp++) != '\0';);
4460	return (p);
4461	}
4462
4463	static int anyspcl(REGISTER struct wdblock *wb)
4464	{
4465	REGISTER int i;
4466	REGISTER char **wd;
4467
4468	wd = wb->w_words;
4469	for (i = 0; i < wb->w_nword; i++)
4470	if (anys(spcl, *wd++))
4471	return (1);
4472	return (0);
4473	}
4474
4475	static int xstrcmp(char p1, char p2)
4476	{
4477	return (strcmp((char ) p1, (char **) p2));
4478	}
4479
4480	/* -------- word.c -------- */
4481
4482	static struct wdblock *newword(REGISTER int nw)
4483	{
4484	REGISTER struct wdblock *wb;
4485
4486	wb = (struct wdblock ) space(sizeof(wb) + nw * sizeof(char *));
4487	wb->w_bsize = nw;
4488	wb->w_nword = 0;
4489	return (wb);
4490	}
4491
4492	static struct wdblock addword(char wd, REGISTER struct wdblock *wb)
4493	{
4494	REGISTER struct wdblock *wb2;
4495	REGISTER int nw;
4496
4497	if (wb == NULL)
4498	wb = newword(NSTART);
4499	if ((nw = wb->w_nword) >= wb->w_bsize) {
4500	wb2 = newword(nw * 2);
4501	memcpy((char ) wb2->w_words, (char ) wb->w_words,
4502	nw * sizeof(char *));
4503	wb2->w_nword = nw;
4504	DELETE(wb);
4505	wb = wb2;
4506	}
4507	wb->w_words[wb->w_nword++] = wd;
4508	return (wb);
4509	}
4510
4511	static
4512	char *getwords(REGISTER struct wdblock wb)
4513	{
4514	REGISTER char **wd;
4515	REGISTER int nb;
4516
4517	if (wb == NULL)
4518	return ((char **) NULL);
4519	if (wb->w_nword == 0) {
4520	DELETE(wb);
4521	return ((char **) NULL);
4522	}
4523	wd = (char *) space(nb = sizeof(wd) * wb->w_nword);
4524	memcpy((char ) wd, (char ) wb->w_words, nb);
4525	DELETE(wb); /* perhaps should done by caller */
4526	return (wd);
4527	}
4528
4529	static int (func) (char , char *);
4530	static int globv;
4531
4532	static void glob0(char a0, unsigned a1, int a2, int (a3) (char , char ))
4533	{
4534	func = a3;
4535	globv = a2;
4536	glob1(a0, a0 + a1 * a2);
4537	}
4538
4539	static void glob1(char base, char lim)
4540	{
4541	REGISTER char i, j;
4542	int v2;
4543	char lptr, hptr;
4544	int c;
4545	unsigned n;
4546
4547
4548	v2 = globv;
4549
4550	top:
4551	if ((n = (int) (lim - base)) <= v2)
4552	return;
4553	n = v2 * (n / (2 * v2));
4554	hptr = lptr = base + n;
4555	i = base;
4556	j = lim - v2;
4557	for (;;) {
4558	if (i < lptr) {
4559	if ((c = (*func) (i, lptr)) == 0) {
4560	glob2(i, lptr -= v2);
4561	continue;
4562	}
4563	if (c < 0) {
4564	i += v2;
4565	continue;
4566	}
4567	}
4568
4569	begin:
4570	if (j > hptr) {
4571	if ((c = (*func) (hptr, j)) == 0) {
4572	glob2(hptr += v2, j);
4573	goto begin;
4574	}
4575	if (c > 0) {
4576	if (i == lptr) {
4577	glob3(i, hptr += v2, j);
4578	i = lptr += v2;
4579	goto begin;
4580	}
4581	glob2(i, j);
4582	j -= v2;
4583	i += v2;
4584	continue;
4585	}
4586	j -= v2;
4587	goto begin;
4588	}
4589
4590
4591	if (i == lptr) {
4592	if (lptr - base >= lim - hptr) {
4593	glob1(hptr + v2, lim);
4594	lim = lptr;
4595	} else {
4596	glob1(base, lptr);
4597	base = hptr + v2;
4598	}
4599	goto top;
4600	}
4601
4602
4603	glob3(j, lptr -= v2, i);
4604	j = hptr -= v2;
4605	}
4606	}
4607
4608	static void glob2(char i, char j)
4609	{
4610	REGISTER char index1, index2, c;
4611	int m;
4612
4613	m = globv;
4614	index1 = i;
4615	index2 = j;
4616	do {
4617	c = *index1;
4618	index1++ = index2;
4619	*index2++ = c;
4620	} while (--m);
4621	}
4622
4623	static void glob3(char i, char j, char *k)
4624	{
4625	REGISTER char index1, index2, *index3;
4626	int c;
4627	int m;
4628
4629	m = globv;
4630	index1 = i;
4631	index2 = j;
4632	index3 = k;
4633	do {
4634	c = *index1;
4635	index1++ = index3;
4636	index3++ = index2;
4637	*index2++ = c;
4638	} while (--m);
4639	}
4640
4641	/* -------- io.c -------- */
4642
4643	/*
4644	* shell IO
4645	*/
4646
4647	static int my_getc(int ec)
4648	{
4649	REGISTER int c;
4650
4651	if (e.linep > elinep) {
4652	while ((c = readc()) != '\n' && c);
4653	err("input line too long");
4654	gflg++;
4655	return (c);
4656	}
4657	c = readc();
4658	if ((ec != '\'') && (ec != '`') && (e.iop->task != XGRAVE)) {
4659	if (c == '\\') {
4660	c = readc();
4661	if (c == '\n' && ec != '\"')
4662	return (my_getc(ec));
4663	c \|= QUOTE;
4664	}
4665	}
4666	return (c);
4667	}
4668
4669	static void unget(int c)
4670	{
4671	if (e.iop >= e.iobase)
4672	e.iop->peekc = c;
4673	}
4674
4675	static int eofc(void)
4676	{
4677	return e.iop < e.iobase \|\| (e.iop->peekc == 0 && e.iop->prev == 0);
4678	}
4679
4680	static int readc(void)
4681	{
4682	REGISTER int c;
4683
4684	RCPRINTF(("READC: e.iop %p, e.iobase %p\n", e.iop, e.iobase));
4685
4686	for (; e.iop >= e.iobase; e.iop--) {
4687	RCPRINTF(("READC: e.iop %p, peekc 0x%x\n", e.iop, e.iop->peekc));
4688	if ((c = e.iop->peekc) != '\0') {
4689	e.iop->peekc = 0;
4690	return (c);
4691	} else {
4692	if (e.iop->prev != 0) {
4693	if ((c = (*e.iop->iofn) (e.iop->argp, e.iop)) != '\0') {
4694	if (c == -1) {
4695	e.iop++;
4696	continue;
4697	}
4698	if (e.iop == iostack)
4699	ioecho(c);
4700	return (e.iop->prev = c);
4701	} else if (e.iop->task == XIO && e.iop->prev != '\n') {
4702	e.iop->prev = 0;
4703	if (e.iop == iostack)
4704	ioecho('\n');
4705	return '\n';
4706	}
4707	}
4708	if (e.iop->task == XIO) {
4709	if (multiline) {
4710	return e.iop->prev = 0;
4711	}
4712	if (interactive && e.iop == iostack + 1) {
4713	#ifdef CONFIG_FEATURE_COMMAND_EDITING
4714	current_prompt = prompt->value;
4715	#else
4716	prs(prompt->value);
4717	#endif
4718	}
4719	}
4720	}
4721
4722	} /* FOR */
4723
4724	if (e.iop >= iostack) {
4725	RCPRINTF(("READC: return 0, e.iop %p\n", e.iop));
4726	return (0);
4727	}
4728
4729	DBGPRINTF(("READC: leave()...\n"));
4730	leave();
4731
4732	/* NOTREACHED */
4733	return (0);
4734	}
4735
4736	static void ioecho(char c)
4737	{
4738	if (flag['v'])
4739	write(2, &c, sizeof c);
4740	}
4741
4742
4743	static void pushio(struct ioarg argp, int (fn) (struct ioarg *))
4744	{
4745	DBGPRINTF(("PUSHIO: argp %p, argp->afid 0x%x, e.iop %p\n", argp,
4746	argp->afid, e.iop));
4747
4748	/* Set env ptr for io source to next array spot and check for array overflow */
4749	if (++e.iop >= &iostack[NPUSH]) {
4750	e.iop--;
4751	err("Shell input nested too deeply");
4752	gflg++;
4753	return;
4754	}
4755
4756	/* We did not overflow the NPUSH array spots so setup data structs */
4757
4758	e.iop->iofn = (int ()(struct ioarg , struct io )) fn; / Store data source func ptr */
4759
4760	if (argp->afid != AFID_NOBUF)
4761	e.iop->argp = argp;
4762	else {
4763
4764	e.iop->argp = ioargstack + (e.iop - iostack); /* MAL - index into stack */
4765	e.iop->argp = argp; /* copy data from temp area into stack spot */
4766
4767	/* MAL - mainbuf is for 1st data source (command line?) and all nested use a single shared buffer? */
4768
4769	if (e.iop == &iostack[0])
4770	e.iop->argp->afbuf = &mainbuf;
4771	else
4772	e.iop->argp->afbuf = &sharedbuf;
4773
4774	/* MAL - if not a termimal AND (commandline OR readable file) then give it a buffer id? */
4775	/* This line appears to be active when running scripts from command line */
4776	if ((isatty(e.iop->argp->afile) == 0)
4777	&& (e.iop == &iostack[0]
4778	\|\| lseek(e.iop->argp->afile, 0L, 1) != -1)) {
4779	if (++bufid == AFID_NOBUF) /* counter rollover check, AFID_NOBUF = 11111111 */
4780	bufid = AFID_ID; /* AFID_ID = 0 */
4781
4782	e.iop->argp->afid = bufid; /* assign buffer id */
4783	}
4784
4785	DBGPRINTF(("PUSHIO: iostack %p, e.iop %p, afbuf %p\n",
4786	iostack, e.iop, e.iop->argp->afbuf));
4787	DBGPRINTF(("PUSHIO: mbuf %p, sbuf %p, bid %d, e.iop %p\n",
4788	&mainbuf, &sharedbuf, bufid, e.iop));
4789
4790	}
4791
4792	e.iop->prev = ~'\n';
4793	e.iop->peekc = 0;
4794	e.iop->xchar = 0;
4795	e.iop->nlcount = 0;
4796
4797	if (fn == filechar \|\| fn == linechar)
4798	e.iop->task = XIO;
4799	else if (fn == (int ()(struct ioarg )) gravechar
4800	\|\| fn == (int ()(struct ioarg )) qgravechar)
4801	e.iop->task = XGRAVE;
4802	else
4803	e.iop->task = XOTHER;
4804
4805	return;
4806	}
4807
4808	static struct io setbase(struct io ip)
4809	{
4810	REGISTER struct io *xp;
4811
4812	xp = e.iobase;
4813	e.iobase = ip;
4814	return (xp);
4815	}
4816
4817	/*
4818	* Input generating functions
4819	*/
4820
4821	/*
4822	* Produce the characters of a string, then a newline, then EOF.
4823	*/
4824	static int nlchar(REGISTER struct ioarg *ap)
4825	{
4826	REGISTER int c;
4827
4828	if (ap->aword == NULL)
4829	return (0);
4830	if ((c = *ap->aword++) == 0) {
4831	ap->aword = NULL;
4832	return ('\n');
4833	}
4834	return (c);
4835	}
4836
4837	/*
4838	* Given a list of words, produce the characters
4839	* in them, with a space after each word.
4840	*/
4841	static int wdchar(REGISTER struct ioarg *ap)
4842	{
4843	REGISTER char c;
4844	REGISTER char **wl;
4845
4846	if ((wl = ap->awordlist) == NULL)
4847	return (0);
4848	if (*wl != NULL) {
4849	if ((c = (wl)++) != 0)
4850	return (c & 0177);
4851	ap->awordlist++;
4852	return (' ');
4853	}
4854	ap->awordlist = NULL;
4855	return ('\n');
4856	}
4857
4858	/*
4859	* Return the characters of a list of words,
4860	* producing a space between them.
4861	*/
4862	static int dolchar(REGISTER struct ioarg *ap)
4863	{
4864	REGISTER char *wp;
4865
4866	if ((wp = *ap->awordlist++) != NULL) {
4867	PUSHIO(aword, wp, *ap->awordlist == NULL ? strchar : xxchar);
4868	return (-1);
4869	}
4870	return (0);
4871	}
4872
4873	static int xxchar(REGISTER struct ioarg *ap)
4874	{
4875	REGISTER int c;
4876
4877	if (ap->aword == NULL)
4878	return (0);
4879	if ((c = *ap->aword++) == '\0') {
4880	ap->aword = NULL;
4881	return (' ');
4882	}
4883	return (c);
4884	}
4885
4886	/*
4887	* Produce the characters from a single word (string).
4888	*/
4889	static int strchar(REGISTER struct ioarg *ap)
4890	{
4891	REGISTER int c;
4892
4893	if (ap->aword == NULL \|\| (c = *ap->aword++) == 0)
4894	return (0);
4895	return (c);
4896	}
4897
4898	/*
4899	* Produce quoted characters from a single word (string).
4900	*/
4901	static int qstrchar(REGISTER struct ioarg *ap)
4902	{
4903	REGISTER int c;
4904
4905	if (ap->aword == NULL \|\| (c = *ap->aword++) == 0)
4906	return (0);
4907	return (c \| QUOTE);
4908	}
4909
4910	/*
4911	* Return the characters from a file.
4912	*/
4913	static int filechar(REGISTER struct ioarg *ap)
4914	{
4915	REGISTER int i;
4916	char c;
4917	struct iobuf *bp = ap->afbuf;
4918
4919	if (ap->afid != AFID_NOBUF) {
4920	if ((i = ap->afid != bp->id) \|\| bp->bufp == bp->ebufp) {
4921
4922	if (i)
4923	lseek(ap->afile, ap->afpos, 0);
4924
4925	i = safe_read(ap->afile, bp->buf, sizeof(bp->buf));
4926
4927	if (i <= 0) {
4928	closef(ap->afile);
4929	return 0;
4930	}
4931
4932	bp->id = ap->afid;
4933	bp->ebufp = (bp->bufp = bp->buf) + i;
4934	}
4935
4936	ap->afpos++;
4937	return *bp->bufp++ & 0177;
4938	}
4939	#ifdef CONFIG_FEATURE_COMMAND_EDITING
4940	if (interactive && isatty(ap->afile)) {
4941	static char mycommand[BUFSIZ];
4942	static int position = 0, size = 0;
4943
4944	while (size == 0 \|\| position >= size) {
4945	cmdedit_read_input(current_prompt, mycommand);
4946	size = strlen(mycommand);
4947	position = 0;
4948	}
4949	c = mycommand[position];
4950	position++;
4951	return (c);
4952	} else
4953	#endif
4954
4955	{
4956	i = safe_read(ap->afile, &c, sizeof(c));
4957	return (i == sizeof(c) ? (c & 0x7f) : (closef(ap->afile), 0));
4958	}
4959	}
4960
4961	/*
4962	* Return the characters from a here temp file.
4963	*/
4964	static int herechar(REGISTER struct ioarg *ap)
4965	{
4966	char c;
4967
4968
4969	if (read(ap->afile, &c, sizeof(c)) != sizeof(c)) {
4970	close(ap->afile);
4971	c = 0;
4972	}
4973	return (c);
4974
4975	}
4976
4977	/*
4978	* Return the characters produced by a process (`...`).
4979	* Quote them if required, and remove any trailing newline characters.
4980	*/
4981	static int gravechar(struct ioarg ap, struct io iop)
4982	{
4983	REGISTER int c;
4984
4985	if ((c = qgravechar(ap, iop) & ~QUOTE) == '\n')
4986	c = ' ';
4987	return (c);
4988	}
4989
4990	static int qgravechar(REGISTER struct ioarg ap, struct io iop)
4991	{
4992	REGISTER int c;
4993
4994	DBGPRINTF3(("QGRAVECHAR: enter, ap=%p, iop=%p\n", ap, iop));
4995
4996	if (iop->xchar) {
4997	if (iop->nlcount) {
4998	iop->nlcount--;
4999	return ('\n' \| QUOTE);
5000	}
5001	c = iop->xchar;
5002	iop->xchar = 0;
5003	} else if ((c = filechar(ap)) == '\n') {
5004	iop->nlcount = 1;
5005	while ((c = filechar(ap)) == '\n')
5006	iop->nlcount++;
5007	iop->xchar = c;
5008	if (c == 0)
5009	return (c);
5010	iop->nlcount--;
5011	c = '\n';
5012	}
5013	return (c != 0 ? c \| QUOTE : 0);
5014	}
5015
5016	/*
5017	* Return a single command (usually the first line) from a file.
5018	*/
5019	static int linechar(REGISTER struct ioarg *ap)
5020	{
5021	REGISTER int c;
5022
5023	if ((c = filechar(ap)) == '\n') {
5024	if (!multiline) {
5025	closef(ap->afile);
5026	ap->afile = -1; /* illegal value */
5027	}
5028	}
5029	return (c);
5030	}
5031
5032	static void prs(REGISTER const char *s)
5033	{
5034	if (*s)
5035	write(2, s, strlen(s));
5036	}
5037
5038	static void prn(unsigned u)
5039	{
5040	prs(itoa(u));
5041	}
5042
5043	static void closef(REGISTER int i)
5044	{
5045	if (i > 2)
5046	close(i);
5047	}
5048
5049	static void closeall(void)
5050	{
5051	REGISTER int u;
5052
5053	for (u = NUFILE; u < NOFILE;)
5054	close(u++);
5055	}
5056
5057
5058	/*
5059	* remap fd into Shell's fd space
5060	*/
5061	static int remap(REGISTER int fd)
5062	{
5063	REGISTER int i;
5064	int map[NOFILE];
5065	int newfd;
5066
5067
5068	DBGPRINTF(("REMAP: fd=%d, e.iofd=%d\n", fd, e.iofd));
5069
5070	if (fd < e.iofd) {
5071	for (i = 0; i < NOFILE; i++)
5072	map[i] = 0;
5073
5074	do {
5075	map[fd] = 1;
5076	newfd = dup(fd);
5077	fd = newfd;
5078	} while (fd >= 0 && fd < e.iofd);
5079
5080	for (i = 0; i < NOFILE; i++)
5081	if (map[i])
5082	close(i);
5083
5084	if (fd < 0)
5085	err("too many files open in shell");
5086	}
5087
5088	return (fd);
5089	}
5090
5091	static int openpipe(REGISTER int *pv)
5092	{
5093	REGISTER int i;
5094
5095	if ((i = pipe(pv)) < 0)
5096	err("can't create pipe - try again");
5097	return (i);
5098	}
5099
5100	static void closepipe(REGISTER int *pv)
5101	{
5102	if (pv != NULL) {
5103	close(*pv++);
5104	close(*pv);
5105	}
5106	}
5107
5108	/* -------- here.c -------- */
5109
5110	/*
5111	* here documents
5112	*/
5113
5114	static void markhere(REGISTER char s, struct ioword iop)
5115	{
5116	REGISTER struct here h, lh;
5117
5118	DBGPRINTF7(("MARKHERE: enter, s=%p\n", s));
5119
5120	h = (struct here *) space(sizeof(struct here));
5121	if (h == 0)
5122	return;
5123
5124	h->h_tag = evalstr(s, DOSUB);
5125	if (h->h_tag == 0)
5126	return;
5127
5128	h->h_iop = iop;
5129	iop->io_name = 0;
5130	h->h_next = NULL;
5131	if (inhere == 0)
5132	inhere = h;
5133	else
5134	for (lh = inhere; lh != NULL; lh = lh->h_next)
5135	if (lh->h_next == 0) {
5136	lh->h_next = h;
5137	break;
5138	}
5139	iop->io_flag \|= IOHERE \| IOXHERE;
5140	for (s = h->h_tag; *s; s++)
5141	if (*s & QUOTE) {
5142	iop->io_flag &= ~IOXHERE;
5143	*s &= ~QUOTE;
5144	}
5145	h->h_dosub = iop->io_flag & IOXHERE;
5146	}
5147
5148	static void gethere(void)
5149	{
5150	REGISTER struct here h, hp;
5151
5152	DBGPRINTF7(("GETHERE: enter...\n"));
5153
5154	/* Scan here files first leaving inhere list in place */
5155	for (hp = h = inhere; h != NULL; hp = h, h = h->h_next)
5156	readhere(&h->h_iop->io_name, h->h_tag, h->h_dosub ? 0 : '\'');
5157
5158	/* Make inhere list active - keep list intact for scraphere */
5159	if (hp != NULL) {
5160	hp->h_next = acthere;
5161	acthere = inhere;
5162	inhere = NULL;
5163	}
5164	}
5165
5166	static void readhere(char *name, REGISTER char s, int ec)
5167	{
5168	int tf;
5169	char tname[30] = ".msh_XXXXXX";
5170	REGISTER int c;
5171	jmp_buf ev;
5172	char myline[LINELIM + 1];
5173	char *thenext;
5174
5175	DBGPRINTF7(("READHERE: enter, name=%p, s=%p\n", name, s));
5176
5177	tf = mkstemp(tname);
5178	if (tf < 0)
5179	return;
5180
5181	*name = strsave(tname, areanum);
5182	if (newenv(setjmp(errpt = ev)) != 0)
5183	unlink(tname);
5184	else {
5185	pushio(e.iop->argp, (int ()(struct ioarg )) e.iop->iofn);
5186	e.iobase = e.iop;
5187	for (;;) {
5188	if (interactive && e.iop <= iostack) {
5189	#ifdef CONFIG_FEATURE_COMMAND_EDITING
5190	current_prompt = cprompt->value;
5191	#else
5192	prs(cprompt->value);
5193	#endif
5194	}
5195	thenext = myline;
5196	while ((c = my_getc(ec)) != '\n' && c) {
5197	if (ec == '\'')
5198	c &= ~QUOTE;
5199	if (thenext >= &myline[LINELIM]) {
5200	c = 0;
5201	break;
5202	}
5203	*thenext++ = c;
5204	}
5205	*thenext = 0;
5206	if (strcmp(s, myline) == 0 \|\| c == 0)
5207	break;
5208	*thenext++ = '\n';
5209	write(tf, myline, (int) (thenext - myline));
5210	}
5211	if (c == 0) {
5212	prs("here document `");
5213	prs(s);
5214	err("' unclosed");
5215	}
5216	quitenv();
5217	}
5218	close(tf);
5219	}
5220
5221	/*
5222	* open here temp file.
5223	* if unquoted here, expand here temp file into second temp file.
5224	*/
5225	static int herein(char *hname, int xdoll)
5226	{
5227	REGISTER int hf;
5228	int tf;
5229
5230	#if __GNUC__
5231	/* Avoid longjmp clobbering */
5232	(void) &tf;
5233	#endif
5234	if (hname == NULL)
5235	return (-1);
5236
5237	DBGPRINTF7(("HEREIN: hname is %s, xdoll=%d\n", hname, xdoll));
5238
5239	hf = open(hname, 0);
5240	if (hf < 0)
5241	return (-1);
5242
5243	if (xdoll) {
5244	char c;
5245	char tname[30] = ".msh_XXXXXX";
5246	jmp_buf ev;
5247
5248	tf = mkstemp(tname);
5249	if (tf < 0)
5250	return (-1);
5251	if (newenv(setjmp(errpt = ev)) == 0) {
5252	PUSHIO(afile, hf, herechar);
5253	setbase(e.iop);
5254	while ((c = subgetc(0, 0)) != 0) {
5255	c &= ~QUOTE;
5256	write(tf, &c, sizeof c);
5257	}
5258	quitenv();
5259	} else
5260	unlink(tname);
5261	close(tf);
5262	tf = open(tname, 0);
5263	unlink(tname);
5264	return (tf);
5265	} else
5266	return (hf);
5267	}
5268
5269	static void scraphere(void)
5270	{
5271	REGISTER struct here *h;
5272
5273	DBGPRINTF7(("SCRAPHERE: enter...\n"));
5274
5275	for (h = inhere; h != NULL; h = h->h_next) {
5276	if (h->h_iop && h->h_iop->io_name)
5277	unlink(h->h_iop->io_name);
5278	}
5279	inhere = NULL;
5280	}
5281
5282	/* unlink here temp files before a freearea(area) */
5283	static void freehere(int area)
5284	{
5285	REGISTER struct here h, hl;
5286
5287	DBGPRINTF6(("FREEHERE: enter, area=%d\n", area));
5288
5289	hl = NULL;
5290	for (h = acthere; h != NULL; h = h->h_next)
5291	if (getarea((char *) h) >= area) {
5292	if (h->h_iop->io_name != NULL)
5293	unlink(h->h_iop->io_name);
5294	if (hl == NULL)
5295	acthere = h->h_next;
5296	else
5297	hl->h_next = h->h_next;
5298	} else
5299	hl = h;
5300	}
5301
5302
5303
5304	/*
5305	* Copyright (c) 1987,1997, Prentice Hall
5306	* All rights reserved.
5307	*
5308	* Redistribution and use of the MINIX operating system in source and
5309	* binary forms, with or without modification, are permitted provided
5310	* that the following conditions are met:
5311	*
5312	* Redistributions of source code must retain the above copyright
5313	* notice, this list of conditions and the following disclaimer.
5314	*
5315	* Redistributions in binary form must reproduce the above
5316	* copyright notice, this list of conditions and the following
5317	* disclaimer in the documentation and/or other materials provided
5318	* with the distribution.
5319	*
5320	* Neither the name of Prentice Hall nor the names of the software
5321	* authors or contributors may be used to endorse or promote
5322	* products derived from this software without specific prior
5323	* written permission.
5324	*
5325	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
5326	* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
5327	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
5328	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
5329	* IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
5330	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
5331	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
5332	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
5333	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
5334	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
5335	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
5336	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
5337	*
5338	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: