1 /* vi: set sw=4 ts=4: */
3 * ash shell port for busybox
5 * Copyright (c) 1989, 1991, 1993, 1994
6 * The Regents of the University of California. All rights reserved.
8 * Copyright (c) 1997-2005 Herbert Xu <herbert@gondor.apana.org.au>
9 * was re-ported from NetBSD and debianized.
12 * This code is derived from software contributed to Berkeley by
15 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
17 * Original BSD copyright notice is retained at the end of this file.
21 * rewrite arith.y to micro stack based cryptic algorithm by
22 * Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
24 * Modified by Paul Mundt <lethal@linux-sh.org> (c) 2004 to support
27 * Modified by Vladimir Oleynik <dzo@simtreas.ru> (c) 2001-2005 to be
28 * used in busybox and size optimizations,
29 * rewrote arith (see notes to this), added locale support,
30 * rewrote dynamic variables.
35 * The follow should be set to reflect the type of system you have:
36 * JOBS -> 1 if you have Berkeley job control, 0 otherwise.
37 * define SYSV if you are running under System V.
38 * define DEBUG=1 to compile in debugging ('set -o debug' to turn on)
39 * define DEBUG=2 to compile in and turn on debugging.
41 * When debugging is on, debugging info will be written to ./trace and
42 * a quit signal will generate a core dump.
47 #if ENABLE_ASH_JOB_CONTROL
56 #include "busybox.h" /* for struct bb_applet */
60 #if JOBS || ENABLE_ASH_READ_NCHARS
63 extern char **environ;
65 #if defined(__uClinux__)
66 #error "Do not even bother, ash will not run on uClinux"
70 /* ============ Misc helpers */
72 #define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0)
74 /* C99 say: "char" declaration may be signed or unsigned default */
75 #define signed_char2int(sc) ((int)((signed char)sc))
78 /* ============ Shell options */
80 static const char *const optletters_optnames[] = {
101 #define optletters(n) optletters_optnames[(n)][0]
102 #define optnames(n) (&optletters_optnames[(n)][1])
104 enum { NOPTS = ARRAY_SIZE(optletters_optnames) };
106 static char optlist[NOPTS];
108 #define eflag optlist[0]
109 #define fflag optlist[1]
110 #define Iflag optlist[2]
111 #define iflag optlist[3]
112 #define mflag optlist[4]
113 #define nflag optlist[5]
114 #define sflag optlist[6]
115 #define xflag optlist[7]
116 #define vflag optlist[8]
117 #define Cflag optlist[9]
118 #define aflag optlist[10]
119 #define bflag optlist[11]
120 #define uflag optlist[12]
121 #define viflag optlist[13]
123 #define nolog optlist[14]
124 #define debug optlist[15]
128 /* ============ Misc data */
130 static char nullstr[1]; /* zero length string */
131 static const char homestr[] = "HOME";
132 static const char snlfmt[] = "%s\n";
133 static const char illnum[] = "Illegal number: %s";
135 static char *minusc; /* argument to -c option */
137 static int isloginsh;
138 /* pid of main shell */
140 /* shell level: 0 for the main shell, 1 for its children, and so on */
142 #define rootshell (!shlvl)
143 /* trap handler commands */
144 static char *trap[NSIG];
145 /* current value of signal */
146 static char sigmode[NSIG - 1];
147 /* indicates specified signal received */
148 static char gotsig[NSIG - 1];
149 static char *arg0; /* value of $0 */
152 /* ============ Interrupts / exceptions */
155 * We enclose jmp_buf in a structure so that we can declare pointers to
156 * jump locations. The global variable handler contains the location to
157 * jump to when an exception occurs, and the global variable exception
158 * contains a code identifying the exception. To implement nested
159 * exception handlers, the user should save the value of handler on entry
160 * to an inner scope, set handler to point to a jmploc structure for the
161 * inner scope, and restore handler on exit from the scope.
166 static struct jmploc *exception_handler;
167 static int exception;
169 #define EXINT 0 /* SIGINT received */
170 #define EXERROR 1 /* a generic error */
171 #define EXSHELLPROC 2 /* execute a shell procedure */
172 #define EXEXEC 3 /* command execution failed */
173 #define EXEXIT 4 /* exit the shell */
174 #define EXSIG 5 /* trapped signal in wait(1) */
175 static volatile int suppressint;
176 static volatile sig_atomic_t intpending;
177 /* do we generate EXSIG events */
179 /* last pending signal */
180 static volatile sig_atomic_t pendingsig;
183 * Sigmode records the current value of the signal handlers for the various
184 * modes. A value of zero means that the current handler is not known.
185 * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
188 #define S_DFL 1 /* default signal handling (SIG_DFL) */
189 #define S_CATCH 2 /* signal is caught */
190 #define S_IGN 3 /* signal is ignored (SIG_IGN) */
191 #define S_HARD_IGN 4 /* signal is ignored permenantly */
192 #define S_RESET 5 /* temporary - to reset a hard ignored sig */
195 * These macros allow the user to suspend the handling of interrupt signals
196 * over a period of time. This is similar to SIGHOLD to or sigblock, but
197 * much more efficient and portable. (But hacking the kernel is so much
198 * more fun than worrying about efficiency and portability. :-))
207 * Called to raise an exception. Since C doesn't include exceptions, we
208 * just do a longjmp to the exception handler. The type of exception is
209 * stored in the global variable "exception".
211 static void raise_exception(int) ATTRIBUTE_NORETURN;
213 raise_exception(int e)
216 if (exception_handler == NULL)
221 longjmp(exception_handler->loc, 1);
225 * Called from trap.c when a SIGINT is received. (If the user specifies
226 * that SIGINT is to be trapped or ignored using the trap builtin, then
227 * this routine is not called.) Suppressint is nonzero when interrupts
228 * are held using the INT_OFF macro. (The test for iflag is just
229 * defensive programming.)
231 static void raise_interrupt(void) ATTRIBUTE_NORETURN;
233 raise_interrupt(void)
239 /* Signal is not automatically re-enabled after it is raised,
242 sigprocmask(SIG_SETMASK, &mask, 0);
243 /* pendingsig = 0; - now done in onsig() */
246 if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
247 if (!(rootshell && iflag)) {
248 signal(SIGINT, SIG_DFL);
257 #if ENABLE_ASH_OPTIMIZE_FOR_SIZE
261 if (--suppressint == 0 && intpending) {
265 #define INT_ON int_on()
273 #define FORCE_INT_ON force_int_on()
278 if (--suppressint == 0 && intpending) \
281 #define FORCE_INT_ON \
288 #endif /* ASH_OPTIMIZE_FOR_SIZE */
290 #define SAVE_INT(v) ((v) = suppressint)
292 #define RESTORE_INT(v) \
296 if (suppressint == 0 && intpending) \
305 raise_exception(EXSIG); \
307 /* EXSIG is turned off by evalbltin(). */
310 * Ignore a signal. Only one usage site - in forkchild()
315 if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
316 signal(signo, SIG_IGN);
318 sigmode[signo - 1] = S_HARD_IGN;
322 * Signal handler. Only one usage site - in setsignal()
327 gotsig[signo - 1] = 1;
330 if (exsig || (signo == SIGINT && !trap[SIGINT])) {
340 /* ============ Stdout/stderr output */
343 outstr(const char *p, FILE *file)
351 flush_stdout_stderr(void)
368 outcslow(int c, FILE *dest)
376 static int out1fmt(const char *, ...) __attribute__((__format__(__printf__,1,2)));
378 out1fmt(const char *fmt, ...)
385 r = vprintf(fmt, ap);
391 static int fmtstr(char *, size_t, const char *, ...) __attribute__((__format__(__printf__,3,4)));
393 fmtstr(char *outbuf, size_t length, const char *fmt, ...)
400 ret = vsnprintf(outbuf, length, fmt, ap);
407 out1str(const char *p)
413 out2str(const char *p)
420 /* ============ Parser structures */
422 /* control characters in argument strings */
423 #define CTLESC '\201' /* escape next character */
424 #define CTLVAR '\202' /* variable defn */
425 #define CTLENDVAR '\203'
426 #define CTLBACKQ '\204'
427 #define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
428 /* CTLBACKQ | CTLQUOTE == '\205' */
429 #define CTLARI '\206' /* arithmetic expression */
430 #define CTLENDARI '\207'
431 #define CTLQUOTEMARK '\210'
433 /* variable substitution byte (follows CTLVAR) */
434 #define VSTYPE 0x0f /* type of variable substitution */
435 #define VSNUL 0x10 /* colon--treat the empty string as unset */
436 #define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
438 /* values of VSTYPE field */
439 #define VSNORMAL 0x1 /* normal variable: $var or ${var} */
440 #define VSMINUS 0x2 /* ${var-text} */
441 #define VSPLUS 0x3 /* ${var+text} */
442 #define VSQUESTION 0x4 /* ${var?message} */
443 #define VSASSIGN 0x5 /* ${var=text} */
444 #define VSTRIMRIGHT 0x6 /* ${var%pattern} */
445 #define VSTRIMRIGHTMAX 0x7 /* ${var%%pattern} */
446 #define VSTRIMLEFT 0x8 /* ${var#pattern} */
447 #define VSTRIMLEFTMAX 0x9 /* ${var##pattern} */
448 #define VSLENGTH 0xa /* ${#var} */
450 static const char dolatstr[] = { CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' };
485 union node *redirect;
491 struct nodelist *cmdlist;
497 union node *redirect;
510 union node *elsepart;
537 struct nodelist *backquote;
572 struct nredir nredir;
573 struct nbinary nbinary;
577 struct nclist nclist;
586 struct nodelist *next;
599 freefunc(struct funcnode *f)
601 if (f && --f->count < 0)
606 /* ============ Debugging output */
610 static FILE *tracefile;
613 trace_printf(const char *fmt, ...)
620 vfprintf(tracefile, fmt, va);
625 trace_vprintf(const char *fmt, va_list va)
629 vfprintf(tracefile, fmt, va);
633 trace_puts(const char *s)
641 trace_puts_quoted(char *s)
648 putc('"', tracefile);
649 for (p = s; *p; p++) {
651 case '\n': c = 'n'; goto backslash;
652 case '\t': c = 't'; goto backslash;
653 case '\r': c = 'r'; goto backslash;
654 case '"': c = '"'; goto backslash;
655 case '\\': c = '\\'; goto backslash;
656 case CTLESC: c = 'e'; goto backslash;
657 case CTLVAR: c = 'v'; goto backslash;
658 case CTLVAR+CTLQUOTE: c = 'V'; goto backslash;
659 case CTLBACKQ: c = 'q'; goto backslash;
660 case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash;
662 putc('\\', tracefile);
666 if (*p >= ' ' && *p <= '~')
669 putc('\\', tracefile);
670 putc(*p >> 6 & 03, tracefile);
671 putc(*p >> 3 & 07, tracefile);
672 putc(*p & 07, tracefile);
677 putc('"', tracefile);
681 trace_puts_args(char **ap)
688 trace_puts_quoted(*ap);
690 putc('\n', tracefile);
693 putc(' ', tracefile);
708 /* leave open because libedit might be using it */
711 strcpy(s, "./trace");
713 if (!freopen(s, "a", tracefile)) {
714 fprintf(stderr, "Can't re-open %s\n", s);
719 tracefile = fopen(s, "a");
720 if (tracefile == NULL) {
721 fprintf(stderr, "Can't open %s\n", s);
727 flags = fcntl(fileno(tracefile), F_GETFL, 0);
729 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
731 setlinebuf(tracefile);
732 fputs("\nTracing started.\n", tracefile);
736 indent(int amount, char *pfx, FILE *fp)
740 for (i = 0; i < amount; i++) {
741 if (pfx && i == amount - 1)
747 /* little circular references here... */
748 static void shtree(union node *n, int ind, char *pfx, FILE *fp);
751 sharg(union node *arg, FILE *fp)
754 struct nodelist *bqlist;
757 if (arg->type != NARG) {
758 out1fmt("<node type %d>\n", arg->type);
761 bqlist = arg->narg.backquote;
762 for (p = arg->narg.text; *p; p++) {
771 if (subtype == VSLENGTH)
780 switch (subtype & VSTYPE) {
813 out1fmt("<subtype %d>", subtype);
820 case CTLBACKQ|CTLQUOTE:
823 shtree(bqlist->n, -1, NULL, fp);
834 shcmd(union node *cmd, FILE *fp)
842 for (np = cmd->ncmd.args; np; np = np->narg.next) {
848 for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
852 switch (np->nfile.type) {
853 case NTO: s = ">>"+1; dftfd = 1; break;
854 case NCLOBBER: s = ">|"; dftfd = 1; break;
855 case NAPPEND: s = ">>"; dftfd = 1; break;
856 case NTOFD: s = ">&"; dftfd = 1; break;
857 case NFROM: s = "<"; break;
858 case NFROMFD: s = "<&"; break;
859 case NFROMTO: s = "<>"; break;
860 default: s = "*error*"; break;
862 if (np->nfile.fd != dftfd)
863 fprintf(fp, "%d", np->nfile.fd);
865 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
866 fprintf(fp, "%d", np->ndup.dupfd);
868 sharg(np->nfile.fname, fp);
875 shtree(union node *n, int ind, char *pfx, FILE *fp)
883 indent(ind, pfx, fp);
894 shtree(n->nbinary.ch1, ind, NULL, fp);
897 shtree(n->nbinary.ch2, ind, NULL, fp);
905 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
910 if (n->npipe.backgnd)
916 fprintf(fp, "<node type %d>", n->type);
924 showtree(union node *n)
926 trace_puts("showtree called\n");
927 shtree(n, 1, NULL, stdout);
930 #define TRACE(param) trace_printf param
931 #define TRACEV(param) trace_vprintf param
936 #define TRACEV(param)
941 /* ============ Parser data */
944 * ash_vmsg() needs parsefile->fd, hence parsefile definition is moved up.
947 struct strlist *next;
956 struct strpush *prev; /* preceding string on stack */
960 struct alias *ap; /* if push was associated with an alias */
962 char *string; /* remember the string since it may change */
966 struct parsefile *prev; /* preceding file on stack */
967 int linno; /* current line */
968 int fd; /* file descriptor (or -1 if string) */
969 int nleft; /* number of chars left in this line */
970 int lleft; /* number of chars left in this buffer */
971 char *nextc; /* next char in buffer */
972 char *buf; /* input buffer */
973 struct strpush *strpush; /* for pushing strings at this level */
974 struct strpush basestrpush; /* so pushing one is fast */
977 static struct parsefile basepf; /* top level input file */
978 static struct parsefile *parsefile = &basepf; /* current input file */
979 static int startlinno; /* line # where last token started */
980 static char *commandname; /* currently executing command */
981 static struct strlist *cmdenviron; /* environment for builtin command */
982 static int exitstatus; /* exit status of last command */
985 /* ============ Message printing */
988 ash_vmsg(const char *msg, va_list ap)
990 fprintf(stderr, "%s: ", arg0);
992 if (strcmp(arg0, commandname))
993 fprintf(stderr, "%s: ", commandname);
994 if (!iflag || parsefile->fd)
995 fprintf(stderr, "line %d: ", startlinno);
997 vfprintf(stderr, msg, ap);
998 outcslow('\n', stderr);
1002 * Exverror is called to raise the error exception. If the second argument
1003 * is not NULL then error prints an error message using printf style
1004 * formatting. It then raises the error exception.
1006 static void ash_vmsg_and_raise(int, const char *, va_list) ATTRIBUTE_NORETURN;
1008 ash_vmsg_and_raise(int cond, const char *msg, va_list ap)
1012 TRACE(("ash_vmsg_and_raise(%d, \"", cond));
1014 TRACE(("\") pid=%d\n", getpid()));
1016 TRACE(("ash_vmsg_and_raise(%d, NULL) pid=%d\n", cond, getpid()));
1021 flush_stdout_stderr();
1022 raise_exception(cond);
1026 static void ash_msg_and_raise_error(const char *, ...) ATTRIBUTE_NORETURN;
1028 ash_msg_and_raise_error(const char *msg, ...)
1033 ash_vmsg_and_raise(EXERROR, msg, ap);
1038 static void ash_msg_and_raise(int, const char *, ...) ATTRIBUTE_NORETURN;
1040 ash_msg_and_raise(int cond, const char *msg, ...)
1045 ash_vmsg_and_raise(cond, msg, ap);
1051 * error/warning routines for external builtins
1054 ash_msg(const char *fmt, ...)
1064 * Return a string describing an error. The returned string may be a
1065 * pointer to a static buffer that will be overwritten on the next call.
1066 * Action describes the operation that got the error.
1069 errmsg(int e, const char *em)
1071 if (e == ENOENT || e == ENOTDIR) {
1078 /* ============ Memory allocation */
1081 * It appears that grabstackstr() will barf with such alignments
1082 * because stalloc() will return a string allocated in a new stackblock.
1084 #define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
1086 /* Most machines require the value returned from malloc to be aligned
1087 * in some way. The following macro will get this right
1088 * on many machines. */
1089 SHELL_SIZE = sizeof(union {int i; char *cp; double d; }) - 1,
1090 /* Minimum size of a block */
1091 MINSIZE = SHELL_ALIGN(504),
1094 struct stack_block {
1095 struct stack_block *prev;
1096 char space[MINSIZE];
1100 struct stack_block *stackp;
1103 struct stackmark *marknext;
1106 static struct stack_block stackbase;
1107 static struct stack_block *stackp = &stackbase;
1108 static struct stackmark *markp;
1109 static char *stacknxt = stackbase.space;
1110 static size_t stacknleft = MINSIZE;
1111 static char *sstrend = stackbase.space + MINSIZE;
1112 static int herefd = -1;
1114 #define stackblock() ((void *)stacknxt)
1115 #define stackblocksize() stacknleft
1118 ckrealloc(void * p, size_t nbytes)
1120 p = realloc(p, nbytes);
1122 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1127 ckmalloc(size_t nbytes)
1129 return ckrealloc(NULL, nbytes);
1133 * Make a copy of a string in safe storage.
1136 ckstrdup(const char *s)
1138 char *p = strdup(s);
1140 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1145 * Parse trees for commands are allocated in lifo order, so we use a stack
1146 * to make this more efficient, and also to avoid all sorts of exception
1147 * handling code to handle interrupts in the middle of a parse.
1149 * The size 504 was chosen because the Ultrix malloc handles that size
1153 stalloc(size_t nbytes)
1158 aligned = SHELL_ALIGN(nbytes);
1159 if (aligned > stacknleft) {
1162 struct stack_block *sp;
1164 blocksize = aligned;
1165 if (blocksize < MINSIZE)
1166 blocksize = MINSIZE;
1167 len = sizeof(struct stack_block) - MINSIZE + blocksize;
1168 if (len < blocksize)
1169 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1173 stacknxt = sp->space;
1174 stacknleft = blocksize;
1175 sstrend = stacknxt + blocksize;
1180 stacknxt += aligned;
1181 stacknleft -= aligned;
1189 if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
1190 write(2, "stunalloc\n", 10);
1194 stacknleft += stacknxt - (char *)p;
1199 * Like strdup but works with the ash stack.
1202 ststrdup(const char *p)
1204 size_t len = strlen(p) + 1;
1205 return memcpy(stalloc(len), p, len);
1209 setstackmark(struct stackmark *mark)
1211 mark->stackp = stackp;
1212 mark->stacknxt = stacknxt;
1213 mark->stacknleft = stacknleft;
1214 mark->marknext = markp;
1219 popstackmark(struct stackmark *mark)
1221 struct stack_block *sp;
1227 markp = mark->marknext;
1228 while (stackp != mark->stackp) {
1233 stacknxt = mark->stacknxt;
1234 stacknleft = mark->stacknleft;
1235 sstrend = mark->stacknxt + mark->stacknleft;
1240 * When the parser reads in a string, it wants to stick the string on the
1241 * stack and only adjust the stack pointer when it knows how big the
1242 * string is. Stackblock (defined in stack.h) returns a pointer to a block
1243 * of space on top of the stack and stackblocklen returns the length of
1244 * this block. Growstackblock will grow this space by at least one byte,
1245 * possibly moving it (like realloc). Grabstackblock actually allocates the
1246 * part of the block that has been used.
1249 growstackblock(void)
1253 newlen = stacknleft * 2;
1254 if (newlen < stacknleft)
1255 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1259 if (stacknxt == stackp->space && stackp != &stackbase) {
1260 struct stack_block *oldstackp;
1261 struct stackmark *xmark;
1262 struct stack_block *sp;
1263 struct stack_block *prevstackp;
1269 prevstackp = sp->prev;
1270 grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
1271 sp = ckrealloc(sp, grosslen);
1272 sp->prev = prevstackp;
1274 stacknxt = sp->space;
1275 stacknleft = newlen;
1276 sstrend = sp->space + newlen;
1279 * Stack marks pointing to the start of the old block
1280 * must be relocated to point to the new block
1283 while (xmark != NULL && xmark->stackp == oldstackp) {
1284 xmark->stackp = stackp;
1285 xmark->stacknxt = stacknxt;
1286 xmark->stacknleft = stacknleft;
1287 xmark = xmark->marknext;
1291 char *oldspace = stacknxt;
1292 int oldlen = stacknleft;
1293 char *p = stalloc(newlen);
1295 /* free the space we just allocated */
1296 stacknxt = memcpy(p, oldspace, oldlen);
1297 stacknleft += newlen;
1302 grabstackblock(size_t len)
1304 len = SHELL_ALIGN(len);
1310 * The following routines are somewhat easier to use than the above.
1311 * The user declares a variable of type STACKSTR, which may be declared
1312 * to be a register. The macro STARTSTACKSTR initializes things. Then
1313 * the user uses the macro STPUTC to add characters to the string. In
1314 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
1315 * grown as necessary. When the user is done, she can just leave the
1316 * string there and refer to it using stackblock(). Or she can allocate
1317 * the space for it using grabstackstr(). If it is necessary to allow
1318 * someone else to use the stack temporarily and then continue to grow
1319 * the string, the user should use grabstack to allocate the space, and
1320 * then call ungrabstr(p) to return to the previous mode of operation.
1322 * USTPUTC is like STPUTC except that it doesn't check for overflow.
1323 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
1324 * is space for at least one character.
1329 size_t len = stackblocksize();
1330 if (herefd >= 0 && len >= 1024) {
1331 full_write(herefd, stackblock(), len);
1332 return stackblock();
1335 return stackblock() + len;
1339 * Called from CHECKSTRSPACE.
1342 makestrspace(size_t newlen, char *p)
1344 size_t len = p - stacknxt;
1345 size_t size = stackblocksize();
1350 size = stackblocksize();
1352 if (nleft >= newlen)
1356 return stackblock() + len;
1360 stack_nputstr(const char *s, size_t n, char *p)
1362 p = makestrspace(n, p);
1363 p = memcpy(p, s, n) + n;
1368 stack_putstr(const char *s, char *p)
1370 return stack_nputstr(s, strlen(s), p);
1374 _STPUTC(int c, char *p)
1382 #define STARTSTACKSTR(p) ((p) = stackblock())
1383 #define STPUTC(c, p) ((p) = _STPUTC((c), (p)))
1384 #define CHECKSTRSPACE(n, p) \
1388 size_t m = sstrend - q; \
1390 (p) = makestrspace(l, q); \
1392 #define USTPUTC(c, p) (*p++ = (c))
1393 #define STACKSTRNUL(p) \
1395 if ((p) == sstrend) \
1396 p = growstackstr(); \
1399 #define STUNPUTC(p) (--p)
1400 #define STTOPC(p) (p[-1])
1401 #define STADJUST(amount, p) (p += (amount))
1403 #define grabstackstr(p) stalloc((char *)(p) - (char *)stackblock())
1404 #define ungrabstackstr(s, p) stunalloc((s))
1405 #define stackstrend() ((void *)sstrend)
1408 /* ============ String helpers */
1411 * prefix -- see if pfx is a prefix of string.
1414 prefix(const char *string, const char *pfx)
1417 if (*pfx++ != *string++)
1420 return (char *) string;
1424 * Check for a valid number. This should be elsewhere.
1427 is_number(const char *p)
1432 } while (*++p != '\0');
1437 * Convert a string of digits to an integer, printing an error message on
1441 number(const char *s)
1444 ash_msg_and_raise_error(illnum, s);
1449 * Produce a possibly single quoted string suitable as input to the shell.
1450 * The return string is allocated on the stack.
1453 single_quote(const char *s)
1463 len = strchrnul(s, '\'') - s;
1465 q = p = makestrspace(len + 3, p);
1468 q = memcpy(q, s, len) + len;
1474 len = strspn(s, "'");
1478 q = p = makestrspace(len + 3, p);
1481 q = memcpy(q, s, len) + len;
1490 return stackblock();
1494 /* ============ nextopt */
1496 static char **argptr; /* argument list for builtin commands */
1497 static char *optionarg; /* set by nextopt (like getopt) */
1498 static char *optptr; /* used by nextopt */
1501 * XXX - should get rid of. have all builtins use getopt(3). the
1502 * library getopt must have the BSD extension static variable "optreset"
1503 * otherwise it can't be used within the shell safely.
1505 * Standard option processing (a la getopt) for builtin routines. The
1506 * only argument that is passed to nextopt is the option string; the
1507 * other arguments are unnecessary. It return the character, or '\0' on
1511 nextopt(const char *optstring)
1518 if (p == NULL || *p == '\0') {
1520 if (p == NULL || *p != '-' || *++p == '\0')
1523 if (LONE_DASH(p)) /* check for "--" */
1527 for (q = optstring; *q != c; ) {
1529 ash_msg_and_raise_error("illegal option -%c", c);
1534 if (*p == '\0' && (p = *argptr++) == NULL)
1535 ash_msg_and_raise_error("no arg for -%c option", c);
1544 /* ============ Math support definitions */
1546 #if ENABLE_ASH_MATH_SUPPORT_64
1547 typedef int64_t arith_t;
1548 #define arith_t_type long long
1550 typedef long arith_t;
1551 #define arith_t_type long
1554 #if ENABLE_ASH_MATH_SUPPORT
1555 static arith_t dash_arith(const char *);
1556 static arith_t arith(const char *expr, int *perrcode);
1559 #if ENABLE_ASH_RANDOM_SUPPORT
1560 static unsigned long rseed;
1567 /* ============ Shell variables */
1570 #define VEXPORT 0x01 /* variable is exported */
1571 #define VREADONLY 0x02 /* variable cannot be modified */
1572 #define VSTRFIXED 0x04 /* variable struct is statically allocated */
1573 #define VTEXTFIXED 0x08 /* text is statically allocated */
1574 #define VSTACK 0x10 /* text is allocated on the stack */
1575 #define VUNSET 0x20 /* the variable is not set */
1576 #define VNOFUNC 0x40 /* don't call the callback function */
1577 #define VNOSET 0x80 /* do not set variable - just readonly test */
1578 #define VNOSAVE 0x100 /* when text is on the heap before setvareq */
1580 # define VDYNAMIC 0x200 /* dynamic variable */
1586 static const char defifsvar[] = "IFS= \t\n";
1587 #define defifs (defifsvar + 4)
1589 static const char defifs[] = " \t\n";
1593 int nparam; /* # of positional parameters (without $0) */
1594 unsigned char malloc; /* if parameter list dynamically allocated */
1595 char **p; /* parameter list */
1596 #if ENABLE_ASH_GETOPTS
1597 int optind; /* next parameter to be processed by getopts */
1598 int optoff; /* used by getopts */
1602 static struct shparam shellparam; /* $@ current positional parameters */
1605 * Free the list of positional parameters.
1608 freeparam(volatile struct shparam *param)
1612 if (param->malloc) {
1613 for (ap = param->p; *ap; ap++)
1619 #if ENABLE_ASH_GETOPTS
1621 getoptsreset(const char *value)
1623 shellparam.optind = number(value);
1624 shellparam.optoff = -1;
1629 struct var *next; /* next entry in hash list */
1630 int flags; /* flags are defined above */
1631 const char *text; /* name=value */
1632 void (*func)(const char *); /* function to be called when */
1633 /* the variable gets set/unset */
1637 struct localvar *next; /* next local variable in list */
1638 struct var *vp; /* the variable that was made local */
1639 int flags; /* saved flags */
1640 const char *text; /* saved text */
1643 /* Forward decls for varinit[] */
1644 #if ENABLE_LOCALE_SUPPORT
1646 change_lc_all(const char *value)
1648 if (value && *value != '\0')
1649 setlocale(LC_ALL, value);
1652 change_lc_ctype(const char *value)
1654 if (value && *value != '\0')
1655 setlocale(LC_CTYPE, value);
1659 static void chkmail(void);
1660 static void changemail(const char *);
1662 static void changepath(const char *);
1663 #if ENABLE_ASH_RANDOM_SUPPORT
1664 static void change_random(const char *);
1667 static struct var varinit[] = {
1669 { NULL, VSTRFIXED|VTEXTFIXED, defifsvar, NULL },
1671 { NULL, VSTRFIXED|VTEXTFIXED|VUNSET, "IFS\0", NULL },
1674 { NULL, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL\0", changemail },
1675 { NULL, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH\0", changemail },
1677 { NULL, VSTRFIXED|VTEXTFIXED, bb_PATH_root_path, changepath },
1678 { NULL, VSTRFIXED|VTEXTFIXED, "PS1=$ ", NULL },
1679 { NULL, VSTRFIXED|VTEXTFIXED, "PS2=> ", NULL },
1680 { NULL, VSTRFIXED|VTEXTFIXED, "PS4=+ ", NULL },
1681 #if ENABLE_ASH_GETOPTS
1682 { NULL, VSTRFIXED|VTEXTFIXED, "OPTIND=1", getoptsreset },
1684 #if ENABLE_ASH_RANDOM_SUPPORT
1685 { NULL, VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM\0", change_random },
1687 #if ENABLE_LOCALE_SUPPORT
1688 { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL\0", change_lc_all },
1689 { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE\0", change_lc_ctype },
1691 #if ENABLE_FEATURE_EDITING_SAVEHISTORY
1692 { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE\0", NULL },
1696 #define vifs varinit[0]
1698 #define vmail (&vifs)[1]
1699 #define vmpath (&vmail)[1]
1703 #define vpath (&vmpath)[1]
1704 #define vps1 (&vpath)[1]
1705 #define vps2 (&vps1)[1]
1706 #define vps4 (&vps2)[1]
1707 #define voptind (&vps4)[1]
1708 #if ENABLE_ASH_GETOPTS
1709 #define vrandom (&voptind)[1]
1711 #define vrandom (&vps4)[1]
1715 * The following macros access the values of the above variables.
1716 * They have to skip over the name. They return the null string
1717 * for unset variables.
1719 #define ifsval() (vifs.text + 4)
1720 #define ifsset() ((vifs.flags & VUNSET) == 0)
1721 #define mailval() (vmail.text + 5)
1722 #define mpathval() (vmpath.text + 9)
1723 #define pathval() (vpath.text + 5)
1724 #define ps1val() (vps1.text + 4)
1725 #define ps2val() (vps2.text + 4)
1726 #define ps4val() (vps4.text + 4)
1727 #define optindval() (voptind.text + 7)
1729 #define mpathset() ((vmpath.flags & VUNSET) == 0)
1732 * The parsefile structure pointed to by the global variable parsefile
1733 * contains information about the current file being read.
1736 struct redirtab *next;
1741 static struct redirtab *redirlist;
1742 static int nullredirs;
1743 static int preverrout_fd; /* save fd2 before print debug if xflag is set. */
1747 static struct var *vartab[VTABSIZE];
1749 #define is_name(c) ((c) == '_' || isalpha((unsigned char)(c)))
1750 #define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
1753 * Return of a legal variable name (a letter or underscore followed by zero or
1754 * more letters, underscores, and digits).
1757 endofname(const char *name)
1765 if (!is_in_name(*p))
1772 * Compares two strings up to the first = or '\0'. The first
1773 * string must be terminated by '='; the second may be terminated by
1774 * either '=' or '\0'.
1777 varcmp(const char *p, const char *q)
1781 while ((c = *p) == (d = *q)) {
1796 varequal(const char *a, const char *b)
1798 return !varcmp(a, b);
1802 * Find the appropriate entry in the hash table from the name.
1804 static struct var **
1805 hashvar(const char *p)
1809 hashval = ((unsigned char) *p) << 4;
1810 while (*p && *p != '=')
1811 hashval += (unsigned char) *p++;
1812 return &vartab[hashval % VTABSIZE];
1816 vpcmp(const void *a, const void *b)
1818 return varcmp(*(const char **)a, *(const char **)b);
1822 * This routine initializes the builtin variables.
1832 * PS1 depends on uid
1834 #if ENABLE_FEATURE_EDITING && ENABLE_FEATURE_EDITING_FANCY_PROMPT
1835 vps1.text = "PS1=\\w \\$ ";
1838 vps1.text = "PS1=# ";
1841 end = vp + ARRAY_SIZE(varinit);
1843 vpp = hashvar(vp->text);
1846 } while (++vp < end);
1849 static struct var **
1850 findvar(struct var **vpp, const char *name)
1852 for (; *vpp; vpp = &(*vpp)->next) {
1853 if (varequal((*vpp)->text, name)) {
1861 * Find the value of a variable. Returns NULL if not set.
1864 lookupvar(const char *name)
1868 v = *findvar(hashvar(name), name);
1872 * Dynamic variables are implemented roughly the same way they are
1873 * in bash. Namely, they're "special" so long as they aren't unset.
1874 * As soon as they're unset, they're no longer dynamic, and dynamic
1875 * lookup will no longer happen at that point. -- PFM.
1877 if ((v->flags & VDYNAMIC))
1880 if (!(v->flags & VUNSET))
1881 return strchrnul(v->text, '=') + 1;
1887 * Search the environment of a builtin command.
1890 bltinlookup(const char *name)
1894 for (sp = cmdenviron; sp; sp = sp->next) {
1895 if (varequal(sp->text, name))
1896 return strchrnul(sp->text, '=') + 1;
1898 return lookupvar(name);
1902 * Same as setvar except that the variable and value are passed in
1903 * the first argument as name=value. Since the first argument will
1904 * be actually stored in the table, it should not be a string that
1906 * Called with interrupts off.
1909 setvareq(char *s, int flags)
1911 struct var *vp, **vpp;
1914 flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
1915 vp = *findvar(vpp, s);
1917 if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) {
1920 if (flags & VNOSAVE)
1923 ash_msg_and_raise_error("%.*s: is read only", strchrnul(n, '=') - n, n);
1929 if (vp->func && (flags & VNOFUNC) == 0)
1930 (*vp->func)(strchrnul(s, '=') + 1);
1932 if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
1933 free((char*)vp->text);
1935 flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
1940 vp = ckmalloc(sizeof(*vp));
1945 if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
1952 * Set the value of a variable. The flags argument is ored with the
1953 * flags of the variable. If val is NULL, the variable is unset.
1956 setvar(const char *name, const char *val, int flags)
1963 q = endofname(name);
1964 p = strchrnul(q, '=');
1966 if (!namelen || p != q)
1967 ash_msg_and_raise_error("%.*s: bad variable name", namelen, name);
1972 vallen = strlen(val);
1975 nameeq = ckmalloc(namelen + vallen + 2);
1976 p = memcpy(nameeq, name, namelen) + namelen;
1979 p = memcpy(p, val, vallen) + vallen;
1982 setvareq(nameeq, flags | VNOSAVE);
1986 #if ENABLE_ASH_GETOPTS
1988 * Safe version of setvar, returns 1 on success 0 on failure.
1991 setvarsafe(const char *name, const char *val, int flags)
1994 volatile int saveint;
1995 struct jmploc *volatile savehandler = exception_handler;
1996 struct jmploc jmploc;
1999 if (setjmp(jmploc.loc))
2002 exception_handler = &jmploc;
2003 setvar(name, val, flags);
2006 exception_handler = savehandler;
2007 RESTORE_INT(saveint);
2013 * Unset the specified variable.
2016 unsetvar(const char *s)
2022 vpp = findvar(hashvar(s), s);
2026 int flags = vp->flags;
2029 if (flags & VREADONLY)
2032 vp->flags &= ~VDYNAMIC;
2036 if ((flags & VSTRFIXED) == 0) {
2038 if ((flags & (VTEXTFIXED|VSTACK)) == 0)
2039 free((char*)vp->text);
2045 vp->flags &= ~VEXPORT;
2055 * Process a linked list of variable assignments.
2058 listsetvar(struct strlist *list_set_var, int flags)
2060 struct strlist *lp = list_set_var;
2066 setvareq(lp->text, flags);
2073 * Generate a list of variables satisfying the given conditions.
2076 listvars(int on, int off, char ***end)
2087 for (vp = *vpp; vp; vp = vp->next) {
2088 if ((vp->flags & mask) == on) {
2089 if (ep == stackstrend())
2090 ep = growstackstr();
2091 *ep++ = (char *) vp->text;
2094 } while (++vpp < vartab + VTABSIZE);
2095 if (ep == stackstrend())
2096 ep = growstackstr();
2100 return grabstackstr(ep);
2104 /* ============ Path search helper
2106 * The variable path (passed by reference) should be set to the start
2107 * of the path before the first call; padvance will update
2108 * this value as it proceeds. Successive calls to padvance will return
2109 * the possible path expansions in sequence. If an option (indicated by
2110 * a percent sign) appears in the path entry then the global variable
2111 * pathopt will be set to point to it; otherwise pathopt will be set to
2114 static const char *pathopt; /* set by padvance */
2117 padvance(const char **path, const char *name)
2127 for (p = start; *p && *p != ':' && *p != '%'; p++);
2128 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
2129 while (stackblocksize() < len)
2133 memcpy(q, start, p - start);
2141 while (*p && *p != ':') p++;
2147 return stalloc(len);
2151 /* ============ Prompt */
2153 static int doprompt; /* if set, prompt the user */
2154 static int needprompt; /* true if interactive and at start of line */
2156 #if ENABLE_FEATURE_EDITING
2157 static line_input_t *line_input_state;
2158 static const char *cmdedit_prompt;
2160 putprompt(const char *s)
2162 if (ENABLE_ASH_EXPAND_PRMT) {
2163 free((char*)cmdedit_prompt);
2164 cmdedit_prompt = ckstrdup(s);
2171 putprompt(const char *s)
2177 #if ENABLE_ASH_EXPAND_PRMT
2178 /* expandstr() needs parsing machinery, so it is far away ahead... */
2179 static const char *expandstr(const char *ps);
2181 #define expandstr(s) s
2185 setprompt(int whichprompt)
2188 #if ENABLE_ASH_EXPAND_PRMT
2189 struct stackmark smark;
2194 switch (whichprompt) {
2204 #if ENABLE_ASH_EXPAND_PRMT
2205 setstackmark(&smark);
2206 stalloc(stackblocksize());
2208 putprompt(expandstr(prompt));
2209 #if ENABLE_ASH_EXPAND_PRMT
2210 popstackmark(&smark);
2215 /* ============ The cd and pwd commands */
2217 #define CD_PHYSICAL 1
2220 static int docd(const char *, int);
2222 static char *curdir = nullstr; /* current working directory */
2223 static char *physdir = nullstr; /* physical working directory */
2232 while ((i = nextopt("LP"))) {
2234 flags ^= CD_PHYSICAL;
2243 * Update curdir (the name of the current directory) in response to a
2247 updatepwd(const char *dir)
2254 cdcomppath = ststrdup(dir);
2257 if (curdir == nullstr)
2259 new = stack_putstr(curdir, new);
2261 new = makestrspace(strlen(dir) + 2, new);
2262 lim = stackblock() + 1;
2266 if (new > lim && *lim == '/')
2271 if (dir[1] == '/' && dir[2] != '/') {
2277 p = strtok(cdcomppath, "/");
2281 if (p[1] == '.' && p[2] == '\0') {
2293 new = stack_putstr(p, new);
2301 return stackblock();
2305 * Find out what the current directory is. If we already know the current
2306 * directory, this routine returns immediately.
2311 char *dir = getcwd(0, 0);
2312 return dir ? dir : nullstr;
2316 setpwd(const char *val, int setold)
2320 oldcur = dir = curdir;
2323 setvar("OLDPWD", oldcur, VEXPORT);
2326 if (physdir != nullstr) {
2327 if (physdir != oldcur)
2331 if (oldcur == val || !val) {
2337 dir = ckstrdup(val);
2338 if (oldcur != dir && oldcur != nullstr) {
2343 setvar("PWD", dir, VEXPORT);
2346 static void hashcd(void);
2349 * Actually do the chdir. We also call hashcd to let the routines in exec.c
2350 * know that the current directory has changed.
2353 docd(const char *dest, int flags)
2355 const char *dir = 0;
2358 TRACE(("docd(\"%s\", %d) called\n", dest, flags));
2361 if (!(flags & CD_PHYSICAL)) {
2362 dir = updatepwd(dest);
2377 cdcmd(int argc, char **argv)
2389 dest = bltinlookup(homestr);
2390 else if (LONE_DASH(dest)) {
2391 dest = bltinlookup("OLDPWD");
2413 path = bltinlookup("CDPATH");
2422 p = padvance(&path, dest);
2423 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
2427 if (!docd(p, flags))
2432 ash_msg_and_raise_error("can't cd to %s", dest);
2435 if (flags & CD_PRINT)
2436 out1fmt(snlfmt, curdir);
2441 pwdcmd(int argc, char **argv)
2444 const char *dir = curdir;
2448 if (physdir == nullstr)
2452 out1fmt(snlfmt, dir);
2457 /* ============ ... */
2459 #define IBUFSIZ (BUFSIZ + 1)
2460 #define basebuf bb_common_bufsiz1 /* buffer for top level input file */
2462 /* Syntax classes */
2463 #define CWORD 0 /* character is nothing special */
2464 #define CNL 1 /* newline character */
2465 #define CBACK 2 /* a backslash character */
2466 #define CSQUOTE 3 /* single quote */
2467 #define CDQUOTE 4 /* double quote */
2468 #define CENDQUOTE 5 /* a terminating quote */
2469 #define CBQUOTE 6 /* backwards single quote */
2470 #define CVAR 7 /* a dollar sign */
2471 #define CENDVAR 8 /* a '}' character */
2472 #define CLP 9 /* a left paren in arithmetic */
2473 #define CRP 10 /* a right paren in arithmetic */
2474 #define CENDFILE 11 /* end of file */
2475 #define CCTL 12 /* like CWORD, except it must be escaped */
2476 #define CSPCL 13 /* these terminate a word */
2477 #define CIGN 14 /* character should be ignored */
2479 #if ENABLE_ASH_ALIAS
2483 #define PEOA_OR_PEOF PEOA
2487 #define PEOA_OR_PEOF PEOF
2490 /* number syntax index */
2491 #define BASESYNTAX 0 /* not in quotes */
2492 #define DQSYNTAX 1 /* in double quotes */
2493 #define SQSYNTAX 2 /* in single quotes */
2494 #define ARISYNTAX 3 /* in arithmetic */
2496 #if ENABLE_ASH_OPTIMIZE_FOR_SIZE
2497 #define USE_SIT_FUNCTION
2500 #if ENABLE_ASH_MATH_SUPPORT
2501 static const char S_I_T[][4] = {
2502 #if ENABLE_ASH_ALIAS
2503 { CSPCL, CIGN, CIGN, CIGN }, /* 0, PEOA */
2505 { CSPCL, CWORD, CWORD, CWORD }, /* 1, ' ' */
2506 { CNL, CNL, CNL, CNL }, /* 2, \n */
2507 { CWORD, CCTL, CCTL, CWORD }, /* 3, !*-/:=?[]~ */
2508 { CDQUOTE, CENDQUOTE, CWORD, CWORD }, /* 4, '"' */
2509 { CVAR, CVAR, CWORD, CVAR }, /* 5, $ */
2510 { CSQUOTE, CWORD, CENDQUOTE, CWORD }, /* 6, "'" */
2511 { CSPCL, CWORD, CWORD, CLP }, /* 7, ( */
2512 { CSPCL, CWORD, CWORD, CRP }, /* 8, ) */
2513 { CBACK, CBACK, CCTL, CBACK }, /* 9, \ */
2514 { CBQUOTE, CBQUOTE, CWORD, CBQUOTE }, /* 10, ` */
2515 { CENDVAR, CENDVAR, CWORD, CENDVAR }, /* 11, } */
2516 #ifndef USE_SIT_FUNCTION
2517 { CENDFILE, CENDFILE, CENDFILE, CENDFILE }, /* 12, PEOF */
2518 { CWORD, CWORD, CWORD, CWORD }, /* 13, 0-9A-Za-z */
2519 { CCTL, CCTL, CCTL, CCTL } /* 14, CTLESC ... */
2523 static const char S_I_T[][3] = {
2524 #if ENABLE_ASH_ALIAS
2525 { CSPCL, CIGN, CIGN }, /* 0, PEOA */
2527 { CSPCL, CWORD, CWORD }, /* 1, ' ' */
2528 { CNL, CNL, CNL }, /* 2, \n */
2529 { CWORD, CCTL, CCTL }, /* 3, !*-/:=?[]~ */
2530 { CDQUOTE, CENDQUOTE, CWORD }, /* 4, '"' */
2531 { CVAR, CVAR, CWORD }, /* 5, $ */
2532 { CSQUOTE, CWORD, CENDQUOTE }, /* 6, "'" */
2533 { CSPCL, CWORD, CWORD }, /* 7, ( */
2534 { CSPCL, CWORD, CWORD }, /* 8, ) */
2535 { CBACK, CBACK, CCTL }, /* 9, \ */
2536 { CBQUOTE, CBQUOTE, CWORD }, /* 10, ` */
2537 { CENDVAR, CENDVAR, CWORD }, /* 11, } */
2538 #ifndef USE_SIT_FUNCTION
2539 { CENDFILE, CENDFILE, CENDFILE }, /* 12, PEOF */
2540 { CWORD, CWORD, CWORD }, /* 13, 0-9A-Za-z */
2541 { CCTL, CCTL, CCTL } /* 14, CTLESC ... */
2544 #endif /* ASH_MATH_SUPPORT */
2546 #ifdef USE_SIT_FUNCTION
2549 SIT(int c, int syntax)
2551 static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
2552 #if ENABLE_ASH_ALIAS
2553 static const char syntax_index_table[] = {
2554 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
2555 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
2556 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */
2560 static const char syntax_index_table[] = {
2561 0, 1, 0, 2, 3, 4, 0, 5, /* "\t\n !\"$&'" */
2562 6, 7, 2, 2, 2, 2, 0, 0, /* "()*-/:;<" */
2563 2, 0, 2, 2, 8, 2, 9, 0, /* "=>?[\\]`|" */
2570 if (c == PEOF) /* 2^8+2 */
2572 #if ENABLE_ASH_ALIAS
2573 if (c == PEOA) /* 2^8+1 */
2577 #define U_C(c) ((unsigned char)(c))
2579 if ((unsigned char)c >= (unsigned char)(CTLESC)
2580 && (unsigned char)c <= (unsigned char)(CTLQUOTEMARK)
2584 s = strchr(spec_symbls, c);
2585 if (s == NULL || *s == '\0')
2587 indx = syntax_index_table[(s - spec_symbls)];
2589 return S_I_T[indx][syntax];
2592 #else /* !USE_SIT_FUNCTION */
2594 #if ENABLE_ASH_ALIAS
2595 #define CSPCL_CIGN_CIGN_CIGN 0
2596 #define CSPCL_CWORD_CWORD_CWORD 1
2597 #define CNL_CNL_CNL_CNL 2
2598 #define CWORD_CCTL_CCTL_CWORD 3
2599 #define CDQUOTE_CENDQUOTE_CWORD_CWORD 4
2600 #define CVAR_CVAR_CWORD_CVAR 5
2601 #define CSQUOTE_CWORD_CENDQUOTE_CWORD 6
2602 #define CSPCL_CWORD_CWORD_CLP 7
2603 #define CSPCL_CWORD_CWORD_CRP 8
2604 #define CBACK_CBACK_CCTL_CBACK 9
2605 #define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10
2606 #define CENDVAR_CENDVAR_CWORD_CENDVAR 11
2607 #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12
2608 #define CWORD_CWORD_CWORD_CWORD 13
2609 #define CCTL_CCTL_CCTL_CCTL 14
2611 #define CSPCL_CWORD_CWORD_CWORD 0
2612 #define CNL_CNL_CNL_CNL 1
2613 #define CWORD_CCTL_CCTL_CWORD 2
2614 #define CDQUOTE_CENDQUOTE_CWORD_CWORD 3
2615 #define CVAR_CVAR_CWORD_CVAR 4
2616 #define CSQUOTE_CWORD_CENDQUOTE_CWORD 5
2617 #define CSPCL_CWORD_CWORD_CLP 6
2618 #define CSPCL_CWORD_CWORD_CRP 7
2619 #define CBACK_CBACK_CCTL_CBACK 8
2620 #define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 9
2621 #define CENDVAR_CENDVAR_CWORD_CENDVAR 10
2622 #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 11
2623 #define CWORD_CWORD_CWORD_CWORD 12
2624 #define CCTL_CCTL_CCTL_CCTL 13
2627 static const char syntax_index_table[258] = {
2628 /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
2629 /* 0 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
2630 #if ENABLE_ASH_ALIAS
2631 /* 1 PEOA */ CSPCL_CIGN_CIGN_CIGN,
2633 /* 2 -128 0x80 */ CWORD_CWORD_CWORD_CWORD,
2634 /* 3 -127 CTLESC */ CCTL_CCTL_CCTL_CCTL,
2635 /* 4 -126 CTLVAR */ CCTL_CCTL_CCTL_CCTL,
2636 /* 5 -125 CTLENDVAR */ CCTL_CCTL_CCTL_CCTL,
2637 /* 6 -124 CTLBACKQ */ CCTL_CCTL_CCTL_CCTL,
2638 /* 7 -123 CTLQUOTE */ CCTL_CCTL_CCTL_CCTL,
2639 /* 8 -122 CTLARI */ CCTL_CCTL_CCTL_CCTL,
2640 /* 9 -121 CTLENDARI */ CCTL_CCTL_CCTL_CCTL,
2641 /* 10 -120 CTLQUOTEMARK */ CCTL_CCTL_CCTL_CCTL,
2642 /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
2643 /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
2644 /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
2645 /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
2646 /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
2647 /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
2648 /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
2649 /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
2650 /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
2651 /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
2652 /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
2653 /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
2654 /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
2655 /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
2656 /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
2657 /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
2658 /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
2659 /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
2660 /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
2661 /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
2662 /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
2663 /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
2664 /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
2665 /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
2666 /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
2667 /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
2668 /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
2669 /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
2670 /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
2671 /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
2672 /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
2673 /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
2674 /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
2675 /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
2676 /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
2677 /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
2678 /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
2679 /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
2680 /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
2681 /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
2682 /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
2683 /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
2684 /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
2685 /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
2686 /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
2687 /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
2688 /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
2689 /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
2690 /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
2691 /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
2692 /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
2693 /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
2694 /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
2695 /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
2696 /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
2697 /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
2698 /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
2699 /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
2700 /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
2701 /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
2702 /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
2703 /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
2704 /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
2705 /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
2706 /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
2707 /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
2708 /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
2709 /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
2710 /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
2711 /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
2712 /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
2713 /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
2714 /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
2715 /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
2716 /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
2717 /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
2718 /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
2719 /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
2720 /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
2721 /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
2722 /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
2723 /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
2724 /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
2725 /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
2726 /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
2727 /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
2728 /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
2729 /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
2730 /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
2731 /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
2732 /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
2733 /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
2734 /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
2735 /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
2736 /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
2737 /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
2738 /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
2739 /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
2740 /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
2741 /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
2742 /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
2743 /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
2744 /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
2745 /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
2746 /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
2747 /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
2748 /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
2749 /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
2750 /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
2751 /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
2752 /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
2753 /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
2754 /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
2755 /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
2756 /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
2757 /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
2758 /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
2759 /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
2760 /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
2761 /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
2762 /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
2763 /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
2764 /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
2765 /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
2766 /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
2767 /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
2768 /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
2769 /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
2770 /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
2771 /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
2772 /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
2773 /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
2774 /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
2775 /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
2776 /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
2777 /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
2778 /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
2779 /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
2780 /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
2781 /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
2782 /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
2783 /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
2784 /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
2785 /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
2786 /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
2787 /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
2788 /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
2789 /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
2790 /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
2791 /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
2792 /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
2793 /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
2794 /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
2795 /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CWORD,
2796 /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
2797 /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
2798 /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
2799 /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
2800 /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CWORD,
2801 /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
2802 /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
2803 /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
2804 /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
2805 /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
2806 /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
2807 /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
2808 /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
2809 /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
2810 /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
2811 /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
2812 /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
2813 /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
2814 /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
2815 /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
2816 /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
2817 /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
2818 /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
2819 /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
2820 /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
2821 /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
2822 /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
2823 /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
2824 /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
2825 /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
2826 /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
2827 /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
2828 /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
2829 /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
2830 /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
2831 /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
2832 /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
2833 /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
2834 /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
2835 /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
2836 /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
2837 /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
2838 /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
2839 /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
2840 /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
2841 /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
2842 /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
2843 /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
2844 /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
2845 /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
2846 /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
2847 /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
2848 /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
2849 /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
2850 /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
2851 /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
2852 /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
2853 /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
2854 /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
2855 /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
2856 /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
2857 /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
2858 /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
2859 /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
2860 /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
2861 /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
2862 /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
2863 /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
2864 /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
2865 /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
2866 /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
2867 /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
2868 /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
2869 /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
2870 /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
2871 /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
2872 /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
2873 /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
2874 /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
2875 /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
2876 /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
2877 /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
2878 /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
2879 /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
2880 /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
2881 /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
2882 /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
2883 /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
2884 /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
2885 /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
2886 /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
2887 /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
2888 /* 257 127 */ CWORD_CWORD_CWORD_CWORD,
2891 #define SIT(c, syntax) (S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax])
2893 #endif /* USE_SIT_FUNCTION */
2896 /* ============ Alias handling */
2898 #if ENABLE_ASH_ALIAS
2900 #define ALIASINUSE 1
2912 static struct alias *atab[ATABSIZE];
2914 static struct alias **
2915 __lookupalias(const char *name) {
2916 unsigned int hashval;
2923 ch = (unsigned char)*p;
2927 ch = (unsigned char)*++p;
2929 app = &atab[hashval % ATABSIZE];
2931 for (; *app; app = &(*app)->next) {
2932 if (strcmp(name, (*app)->name) == 0) {
2940 static struct alias *
2941 lookupalias(const char *name, int check)
2943 struct alias *ap = *__lookupalias(name);
2945 if (check && ap && (ap->flag & ALIASINUSE))
2950 static struct alias *
2951 freealias(struct alias *ap)
2955 if (ap->flag & ALIASINUSE) {
2956 ap->flag |= ALIASDEAD;
2968 setalias(const char *name, const char *val)
2970 struct alias *ap, **app;
2972 app = __lookupalias(name);
2976 if (!(ap->flag & ALIASINUSE)) {
2979 ap->val = ckstrdup(val);
2980 ap->flag &= ~ALIASDEAD;
2983 ap = ckmalloc(sizeof(struct alias));
2984 ap->name = ckstrdup(name);
2985 ap->val = ckstrdup(val);
2994 unalias(const char *name)
2998 app = __lookupalias(name);
3002 *app = freealias(*app);
3013 struct alias *ap, **app;
3017 for (i = 0; i < ATABSIZE; i++) {
3019 for (ap = *app; ap; ap = *app) {
3020 *app = freealias(*app);
3030 printalias(const struct alias *ap)
3032 out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
3036 * TODO - sort output
3039 aliascmd(int argc, char **argv)
3048 for (i = 0; i < ATABSIZE; i++)
3049 for (ap = atab[i]; ap; ap = ap->next) {
3054 while ((n = *++argv) != NULL) {
3055 v = strchr(n+1, '=');
3056 if (v == NULL) { /* n+1: funny ksh stuff */
3057 ap = *__lookupalias(n);
3059 fprintf(stderr, "%s: %s not found\n", "alias", n);
3073 unaliascmd(int argc, char **argv)
3077 while ((i = nextopt("a")) != '\0') {
3083 for (i = 0; *argptr; argptr++) {
3084 if (unalias(*argptr)) {
3085 fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
3093 #endif /* ASH_ALIAS */
3096 /* ============ jobs.c */
3098 /* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
3101 #define FORK_NOJOB 2
3103 /* mode flags for showjob(s) */
3104 #define SHOW_PGID 0x01 /* only show pgid - for jobs -p */
3105 #define SHOW_PID 0x04 /* include process pid */
3106 #define SHOW_CHANGED 0x08 /* only jobs whose state has changed */
3109 * A job structure contains information about a job. A job is either a
3110 * single process or a set of processes contained in a pipeline. In the
3111 * latter case, pidlist will be non-NULL, and will point to a -1 terminated
3116 pid_t pid; /* process id */
3117 int status; /* last process status from wait() */
3118 char *cmd; /* text of command being run */
3122 struct procstat ps0; /* status of process */
3123 struct procstat *ps; /* status or processes when more than one */
3125 int stopstatus; /* status of a stopped job */
3128 nprocs: 16, /* number of processes */
3130 #define JOBRUNNING 0 /* at least one proc running */
3131 #define JOBSTOPPED 1 /* all procs are stopped */
3132 #define JOBDONE 2 /* all procs are completed */
3134 sigint: 1, /* job was killed by SIGINT */
3135 jobctl: 1, /* job running under job control */
3137 waited: 1, /* true if this entry has been waited for */
3138 used: 1, /* true if this entry is in used */
3139 changed: 1; /* true if status has changed */
3140 struct job *prev_job; /* previous job */
3143 static pid_t backgndpid; /* pid of last background process */
3144 static int job_warning; /* user was warned about stopped jobs */
3146 static int jobctl; /* true if doing job control */
3149 static struct job *makejob(union node *, int);
3150 static int forkshell(struct job *, union node *, int);
3151 static int waitforjob(struct job *);
3154 #define setjobctl(on) /* do nothing */
3156 static void setjobctl(int);
3157 static void showjobs(FILE *, int);
3161 * Set the signal handler for the specified signal. The routine figures
3162 * out what it should be set to.
3165 setsignal(int signo)
3169 struct sigaction act;
3174 else if (*t != '\0')
3178 if (rootshell && action == S_DFL) {
3181 if (iflag || minusc || sflag == 0)
3204 t = &sigmode[signo - 1];
3208 * current setting unknown
3210 if (sigaction(signo, 0, &act) == -1) {
3212 * Pretend it worked; maybe we should give a warning
3213 * here, but other shells don't. We don't alter
3214 * sigmode, so that we retry every time.
3218 if (act.sa_handler == SIG_IGN) {
3220 && (signo == SIGTSTP || signo == SIGTTIN || signo == SIGTTOU)
3222 tsig = S_IGN; /* don't hard ignore these */
3226 tsig = S_RESET; /* force to be set */
3229 if (tsig == S_HARD_IGN || tsig == action)
3233 act.sa_handler = onsig;
3236 act.sa_handler = SIG_IGN;
3239 act.sa_handler = SIG_DFL;
3243 sigfillset(&act.sa_mask);
3244 sigaction(signo, &act, 0);
3247 /* mode flags for set_curjob */
3248 #define CUR_DELETE 2
3249 #define CUR_RUNNING 1
3250 #define CUR_STOPPED 0
3252 /* mode flags for dowait */
3253 #define DOWAIT_NORMAL 0
3254 #define DOWAIT_BLOCK 1
3257 /* pgrp of shell on invocation */
3258 static int initialpgrp;
3259 static int ttyfd = -1;
3262 static struct job *jobtab;
3264 static unsigned njobs;
3266 static struct job *curjob;
3267 /* number of presumed living untracked jobs */
3271 set_curjob(struct job *jp, unsigned mode)
3274 struct job **jpp, **curp;
3276 /* first remove from list */
3277 jpp = curp = &curjob;
3282 jpp = &jp1->prev_job;
3284 *jpp = jp1->prev_job;
3286 /* Then re-insert in correct position */
3294 /* job being deleted */
3297 /* newly created job or backgrounded job,
3298 put after all stopped jobs. */
3302 if (!jp1 || jp1->state != JOBSTOPPED)
3305 jpp = &jp1->prev_job;
3311 /* newly stopped job - becomes curjob */
3312 jp->prev_job = *jpp;
3320 jobno(const struct job *jp)
3322 return jp - jobtab + 1;
3327 * Convert a job name to a job structure.
3330 getjob(const char *name, int getctl)
3334 const char *err_msg = "No such job: %s";
3338 char *(*match)(const char *, const char *);
3353 if (c == '+' || c == '%') {
3355 err_msg = "No current job";
3361 err_msg = "No previous job";
3372 jp = jobtab + num - 1;
3389 if (match(jp->ps[0].cmd, p)) {
3393 err_msg = "%s: ambiguous";
3400 err_msg = "job %s not created under job control";
3401 if (getctl && jp->jobctl == 0)
3406 ash_msg_and_raise_error(err_msg, name);
3410 * Mark a job structure as unused.
3413 freejob(struct job *jp)
3415 struct procstat *ps;
3419 for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
3420 if (ps->cmd != nullstr)
3423 if (jp->ps != &jp->ps0)
3426 set_curjob(jp, CUR_DELETE);
3432 xtcsetpgrp(int fd, pid_t pgrp)
3434 if (tcsetpgrp(fd, pgrp))
3435 ash_msg_and_raise_error("cannot set tty process group (%m)");
3439 * Turn job control on and off.
3441 * Note: This code assumes that the third arg to ioctl is a character
3442 * pointer, which is true on Berkeley systems but not System V. Since
3443 * System V doesn't have job control yet, this isn't a problem now.
3445 * Called with interrupts off.
3453 if (on == jobctl || rootshell == 0)
3457 ofd = fd = open(_PATH_TTY, O_RDWR);
3459 /* BTW, bash will try to open(ttyname(0)) if open("/dev/tty") fails.
3460 * That sometimes helps to acquire controlling tty.
3461 * Obviously, a workaround for bugs when someone
3462 * failed to provide a controlling tty to bash! :) */
3464 while (!isatty(fd) && --fd >= 0)
3467 fd = fcntl(fd, F_DUPFD, 10);
3471 fcntl(fd, F_SETFD, FD_CLOEXEC);
3472 do { /* while we are in the background */
3473 pgrp = tcgetpgrp(fd);
3476 ash_msg("can't access tty; job control turned off");
3480 if (pgrp == getpgrp())
3491 xtcsetpgrp(fd, pgrp);
3493 /* turning job control off */
3496 /* was xtcsetpgrp, but this can make exiting ash
3497 * with pty already deleted loop forever */
3498 tcsetpgrp(fd, pgrp);
3512 killcmd(int argc, char **argv)
3514 if (argv[1] && strcmp(argv[1], "-l") != 0) {
3517 if (argv[i][0] == '%') {
3518 struct job *jp = getjob(argv[i], 0);
3519 unsigned pid = jp->ps[0].pid;
3520 /* Enough space for ' -NNN<nul>' */
3521 argv[i] = alloca(sizeof(int)*3 + 3);
3522 /* kill_main has matching code to expect
3523 * leading space. Needed to not confuse
3524 * negative pids with "kill -SIGNAL_NO" syntax */
3525 sprintf(argv[i], " -%u", pid);
3527 } while (argv[++i]);
3529 return kill_main(argc, argv);
3533 showpipe(struct job *jp, FILE *out)
3535 struct procstat *sp;
3536 struct procstat *spend;
3538 spend = jp->ps + jp->nprocs;
3539 for (sp = jp->ps + 1; sp < spend; sp++)
3540 fprintf(out, " | %s", sp->cmd);
3541 outcslow('\n', out);
3542 flush_stdout_stderr();
3547 restartjob(struct job *jp, int mode)
3549 struct procstat *ps;
3555 if (jp->state == JOBDONE)
3557 jp->state = JOBRUNNING;
3559 if (mode == FORK_FG)
3560 xtcsetpgrp(ttyfd, pgid);
3561 killpg(pgid, SIGCONT);
3565 if (WIFSTOPPED(ps->status)) {
3571 status = (mode == FORK_FG) ? waitforjob(jp) : 0;
3577 fg_bgcmd(int argc, char **argv)
3584 mode = (**argv == 'f') ? FORK_FG : FORK_BG;
3589 jp = getjob(*argv, 1);
3590 if (mode == FORK_BG) {
3591 set_curjob(jp, CUR_RUNNING);
3592 fprintf(out, "[%d] ", jobno(jp));
3594 outstr(jp->ps->cmd, out);
3596 retval = restartjob(jp, mode);
3597 } while (*argv && *++argv);
3603 sprint_status(char *s, int status, int sigonly)
3609 if (!WIFEXITED(status)) {
3611 if (WIFSTOPPED(status))
3612 st = WSTOPSIG(status);
3615 st = WTERMSIG(status);
3617 if (st == SIGINT || st == SIGPIPE)
3620 if (WIFSTOPPED(status))
3625 col = fmtstr(s, 32, strsignal(st));
3626 if (WCOREDUMP(status)) {
3627 col += fmtstr(s + col, 16, " (core dumped)");
3629 } else if (!sigonly) {
3630 st = WEXITSTATUS(status);
3632 col = fmtstr(s, 16, "Done(%d)", st);
3634 col = fmtstr(s, 16, "Done");
3641 * Do a wait system call. If job control is compiled in, we accept
3642 * stopped processes. If block is zero, we return a value of zero
3643 * rather than blocking.
3645 * System V doesn't have a non-blocking wait system call. It does
3646 * have a SIGCLD signal that is sent to a process when one of it's
3647 * children dies. The obvious way to use SIGCLD would be to install
3648 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
3649 * was received, and have waitproc bump another counter when it got
3650 * the status of a process. Waitproc would then know that a wait
3651 * system call would not block if the two counters were different.
3652 * This approach doesn't work because if a process has children that
3653 * have not been waited for, System V will send it a SIGCLD when it
3654 * installs a signal handler for SIGCLD. What this means is that when
3655 * a child exits, the shell will be sent SIGCLD signals continuously
3656 * until is runs out of stack space, unless it does a wait call before
3657 * restoring the signal handler. The code below takes advantage of
3658 * this (mis)feature by installing a signal handler for SIGCLD and
3659 * then checking to see whether it was called. If there are any
3660 * children to be waited for, it will be.
3662 * If neither SYSV nor BSD is defined, we don't implement nonblocking
3663 * waits at all. In this case, the user will not be informed when
3664 * a background process until the next time she runs a real program
3665 * (as opposed to running a builtin command or just typing return),
3666 * and the jobs command may give out of date information.
3669 waitproc(int block, int *status)
3679 return wait3(status, flags, (struct rusage *)NULL);
3683 * Wait for a process to terminate.
3686 dowait(int block, struct job *job)
3691 struct job *thisjob;
3694 TRACE(("dowait(%d) called\n", block));
3695 pid = waitproc(block, &status);
3696 TRACE(("wait returns pid %d, status=%d\n", pid, status));
3701 for (jp = curjob; jp; jp = jp->prev_job) {
3702 struct procstat *sp;
3703 struct procstat *spend;
3704 if (jp->state == JOBDONE)
3707 spend = jp->ps + jp->nprocs;
3710 if (sp->pid == pid) {
3711 TRACE(("Job %d: changing status of proc %d "
3712 "from 0x%x to 0x%x\n",
3713 jobno(jp), pid, sp->status, status));
3714 sp->status = status;
3717 if (sp->status == -1)
3720 if (state == JOBRUNNING)
3722 if (WIFSTOPPED(sp->status)) {
3723 jp->stopstatus = sp->status;
3727 } while (++sp < spend);
3732 if (!WIFSTOPPED(status))
3739 if (state != JOBRUNNING) {
3740 thisjob->changed = 1;
3742 if (thisjob->state != state) {
3743 TRACE(("Job %d: changing state from %d to %d\n",
3744 jobno(thisjob), thisjob->state, state));
3745 thisjob->state = state;
3747 if (state == JOBSTOPPED) {
3748 set_curjob(thisjob, CUR_STOPPED);
3757 if (thisjob && thisjob == job) {
3761 len = sprint_status(s, status, 1);
3773 showjob(FILE *out, struct job *jp, int mode)
3775 struct procstat *ps;
3776 struct procstat *psend;
3783 if (mode & SHOW_PGID) {
3784 /* just output process (group) id of pipeline */
3785 fprintf(out, "%d\n", ps->pid);
3789 col = fmtstr(s, 16, "[%d] ", jobno(jp));
3794 else if (curjob && jp == curjob->prev_job)
3797 if (mode & SHOW_PID)
3798 col += fmtstr(s + col, 16, "%d ", ps->pid);
3800 psend = ps + jp->nprocs;
3802 if (jp->state == JOBRUNNING) {
3803 strcpy(s + col, "Running");
3804 col += sizeof("Running") - 1;
3806 int status = psend[-1].status;
3807 if (jp->state == JOBSTOPPED)
3808 status = jp->stopstatus;
3809 col += sprint_status(s + col, status, 0);
3815 /* for each process */
3816 col = fmtstr(s, 48, " |\n%*c%d ", indent_col, ' ', ps->pid) - 3;
3818 fprintf(out, "%s%*c%s",
3819 s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd
3821 if (!(mode & SHOW_PID)) {
3825 if (++ps == psend) {
3826 outcslow('\n', out);
3833 if (jp->state == JOBDONE) {
3834 TRACE(("showjob: freeing job %d\n", jobno(jp)));
3840 jobscmd(int argc, char **argv)
3846 while ((m = nextopt("lp"))) {
3857 showjob(out, getjob(*argv,0), mode);
3860 showjobs(out, mode);
3866 * Print a list of jobs. If "change" is nonzero, only print jobs whose
3867 * statuses have changed since the last call to showjobs.
3870 showjobs(FILE *out, int mode)
3874 TRACE(("showjobs(%x) called\n", mode));
3876 /* If not even one one job changed, there is nothing to do */
3877 while (dowait(DOWAIT_NORMAL, NULL) > 0)
3880 for (jp = curjob; jp; jp = jp->prev_job) {
3881 if (!(mode & SHOW_CHANGED) || jp->changed)
3882 showjob(out, jp, mode);
3888 getstatus(struct job *job)
3893 status = job->ps[job->nprocs - 1].status;
3894 retval = WEXITSTATUS(status);
3895 if (!WIFEXITED(status)) {
3897 retval = WSTOPSIG(status);
3898 if (!WIFSTOPPED(status))
3901 /* XXX: limits number of signals */
3902 retval = WTERMSIG(status);
3904 if (retval == SIGINT)
3910 TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
3911 jobno(job), job->nprocs, status, retval));
3916 waitcmd(int argc, char **argv)
3929 /* wait for all jobs */
3934 /* no running procs */
3937 if (jp->state == JOBRUNNING)
3942 dowait(DOWAIT_BLOCK, 0);
3948 if (**argv != '%') {
3949 pid_t pid = number(*argv);
3953 if (job->ps[job->nprocs - 1].pid == pid)
3955 job = job->prev_job;
3961 job = getjob(*argv, 0);
3962 /* loop until process terminated or stopped */
3963 while (job->state == JOBRUNNING)
3964 dowait(DOWAIT_BLOCK, 0);
3966 retval = getstatus(job);
3980 struct job *jp, *jq;
3982 len = njobs * sizeof(*jp);
3984 jp = ckrealloc(jq, len + 4 * sizeof(*jp));
3986 offset = (char *)jp - (char *)jq;
3988 /* Relocate pointers */
3991 jq = (struct job *)((char *)jq + l);
3995 #define joff(p) ((struct job *)((char *)(p) + l))
3996 #define jmove(p) (p) = (void *)((char *)(p) + offset)
3997 if (joff(jp)->ps == &jq->ps0)
3998 jmove(joff(jp)->ps);
3999 if (joff(jp)->prev_job)
4000 jmove(joff(jp)->prev_job);
4010 jp = (struct job *)((char *)jp + len);
4014 } while (--jq >= jp);
4019 * Return a new job structure.
4020 * Called with interrupts off.
4023 makejob(union node *node, int nprocs)
4028 for (i = njobs, jp = jobtab; ; jp++) {
4035 if (jp->state != JOBDONE || !jp->waited)
4044 memset(jp, 0, sizeof(*jp));
4049 jp->prev_job = curjob;
4054 jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
4056 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
4063 * Return a string identifying a command (to be printed by the
4066 static char *cmdnextc;
4069 cmdputs(const char *s)
4071 const char *p, *str;
4072 char c, cc[2] = " ";
4076 static const char vstype[VSTYPE + 1][4] = {
4077 "", "}", "-", "+", "?", "=",
4078 "%", "%%", "#", "##"
4081 nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
4083 while ((c = *p++) != 0) {
4091 if ((subtype & VSTYPE) == VSLENGTH)
4095 if (!(subtype & VSQUOTE) == !(quoted & 1))
4101 str = "\"}" + !(quoted & 1);
4108 case CTLBACKQ+CTLQUOTE:
4111 #if ENABLE_ASH_MATH_SUPPORT
4126 if ((subtype & VSTYPE) != VSNORMAL)
4128 str = vstype[subtype & VSTYPE];
4129 if (subtype & VSNUL)
4138 /* These can only happen inside quotes */
4151 while ((c = *str++)) {
4156 USTPUTC('"', nextc);
4162 /* cmdtxt() and cmdlist() call each other */
4163 static void cmdtxt(union node *n);
4166 cmdlist(union node *np, int sep)
4168 for (; np; np = np->narg.next) {
4172 if (sep && np->narg.next)
4178 cmdtxt(union node *n)
4181 struct nodelist *lp;
4193 lp = n->npipe.cmdlist;
4211 cmdtxt(n->nbinary.ch1);
4227 cmdtxt(n->nif.test);
4230 if (n->nif.elsepart) {
4233 n = n->nif.elsepart;
4249 cmdtxt(n->nbinary.ch1);
4259 cmdputs(n->nfor.var);
4261 cmdlist(n->nfor.args, 1);
4266 cmdputs(n->narg.text);
4270 cmdlist(n->ncmd.args, 1);
4271 cmdlist(n->ncmd.redirect, 0);
4284 cmdputs(n->ncase.expr->narg.text);
4286 for (np = n->ncase.cases; np; np = np->nclist.next) {
4287 cmdtxt(np->nclist.pattern);
4289 cmdtxt(np->nclist.body);
4315 s[0] = n->nfile.fd + '0';
4319 if (n->type == NTOFD || n->type == NFROMFD) {
4320 s[0] = n->ndup.dupfd + '0';
4330 commandtext(union node *n)
4334 STARTSTACKSTR(cmdnextc);
4336 name = stackblock();
4337 TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
4338 name, cmdnextc, cmdnextc));
4339 return ckstrdup(name);
4344 * Fork off a subshell. If we are doing job control, give the subshell its
4345 * own process group. Jp is a job structure that the job is to be added to.
4346 * N is the command that will be evaluated by the child. Both jp and n may
4347 * be NULL. The mode parameter can be one of the following:
4348 * FORK_FG - Fork off a foreground process.
4349 * FORK_BG - Fork off a background process.
4350 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
4351 * process group even if job control is on.
4353 * When job control is turned off, background processes have their standard
4354 * input redirected to /dev/null (except for the second and later processes
4357 * Called with interrupts off.
4360 * Clear traps on a fork.
4367 for (tp = trap; tp < &trap[NSIG]; tp++) {
4368 if (*tp && **tp) { /* trap not NULL or SIG_IGN */
4373 setsignal(tp - trap);
4378 /* lives far away from here, needed for forkchild */
4379 static void closescript(void);
4381 forkchild(struct job *jp, union node *n, int mode)
4385 TRACE(("Child shell %d\n", getpid()));
4392 /* do job control only in root shell */
4394 if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) {
4397 if (jp->nprocs == 0)
4400 pgrp = jp->ps[0].pid;
4401 /* This can fail because we are doing it in the parent also */
4402 (void)setpgid(0, pgrp);
4403 if (mode == FORK_FG)
4404 xtcsetpgrp(ttyfd, pgrp);
4409 if (mode == FORK_BG) {
4412 if (jp->nprocs == 0) {
4414 if (open(bb_dev_null, O_RDONLY) != 0)
4415 ash_msg_and_raise_error("can't open %s", bb_dev_null);
4418 if (!oldlvl && iflag) {
4423 for (jp = curjob; jp; jp = jp->prev_job)
4429 forkparent(struct job *jp, union node *n, int mode, pid_t pid)
4431 TRACE(("In parent shell: child = %d\n", pid));
4433 while (jobless && dowait(DOWAIT_NORMAL, 0) > 0);
4438 if (mode != FORK_NOJOB && jp->jobctl) {
4441 if (jp->nprocs == 0)
4444 pgrp = jp->ps[0].pid;
4445 /* This can fail because we are doing it in the child also */
4449 if (mode == FORK_BG) {
4450 backgndpid = pid; /* set $! */
4451 set_curjob(jp, CUR_RUNNING);
4454 struct procstat *ps = &jp->ps[jp->nprocs++];
4460 ps->cmd = commandtext(n);
4466 forkshell(struct job *jp, union node *n, int mode)
4470 TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
4473 TRACE(("Fork failed, errno=%d", errno));
4476 ash_msg_and_raise_error("cannot fork");
4479 forkchild(jp, n, mode);
4481 forkparent(jp, n, mode, pid);
4486 * Wait for job to finish.
4488 * Under job control we have the problem that while a child process is
4489 * running interrupts generated by the user are sent to the child but not
4490 * to the shell. This means that an infinite loop started by an inter-
4491 * active user may be hard to kill. With job control turned off, an
4492 * interactive user may place an interactive program inside a loop. If
4493 * the interactive program catches interrupts, the user doesn't want
4494 * these interrupts to also abort the loop. The approach we take here
4495 * is to have the shell ignore interrupt signals while waiting for a
4496 * foreground process to terminate, and then send itself an interrupt
4497 * signal if the child process was terminated by an interrupt signal.
4498 * Unfortunately, some programs want to do a bit of cleanup and then
4499 * exit on interrupt; unless these processes terminate themselves by
4500 * sending a signal to themselves (instead of calling exit) they will
4501 * confuse this approach.
4503 * Called with interrupts off.
4506 waitforjob(struct job *jp)
4510 TRACE(("waitforjob(%%%d) called\n", jobno(jp)));
4511 while (jp->state == JOBRUNNING) {
4512 dowait(DOWAIT_BLOCK, jp);
4517 xtcsetpgrp(ttyfd, rootpid);
4519 * This is truly gross.
4520 * If we're doing job control, then we did a TIOCSPGRP which
4521 * caused us (the shell) to no longer be in the controlling
4522 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
4523 * intuit from the subprocess exit status whether a SIGINT
4524 * occurred, and if so interrupt ourselves. Yuck. - mycroft
4529 if (jp->state == JOBDONE)
4536 * return 1 if there are stopped jobs, otherwise 0
4548 if (jp && jp->state == JOBSTOPPED) {
4549 out2str("You have stopped jobs.\n");
4558 /* ============ redir.c
4560 * Code for dealing with input/output redirection.
4563 #define EMPTY -2 /* marks an unused slot in redirtab */
4565 # define PIPESIZE 4096 /* amount of buffering in a pipe */
4567 # define PIPESIZE PIPE_BUF
4571 * Open a file in noclobber mode.
4572 * The code was copied from bash.
4575 noclobberopen(const char *fname)
4578 struct stat finfo, finfo2;
4581 * If the file exists and is a regular file, return an error
4584 r = stat(fname, &finfo);
4585 if (r == 0 && S_ISREG(finfo.st_mode)) {
4591 * If the file was not present (r != 0), make sure we open it
4592 * exclusively so that if it is created before we open it, our open
4593 * will fail. Make sure that we do not truncate an existing file.
4594 * Note that we don't turn on O_EXCL unless the stat failed -- if the
4595 * file was not a regular file, we leave O_EXCL off.
4598 return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
4599 fd = open(fname, O_WRONLY|O_CREAT, 0666);
4601 /* If the open failed, return the file descriptor right away. */
4606 * OK, the open succeeded, but the file may have been changed from a
4607 * non-regular file to a regular file between the stat and the open.
4608 * We are assuming that the O_EXCL open handles the case where FILENAME
4609 * did not exist and is symlinked to an existing file between the stat
4614 * If we can open it and fstat the file descriptor, and neither check
4615 * revealed that it was a regular file, and the file has not been
4616 * replaced, return the file descriptor.
4618 if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode)
4619 && finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
4622 /* The file has been replaced. badness. */
4629 * Handle here documents. Normally we fork off a process to write the
4630 * data to a pipe. If the document is short, we can stuff the data in
4631 * the pipe without forking.
4633 /* openhere needs this forward reference */
4634 static void expandhere(union node *arg, int fd);
4636 openhere(union node *redir)
4642 ash_msg_and_raise_error("pipe call failed");
4643 if (redir->type == NHERE) {
4644 len = strlen(redir->nhere.doc->narg.text);
4645 if (len <= PIPESIZE) {
4646 full_write(pip[1], redir->nhere.doc->narg.text, len);
4650 if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
4652 signal(SIGINT, SIG_IGN);
4653 signal(SIGQUIT, SIG_IGN);
4654 signal(SIGHUP, SIG_IGN);
4656 signal(SIGTSTP, SIG_IGN);
4658 signal(SIGPIPE, SIG_DFL);
4659 if (redir->type == NHERE)
4660 full_write(pip[1], redir->nhere.doc->narg.text, len);
4662 expandhere(redir->nhere.doc, pip[1]);
4671 openredirect(union node *redir)
4676 switch (redir->nfile.type) {
4678 fname = redir->nfile.expfname;
4679 f = open(fname, O_RDONLY);
4684 fname = redir->nfile.expfname;
4685 f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666);
4690 /* Take care of noclobber mode. */
4692 fname = redir->nfile.expfname;
4693 f = noclobberopen(fname);
4700 fname = redir->nfile.expfname;
4701 f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
4706 fname = redir->nfile.expfname;
4707 f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666);
4715 /* Fall through to eliminate warning. */
4722 f = openhere(redir);
4728 ash_msg_and_raise_error("cannot create %s: %s", fname, errmsg(errno, "nonexistent directory"));
4730 ash_msg_and_raise_error("cannot open %s: %s", fname, errmsg(errno, "no such file"));
4734 * Copy a file descriptor to be >= to. Returns -1
4735 * if the source file descriptor is closed, EMPTY if there are no unused
4736 * file descriptors left.
4739 copyfd(int from, int to)
4743 newfd = fcntl(from, F_DUPFD, to);
4745 if (errno == EMFILE)
4747 ash_msg_and_raise_error("%d: %m", from);
4753 dupredirect(union node *redir, int f)
4755 int fd = redir->nfile.fd;
4757 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
4758 if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
4759 copyfd(redir->ndup.dupfd, fd);
4771 * Process a list of redirection commands. If the REDIR_PUSH flag is set,
4772 * old file descriptors are stashed away so that the redirection can be
4773 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
4774 * standard output, and the standard error if it becomes a duplicate of
4775 * stdout, is saved in memory.
4777 /* flags passed to redirect */
4778 #define REDIR_PUSH 01 /* save previous values of file descriptors */
4779 #define REDIR_SAVEFD2 03 /* set preverrout */
4781 redirect(union node *redir, int flags)
4784 struct redirtab *sv;
4795 if (flags & REDIR_PUSH) {
4797 q = ckmalloc(sizeof(struct redirtab));
4798 q->next = redirlist;
4800 q->nullredirs = nullredirs - 1;
4801 for (i = 0; i < 10; i++)
4802 q->renamed[i] = EMPTY;
4809 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD)
4810 && n->ndup.dupfd == fd)
4811 continue; /* redirect from/to same file descriptor */
4813 newfd = openredirect(n);
4816 if (sv && *(p = &sv->renamed[fd]) == EMPTY) {
4817 i = fcntl(fd, F_DUPFD, 10);
4824 ash_msg_and_raise_error("%d: %m", fd);
4834 dupredirect(n, newfd);
4835 } while ((n = n->nfile.next));
4837 if (flags & REDIR_SAVEFD2 && sv && sv->renamed[2] >= 0)
4838 preverrout_fd = sv->renamed[2];
4842 * Undo the effects of the last redirection.
4847 struct redirtab *rp;
4850 if (--nullredirs >= 0)
4854 for (i = 0; i < 10; i++) {
4855 if (rp->renamed[i] != EMPTY) {
4858 copyfd(rp->renamed[i], i);
4860 close(rp->renamed[i]);
4863 redirlist = rp->next;
4864 nullredirs = rp->nullredirs;
4870 * Undo all redirections. Called on error or interrupt.
4874 * Discard all saved file descriptors.
4877 clearredir(int drop)
4888 redirectsafe(union node *redir, int flags)
4891 volatile int saveint;
4892 struct jmploc *volatile savehandler = exception_handler;
4893 struct jmploc jmploc;
4896 err = setjmp(jmploc.loc) * 2;
4898 exception_handler = &jmploc;
4899 redirect(redir, flags);
4901 exception_handler = savehandler;
4902 if (err && exception != EXERROR)
4903 longjmp(exception_handler->loc, 1);
4904 RESTORE_INT(saveint);
4909 /* ============ Routines to expand arguments to commands
4911 * We have to deal with backquotes, shell variables, and file metacharacters.
4917 #define EXP_FULL 0x1 /* perform word splitting & file globbing */
4918 #define EXP_TILDE 0x2 /* do normal tilde expansion */
4919 #define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
4920 #define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
4921 #define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
4922 #define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
4923 #define EXP_VARTILDE2 0x40 /* expand tildes after colons only */
4924 #define EXP_WORD 0x80 /* expand word in parameter expansion */
4925 #define EXP_QWORD 0x100 /* expand word in quoted parameter expansion */
4929 #define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
4930 #define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
4931 #define RMESCAPE_QUOTED 0x4 /* Remove CTLESC unless in quotes */
4932 #define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */
4933 #define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */
4936 * Structure specifying which parts of the string should be searched
4937 * for IFS characters.
4940 struct ifsregion *next; /* next region in list */
4941 int begoff; /* offset of start of region */
4942 int endoff; /* offset of end of region */
4943 int nulonly; /* search for nul bytes only */
4947 struct strlist *list;
4948 struct strlist **lastp;
4951 /* output of current string */
4952 static char *expdest;
4953 /* list of back quote expressions */
4954 static struct nodelist *argbackq;
4955 /* first struct in list of ifs regions */
4956 static struct ifsregion ifsfirst;
4957 /* last struct in list */
4958 static struct ifsregion *ifslastp;
4959 /* holds expanded arg list */
4960 static struct arglist exparg;
4970 expdest = makestrspace(32, expdest);
4971 #if ENABLE_ASH_MATH_SUPPORT_64
4972 len = fmtstr(expdest, 32, "%lld", (long long) num);
4974 len = fmtstr(expdest, 32, "%ld", num);
4976 STADJUST(len, expdest);
4981 esclen(const char *start, const char *p)
4985 while (p > start && *--p == CTLESC) {
4992 * Remove any CTLESC characters from a string.
4995 _rmescapes(char *str, int flag)
4997 static const char qchars[] = { CTLESC, CTLQUOTEMARK, '\0' };
5004 p = strpbrk(str, qchars);
5010 if (flag & RMESCAPE_ALLOC) {
5011 size_t len = p - str;
5012 size_t fulllen = len + strlen(p) + 1;
5014 if (flag & RMESCAPE_GROW) {
5015 r = makestrspace(fulllen, expdest);
5016 } else if (flag & RMESCAPE_HEAP) {
5017 r = ckmalloc(fulllen);
5019 r = stalloc(fulllen);
5023 q = memcpy(q, str, len) + len;
5026 inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
5027 globbing = flag & RMESCAPE_GLOB;
5028 notescaped = globbing;
5030 if (*p == CTLQUOTEMARK) {
5031 inquotes = ~inquotes;
5033 notescaped = globbing;
5037 /* naked back slash */
5043 if (notescaped && inquotes && *p != '/') {
5047 notescaped = globbing;
5052 if (flag & RMESCAPE_GROW) {
5054 STADJUST(q - r + 1, expdest);
5058 #define rmescapes(p) _rmescapes((p), 0)
5060 #define pmatch(a, b) !fnmatch((a), (b), 0)
5063 * Prepare a pattern for a expmeta (internal glob(3)) call.
5065 * Returns an stalloced string.
5068 preglob(const char *pattern, int quoted, int flag)
5070 flag |= RMESCAPE_GLOB;
5072 flag |= RMESCAPE_QUOTED;
5074 return _rmescapes((char *)pattern, flag);
5078 * Put a string on the stack.
5081 memtodest(const char *p, size_t len, int syntax, int quotes)
5085 q = makestrspace(len * 2, q);
5088 int c = signed_char2int(*p++);
5091 if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK))
5100 strtodest(const char *p, int syntax, int quotes)
5102 memtodest(p, strlen(p), syntax, quotes);
5106 * Record the fact that we have to scan this region of the
5107 * string for IFS characters.
5110 recordregion(int start, int end, int nulonly)
5112 struct ifsregion *ifsp;
5114 if (ifslastp == NULL) {
5118 ifsp = ckmalloc(sizeof(*ifsp));
5120 ifslastp->next = ifsp;
5124 ifslastp->begoff = start;
5125 ifslastp->endoff = end;
5126 ifslastp->nulonly = nulonly;
5130 removerecordregions(int endoff)
5132 if (ifslastp == NULL)
5135 if (ifsfirst.endoff > endoff) {
5136 while (ifsfirst.next != NULL) {
5137 struct ifsregion *ifsp;
5139 ifsp = ifsfirst.next->next;
5140 free(ifsfirst.next);
5141 ifsfirst.next = ifsp;
5144 if (ifsfirst.begoff > endoff)
5147 ifslastp = &ifsfirst;
5148 ifsfirst.endoff = endoff;
5153 ifslastp = &ifsfirst;
5154 while (ifslastp->next && ifslastp->next->begoff < endoff)
5155 ifslastp=ifslastp->next;
5156 while (ifslastp->next != NULL) {
5157 struct ifsregion *ifsp;
5159 ifsp = ifslastp->next->next;
5160 free(ifslastp->next);
5161 ifslastp->next = ifsp;
5164 if (ifslastp->endoff > endoff)
5165 ifslastp->endoff = endoff;
5169 exptilde(char *startp, char *p, int flag)
5175 int quotes = flag & (EXP_FULL | EXP_CASE);
5180 while ((c = *++p) != '\0') {
5187 if (flag & EXP_VARTILDE)
5197 if (*name == '\0') {
5198 home = lookupvar(homestr);
5200 pw = getpwnam(name);
5205 if (!home || !*home)
5208 startloc = expdest - (char *)stackblock();
5209 strtodest(home, SQSYNTAX, quotes);
5210 recordregion(startloc, expdest - (char *)stackblock(), 0);
5218 * Execute a command inside back quotes. If it's a builtin command, we
5219 * want to save its output in a block obtained from malloc. Otherwise
5220 * we fork off a subprocess and get the output of the command via a pipe.
5221 * Should be called with interrupts off.
5223 struct backcmd { /* result of evalbackcmd */
5224 int fd; /* file descriptor to read from */
5225 char *buf; /* buffer */
5226 int nleft; /* number of chars in buffer */
5227 struct job *jp; /* job structure for command */
5230 /* These forward decls are needed to use "eval" code for backticks handling: */
5231 static int back_exitstatus; /* exit status of backquoted command */
5232 #define EV_EXIT 01 /* exit after evaluating tree */
5233 static void evaltree(union node *, int);
5236 evalbackcmd(union node *n, struct backcmd *result)
5248 saveherefd = herefd;
5256 ash_msg_and_raise_error("pipe call failed");
5258 if (forkshell(jp, n, FORK_NOJOB) == 0) {
5267 evaltree(n, EV_EXIT); /* actually evaltreenr... */
5271 result->fd = pip[0];
5274 herefd = saveherefd;
5276 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
5277 result->fd, result->buf, result->nleft, result->jp));
5281 * Expand stuff in backwards quotes.
5284 expbackq(union node *cmd, int quoted, int quotes)
5292 int syntax = quoted? DQSYNTAX : BASESYNTAX;
5293 struct stackmark smark;
5296 setstackmark(&smark);
5298 startloc = dest - (char *)stackblock();
5300 evalbackcmd(cmd, &in);
5301 popstackmark(&smark);
5308 memtodest(p, i, syntax, quotes);
5312 i = safe_read(in.fd, buf, sizeof(buf));
5313 TRACE(("expbackq: read returns %d\n", i));
5323 back_exitstatus = waitforjob(in.jp);
5327 /* Eat all trailing newlines */
5329 for (; dest > (char *)stackblock() && dest[-1] == '\n';)
5334 recordregion(startloc, dest - (char *)stackblock(), 0);
5335 TRACE(("evalbackq: size=%d: \"%.*s\"\n",
5336 (dest - (char *)stackblock()) - startloc,
5337 (dest - (char *)stackblock()) - startloc,
5338 stackblock() + startloc));
5341 #if ENABLE_ASH_MATH_SUPPORT
5343 * Expand arithmetic expression. Backup to start of expression,
5344 * evaluate, place result in (backed up) result, adjust string position.
5357 * This routine is slightly over-complicated for
5358 * efficiency. Next we scan backwards looking for the
5359 * start of arithmetic.
5361 start = stackblock();
5368 while (*p != CTLARI) {
5372 ash_msg_and_raise_error("missing CTLARI (shouldn't happen)");
5377 esc = esclen(start, p);
5387 removerecordregions(begoff);
5396 len = cvtnum(dash_arith(p + 2));
5399 recordregion(begoff, begoff + len, 0);
5403 /* argstr needs it */
5404 static char *evalvar(char *p, int flag);
5407 * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
5408 * characters to allow for further processing. Otherwise treat
5409 * $@ like $* since no splitting will be performed.
5412 argstr(char *p, int flag)
5414 static const char spclchars[] = {
5422 CTLBACKQ | CTLQUOTE,
5423 #if ENABLE_ASH_MATH_SUPPORT
5428 const char *reject = spclchars;
5430 int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
5431 int breakall = flag & EXP_WORD;
5436 if (!(flag & EXP_VARTILDE)) {
5438 } else if (flag & EXP_VARTILDE2) {
5443 if (flag & EXP_TILDE) {
5449 if (*q == CTLESC && (flag & EXP_QWORD))
5452 p = exptilde(p, q, flag);
5455 startloc = expdest - (char *)stackblock();
5457 length += strcspn(p + length, reject);
5459 if (c && (!(c & 0x80)
5460 #if ENABLE_ASH_MATH_SUPPORT
5464 /* c == '=' || c == ':' || c == CTLENDARI */
5469 expdest = stack_nputstr(p, length, expdest);
5470 newloc = expdest - (char *)stackblock();
5471 if (breakall && !inquotes && newloc > startloc) {
5472 recordregion(startloc, newloc, 0);
5483 if (flag & EXP_VARTILDE2) {
5487 flag |= EXP_VARTILDE2;
5492 * sort of a hack - expand tildes in variable
5493 * assignments (after the first '=' and after ':'s).
5502 case CTLENDVAR: /* ??? */
5505 /* "$@" syntax adherence hack */
5508 !memcmp(p, dolatstr, 4) &&
5509 (p[4] == CTLQUOTEMARK || (
5510 p[4] == CTLENDVAR &&
5511 p[5] == CTLQUOTEMARK
5514 p = evalvar(p + 1, flag) + 1;
5517 inquotes = !inquotes;
5530 p = evalvar(p, flag);
5534 case CTLBACKQ|CTLQUOTE:
5535 expbackq(argbackq->n, c, quotes);
5536 argbackq = argbackq->next;
5538 #if ENABLE_ASH_MATH_SUPPORT
5551 scanleft(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
5562 const char *s = loc2;
5568 match = pmatch(str, s);
5572 if (quotes && *loc == CTLESC)
5581 scanright(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
5588 for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
5591 const char *s = loc2;
5596 match = pmatch(str, s);
5603 esc = esclen(startp, loc);
5614 static void varunset(const char *, const char *, const char *, int) ATTRIBUTE_NORETURN;
5616 varunset(const char *end, const char *var, const char *umsg, int varflags)
5622 msg = "parameter not set";
5624 if (*end == CTLENDVAR) {
5625 if (varflags & VSNUL)
5630 ash_msg_and_raise_error("%.*s: %s%s", end - var - 1, var, msg, tail);
5634 subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
5638 int saveherefd = herefd;
5639 struct nodelist *saveargbackq = argbackq;
5641 char *rmesc, *rmescend;
5643 char *(*scan)(char *, char *, char *, char *, int , int);
5646 argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
5647 STPUTC('\0', expdest);
5648 herefd = saveherefd;
5649 argbackq = saveargbackq;
5650 startp = stackblock() + startloc;
5654 setvar(str, startp, 0);
5655 amount = startp - expdest;
5656 STADJUST(amount, expdest);
5660 varunset(p, str, startp, varflags);
5664 subtype -= VSTRIMRIGHT;
5666 if (subtype < 0 || subtype > 3)
5671 rmescend = stackblock() + strloc;
5673 rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
5674 if (rmesc != startp) {
5676 startp = stackblock() + startloc;
5680 str = stackblock() + strloc;
5681 preglob(str, varflags & VSQUOTE, 0);
5683 /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
5684 zero = subtype >> 1;
5685 /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
5686 scan = (subtype & 1) ^ zero ? scanleft : scanright;
5688 loc = scan(startp, rmesc, rmescend, str, quotes, zero);
5691 memmove(startp, loc, str - loc);
5692 loc = startp + (str - loc) - 1;
5695 amount = loc - expdest;
5696 STADJUST(amount, expdest);
5702 * Add the value of a specialized variable to the stack string.
5705 varvalue(char *name, int varflags, int flags)
5715 int quoted = varflags & VSQUOTE;
5716 int subtype = varflags & VSTYPE;
5717 int quotes = flags & (EXP_FULL | EXP_CASE);
5719 if (quoted && (flags & EXP_FULL))
5720 sep = 1 << CHAR_BIT;
5722 syntax = quoted ? DQSYNTAX : BASESYNTAX;
5731 num = shellparam.nparam;
5741 p = makestrspace(NOPTS, expdest);
5742 for (i = NOPTS - 1; i >= 0; i--) {
5744 USTPUTC(optletters(i), p);
5755 sep = ifsset() ? signed_char2int(ifsval()[0]) : ' ';
5756 if (quotes && (SIT(sep, syntax) == CCTL || SIT(sep, syntax) == CBACK))
5762 while ((p = *ap++)) {
5765 partlen = strlen(p);
5768 if (!(subtype == VSPLUS || subtype == VSLENGTH))
5769 memtodest(p, partlen, syntax, quotes);
5775 if (subtype == VSPLUS || subtype == VSLENGTH) {
5797 if (num < 0 || num > shellparam.nparam)
5799 p = num ? shellparam.p[num - 1] : arg0;
5802 p = lookupvar(name);
5808 if (!(subtype == VSPLUS || subtype == VSLENGTH))
5809 memtodest(p, len, syntax, quotes);
5813 if (subtype == VSPLUS || subtype == VSLENGTH)
5814 STADJUST(-len, expdest);
5819 * Expand a variable, and return a pointer to the next character in the
5823 evalvar(char *p, int flag)
5836 quotes = flag & (EXP_FULL | EXP_CASE);
5838 subtype = varflags & VSTYPE;
5839 quoted = varflags & VSQUOTE;
5841 easy = (!quoted || (*var == '@' && shellparam.nparam));
5842 startloc = expdest - (char *)stackblock();
5843 p = strchr(p, '=') + 1;
5846 varlen = varvalue(var, varflags, flag);
5847 if (varflags & VSNUL)
5850 if (subtype == VSPLUS) {
5851 varlen = -1 - varlen;
5855 if (subtype == VSMINUS) {
5859 p, flag | EXP_TILDE |
5860 (quoted ? EXP_QWORD : EXP_WORD)
5869 if (subtype == VSASSIGN || subtype == VSQUESTION) {
5871 if (subevalvar(p, var, 0, subtype, startloc, varflags, 0)) {
5874 * Remove any recorded regions beyond
5877 removerecordregions(startloc);
5887 if (varlen < 0 && uflag)
5888 varunset(p, var, 0, 0);
5890 if (subtype == VSLENGTH) {
5891 cvtnum(varlen > 0 ? varlen : 0);
5895 if (subtype == VSNORMAL) {
5899 recordregion(startloc, expdest - (char *)stackblock(), quoted);
5908 case VSTRIMRIGHTMAX:
5917 * Terminate the string and start recording the pattern
5920 STPUTC('\0', expdest);
5921 patloc = expdest - (char *)stackblock();
5922 if (subevalvar(p, NULL, patloc, subtype,
5923 startloc, varflags, quotes) == 0) {
5924 int amount = expdest - (
5925 (char *)stackblock() + patloc - 1
5927 STADJUST(-amount, expdest);
5929 /* Remove any recorded regions beyond start of variable */
5930 removerecordregions(startloc);
5935 if (subtype != VSNORMAL) { /* skip to end of alternative */
5941 else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
5943 argbackq = argbackq->next;
5944 } else if (c == CTLVAR) {
5945 if ((*p++ & VSTYPE) != VSNORMAL)
5947 } else if (c == CTLENDVAR) {
5957 * Break the argument string into pieces based upon IFS and add the
5958 * strings to the argument list. The regions of the string to be
5959 * searched for IFS characters have been stored by recordregion.
5962 ifsbreakup(char *string, struct arglist *arglist)
5964 struct ifsregion *ifsp;
5969 const char *ifs, *realifs;
5974 if (ifslastp != NULL) {
5977 realifs = ifsset() ? ifsval() : defifs;
5980 p = string + ifsp->begoff;
5981 nulonly = ifsp->nulonly;
5982 ifs = nulonly ? nullstr : realifs;
5984 while (p < string + ifsp->endoff) {
5988 if (!strchr(ifs, *p)) {
5993 ifsspc = (strchr(defifs, *p) != NULL);
5994 /* Ignore IFS whitespace at start */
5995 if (q == start && ifsspc) {
6001 sp = stalloc(sizeof(*sp));
6003 *arglist->lastp = sp;
6004 arglist->lastp = &sp->next;
6008 if (p >= string + ifsp->endoff) {
6014 if (strchr(ifs, *p) == NULL ) {
6017 } else if (strchr(defifs, *p) == NULL) {
6032 } while (ifsp != NULL);
6041 sp = stalloc(sizeof(*sp));
6043 *arglist->lastp = sp;
6044 arglist->lastp = &sp->next;
6050 struct ifsregion *p;
6055 struct ifsregion *ifsp;
6061 ifsfirst.next = NULL;
6066 * Add a file name to the list.
6069 addfname(const char *name)
6073 sp = stalloc(sizeof(*sp));
6074 sp->text = ststrdup(name);
6076 exparg.lastp = &sp->next;
6079 static char *expdir;
6082 * Do metacharacter (i.e. *, ?, [...]) expansion.
6085 expmeta(char *enddir, char *name)
6100 for (p = name; *p; p++) {
6101 if (*p == '*' || *p == '?')
6103 else if (*p == '[') {
6110 if (*q == '/' || *q == '\0')
6117 } else if (*p == '\\')
6119 else if (*p == '/') {
6126 if (metaflag == 0) { /* we've reached the end of the file name */
6127 if (enddir != expdir)
6135 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
6146 } while (p < start);
6148 if (enddir == expdir) {
6150 } else if (enddir == expdir + 1 && *expdir == '/') {
6159 if (enddir != expdir)
6161 if (*endname == 0) {
6173 while (! intpending && (dp = readdir(dirp)) != NULL) {
6174 if (dp->d_name[0] == '.' && ! matchdot)
6176 if (pmatch(start, dp->d_name)) {
6178 strcpy(enddir, dp->d_name);
6181 for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
6184 expmeta(p, endname);
6193 static struct strlist *
6194 msort(struct strlist *list, int len)
6196 struct strlist *p, *q = NULL;
6197 struct strlist **lpp;
6205 for (n = half; --n >= 0; ) {
6209 q->next = NULL; /* terminate first half of list */
6210 q = msort(list, half); /* sort first half of list */
6211 p = msort(p, len - half); /* sort second half */
6214 #if ENABLE_LOCALE_SUPPORT
6215 if (strcoll(p->text, q->text) < 0)
6217 if (strcmp(p->text, q->text) < 0)
6241 * Sort the results of file name expansion. It calculates the number of
6242 * strings to sort and then calls msort (short for merge sort) to do the
6245 static struct strlist *
6246 expsort(struct strlist *str)
6252 for (sp = str; sp; sp = sp->next)
6254 return msort(str, len);
6258 expandmeta(struct strlist *str, int flag)
6260 static const char metachars[] = {
6263 /* TODO - EXP_REDIR */
6266 struct strlist **savelastp;
6272 if (!strpbrk(str->text, metachars))
6274 savelastp = exparg.lastp;
6277 p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
6279 int i = strlen(str->text);
6280 expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
6288 if (exparg.lastp == savelastp) {
6293 *exparg.lastp = str;
6294 rmescapes(str->text);
6295 exparg.lastp = &str->next;
6297 *exparg.lastp = NULL;
6298 *savelastp = sp = expsort(*savelastp);
6299 while (sp->next != NULL)
6301 exparg.lastp = &sp->next;
6308 * Perform variable substitution and command substitution on an argument,
6309 * placing the resulting list of arguments in arglist. If EXP_FULL is true,
6310 * perform splitting and file name expansion. When arglist is NULL, perform
6311 * here document expansion.
6314 expandarg(union node *arg, struct arglist *arglist, int flag)
6319 argbackq = arg->narg.backquote;
6320 STARTSTACKSTR(expdest);
6321 ifsfirst.next = NULL;
6323 argstr(arg->narg.text, flag);
6324 p = _STPUTC('\0', expdest);
6326 if (arglist == NULL) {
6327 return; /* here document expanded */
6329 p = grabstackstr(p);
6330 exparg.lastp = &exparg.list;
6334 if (flag & EXP_FULL) {
6335 ifsbreakup(p, &exparg);
6336 *exparg.lastp = NULL;
6337 exparg.lastp = &exparg.list;
6338 expandmeta(exparg.list, flag);
6340 if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
6342 sp = stalloc(sizeof(*sp));
6345 exparg.lastp = &sp->next;
6349 *exparg.lastp = NULL;
6351 *arglist->lastp = exparg.list;
6352 arglist->lastp = exparg.lastp;
6357 * Expand shell variables and backquotes inside a here document.
6360 expandhere(union node *arg, int fd)
6363 expandarg(arg, (struct arglist *)NULL, 0);
6364 full_write(fd, stackblock(), expdest - (char *)stackblock());
6368 * Returns true if the pattern matches the string.
6371 patmatch(char *pattern, const char *string)
6373 return pmatch(preglob(pattern, 0, 0), string);
6377 * See if a pattern matches in a case statement.
6380 casematch(union node *pattern, char *val)
6382 struct stackmark smark;
6385 setstackmark(&smark);
6386 argbackq = pattern->narg.backquote;
6387 STARTSTACKSTR(expdest);
6389 argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
6390 STACKSTRNUL(expdest);
6391 result = patmatch(stackblock(), val);
6392 popstackmark(&smark);
6397 /* ============ find_command */
6401 int (*builtin)(int, char **);
6402 /* unsigned flags; */
6404 #define IS_BUILTIN_SPECIAL(b) ((b)->name[0] & 1)
6405 #define IS_BUILTIN_REGULAR(b) ((b)->name[0] & 2)
6406 #define IS_BUILTIN_ASSIGN(b) ((b)->name[0] & 4)
6412 const struct builtincmd *cmd;
6413 struct funcnode *func;
6416 /* values of cmdtype */
6417 #define CMDUNKNOWN -1 /* no entry in table for command */
6418 #define CMDNORMAL 0 /* command is an executable program */
6419 #define CMDFUNCTION 1 /* command is a shell function */
6420 #define CMDBUILTIN 2 /* command is a shell builtin */
6422 /* action to find_command() */
6423 #define DO_ERR 0x01 /* prints errors */
6424 #define DO_ABS 0x02 /* checks absolute paths */
6425 #define DO_NOFUNC 0x04 /* don't return shell functions, for command */
6426 #define DO_ALTPATH 0x08 /* using alternate path */
6427 #define DO_ALTBLTIN 0x20 /* %builtin in alt. path */
6429 static void find_command(char *, struct cmdentry *, int, const char *);
6432 /* ============ Hashing commands */
6435 * When commands are first encountered, they are entered in a hash table.
6436 * This ensures that a full path search will not have to be done for them
6437 * on each invocation.
6439 * We should investigate converting to a linear search, even though that
6440 * would make the command name "hash" a misnomer.
6443 #define CMDTABLESIZE 31 /* should be prime */
6444 #define ARB 1 /* actual size determined at run time */
6447 struct tblentry *next; /* next entry in hash chain */
6448 union param param; /* definition of builtin function */
6449 short cmdtype; /* index identifying command */
6450 char rehash; /* if set, cd done since entry created */
6451 char cmdname[ARB]; /* name of command */
6454 static struct tblentry *cmdtable[CMDTABLESIZE];
6455 static int builtinloc = -1; /* index in path of %builtin, or -1 */
6458 tryexec(char *cmd, char **argv, char **envp)
6462 #if ENABLE_FEATURE_SH_STANDALONE
6463 if (strchr(cmd, '/') == NULL) {
6464 const struct bb_applet *a;
6466 a = find_applet_by_name(cmd);
6470 run_current_applet_and_exit(argv);
6472 /* re-exec ourselves with the new arguments */
6473 execve(bb_busybox_exec_path, argv, envp);
6474 /* If they called chroot or otherwise made the binary no longer
6475 * executable, fall through */
6483 execve(cmd, argv, envp);
6484 } while (errno == EINTR);
6486 execve(cmd, argv, envp);
6490 } else if (errno == ENOEXEC) {
6494 for (ap = argv; *ap; ap++)
6496 ap = new = ckmalloc((ap - argv + 2) * sizeof(char *));
6498 ap[0] = cmd = (char *)DEFAULT_SHELL;
6501 while ((*ap++ = *argv++))
6509 * Exec a program. Never returns. If you change this routine, you may
6510 * have to change the find_command routine as well.
6512 #define environment() listvars(VEXPORT, VUNSET, 0)
6513 static void shellexec(char **, const char *, int) ATTRIBUTE_NORETURN;
6515 shellexec(char **argv, const char *path, int idx)
6523 envp = environment();
6524 if (strchr(argv[0], '/')
6525 #if ENABLE_FEATURE_SH_STANDALONE
6526 || find_applet_by_name(argv[0])
6529 tryexec(argv[0], argv, envp);
6533 while ((cmdname = padvance(&path, argv[0])) != NULL) {
6534 if (--idx < 0 && pathopt == NULL) {
6535 tryexec(cmdname, argv, envp);
6536 if (errno != ENOENT && errno != ENOTDIR)
6543 /* Map to POSIX errors */
6555 exitstatus = exerrno;
6556 TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
6557 argv[0], e, suppressint ));
6558 ash_msg_and_raise(EXEXEC, "%s: %s", argv[0], errmsg(e, "not found"));
6563 printentry(struct tblentry *cmdp)
6569 idx = cmdp->param.index;
6572 name = padvance(&path, cmdp->cmdname);
6574 } while (--idx >= 0);
6575 out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr));
6579 * Clear out command entries. The argument specifies the first entry in
6580 * PATH which has changed.
6583 clearcmdentry(int firstchange)
6585 struct tblentry **tblp;
6586 struct tblentry **pp;
6587 struct tblentry *cmdp;
6590 for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
6592 while ((cmdp = *pp) != NULL) {
6593 if ((cmdp->cmdtype == CMDNORMAL &&
6594 cmdp->param.index >= firstchange)
6595 || (cmdp->cmdtype == CMDBUILTIN &&
6596 builtinloc >= firstchange)
6609 * Locate a command in the command hash table. If "add" is nonzero,
6610 * add the command to the table if it is not already present. The
6611 * variable "lastcmdentry" is set to point to the address of the link
6612 * pointing to the entry, so that delete_cmd_entry can delete the
6615 * Interrupts must be off if called with add != 0.
6617 static struct tblentry **lastcmdentry;
6619 static struct tblentry *
6620 cmdlookup(const char *name, int add)
6622 unsigned int hashval;
6624 struct tblentry *cmdp;
6625 struct tblentry **pp;
6628 hashval = (unsigned char)*p << 4;
6630 hashval += (unsigned char)*p++;
6632 pp = &cmdtable[hashval % CMDTABLESIZE];
6633 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
6634 if (strcmp(cmdp->cmdname, name) == 0)
6638 if (add && cmdp == NULL) {
6639 cmdp = *pp = ckmalloc(sizeof(struct tblentry) - ARB
6640 + strlen(name) + 1);
6642 cmdp->cmdtype = CMDUNKNOWN;
6643 strcpy(cmdp->cmdname, name);
6650 * Delete the command entry returned on the last lookup.
6653 delete_cmd_entry(void)
6655 struct tblentry *cmdp;
6658 cmdp = *lastcmdentry;
6659 *lastcmdentry = cmdp->next;
6660 if (cmdp->cmdtype == CMDFUNCTION)
6661 freefunc(cmdp->param.func);
6667 * Add a new command entry, replacing any existing command entry for
6668 * the same name - except special builtins.
6671 addcmdentry(char *name, struct cmdentry *entry)
6673 struct tblentry *cmdp;
6675 cmdp = cmdlookup(name, 1);
6676 if (cmdp->cmdtype == CMDFUNCTION) {
6677 freefunc(cmdp->param.func);
6679 cmdp->cmdtype = entry->cmdtype;
6680 cmdp->param = entry->u;
6685 hashcmd(int argc, char **argv)
6687 struct tblentry **pp;
6688 struct tblentry *cmdp;
6690 struct cmdentry entry;
6693 while ((c = nextopt("r")) != '\0') {
6697 if (*argptr == NULL) {
6698 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
6699 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
6700 if (cmdp->cmdtype == CMDNORMAL)
6707 while ((name = *argptr) != NULL) {
6708 cmdp = cmdlookup(name, 0);
6710 && (cmdp->cmdtype == CMDNORMAL
6711 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
6713 find_command(name, &entry, DO_ERR, pathval());
6714 if (entry.cmdtype == CMDUNKNOWN)
6722 * Called when a cd is done. Marks all commands so the next time they
6723 * are executed they will be rehashed.
6728 struct tblentry **pp;
6729 struct tblentry *cmdp;
6731 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
6732 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
6733 if (cmdp->cmdtype == CMDNORMAL || (
6734 cmdp->cmdtype == CMDBUILTIN &&
6735 !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) &&
6744 * Fix command hash table when PATH changed.
6745 * Called before PATH is changed. The argument is the new value of PATH;
6746 * pathval() still returns the old value at this point.
6747 * Called with interrupts off.
6750 changepath(const char *newval)
6752 const char *old, *new;
6759 firstchange = 9999; /* assume no change */
6765 if ((*old == '\0' && *new == ':')
6766 || (*old == ':' && *new == '\0'))
6768 old = new; /* ignore subsequent differences */
6772 if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
6779 if (builtinloc < 0 && idx_bltin >= 0)
6780 builtinloc = idx_bltin; /* zap builtins */
6781 if (builtinloc >= 0 && idx_bltin < 0)
6783 clearcmdentry(firstchange);
6784 builtinloc = idx_bltin;
6799 #define TENDBQUOTE 12
6817 /* first char is indicating which tokens mark the end of a list */
6818 static const char *const tokname_array[] = {
6832 #define KWDOFFSET 13
6833 /* the following are keywords */
6855 static char buf[16];
6858 //if (tok < TSEMI) return tokname_array[tok] + 1;
6859 //sprintf(buf, "\"%s\"", tokname_array[tok] + 1);
6864 sprintf(buf + (tok >= TSEMI), "%s%c",
6865 tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
6869 /* Wrapper around strcmp for qsort/bsearch/... */
6871 pstrcmp(const void *a, const void *b)
6873 return strcmp((char*) a, (*(char**) b) + 1);
6876 static const char *const *
6877 findkwd(const char *s)
6879 return bsearch(s, tokname_array + KWDOFFSET,
6880 ARRAY_SIZE(tokname_array) - KWDOFFSET,
6881 sizeof(tokname_array[0]), pstrcmp);
6885 * Locate and print what a word is...
6888 describe_command(char *command, int describe_command_verbose)
6890 struct cmdentry entry;
6891 struct tblentry *cmdp;
6892 #if ENABLE_ASH_ALIAS
6893 const struct alias *ap;
6895 const char *path = pathval();
6897 if (describe_command_verbose) {
6901 /* First look at the keywords */
6902 if (findkwd(command)) {
6903 out1str(describe_command_verbose ? " is a shell keyword" : command);
6907 #if ENABLE_ASH_ALIAS
6908 /* Then look at the aliases */
6909 ap = lookupalias(command, 0);
6911 if (!describe_command_verbose) {
6916 out1fmt(" is an alias for %s", ap->val);
6920 /* Then check if it is a tracked alias */
6921 cmdp = cmdlookup(command, 0);
6923 entry.cmdtype = cmdp->cmdtype;
6924 entry.u = cmdp->param;
6926 /* Finally use brute force */
6927 find_command(command, &entry, DO_ABS, path);
6930 switch (entry.cmdtype) {
6932 int j = entry.u.index;
6938 p = padvance(&path, command);
6942 if (describe_command_verbose) {
6944 (cmdp ? " a tracked alias for" : nullstr), p
6953 if (describe_command_verbose) {
6954 out1str(" is a shell function");
6961 if (describe_command_verbose) {
6962 out1fmt(" is a %sshell builtin",
6963 IS_BUILTIN_SPECIAL(entry.u.cmd) ?
6964 "special " : nullstr
6972 if (describe_command_verbose) {
6973 out1str(": not found\n");
6978 outstr("\n", stdout);
6983 typecmd(int argc, char **argv)
6989 /* type -p ... ? (we don't bother checking for 'p') */
6990 if (argv[1] && argv[1][0] == '-') {
6995 err |= describe_command(argv[i++], verbose);
7000 #if ENABLE_ASH_CMDCMD
7002 commandcmd(int argc, char **argv)
7010 while ((c = nextopt("pvV")) != '\0')
7012 verify |= VERIFY_VERBOSE;
7014 verify |= VERIFY_BRIEF;
7020 return describe_command(*argptr, verify - VERIFY_BRIEF);
7027 /* ============ eval.c */
7029 static int funcblocksize; /* size of structures in function */
7030 static int funcstringsize; /* size of strings in node */
7031 static void *funcblock; /* block to allocate function from */
7032 static char *funcstring; /* block to allocate strings from */
7034 /* flags in argument to evaltree */
7035 #define EV_EXIT 01 /* exit after evaluating tree */
7036 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
7037 #define EV_BACKCMD 04 /* command executing within back quotes */
7039 static const short nodesize[26] = {
7040 SHELL_ALIGN(sizeof(struct ncmd)),
7041 SHELL_ALIGN(sizeof(struct npipe)),
7042 SHELL_ALIGN(sizeof(struct nredir)),
7043 SHELL_ALIGN(sizeof(struct nredir)),
7044 SHELL_ALIGN(sizeof(struct nredir)),
7045 SHELL_ALIGN(sizeof(struct nbinary)),
7046 SHELL_ALIGN(sizeof(struct nbinary)),
7047 SHELL_ALIGN(sizeof(struct nbinary)),
7048 SHELL_ALIGN(sizeof(struct nif)),
7049 SHELL_ALIGN(sizeof(struct nbinary)),
7050 SHELL_ALIGN(sizeof(struct nbinary)),
7051 SHELL_ALIGN(sizeof(struct nfor)),
7052 SHELL_ALIGN(sizeof(struct ncase)),
7053 SHELL_ALIGN(sizeof(struct nclist)),
7054 SHELL_ALIGN(sizeof(struct narg)),
7055 SHELL_ALIGN(sizeof(struct narg)),
7056 SHELL_ALIGN(sizeof(struct nfile)),
7057 SHELL_ALIGN(sizeof(struct nfile)),
7058 SHELL_ALIGN(sizeof(struct nfile)),
7059 SHELL_ALIGN(sizeof(struct nfile)),
7060 SHELL_ALIGN(sizeof(struct nfile)),
7061 SHELL_ALIGN(sizeof(struct ndup)),
7062 SHELL_ALIGN(sizeof(struct ndup)),
7063 SHELL_ALIGN(sizeof(struct nhere)),
7064 SHELL_ALIGN(sizeof(struct nhere)),
7065 SHELL_ALIGN(sizeof(struct nnot)),
7068 static void calcsize(union node *n);
7071 sizenodelist(struct nodelist *lp)
7074 funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
7081 calcsize(union node *n)
7085 funcblocksize += nodesize[n->type];
7088 calcsize(n->ncmd.redirect);
7089 calcsize(n->ncmd.args);
7090 calcsize(n->ncmd.assign);
7093 sizenodelist(n->npipe.cmdlist);
7098 calcsize(n->nredir.redirect);
7099 calcsize(n->nredir.n);
7106 calcsize(n->nbinary.ch2);
7107 calcsize(n->nbinary.ch1);
7110 calcsize(n->nif.elsepart);
7111 calcsize(n->nif.ifpart);
7112 calcsize(n->nif.test);
7115 funcstringsize += strlen(n->nfor.var) + 1;
7116 calcsize(n->nfor.body);
7117 calcsize(n->nfor.args);
7120 calcsize(n->ncase.cases);
7121 calcsize(n->ncase.expr);
7124 calcsize(n->nclist.body);
7125 calcsize(n->nclist.pattern);
7126 calcsize(n->nclist.next);
7130 sizenodelist(n->narg.backquote);
7131 funcstringsize += strlen(n->narg.text) + 1;
7132 calcsize(n->narg.next);
7139 calcsize(n->nfile.fname);
7140 calcsize(n->nfile.next);
7144 calcsize(n->ndup.vname);
7145 calcsize(n->ndup.next);
7149 calcsize(n->nhere.doc);
7150 calcsize(n->nhere.next);
7153 calcsize(n->nnot.com);
7159 nodeckstrdup(char *s)
7161 char *rtn = funcstring;
7163 strcpy(funcstring, s);
7164 funcstring += strlen(s) + 1;
7168 static union node *copynode(union node *);
7170 static struct nodelist *
7171 copynodelist(struct nodelist *lp)
7173 struct nodelist *start;
7174 struct nodelist **lpp;
7179 funcblock = (char *) funcblock + SHELL_ALIGN(sizeof(struct nodelist));
7180 (*lpp)->n = copynode(lp->n);
7182 lpp = &(*lpp)->next;
7189 copynode(union node *n)
7196 funcblock = (char *) funcblock + nodesize[n->type];
7200 new->ncmd.redirect = copynode(n->ncmd.redirect);
7201 new->ncmd.args = copynode(n->ncmd.args);
7202 new->ncmd.assign = copynode(n->ncmd.assign);
7205 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
7206 new->npipe.backgnd = n->npipe.backgnd;
7211 new->nredir.redirect = copynode(n->nredir.redirect);
7212 new->nredir.n = copynode(n->nredir.n);
7219 new->nbinary.ch2 = copynode(n->nbinary.ch2);
7220 new->nbinary.ch1 = copynode(n->nbinary.ch1);
7223 new->nif.elsepart = copynode(n->nif.elsepart);
7224 new->nif.ifpart = copynode(n->nif.ifpart);
7225 new->nif.test = copynode(n->nif.test);
7228 new->nfor.var = nodeckstrdup(n->nfor.var);
7229 new->nfor.body = copynode(n->nfor.body);
7230 new->nfor.args = copynode(n->nfor.args);
7233 new->ncase.cases = copynode(n->ncase.cases);
7234 new->ncase.expr = copynode(n->ncase.expr);
7237 new->nclist.body = copynode(n->nclist.body);
7238 new->nclist.pattern = copynode(n->nclist.pattern);
7239 new->nclist.next = copynode(n->nclist.next);
7243 new->narg.backquote = copynodelist(n->narg.backquote);
7244 new->narg.text = nodeckstrdup(n->narg.text);
7245 new->narg.next = copynode(n->narg.next);
7252 new->nfile.fname = copynode(n->nfile.fname);
7253 new->nfile.fd = n->nfile.fd;
7254 new->nfile.next = copynode(n->nfile.next);
7258 new->ndup.vname = copynode(n->ndup.vname);
7259 new->ndup.dupfd = n->ndup.dupfd;
7260 new->ndup.fd = n->ndup.fd;
7261 new->ndup.next = copynode(n->ndup.next);
7265 new->nhere.doc = copynode(n->nhere.doc);
7266 new->nhere.fd = n->nhere.fd;
7267 new->nhere.next = copynode(n->nhere.next);
7270 new->nnot.com = copynode(n->nnot.com);
7273 new->type = n->type;
7278 * Make a copy of a parse tree.
7280 static struct funcnode *
7281 copyfunc(union node *n)
7286 funcblocksize = offsetof(struct funcnode, n);
7289 blocksize = funcblocksize;
7290 f = ckmalloc(blocksize + funcstringsize);
7291 funcblock = (char *) f + offsetof(struct funcnode, n);
7292 funcstring = (char *) f + blocksize;
7299 * Define a shell function.
7302 defun(char *name, union node *func)
7304 struct cmdentry entry;
7307 entry.cmdtype = CMDFUNCTION;
7308 entry.u.func = copyfunc(func);
7309 addcmdentry(name, &entry);
7313 static int evalskip; /* set if we are skipping commands */
7314 /* reasons for skipping commands (see comment on breakcmd routine) */
7315 #define SKIPBREAK (1 << 0)
7316 #define SKIPCONT (1 << 1)
7317 #define SKIPFUNC (1 << 2)
7318 #define SKIPFILE (1 << 3)
7319 #define SKIPEVAL (1 << 4)
7320 static int skipcount; /* number of levels to skip */
7321 static int funcnest; /* depth of function calls */
7323 /* forward decl way out to parsing code - dotrap needs it */
7324 static int evalstring(char *s, int mask);
7327 * Called to execute a trap. Perhaps we should avoid entering new trap
7328 * handlers while we are executing a trap handler.
7339 savestatus = exitstatus;
7343 for (i = 0, q = gotsig; i < NSIG - 1; i++, q++) {
7351 skip = evalstring(p, SKIPEVAL);
7352 exitstatus = savestatus;
7360 /* forward declarations - evaluation is fairly recursive business... */
7361 static void evalloop(union node *, int);
7362 static void evalfor(union node *, int);
7363 static void evalcase(union node *, int);
7364 static void evalsubshell(union node *, int);
7365 static void expredir(union node *);
7366 static void evalpipe(union node *, int);
7367 static void evalcommand(union node *, int);
7368 static int evalbltin(const struct builtincmd *, int, char **);
7369 static void prehash(union node *);
7372 * Evaluate a parse tree. The value is left in the global variable
7376 evaltree(union node *n, int flags)
7379 void (*evalfn)(union node *, int);
7383 TRACE(("evaltree(NULL) called\n"));
7386 TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
7387 getpid(), n, n->type, flags));
7391 out1fmt("Node type = %d\n", n->type);
7396 evaltree(n->nnot.com, EV_TESTED);
7397 status = !exitstatus;
7400 expredir(n->nredir.redirect);
7401 status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
7403 evaltree(n->nredir.n, flags & EV_TESTED);
7404 status = exitstatus;
7409 evalfn = evalcommand;
7411 if (eflag && !(flags & EV_TESTED))
7423 evalfn = evalsubshell;
7435 #error NAND + 1 != NOR
7437 #if NOR + 1 != NSEMI
7438 #error NOR + 1 != NSEMI
7440 isor = n->type - NAND;
7443 (flags | ((isor >> 1) - 1)) & EV_TESTED
7445 if (!exitstatus == isor)
7457 evaltree(n->nif.test, EV_TESTED);
7460 if (exitstatus == 0) {
7463 } else if (n->nif.elsepart) {
7464 n = n->nif.elsepart;
7469 defun(n->narg.text, n->narg.next);
7473 exitstatus = status;
7477 if ((checkexit & exitstatus))
7478 evalskip |= SKIPEVAL;
7479 else if (pendingsig && dotrap())
7482 if (flags & EV_EXIT) {
7484 raise_exception(EXEXIT);
7488 #if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
7491 void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
7493 static int loopnest; /* current loop nesting level */
7496 evalloop(union node *n, int flags)
7506 evaltree(n->nbinary.ch1, EV_TESTED);
7509 if (evalskip == SKIPCONT && --skipcount <= 0) {
7513 if (evalskip == SKIPBREAK && --skipcount <= 0)
7518 if (n->type != NWHILE)
7522 evaltree(n->nbinary.ch2, flags);
7523 status = exitstatus;
7528 exitstatus = status;
7532 evalfor(union node *n, int flags)
7534 struct arglist arglist;
7537 struct stackmark smark;
7539 setstackmark(&smark);
7540 arglist.lastp = &arglist.list;
7541 for (argp = n->nfor.args; argp; argp = argp->narg.next) {
7542 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
7547 *arglist.lastp = NULL;
7552 for (sp = arglist.list; sp; sp = sp->next) {
7553 setvar(n->nfor.var, sp->text, 0);
7554 evaltree(n->nfor.body, flags);
7556 if (evalskip == SKIPCONT && --skipcount <= 0) {
7560 if (evalskip == SKIPBREAK && --skipcount <= 0)
7567 popstackmark(&smark);
7571 evalcase(union node *n, int flags)
7575 struct arglist arglist;
7576 struct stackmark smark;
7578 setstackmark(&smark);
7579 arglist.lastp = &arglist.list;
7580 expandarg(n->ncase.expr, &arglist, EXP_TILDE);
7582 for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
7583 for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
7584 if (casematch(patp, arglist.list->text)) {
7585 if (evalskip == 0) {
7586 evaltree(cp->nclist.body, flags);
7593 popstackmark(&smark);
7597 * Kick off a subshell to evaluate a tree.
7600 evalsubshell(union node *n, int flags)
7603 int backgnd = (n->type == NBACKGND);
7606 expredir(n->nredir.redirect);
7607 if (!backgnd && flags & EV_EXIT && !trap[0])
7611 if (forkshell(jp, n, backgnd) == 0) {
7615 flags &=~ EV_TESTED;
7617 redirect(n->nredir.redirect, 0);
7618 evaltreenr(n->nredir.n, flags);
7623 status = waitforjob(jp);
7624 exitstatus = status;
7629 * Compute the names of the files in a redirection list.
7631 static void fixredir(union node *, const char *, int);
7633 expredir(union node *n)
7637 for (redir = n; redir; redir = redir->nfile.next) {
7640 memset(&fn, 0, sizeof(fn));
7641 fn.lastp = &fn.list;
7642 switch (redir->type) {
7648 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
7649 redir->nfile.expfname = fn.list->text;
7653 if (redir->ndup.vname) {
7654 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
7655 if (fn.list == NULL)
7656 ash_msg_and_raise_error("redir error");
7657 fixredir(redir, fn.list->text, 1);
7665 * Evaluate a pipeline. All the processes in the pipeline are children
7666 * of the process creating the pipeline. (This differs from some versions
7667 * of the shell, which make the last process in a pipeline the parent
7671 evalpipe(union node *n, int flags)
7674 struct nodelist *lp;
7679 TRACE(("evalpipe(0x%lx) called\n", (long)n));
7681 for (lp = n->npipe.cmdlist; lp; lp = lp->next)
7685 jp = makejob(n, pipelen);
7687 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
7691 if (pipe(pip) < 0) {
7693 ash_msg_and_raise_error("pipe call failed");
7696 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
7709 evaltreenr(lp->n, flags);
7717 if (n->npipe.backgnd == 0) {
7718 exitstatus = waitforjob(jp);
7719 TRACE(("evalpipe: job done exit status %d\n", exitstatus));
7725 * Controls whether the shell is interactive or not.
7728 setinteractive(int on)
7730 static int is_interactive;
7732 if (++on == is_interactive)
7734 is_interactive = on;
7738 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
7739 if (is_interactive > 1) {
7740 /* Looks like they want an interactive shell */
7741 static smallint did_banner;
7746 "%s built-in shell (ash)\n"
7747 "Enter 'help' for a list of built-in commands."
7756 #if ENABLE_FEATURE_EDITING_VI
7757 #define setvimode(on) do { \
7758 if (on) line_input_state->flags |= VI_MODE; \
7759 else line_input_state->flags &= ~VI_MODE; \
7762 #define setvimode(on) viflag = 0 /* forcibly keep the option off */
7771 setinteractive(iflag);
7776 static struct localvar *localvars;
7779 * Called after a function returns.
7780 * Interrupts must be off.
7785 struct localvar *lvp;
7788 while ((lvp = localvars) != NULL) {
7789 localvars = lvp->next;
7791 TRACE(("poplocalvar %s", vp ? vp->text : "-"));
7792 if (vp == NULL) { /* $- saved */
7793 memcpy(optlist, lvp->text, sizeof(optlist));
7794 free((char*)lvp->text);
7796 } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
7800 (*vp->func)(strchrnul(lvp->text, '=') + 1);
7801 if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
7802 free((char*)vp->text);
7803 vp->flags = lvp->flags;
7804 vp->text = lvp->text;
7811 evalfun(struct funcnode *func, int argc, char **argv, int flags)
7813 volatile struct shparam saveparam;
7814 struct localvar *volatile savelocalvars;
7815 struct jmploc *volatile savehandler;
7816 struct jmploc jmploc;
7819 saveparam = shellparam;
7820 savelocalvars = localvars;
7821 e = setjmp(jmploc.loc);
7826 savehandler = exception_handler;
7827 exception_handler = &jmploc;
7829 shellparam.malloc = 0;
7833 shellparam.nparam = argc - 1;
7834 shellparam.p = argv + 1;
7835 #if ENABLE_ASH_GETOPTS
7836 shellparam.optind = 1;
7837 shellparam.optoff = -1;
7839 evaltree(&func->n, flags & EV_TESTED);
7845 localvars = savelocalvars;
7846 freeparam(&shellparam);
7847 shellparam = saveparam;
7848 exception_handler = savehandler;
7850 evalskip &= ~SKIPFUNC;
7854 #if ENABLE_ASH_CMDCMD
7856 parse_command_args(char **argv, const char **path)
7869 if (c == '-' && !*cp) {
7876 *path = bb_default_path;
7879 /* run 'typecmd' for other options */
7890 * Make a variable a local variable. When a variable is made local, it's
7891 * value and flags are saved in a localvar structure. The saved values
7892 * will be restored when the shell function returns. We handle the name
7893 * "-" as a special case.
7898 struct localvar *lvp;
7903 lvp = ckmalloc(sizeof(struct localvar));
7904 if (LONE_DASH(name)) {
7906 p = ckmalloc(sizeof(optlist));
7907 lvp->text = memcpy(p, optlist, sizeof(optlist));
7912 vpp = hashvar(name);
7913 vp = *findvar(vpp, name);
7914 eq = strchr(name, '=');
7917 setvareq(name, VSTRFIXED);
7919 setvar(name, NULL, VSTRFIXED);
7920 vp = *vpp; /* the new variable */
7921 lvp->flags = VUNSET;
7923 lvp->text = vp->text;
7924 lvp->flags = vp->flags;
7925 vp->flags |= VSTRFIXED|VTEXTFIXED;
7931 lvp->next = localvars;
7937 * The "local" command.
7940 localcmd(int argc, char **argv)
7945 while ((name = *argv++) != NULL) {
7952 falsecmd(int argc, char **argv)
7958 truecmd(int argc, char **argv)
7964 execcmd(int argc, char **argv)
7967 iflag = 0; /* exit on error */
7970 shellexec(argv + 1, pathval(), 0);
7976 * The return command.
7979 returncmd(int argc, char **argv)
7982 * If called outside a function, do what ksh does;
7983 * skip the rest of the file.
7985 evalskip = funcnest ? SKIPFUNC : SKIPFILE;
7986 return argv[1] ? number(argv[1]) : exitstatus;
7989 /* Forward declarations for builtintab[] */
7990 static int breakcmd(int, char **);
7991 static int dotcmd(int, char **);
7992 static int evalcmd(int, char **);
7993 #if ENABLE_ASH_BUILTIN_ECHO
7994 static int echocmd(int, char **);
7996 #if ENABLE_ASH_BUILTIN_TEST
7997 static int testcmd(int, char **);
7999 static int exitcmd(int, char **);
8000 static int exportcmd(int, char **);
8001 #if ENABLE_ASH_GETOPTS
8002 static int getoptscmd(int, char **);
8004 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
8005 static int helpcmd(int argc, char **argv);
8007 #if ENABLE_ASH_MATH_SUPPORT
8008 static int letcmd(int, char **);
8010 static int readcmd(int, char **);
8011 static int setcmd(int, char **);
8012 static int shiftcmd(int, char **);
8013 static int timescmd(int, char **);
8014 static int trapcmd(int, char **);
8015 static int umaskcmd(int, char **);
8016 static int unsetcmd(int, char **);
8017 static int ulimitcmd(int, char **);
8019 #define BUILTIN_NOSPEC "0"
8020 #define BUILTIN_SPECIAL "1"
8021 #define BUILTIN_REGULAR "2"
8022 #define BUILTIN_SPEC_REG "3"
8023 #define BUILTIN_ASSIGN "4"
8024 #define BUILTIN_SPEC_ASSG "5"
8025 #define BUILTIN_REG_ASSG "6"
8026 #define BUILTIN_SPEC_REG_ASSG "7"
8028 /* make sure to keep these in proper order since it is searched via bsearch() */
8029 static const struct builtincmd builtintab[] = {
8030 { BUILTIN_SPEC_REG ".", dotcmd },
8031 { BUILTIN_SPEC_REG ":", truecmd },
8032 #if ENABLE_ASH_BUILTIN_TEST
8033 { BUILTIN_REGULAR "[", testcmd },
8034 { BUILTIN_REGULAR "[[", testcmd },
8036 #if ENABLE_ASH_ALIAS
8037 { BUILTIN_REG_ASSG "alias", aliascmd },
8040 { BUILTIN_REGULAR "bg", fg_bgcmd },
8042 { BUILTIN_SPEC_REG "break", breakcmd },
8043 { BUILTIN_REGULAR "cd", cdcmd },
8044 { BUILTIN_NOSPEC "chdir", cdcmd },
8045 #if ENABLE_ASH_CMDCMD
8046 { BUILTIN_REGULAR "command", commandcmd },
8048 { BUILTIN_SPEC_REG "continue", breakcmd },
8049 #if ENABLE_ASH_BUILTIN_ECHO
8050 { BUILTIN_REGULAR "echo", echocmd },
8052 { BUILTIN_SPEC_REG "eval", evalcmd },
8053 { BUILTIN_SPEC_REG "exec", execcmd },
8054 { BUILTIN_SPEC_REG "exit", exitcmd },
8055 { BUILTIN_SPEC_REG_ASSG "export", exportcmd },
8056 { BUILTIN_REGULAR "false", falsecmd },
8058 { BUILTIN_REGULAR "fg", fg_bgcmd },
8060 #if ENABLE_ASH_GETOPTS
8061 { BUILTIN_REGULAR "getopts", getoptscmd },
8063 { BUILTIN_NOSPEC "hash", hashcmd },
8064 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
8065 { BUILTIN_NOSPEC "help", helpcmd },
8068 { BUILTIN_REGULAR "jobs", jobscmd },
8069 { BUILTIN_REGULAR "kill", killcmd },
8071 #if ENABLE_ASH_MATH_SUPPORT
8072 { BUILTIN_NOSPEC "let", letcmd },
8074 { BUILTIN_ASSIGN "local", localcmd },
8075 { BUILTIN_NOSPEC "pwd", pwdcmd },
8076 { BUILTIN_REGULAR "read", readcmd },
8077 { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd },
8078 { BUILTIN_SPEC_REG "return", returncmd },
8079 { BUILTIN_SPEC_REG "set", setcmd },
8080 { BUILTIN_SPEC_REG "shift", shiftcmd },
8081 { BUILTIN_SPEC_REG "source", dotcmd },
8082 #if ENABLE_ASH_BUILTIN_TEST
8083 { BUILTIN_REGULAR "test", testcmd },
8085 { BUILTIN_SPEC_REG "times", timescmd },
8086 { BUILTIN_SPEC_REG "trap", trapcmd },
8087 { BUILTIN_REGULAR "true", truecmd },
8088 { BUILTIN_NOSPEC "type", typecmd },
8089 { BUILTIN_NOSPEC "ulimit", ulimitcmd },
8090 { BUILTIN_REGULAR "umask", umaskcmd },
8091 #if ENABLE_ASH_ALIAS
8092 { BUILTIN_REGULAR "unalias", unaliascmd },
8094 { BUILTIN_SPEC_REG "unset", unsetcmd },
8095 { BUILTIN_REGULAR "wait", waitcmd },
8099 #define COMMANDCMD (builtintab + 5 + \
8100 2 * ENABLE_ASH_BUILTIN_TEST + \
8101 ENABLE_ASH_ALIAS + \
8102 ENABLE_ASH_JOB_CONTROL)
8103 #define EXECCMD (builtintab + 7 + \
8104 2 * ENABLE_ASH_BUILTIN_TEST + \
8105 ENABLE_ASH_ALIAS + \
8106 ENABLE_ASH_JOB_CONTROL + \
8107 ENABLE_ASH_CMDCMD + \
8108 ENABLE_ASH_BUILTIN_ECHO)
8111 * Search the table of builtin commands.
8113 static struct builtincmd *
8114 find_builtin(const char *name)
8116 struct builtincmd *bp;
8119 name, builtintab, ARRAY_SIZE(builtintab), sizeof(builtintab[0]),
8126 * Execute a simple command.
8128 static int back_exitstatus; /* exit status of backquoted command */
8130 isassignment(const char *p)
8132 const char *q = endofname(p);
8138 bltincmd(int argc, char **argv)
8140 /* Preserve exitstatus of a previous possible redirection
8141 * as POSIX mandates */
8142 return back_exitstatus;
8145 evalcommand(union node *cmd, int flags)
8147 static const struct builtincmd bltin = {
8150 struct stackmark smark;
8152 struct arglist arglist;
8153 struct arglist varlist;
8156 const struct strlist *sp;
8157 struct cmdentry cmdentry;
8165 struct builtincmd *bcmd;
8166 int pseudovarflag = 0;
8168 /* First expand the arguments. */
8169 TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
8170 setstackmark(&smark);
8171 back_exitstatus = 0;
8173 cmdentry.cmdtype = CMDBUILTIN;
8174 cmdentry.u.cmd = &bltin;
8175 varlist.lastp = &varlist.list;
8176 *varlist.lastp = NULL;
8177 arglist.lastp = &arglist.list;
8178 *arglist.lastp = NULL;
8181 if (cmd->ncmd.args) {
8182 bcmd = find_builtin(cmd->ncmd.args->narg.text);
8183 pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
8186 for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
8187 struct strlist **spp;
8189 spp = arglist.lastp;
8190 if (pseudovarflag && isassignment(argp->narg.text))
8191 expandarg(argp, &arglist, EXP_VARTILDE);
8193 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
8195 for (sp = *spp; sp; sp = sp->next)
8199 argv = nargv = stalloc(sizeof(char *) * (argc + 1));
8200 for (sp = arglist.list; sp; sp = sp->next) {
8201 TRACE(("evalcommand arg: %s\n", sp->text));
8202 *nargv++ = sp->text;
8207 if (iflag && funcnest == 0 && argc > 0)
8208 lastarg = nargv[-1];
8211 expredir(cmd->ncmd.redirect);
8212 status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2);
8215 for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
8216 struct strlist **spp;
8219 spp = varlist.lastp;
8220 expandarg(argp, &varlist, EXP_VARTILDE);
8223 * Modify the command lookup path, if a PATH= assignment
8227 if (varequal(p, path))
8231 /* Print the command if xflag is set. */
8234 const char *p = " %s";
8237 dprintf(preverrout_fd, p, expandstr(ps4val()));
8240 for (n = 0; n < 2; n++) {
8242 dprintf(preverrout_fd, p, sp->text);
8250 full_write(preverrout_fd, "\n", 1);
8256 /* Now locate the command. */
8258 const char *oldpath;
8259 int cmd_flag = DO_ERR;
8264 find_command(argv[0], &cmdentry, cmd_flag, path);
8265 if (cmdentry.cmdtype == CMDUNKNOWN) {
8271 /* implement bltin and command here */
8272 if (cmdentry.cmdtype != CMDBUILTIN)
8275 spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
8276 if (cmdentry.u.cmd == EXECCMD)
8278 #if ENABLE_ASH_CMDCMD
8279 if (cmdentry.u.cmd == COMMANDCMD) {
8281 nargv = parse_command_args(argv, &path);
8284 argc -= nargv - argv;
8286 cmd_flag |= DO_NOFUNC;
8294 /* We have a redirection error. */
8296 raise_exception(EXERROR);
8298 exitstatus = status;
8302 /* Execute the command. */
8303 switch (cmdentry.cmdtype) {
8305 /* Fork off a child process if necessary. */
8306 if (!(flags & EV_EXIT) || trap[0]) {
8308 jp = makejob(cmd, 1);
8309 if (forkshell(jp, cmd, FORK_FG) != 0) {
8310 exitstatus = waitforjob(jp);
8316 listsetvar(varlist.list, VEXPORT|VSTACK);
8317 shellexec(argv, path, cmdentry.u.index);
8321 cmdenviron = varlist.list;
8323 struct strlist *list = cmdenviron;
8325 if (spclbltin > 0 || argc == 0) {
8327 if (cmd_is_exec && argc > 1)
8330 listsetvar(list, i);
8332 if (evalbltin(cmdentry.u.cmd, argc, argv)) {
8347 exit_status = j + 128;
8348 exitstatus = exit_status;
8350 if (i == EXINT || spclbltin > 0) {
8352 longjmp(exception_handler->loc, 1);
8359 listsetvar(varlist.list, 0);
8360 if (evalfun(cmdentry.u.func, argc, argv, flags))
8366 popredir(cmd_is_exec);
8368 /* dsl: I think this is intended to be used to support
8369 * '_' in 'vi' command mode during line editing...
8370 * However I implemented that within libedit itself.
8372 setvar("_", lastarg, 0);
8373 popstackmark(&smark);
8377 evalbltin(const struct builtincmd *cmd, int argc, char **argv)
8379 char *volatile savecmdname;
8380 struct jmploc *volatile savehandler;
8381 struct jmploc jmploc;
8384 savecmdname = commandname;
8385 i = setjmp(jmploc.loc);
8388 savehandler = exception_handler;
8389 exception_handler = &jmploc;
8390 commandname = argv[0];
8392 optptr = NULL; /* initialize nextopt */
8393 exitstatus = (*cmd->builtin)(argc, argv);
8394 flush_stdout_stderr();
8396 exitstatus |= ferror(stdout);
8398 commandname = savecmdname;
8400 exception_handler = savehandler;
8406 goodname(const char *p)
8408 return !*endofname(p);
8413 * Search for a command. This is called before we fork so that the
8414 * location of the command will be available in the parent as well as
8415 * the child. The check for "goodname" is an overly conservative
8416 * check that the name will not be subject to expansion.
8419 prehash(union node *n)
8421 struct cmdentry entry;
8423 if (n->type == NCMD && n->ncmd.args && goodname(n->ncmd.args->narg.text))
8424 find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
8428 /* ============ Builtin commands
8430 * Builtin commands whose functions are closely tied to evaluation
8431 * are implemented here.
8435 * Handle break and continue commands. Break, continue, and return are
8436 * all handled by setting the evalskip flag. The evaluation routines
8437 * above all check this flag, and if it is set they start skipping
8438 * commands rather than executing them. The variable skipcount is
8439 * the number of loops to break/continue, or the number of function
8440 * levels to return. (The latter is always 1.) It should probably
8441 * be an error to break out of more loops than exist, but it isn't
8442 * in the standard shell so we don't make it one here.
8445 breakcmd(int argc, char **argv)
8447 int n = argc > 1 ? number(argv[1]) : 1;
8450 ash_msg_and_raise_error(illnum, argv[1]);
8454 evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
8461 /* ============ input.c
8463 * This implements the input routines used by the parser.
8466 #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
8469 INPUT_PUSH_FILE = 1,
8470 INPUT_NOFILE_OK = 2,
8474 * NEOF is returned by parsecmd when it encounters an end of file. It
8475 * must be distinct from NULL, so we use the address of a variable that
8476 * happens to be handy.
8478 static int plinno = 1; /* input line number */
8479 /* number of characters left in input buffer */
8480 static int parsenleft; /* copy of parsefile->nleft */
8481 static int parselleft; /* copy of parsefile->lleft */
8482 /* next character in input buffer */
8483 static char *parsenextc; /* copy of parsefile->nextc */
8485 static int checkkwd;
8486 /* values of checkkwd variable */
8487 #define CHKALIAS 0x1
8494 struct strpush *sp = parsefile->strpush;
8497 #if ENABLE_ASH_ALIAS
8499 if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
8500 checkkwd |= CHKALIAS;
8502 if (sp->string != sp->ap->val) {
8505 sp->ap->flag &= ~ALIASINUSE;
8506 if (sp->ap->flag & ALIASDEAD) {
8507 unalias(sp->ap->name);
8511 parsenextc = sp->prevstring;
8512 parsenleft = sp->prevnleft;
8513 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
8514 parsefile->strpush = sp->prev;
8515 if (sp != &(parsefile->basestrpush))
8524 char *buf = parsefile->buf;
8528 #if ENABLE_FEATURE_EDITING
8529 if (!iflag || parsefile->fd)
8530 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
8532 #if ENABLE_FEATURE_TAB_COMPLETION
8533 line_input_state->path_lookup = pathval();
8535 nr = read_line_input(cmdedit_prompt, buf, BUFSIZ, line_input_state);
8537 /* Ctrl+C pressed */
8546 if (nr < 0 && errno == 0) {
8547 /* Ctrl+D presend */
8552 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
8556 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
8557 int flags = fcntl(0, F_GETFL, 0);
8558 if (flags >= 0 && flags & O_NONBLOCK) {
8559 flags &=~ O_NONBLOCK;
8560 if (fcntl(0, F_SETFL, flags) >= 0) {
8561 out2str("sh: turning off NDELAY mode\n");
8571 * Refill the input buffer and return the next input character:
8573 * 1) If a string was pushed back on the input, pop it;
8574 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
8575 * from a string so we can't refill the buffer, return EOF.
8576 * 3) If the is more stuff in this buffer, use it else call read to fill it.
8577 * 4) Process input up to the next newline, deleting nul characters.
8586 while (parsefile->strpush) {
8587 #if ENABLE_ASH_ALIAS
8588 if (parsenleft == -1 && parsefile->strpush->ap &&
8589 parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
8594 if (--parsenleft >= 0)
8595 return signed_char2int(*parsenextc++);
8597 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
8599 flush_stdout_stderr();
8606 parselleft = parsenleft = EOF_NLEFT;
8613 /* delete nul characters */
8621 memmove(q, q + 1, more);
8625 parsenleft = q - parsenextc - 1;
8631 parsenleft = q - parsenextc - 1;
8643 out2str(parsenextc);
8648 return signed_char2int(*parsenextc++);
8651 #define pgetc_as_macro() (--parsenleft >= 0? signed_char2int(*parsenextc++) : preadbuffer())
8655 return pgetc_as_macro();
8658 #if ENABLE_ASH_OPTIMIZE_FOR_SIZE
8659 #define pgetc_macro() pgetc()
8661 #define pgetc_macro() pgetc_as_macro()
8665 * Same as pgetc(), but ignores PEOA.
8667 #if ENABLE_ASH_ALIAS
8675 } while (c == PEOA);
8682 return pgetc_macro();
8687 * Read a line from the script.
8690 pfgets(char *line, int len)
8696 while (--nleft > 0) {
8712 * Undo the last call to pgetc. Only one character may be pushed back.
8713 * PEOF may be pushed back.
8723 * Push a string back onto the input at this current parsefile level.
8724 * We handle aliases this way.
8727 pushstring(char *s, void *ap)
8734 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
8735 if (parsefile->strpush) {
8736 sp = ckmalloc(sizeof(struct strpush));
8737 sp->prev = parsefile->strpush;
8738 parsefile->strpush = sp;
8740 sp = parsefile->strpush = &(parsefile->basestrpush);
8741 sp->prevstring = parsenextc;
8742 sp->prevnleft = parsenleft;
8743 #if ENABLE_ASH_ALIAS
8744 sp->ap = (struct alias *)ap;
8746 ((struct alias *)ap)->flag |= ALIASINUSE;
8756 * To handle the "." command, a stack of input files is used. Pushfile
8757 * adds a new entry to the stack and popfile restores the previous level.
8762 struct parsefile *pf;
8764 parsefile->nleft = parsenleft;
8765 parsefile->lleft = parselleft;
8766 parsefile->nextc = parsenextc;
8767 parsefile->linno = plinno;
8768 pf = ckmalloc(sizeof(*pf));
8769 pf->prev = parsefile;
8772 pf->basestrpush.prev = NULL;
8779 struct parsefile *pf = parsefile;
8788 parsefile = pf->prev;
8790 parsenleft = parsefile->nleft;
8791 parselleft = parsefile->lleft;
8792 parsenextc = parsefile->nextc;
8793 plinno = parsefile->linno;
8798 * Return to top level.
8803 while (parsefile != &basepf)
8808 * Close the file(s) that the shell is reading commands from. Called
8809 * after a fork is done.
8815 if (parsefile->fd > 0) {
8816 close(parsefile->fd);
8822 * Like setinputfile, but takes an open file descriptor. Call this with
8826 setinputfd(int fd, int push)
8828 fcntl(fd, F_SETFD, FD_CLOEXEC);
8834 if (parsefile->buf == NULL)
8835 parsefile->buf = ckmalloc(IBUFSIZ);
8836 parselleft = parsenleft = 0;
8841 * Set the input to take input from a file. If push is set, push the
8842 * old input onto the stack first.
8845 setinputfile(const char *fname, int flags)
8851 fd = open(fname, O_RDONLY);
8853 if (flags & INPUT_NOFILE_OK)
8855 ash_msg_and_raise_error("can't open %s", fname);
8858 fd2 = copyfd(fd, 10);
8861 ash_msg_and_raise_error("out of file descriptors");
8864 setinputfd(fd, flags & INPUT_PUSH_FILE);
8871 * Like setinputfile, but takes input from a string.
8874 setinputstring(char *string)
8878 parsenextc = string;
8879 parsenleft = strlen(string);
8880 parsefile->buf = NULL;
8886 /* ============ mail.c
8888 * Routines to check for mail.
8893 #define MAXMBOXES 10
8895 /* times of mailboxes */
8896 static time_t mailtime[MAXMBOXES];
8897 /* Set if MAIL or MAILPATH is changed. */
8898 static int mail_var_path_changed;
8901 * Print appropriate message(s) if mail has arrived.
8902 * If mail_var_path_changed is set,
8903 * then the value of MAIL has mail_var_path_changed,
8904 * so we just update the values.
8913 struct stackmark smark;
8916 setstackmark(&smark);
8917 mpath = mpathset() ? mpathval() : mailval();
8918 for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) {
8919 p = padvance(&mpath, nullstr);
8924 for (q = p; *q; q++);
8929 q[-1] = '\0'; /* delete trailing '/' */
8930 if (stat(p, &statb) < 0) {
8934 if (!mail_var_path_changed && statb.st_mtime != *mtp) {
8937 pathopt ? pathopt : "you have mail"
8940 *mtp = statb.st_mtime;
8942 mail_var_path_changed = 0;
8943 popstackmark(&smark);
8947 changemail(const char *val)
8949 mail_var_path_changed++;
8952 #endif /* ASH_MAIL */
8955 /* ============ ??? */
8958 * Set the shell parameters.
8961 setparam(char **argv)
8967 for (nparam = 0; argv[nparam]; nparam++);
8968 ap = newparam = ckmalloc((nparam + 1) * sizeof(*ap));
8970 *ap++ = ckstrdup(*argv++);
8973 freeparam(&shellparam);
8974 shellparam.malloc = 1;
8975 shellparam.nparam = nparam;
8976 shellparam.p = newparam;
8977 #if ENABLE_ASH_GETOPTS
8978 shellparam.optind = 1;
8979 shellparam.optoff = -1;
8984 * Process shell options. The global variable argptr contains a pointer
8985 * to the argument list; we advance it past the options.
8988 minus_o(char *name, int val)
8993 for (i = 0; i < NOPTS; i++) {
8994 if (strcmp(name, optnames(i)) == 0) {
8999 ash_msg_and_raise_error("illegal option -o %s", name);
9001 out1str("Current option settings\n");
9002 for (i = 0; i < NOPTS; i++)
9003 out1fmt("%-16s%s\n", optnames(i),
9004 optlist[i] ? "on" : "off");
9007 setoption(int flag, int val)
9011 for (i = 0; i < NOPTS; i++) {
9012 if (optletters(i) == flag) {
9017 ash_msg_and_raise_error("illegal option -%c", flag);
9021 options(int cmdline)
9029 while ((p = *argptr) != NULL) {
9034 if (p[0] == '\0' || LONE_DASH(p)) {
9036 /* "-" means turn off -x and -v */
9039 /* "--" means reset params */
9040 else if (*argptr == NULL)
9043 break; /* "-" or "--" terminates options */
9045 } else if (c == '+') {
9051 while ((c = *p++) != '\0') {
9052 if (c == 'c' && cmdline) {
9053 minusc = p; /* command is after shell args*/
9054 } else if (c == 'o') {
9055 minus_o(*argptr, val);
9058 } else if (cmdline && (c == '-')) { // long options
9059 if (strcmp(p, "login") == 0)
9070 * The shift builtin command.
9073 shiftcmd(int argc, char **argv)
9080 n = number(argv[1]);
9081 if (n > shellparam.nparam)
9082 ash_msg_and_raise_error("can't shift that many");
9084 shellparam.nparam -= n;
9085 for (ap1 = shellparam.p; --n >= 0; ap1++) {
9086 if (shellparam.malloc)
9090 while ((*ap2++ = *ap1++) != NULL);
9091 #if ENABLE_ASH_GETOPTS
9092 shellparam.optind = 1;
9093 shellparam.optoff = -1;
9100 * POSIX requires that 'set' (but not export or readonly) output the
9101 * variables in lexicographic order - by the locale's collating order (sigh).
9102 * Maybe we could keep them in an ordered balanced binary tree
9103 * instead of hashed lists.
9104 * For now just roll 'em through qsort for printing...
9107 showvars(const char *sep_prefix, int on, int off)
9112 ep = listvars(on, off, &epend);
9113 qsort(ep, epend - ep, sizeof(char *), vpcmp);
9115 sep = *sep_prefix ? " " : sep_prefix;
9117 for (; ep < epend; ep++) {
9121 p = strchrnul(*ep, '=');
9124 q = single_quote(++p);
9125 out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q);
9131 * The set command builtin.
9134 setcmd(int argc, char **argv)
9137 return showvars(nullstr, 0, VUNSET);
9141 if (*argptr != NULL) {
9148 #if ENABLE_ASH_RANDOM_SUPPORT
9149 /* Roughly copied from bash.. */
9151 change_random(const char *value)
9153 if (value == NULL) {
9154 /* "get", generate */
9157 rseed = rseed * 1103515245 + 12345;
9158 sprintf(buf, "%d", (unsigned int)((rseed & 32767)));
9159 /* set without recursion */
9160 setvar(vrandom.text, buf, VNOFUNC);
9161 vrandom.flags &= ~VNOFUNC;
9164 rseed = strtoul(value, (char **)NULL, 10);
9169 #if ENABLE_ASH_GETOPTS
9171 getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff)
9180 if (*param_optind < 1)
9182 optnext = optfirst + *param_optind - 1;
9184 if (*param_optind <= 1 || *optoff < 0 || strlen(optnext[-1]) < *optoff)
9187 p = optnext[-1] + *optoff;
9188 if (p == NULL || *p == '\0') {
9189 /* Current word is done, advance */
9191 if (p == NULL || *p != '-' || *++p == '\0') {
9198 if (LONE_DASH(p)) /* check for "--" */
9203 for (q = optstr; *q != c; ) {
9205 if (optstr[0] == ':') {
9208 err |= setvarsafe("OPTARG", s, 0);
9210 fprintf(stderr, "Illegal option -%c\n", c);
9221 if (*p == '\0' && (p = *optnext) == NULL) {
9222 if (optstr[0] == ':') {
9225 err |= setvarsafe("OPTARG", s, 0);
9228 fprintf(stderr, "No arg for -%c option\n", c);
9237 err |= setvarsafe("OPTARG", p, 0);
9240 err |= setvarsafe("OPTARG", nullstr, 0);
9242 *optoff = p ? p - *(optnext - 1) : -1;
9243 *param_optind = optnext - optfirst + 1;
9244 fmtstr(s, sizeof(s), "%d", *param_optind);
9245 err |= setvarsafe("OPTIND", s, VNOFUNC);
9248 err |= setvarsafe(optvar, s, 0);
9252 flush_stdout_stderr();
9253 raise_exception(EXERROR);
9259 * The getopts builtin. Shellparam.optnext points to the next argument
9260 * to be processed. Shellparam.optptr points to the next character to
9261 * be processed in the current argument. If shellparam.optnext is NULL,
9262 * then it's the first time getopts has been called.
9265 getoptscmd(int argc, char **argv)
9270 ash_msg_and_raise_error("usage: getopts optstring var [arg]");
9272 optbase = shellparam.p;
9273 if (shellparam.optind > shellparam.nparam + 1) {
9274 shellparam.optind = 1;
9275 shellparam.optoff = -1;
9279 if (shellparam.optind > argc - 2) {
9280 shellparam.optind = 1;
9281 shellparam.optoff = -1;
9285 return getopts(argv[1], argv[2], optbase, &shellparam.optind,
9286 &shellparam.optoff);
9288 #endif /* ASH_GETOPTS */
9291 /* ============ Shell parser */
9293 static int tokpushback; /* last token pushed back */
9294 #define NEOF ((union node *)&tokpushback)
9295 static int parsebackquote; /* nonzero if we are inside backquotes */
9296 static int lasttoken; /* last token read */
9297 static char *wordtext; /* text of last word returned by readtoken */
9298 static struct nodelist *backquotelist;
9299 static union node *redirnode;
9300 static struct heredoc *heredoc;
9301 static int quoteflag; /* set if (part of) last token was quoted */
9303 static void raise_error_syntax(const char *) ATTRIBUTE_NORETURN;
9305 raise_error_syntax(const char *msg)
9307 ash_msg_and_raise_error("syntax error: %s", msg);
9312 * Called when an unexpected token is read during the parse. The argument
9313 * is the token that is expected, or -1 if more than one type of token can
9314 * occur at this point.
9316 static void raise_error_unexpected_syntax(int) ATTRIBUTE_NORETURN;
9318 raise_error_unexpected_syntax(int token)
9323 l = sprintf(msg, "%s unexpected", tokname(lasttoken));
9325 sprintf(msg + l, " (expecting %s)", tokname(token));
9326 raise_error_syntax(msg);
9330 #define EOFMARKLEN 79
9333 struct heredoc *next; /* next here document in list */
9334 union node *here; /* redirection node */
9335 char *eofmark; /* string indicating end of input */
9336 int striptabs; /* if set, strip leading tabs */
9339 static struct heredoc *heredoclist; /* list of here documents to read */
9341 /* parsing is heavily cross-recursive, need these forward decls */
9342 static union node *andor(void);
9343 static union node *pipeline(void);
9344 static union node *parse_command(void);
9345 static void parseheredoc(void);
9346 static char peektoken(void);
9347 static int readtoken(void);
9352 union node *n1, *n2, *n3;
9355 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9356 if (nlflag == 2 && peektoken())
9362 if (tok == TBACKGND) {
9363 if (n2->type == NPIPE) {
9364 n2->npipe.backgnd = 1;
9366 if (n2->type != NREDIR) {
9367 n3 = stalloc(sizeof(struct nredir));
9369 n3->nredir.redirect = NULL;
9372 n2->type = NBACKGND;
9378 n3 = stalloc(sizeof(struct nbinary));
9380 n3->nbinary.ch1 = n1;
9381 n3->nbinary.ch2 = n2;
9397 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9405 pungetc(); /* push back EOF on input */
9409 raise_error_unexpected_syntax(-1);
9419 union node *n1, *n2, *n3;
9427 } else if (t == TOR) {
9433 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9435 n3 = stalloc(sizeof(struct nbinary));
9437 n3->nbinary.ch1 = n1;
9438 n3->nbinary.ch2 = n2;
9446 union node *n1, *n2, *pipenode;
9447 struct nodelist *lp, *prev;
9451 TRACE(("pipeline: entered\n"));
9452 if (readtoken() == TNOT) {
9454 checkkwd = CHKKWD | CHKALIAS;
9457 n1 = parse_command();
9458 if (readtoken() == TPIPE) {
9459 pipenode = stalloc(sizeof(struct npipe));
9460 pipenode->type = NPIPE;
9461 pipenode->npipe.backgnd = 0;
9462 lp = stalloc(sizeof(struct nodelist));
9463 pipenode->npipe.cmdlist = lp;
9467 lp = stalloc(sizeof(struct nodelist));
9468 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9469 lp->n = parse_command();
9471 } while (readtoken() == TPIPE);
9477 n2 = stalloc(sizeof(struct nnot));
9490 n = stalloc(sizeof(struct narg));
9492 n->narg.next = NULL;
9493 n->narg.text = wordtext;
9494 n->narg.backquote = backquotelist;
9499 fixredir(union node *n, const char *text, int err)
9501 TRACE(("Fix redir %s %d\n", text, err));
9503 n->ndup.vname = NULL;
9505 if (isdigit(text[0]) && text[1] == '\0')
9506 n->ndup.dupfd = text[0] - '0';
9507 else if (LONE_DASH(text))
9511 raise_error_syntax("Bad fd number");
9512 n->ndup.vname = makename();
9517 * Returns true if the text contains nothing to expand (no dollar signs
9521 noexpand(char *text)
9527 while ((c = *p++) != '\0') {
9528 if (c == CTLQUOTEMARK)
9532 else if (SIT(c, BASESYNTAX) == CCTL)
9541 union node *n = redirnode;
9543 if (readtoken() != TWORD)
9544 raise_error_unexpected_syntax(-1);
9545 if (n->type == NHERE) {
9546 struct heredoc *here = heredoc;
9552 TRACE(("Here document %d\n", n->type));
9553 if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
9554 raise_error_syntax("Illegal eof marker for << redirection");
9555 rmescapes(wordtext);
9556 here->eofmark = wordtext;
9558 if (heredoclist == NULL)
9561 for (p = heredoclist; p->next; p = p->next);
9564 } else if (n->type == NTOFD || n->type == NFROMFD) {
9565 fixredir(n, wordtext, 0);
9567 n->nfile.fname = makename();
9574 union node *args, **app;
9575 union node *n = NULL;
9576 union node *vars, **vpp;
9577 union node **rpp, *redir;
9587 savecheckkwd = CHKALIAS;
9589 checkkwd = savecheckkwd;
9590 switch (readtoken()) {
9592 n = stalloc(sizeof(struct narg));
9594 n->narg.text = wordtext;
9595 n->narg.backquote = backquotelist;
9596 if (savecheckkwd && isassignment(wordtext)) {
9598 vpp = &n->narg.next;
9601 app = &n->narg.next;
9606 *rpp = n = redirnode;
9607 rpp = &n->nfile.next;
9608 parsefname(); /* read name of redirection file */
9611 if (args && app == &args->narg.next
9614 struct builtincmd *bcmd;
9617 /* We have a function */
9618 if (readtoken() != TRP)
9619 raise_error_unexpected_syntax(TRP);
9620 name = n->narg.text;
9622 || ((bcmd = find_builtin(name)) && IS_BUILTIN_SPECIAL(bcmd))
9624 raise_error_syntax("Bad function name");
9627 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9628 n->narg.next = parse_command();
9641 n = stalloc(sizeof(struct ncmd));
9643 n->ncmd.args = args;
9644 n->ncmd.assign = vars;
9645 n->ncmd.redirect = redir;
9652 union node *n1, *n2;
9653 union node *ap, **app;
9654 union node *cp, **cpp;
9655 union node *redir, **rpp;
9662 switch (readtoken()) {
9664 raise_error_unexpected_syntax(-1);
9667 n1 = stalloc(sizeof(struct nif));
9669 n1->nif.test = list(0);
9670 if (readtoken() != TTHEN)
9671 raise_error_unexpected_syntax(TTHEN);
9672 n1->nif.ifpart = list(0);
9674 while (readtoken() == TELIF) {
9675 n2->nif.elsepart = stalloc(sizeof(struct nif));
9676 n2 = n2->nif.elsepart;
9678 n2->nif.test = list(0);
9679 if (readtoken() != TTHEN)
9680 raise_error_unexpected_syntax(TTHEN);
9681 n2->nif.ifpart = list(0);
9683 if (lasttoken == TELSE)
9684 n2->nif.elsepart = list(0);
9686 n2->nif.elsepart = NULL;
9694 n1 = stalloc(sizeof(struct nbinary));
9695 n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
9696 n1->nbinary.ch1 = list(0);
9699 TRACE(("expecting DO got %s %s\n", tokname(got),
9700 got == TWORD ? wordtext : ""));
9701 raise_error_unexpected_syntax(TDO);
9703 n1->nbinary.ch2 = list(0);
9708 if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
9709 raise_error_syntax("Bad for loop variable");
9710 n1 = stalloc(sizeof(struct nfor));
9712 n1->nfor.var = wordtext;
9713 checkkwd = CHKKWD | CHKALIAS;
9714 if (readtoken() == TIN) {
9716 while (readtoken() == TWORD) {
9717 n2 = stalloc(sizeof(struct narg));
9719 n2->narg.text = wordtext;
9720 n2->narg.backquote = backquotelist;
9722 app = &n2->narg.next;
9726 if (lasttoken != TNL && lasttoken != TSEMI)
9727 raise_error_unexpected_syntax(-1);
9729 n2 = stalloc(sizeof(struct narg));
9731 n2->narg.text = (char *)dolatstr;
9732 n2->narg.backquote = NULL;
9733 n2->narg.next = NULL;
9736 * Newline or semicolon here is optional (but note
9737 * that the original Bourne shell only allowed NL).
9739 if (lasttoken != TNL && lasttoken != TSEMI)
9742 checkkwd = CHKNL | CHKKWD | CHKALIAS;
9743 if (readtoken() != TDO)
9744 raise_error_unexpected_syntax(TDO);
9745 n1->nfor.body = list(0);
9749 n1 = stalloc(sizeof(struct ncase));
9751 if (readtoken() != TWORD)
9752 raise_error_unexpected_syntax(TWORD);
9753 n1->ncase.expr = n2 = stalloc(sizeof(struct narg));
9755 n2->narg.text = wordtext;
9756 n2->narg.backquote = backquotelist;
9757 n2->narg.next = NULL;
9759 checkkwd = CHKKWD | CHKALIAS;
9760 } while (readtoken() == TNL);
9761 if (lasttoken != TIN)
9762 raise_error_unexpected_syntax(TIN);
9763 cpp = &n1->ncase.cases;
9765 checkkwd = CHKNL | CHKKWD;
9767 while (t != TESAC) {
9768 if (lasttoken == TLP)
9770 *cpp = cp = stalloc(sizeof(struct nclist));
9772 app = &cp->nclist.pattern;
9774 *app = ap = stalloc(sizeof(struct narg));
9776 ap->narg.text = wordtext;
9777 ap->narg.backquote = backquotelist;
9778 if (readtoken() != TPIPE)
9780 app = &ap->narg.next;
9783 ap->narg.next = NULL;
9784 if (lasttoken != TRP)
9785 raise_error_unexpected_syntax(TRP);
9786 cp->nclist.body = list(2);
9788 cpp = &cp->nclist.next;
9790 checkkwd = CHKNL | CHKKWD;
9794 raise_error_unexpected_syntax(TENDCASE);
9801 n1 = stalloc(sizeof(struct nredir));
9802 n1->type = NSUBSHELL;
9803 n1->nredir.n = list(0);
9804 n1->nredir.redirect = NULL;
9817 if (readtoken() != t)
9818 raise_error_unexpected_syntax(t);
9821 /* Now check for redirection which may follow command */
9822 checkkwd = CHKKWD | CHKALIAS;
9824 while (readtoken() == TREDIR) {
9825 *rpp = n2 = redirnode;
9826 rpp = &n2->nfile.next;
9832 if (n1->type != NSUBSHELL) {
9833 n2 = stalloc(sizeof(struct nredir));
9838 n1->nredir.redirect = redir;
9844 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
9845 * is not NULL, read a here document. In the latter case, eofmark is the
9846 * word which marks the end of the document and striptabs is true if
9847 * leading tabs should be stripped from the document. The argument firstc
9848 * is the first character of the input token or document.
9850 * Because C does not have internal subroutines, I have simulated them
9851 * using goto's to implement the subroutine linkage. The following macros
9852 * will run code that appears at the end of readtoken1.
9855 static int parsebackquote; /* nonzero if we are inside backquotes */
9857 #define CHECKEND() {goto checkend; checkend_return:;}
9858 #define PARSEREDIR() {goto parseredir; parseredir_return:;}
9859 #define PARSESUB() {goto parsesub; parsesub_return:;}
9860 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
9861 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
9862 #define PARSEARITH() {goto parsearith; parsearith_return:;}
9865 readtoken1(int firstc, int syntax, char *eofmark, int striptabs)
9870 char line[EOFMARKLEN + 1];
9871 struct nodelist *bqlist = 0;
9874 int varnest = 0; /* levels of variables expansion */
9875 int arinest = 0; /* levels of arithmetic expansion */
9876 int parenlevel = 0; /* levels of parens in arithmetic */
9877 int dqvarnest = 0; /* levels of variables expansion within double quotes */
9879 int prevsyntax = 0; /* syntax before arithmetic */
9881 /* Avoid longjmp clobbering */
9894 startlinno = plinno;
9896 if (syntax == DQSYNTAX)
9906 loop: { /* for each line, until end of word */
9907 CHECKEND(); /* set c to PEOF if at end of here document */
9908 for (;;) { /* until end of line or end of word */
9909 CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
9910 switch (SIT(c, syntax)) {
9911 case CNL: /* '\n' */
9912 if (syntax == BASESYNTAX)
9913 goto endword; /* exit outer loop */
9919 goto loop; /* continue outer loop */
9924 if (eofmark == NULL || dblquote)
9925 USTPUTC(CTLESC, out);
9928 case CBACK: /* backslash */
9931 USTPUTC(CTLESC, out);
9934 } else if (c == '\n') {
9939 c != '\\' && c != '`' &&
9944 USTPUTC(CTLESC, out);
9947 if (SIT(c, SQSYNTAX) == CCTL)
9948 USTPUTC(CTLESC, out);
9956 if (eofmark == NULL) {
9957 USTPUTC(CTLQUOTEMARK, out);
9965 if (eofmark != NULL && arinest == 0
9970 if (dqvarnest == 0) {
9971 syntax = BASESYNTAX;
9978 case CVAR: /* '$' */
9979 PARSESUB(); /* parse substitution */
9981 case CENDVAR: /* '}' */
9984 if (dqvarnest > 0) {
9987 USTPUTC(CTLENDVAR, out);
9992 #if ENABLE_ASH_MATH_SUPPORT
9993 case CLP: /* '(' in arithmetic */
9997 case CRP: /* ')' in arithmetic */
9998 if (parenlevel > 0) {
10002 if (pgetc() == ')') {
10003 if (--arinest == 0) {
10004 USTPUTC(CTLENDARI, out);
10005 syntax = prevsyntax;
10006 if (syntax == DQSYNTAX)
10014 * unbalanced parens
10015 * (don't 2nd guess - no error)
10023 case CBQUOTE: /* '`' */
10027 goto endword; /* exit outer loop */
10032 goto endword; /* exit outer loop */
10033 #if ENABLE_ASH_ALIAS
10043 #if ENABLE_ASH_MATH_SUPPORT
10044 if (syntax == ARISYNTAX)
10045 raise_error_syntax("Missing '))'");
10047 if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
10048 raise_error_syntax("Unterminated quoted string");
10049 if (varnest != 0) {
10050 startlinno = plinno;
10052 raise_error_syntax("Missing '}'");
10054 USTPUTC('\0', out);
10055 len = out - (char *)stackblock();
10056 out = stackblock();
10057 if (eofmark == NULL) {
10058 if ((c == '>' || c == '<')
10061 && (*out == '\0' || isdigit(*out))) {
10063 return lasttoken = TREDIR;
10068 quoteflag = quotef;
10069 backquotelist = bqlist;
10070 grabstackblock(len);
10074 /* end of readtoken routine */
10077 * Check to see whether we are at the end of the here document. When this
10078 * is called, c is set to the first character of the next input line. If
10079 * we are at the end of the here document, this routine sets the c to PEOF.
10083 #if ENABLE_ASH_ALIAS
10089 while (c == '\t') {
10093 if (c == *eofmark) {
10094 if (pfgets(line, sizeof(line)) != NULL) {
10098 for (q = eofmark + 1; *q && *p == *q; p++, q++);
10099 if (*p == '\n' && *q == '\0') {
10102 needprompt = doprompt;
10104 pushstring(line, NULL);
10109 goto checkend_return;
10113 * Parse a redirection operator. The variable "out" points to a string
10114 * specifying the fd to be redirected. The variable "c" contains the
10115 * first character of the redirection operator.
10121 np = stalloc(sizeof(struct nfile));
10126 np->type = NAPPEND;
10128 np->type = NCLOBBER;
10135 } else { /* c == '<' */
10140 if (sizeof(struct nfile) != sizeof(struct nhere)) {
10141 np = stalloc(sizeof(struct nhere));
10145 heredoc = stalloc(sizeof(struct heredoc));
10146 heredoc->here = np;
10149 heredoc->striptabs = 1;
10151 heredoc->striptabs = 0;
10157 np->type = NFROMFD;
10161 np->type = NFROMTO;
10171 np->nfile.fd = fd - '0';
10173 goto parseredir_return;
10177 * Parse a substitution. At this point, we have read the dollar sign
10178 * and nothing else.
10181 /* is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
10182 * (assuming ascii char codes, as the original implementation did) */
10183 #define is_special(c) \
10184 ((((unsigned int)c) - 33 < 32) \
10185 && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
10191 static const char types[] = "}-+?=";
10195 c <= PEOA_OR_PEOF ||
10196 (c != '(' && c != '{' && !is_name(c) && !is_special(c))
10200 } else if (c == '(') { /* $(command) or $((arith)) */
10201 if (pgetc() == '(') {
10202 #if ENABLE_ASH_MATH_SUPPORT
10205 raise_error_syntax("We unsupport $((arith))");
10212 USTPUTC(CTLVAR, out);
10213 typeloc = out - (char *)stackblock();
10214 USTPUTC(VSNORMAL, out);
10215 subtype = VSNORMAL;
10223 subtype = VSLENGTH;
10227 if (c > PEOA_OR_PEOF && is_name(c)) {
10231 } while (c > PEOA_OR_PEOF && is_in_name(c));
10232 } else if (isdigit(c)) {
10236 } while (isdigit(c));
10237 } else if (is_special(c)) {
10241 badsub: raise_error_syntax("Bad substitution");
10245 if (subtype == 0) {
10252 p = strchr(types, c);
10255 subtype = p - types + VSNORMAL;
10261 subtype = c == '#' ? VSTRIMLEFT :
10274 if (dblquote || arinest)
10276 *((char *)stackblock() + typeloc) = subtype | flags;
10277 if (subtype != VSNORMAL) {
10279 if (dblquote || arinest) {
10284 goto parsesub_return;
10288 * Called to parse command substitutions. Newstyle is set if the command
10289 * is enclosed inside $(...); nlpp is a pointer to the head of the linked
10290 * list of commands (passed by reference), and savelen is the number of
10291 * characters on the top of the stack which must be preserved.
10294 struct nodelist **nlpp;
10297 char *volatile str;
10298 struct jmploc jmploc;
10299 struct jmploc *volatile savehandler;
10301 int saveprompt = 0;
10303 (void) &saveprompt;
10306 savepbq = parsebackquote;
10307 if (setjmp(jmploc.loc)) {
10310 parsebackquote = 0;
10311 exception_handler = savehandler;
10312 longjmp(exception_handler->loc, 1);
10316 savelen = out - (char *)stackblock();
10318 str = ckmalloc(savelen);
10319 memcpy(str, stackblock(), savelen);
10321 savehandler = exception_handler;
10322 exception_handler = &jmploc;
10325 /* We must read until the closing backquote, giving special
10326 treatment to some slashes, and then push the string and
10327 reread it as input, interpreting it normally. */
10334 STARTSTACKSTR(pout);
10351 * If eating a newline, avoid putting
10352 * the newline into the new character
10353 * stream (via the STPUTC after the
10358 if (pc != '\\' && pc != '`' && pc != '$'
10359 && (!dblquote || pc != '"'))
10360 STPUTC('\\', pout);
10361 if (pc > PEOA_OR_PEOF) {
10367 #if ENABLE_ASH_ALIAS
10370 startlinno = plinno;
10371 raise_error_syntax("EOF in backquote substitution");
10375 needprompt = doprompt;
10384 STPUTC('\0', pout);
10385 psavelen = pout - (char *)stackblock();
10386 if (psavelen > 0) {
10387 pstr = grabstackstr(pout);
10388 setinputstring(pstr);
10393 nlpp = &(*nlpp)->next;
10394 *nlpp = stalloc(sizeof(**nlpp));
10395 (*nlpp)->next = NULL;
10396 parsebackquote = oldstyle;
10399 saveprompt = doprompt;
10406 doprompt = saveprompt;
10407 else if (readtoken() != TRP)
10408 raise_error_unexpected_syntax(TRP);
10413 * Start reading from old file again, ignoring any pushed back
10414 * tokens left from the backquote parsing
10419 while (stackblocksize() <= savelen)
10421 STARTSTACKSTR(out);
10423 memcpy(out, str, savelen);
10424 STADJUST(savelen, out);
10430 parsebackquote = savepbq;
10431 exception_handler = savehandler;
10432 if (arinest || dblquote)
10433 USTPUTC(CTLBACKQ | CTLQUOTE, out);
10435 USTPUTC(CTLBACKQ, out);
10437 goto parsebackq_oldreturn;
10438 goto parsebackq_newreturn;
10441 #if ENABLE_ASH_MATH_SUPPORT
10443 * Parse an arithmetic expansion (indicate start of one and set state)
10446 if (++arinest == 1) {
10447 prevsyntax = syntax;
10448 syntax = ARISYNTAX;
10449 USTPUTC(CTLARI, out);
10456 * we collapse embedded arithmetic expansion to
10457 * parenthesis, which should be equivalent
10461 goto parsearith_return;
10465 } /* end of readtoken */
10468 * Read the next input token.
10469 * If the token is a word, we set backquotelist to the list of cmds in
10470 * backquotes. We set quoteflag to true if any part of the word was
10472 * If the token is TREDIR, then we set redirnode to a structure containing
10474 * In all cases, the variable startlinno is set to the number of the line
10475 * on which the token starts.
10477 * [Change comment: here documents and internal procedures]
10478 * [Readtoken shouldn't have any arguments. Perhaps we should make the
10479 * word parsing code into a separate routine. In this case, readtoken
10480 * doesn't need to have any internal procedures, but parseword does.
10481 * We could also make parseoperator in essence the main routine, and
10482 * have parseword (readtoken1?) handle both words and redirection.]
10484 #define NEW_xxreadtoken
10485 #ifdef NEW_xxreadtoken
10486 /* singles must be first! */
10487 static const char xxreadtoken_chars[7] = { '\n', '(', ')', '&', '|', ';', 0 };
10489 static const char xxreadtoken_tokens[] = {
10490 TNL, TLP, TRP, /* only single occurrence allowed */
10491 TBACKGND, TPIPE, TSEMI, /* if single occurrence */
10492 TEOF, /* corresponds to trailing nul */
10493 TAND, TOR, TENDCASE, /* if double occurrence */
10496 #define xxreadtoken_doubles \
10497 (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
10498 #define xxreadtoken_singles \
10499 (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
10513 startlinno = plinno;
10514 for (;;) { /* until token or start of word found */
10517 if ((c != ' ') && (c != '\t')
10518 #if ENABLE_ASH_ALIAS
10523 while ((c = pgetc()) != '\n' && c != PEOF);
10525 } else if (c == '\\') {
10526 if (pgetc() != '\n') {
10530 startlinno = ++plinno;
10535 = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
10540 needprompt = doprompt;
10543 p = strchr(xxreadtoken_chars, c);
10546 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
10549 if (p - xxreadtoken_chars >= xxreadtoken_singles) {
10550 if (pgetc() == *p) { /* double occurrence? */
10551 p += xxreadtoken_doubles + 1;
10557 return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
10563 #define RETURN(token) return lasttoken = token
10576 startlinno = plinno;
10577 for (;;) { /* until token or start of word found */
10580 case ' ': case '\t':
10581 #if ENABLE_ASH_ALIAS
10586 while ((c = pgetc()) != '\n' && c != PEOF);
10590 if (pgetc() == '\n') {
10591 startlinno = ++plinno;
10600 needprompt = doprompt;
10605 if (pgetc() == '&')
10610 if (pgetc() == '|')
10615 if (pgetc() == ';')
10628 return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
10631 #endif /* NEW_xxreadtoken */
10638 int alreadyseen = tokpushback;
10641 #if ENABLE_ASH_ALIAS
10650 if (checkkwd & CHKNL) {
10657 if (t != TWORD || quoteflag) {
10662 * check for keywords
10664 if (checkkwd & CHKKWD) {
10665 const char *const *pp;
10667 pp = findkwd(wordtext);
10669 lasttoken = t = pp - tokname_array;
10670 TRACE(("keyword %s recognized\n", tokname(t)));
10675 if (checkkwd & CHKALIAS) {
10676 #if ENABLE_ASH_ALIAS
10678 ap = lookupalias(wordtext, 1);
10681 pushstring(ap->val, ap);
10691 TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
10693 TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
10705 return tokname_array[t][0];
10709 * Read and parse a command. Returns NEOF on end of file. (NULL is a
10710 * valid parse tree indicating a blank line.)
10712 static union node *
10713 parsecmd(int interact)
10718 doprompt = interact;
10720 setprompt(doprompt);
10732 * Input any here documents.
10737 struct heredoc *here;
10740 here = heredoclist;
10747 readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
10748 here->eofmark, here->striptabs);
10749 n = stalloc(sizeof(struct narg));
10750 n->narg.type = NARG;
10751 n->narg.next = NULL;
10752 n->narg.text = wordtext;
10753 n->narg.backquote = backquotelist;
10754 here->here->nhere.doc = n;
10761 * called by editline -- any expansions to the prompt should be added here.
10763 #if ENABLE_ASH_EXPAND_PRMT
10764 static const char *
10765 expandstr(const char *ps)
10769 /* XXX Fix (char *) cast. */
10770 setinputstring((char *)ps);
10771 readtoken1(pgetc(), DQSYNTAX, nullstr, 0);
10774 n.narg.type = NARG;
10775 n.narg.next = NULL;
10776 n.narg.text = wordtext;
10777 n.narg.backquote = backquotelist;
10779 expandarg(&n, NULL, 0);
10780 return stackblock();
10785 * Execute a command or commands contained in a string.
10788 evalstring(char *s, int mask)
10791 struct stackmark smark;
10795 setstackmark(&smark);
10798 while ((n = parsecmd(0)) != NEOF) {
10800 popstackmark(&smark);
10813 * The eval command.
10816 evalcmd(int argc, char **argv)
10825 STARTSTACKSTR(concat);
10828 concat = stack_putstr(p, concat);
10832 STPUTC(' ', concat);
10834 STPUTC('\0', concat);
10835 p = grabstackstr(concat);
10837 evalstring(p, ~SKIPEVAL);
10844 * Read and execute commands. "Top" is nonzero for the top level command
10845 * loop; it turns on prompting if the shell is interactive.
10851 struct stackmark smark;
10855 TRACE(("cmdloop(%d) called\n", top));
10859 setstackmark(&smark);
10862 showjobs(stderr, SHOW_CHANGED);
10865 if (iflag && top) {
10867 #if ENABLE_ASH_MAIL
10871 n = parsecmd(inter);
10872 /* showtree(n); DEBUG */
10874 if (!top || numeof >= 50)
10876 if (!stoppedjobs()) {
10879 out2str("\nUse \"exit\" to leave shell.\n");
10882 } else if (nflag == 0) {
10883 job_warning = (job_warning == 2) ? 1 : 0;
10887 popstackmark(&smark);
10892 return skip & SKIPEVAL;
10899 * Take commands from a file. To be compatible we should do a path
10900 * search for the file, which is necessary to find sub-commands.
10903 find_dot_file(char *name)
10906 const char *path = pathval();
10909 /* don't try this for absolute or relative paths */
10910 if (strchr(name, '/'))
10913 while ((fullname = padvance(&path, name)) != NULL) {
10914 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
10916 * Don't bother freeing here, since it will
10917 * be freed by the caller.
10921 stunalloc(fullname);
10924 /* not found in the PATH */
10925 ash_msg_and_raise_error("%s: not found", name);
10930 dotcmd(int argc, char **argv)
10932 struct strlist *sp;
10933 volatile struct shparam saveparam;
10936 for (sp = cmdenviron; sp; sp = sp->next)
10937 setvareq(ckstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
10939 if (argc >= 2) { /* That's what SVR2 does */
10942 fullname = find_dot_file(argv[1]);
10945 saveparam = shellparam;
10946 shellparam.malloc = 0;
10947 shellparam.nparam = argc - 2;
10948 shellparam.p = argv + 2;
10951 setinputfile(fullname, INPUT_PUSH_FILE);
10952 commandname = fullname;
10957 freeparam(&shellparam);
10958 shellparam = saveparam;
10960 status = exitstatus;
10966 exitcmd(int argc, char **argv)
10971 exitstatus = number(argv[1]);
10972 raise_exception(EXEXIT);
10976 #if ENABLE_ASH_BUILTIN_ECHO
10978 echocmd(int argc, char **argv)
10980 return bb_echo(argv);
10984 #if ENABLE_ASH_BUILTIN_TEST
10986 testcmd(int argc, char **argv)
10988 return test_main(argc, argv);
10993 * Read a file containing shell functions.
10996 readcmdfile(char *name)
10998 setinputfile(name, INPUT_PUSH_FILE);
11004 /* ============ find_command inplementation */
11007 * Resolve a command name. If you change this routine, you may have to
11008 * change the shellexec routine as well.
11011 find_command(char *name, struct cmdentry *entry, int act, const char *path)
11013 struct tblentry *cmdp;
11020 struct builtincmd *bcmd;
11022 /* If name contains a slash, don't use PATH or hash table */
11023 if (strchr(name, '/') != NULL) {
11024 entry->u.index = -1;
11025 if (act & DO_ABS) {
11026 while (stat(name, &statb) < 0) {
11028 if (errno == EINTR)
11031 entry->cmdtype = CMDUNKNOWN;
11035 entry->cmdtype = CMDNORMAL;
11039 /* #if ENABLE_FEATURE_SH_STANDALONE... moved after builtin check */
11041 updatetbl = (path == pathval());
11044 if (strstr(path, "%builtin") != NULL)
11045 act |= DO_ALTBLTIN;
11048 /* If name is in the table, check answer will be ok */
11049 cmdp = cmdlookup(name, 0);
11050 if (cmdp != NULL) {
11053 switch (cmdp->cmdtype) {
11071 } else if (cmdp->rehash == 0)
11072 /* if not invalidated by cd, we're done */
11076 /* If %builtin not in path, check for builtin next */
11077 bcmd = find_builtin(name);
11079 if (IS_BUILTIN_REGULAR(bcmd))
11080 goto builtin_success;
11081 if (act & DO_ALTPATH) {
11082 if (!(act & DO_ALTBLTIN))
11083 goto builtin_success;
11084 } else if (builtinloc <= 0) {
11085 goto builtin_success;
11089 #if ENABLE_FEATURE_SH_STANDALONE
11090 if (find_applet_by_name(name)) {
11091 entry->cmdtype = CMDNORMAL;
11092 entry->u.index = -1;
11097 /* We have to search path. */
11098 prev = -1; /* where to start */
11099 if (cmdp && cmdp->rehash) { /* doing a rehash */
11100 if (cmdp->cmdtype == CMDBUILTIN)
11103 prev = cmdp->param.index;
11109 while ((fullname = padvance(&path, name)) != NULL) {
11110 stunalloc(fullname);
11113 if (prefix(pathopt, "builtin")) {
11115 goto builtin_success;
11117 } else if (!(act & DO_NOFUNC) &&
11118 prefix(pathopt, "func")) {
11119 /* handled below */
11121 /* ignore unimplemented options */
11125 /* if rehash, don't redo absolute path names */
11126 if (fullname[0] == '/' && idx <= prev) {
11129 TRACE(("searchexec \"%s\": no change\n", name));
11132 while (stat(fullname, &statb) < 0) {
11134 if (errno == EINTR)
11137 if (errno != ENOENT && errno != ENOTDIR)
11141 e = EACCES; /* if we fail, this will be the error */
11142 if (!S_ISREG(statb.st_mode))
11144 if (pathopt) { /* this is a %func directory */
11145 stalloc(strlen(fullname) + 1);
11146 readcmdfile(fullname);
11147 cmdp = cmdlookup(name, 0);
11148 if (cmdp == NULL || cmdp->cmdtype != CMDFUNCTION)
11149 ash_msg_and_raise_error("%s not defined in %s", name, fullname);
11150 stunalloc(fullname);
11153 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
11155 entry->cmdtype = CMDNORMAL;
11156 entry->u.index = idx;
11160 cmdp = cmdlookup(name, 1);
11161 cmdp->cmdtype = CMDNORMAL;
11162 cmdp->param.index = idx;
11167 /* We failed. If there was an entry for this command, delete it */
11168 if (cmdp && updatetbl)
11169 delete_cmd_entry();
11171 ash_msg("%s: %s", name, errmsg(e, "not found"));
11172 entry->cmdtype = CMDUNKNOWN;
11177 entry->cmdtype = CMDBUILTIN;
11178 entry->u.cmd = bcmd;
11182 cmdp = cmdlookup(name, 1);
11183 cmdp->cmdtype = CMDBUILTIN;
11184 cmdp->param.cmd = bcmd;
11188 entry->cmdtype = cmdp->cmdtype;
11189 entry->u = cmdp->param;
11193 /* ============ trap.c */
11196 * The trap builtin.
11199 trapcmd(int argc, char **argv)
11208 for (signo = 0; signo < NSIG; signo++) {
11209 if (trap[signo] != NULL) {
11212 sn = get_signame(signo);
11213 out1fmt("trap -- %s %s\n",
11214 single_quote(trap[signo]), sn);
11224 signo = get_signum(*ap);
11226 ash_msg_and_raise_error("%s: bad trap", *ap);
11229 if (LONE_DASH(action))
11232 action = ckstrdup(action);
11236 trap[signo] = action;
11246 /* ============ Builtins */
11248 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
11250 * Lists available builtins
11253 helpcmd(int argc, char **argv)
11257 out1fmt("\nBuilt-in commands:\n-------------------\n");
11258 for (col = 0, i = 0; i < ARRAY_SIZE(builtintab) ; i++) {
11259 col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
11260 builtintab[i].name + 1);
11266 #if ENABLE_FEATURE_SH_STANDALONE
11267 for (i = 0; i < NUM_APPLETS; i++) {
11268 col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
11276 return EXIT_SUCCESS;
11278 #endif /* FEATURE_SH_EXTRA_QUIET */
11281 * The export and readonly commands.
11284 exportcmd(int argc, char **argv)
11290 int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
11292 if (nextopt("p") != 'p') {
11297 p = strchr(name, '=');
11301 vp = *findvar(hashvar(name), name);
11307 setvar(name, p, flag);
11308 } while ((name = *++aptr) != NULL);
11312 showvars(argv[0], flag, 0);
11317 * Delete a function if it exists.
11320 unsetfunc(const char *name)
11322 struct tblentry *cmdp;
11324 cmdp = cmdlookup(name, 0);
11325 if (cmdp!= NULL && cmdp->cmdtype == CMDFUNCTION)
11326 delete_cmd_entry();
11330 * The unset builtin command. We unset the function before we unset the
11331 * variable to allow a function to be unset when there is a readonly variable
11332 * with the same name.
11335 unsetcmd(int argc, char **argv)
11342 while ((i = nextopt("vf")) != '\0') {
11346 for (ap = argptr; *ap; ap++) {
11362 #include <sys/times.h>
11364 static const unsigned char timescmd_str[] = {
11365 ' ', offsetof(struct tms, tms_utime),
11366 '\n', offsetof(struct tms, tms_stime),
11367 ' ', offsetof(struct tms, tms_cutime),
11368 '\n', offsetof(struct tms, tms_cstime),
11373 timescmd(int ac, char **av)
11375 long clk_tck, s, t;
11376 const unsigned char *p;
11379 clk_tck = sysconf(_SC_CLK_TCK);
11384 t = *(clock_t *)(((char *) &buf) + p[1]);
11386 out1fmt("%ldm%ld.%.3lds%c",
11388 ((t - s * clk_tck) * 1000) / clk_tck,
11390 } while (*(p += 2));
11395 #if ENABLE_ASH_MATH_SUPPORT
11397 dash_arith(const char *s)
11403 result = arith(s, &errcode);
11406 ash_msg_and_raise_error("exponent less than 0");
11408 ash_msg_and_raise_error("divide by zero");
11410 ash_msg_and_raise_error("expression recursion loop detected");
11411 raise_error_syntax(s);
11419 * The let builtin. partial stolen from GNU Bash, the Bourne Again SHell.
11420 * Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
11422 * Copyright (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
11425 letcmd(int argc, char **argv)
11432 ash_msg_and_raise_error("expression expected");
11433 for (ap = argv + 1; *ap; ap++) {
11434 i = dash_arith(*ap);
11439 #endif /* ASH_MATH_SUPPORT */
11442 /* ============ miscbltin.c
11444 * Miscellaneous builtins.
11449 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
11450 typedef enum __rlimit_resource rlim_t;
11454 * The read builtin. The -e option causes backslashes to escape the
11455 * following character.
11457 * This uses unbuffered input, which may be avoidable in some cases.
11460 readcmd(int argc, char **argv)
11472 #if ENABLE_ASH_READ_NCHARS
11476 struct termios tty, old_tty;
11478 #if ENABLE_ASH_READ_TIMEOUT
11482 ts.tv_sec = ts.tv_usec = 0;
11487 #if ENABLE_ASH_READ_NCHARS && ENABLE_ASH_READ_TIMEOUT
11488 while ((i = nextopt("p:rt:n:s")) != '\0')
11489 #elif ENABLE_ASH_READ_NCHARS
11490 while ((i = nextopt("p:rn:s")) != '\0')
11491 #elif ENABLE_ASH_READ_TIMEOUT
11492 while ((i = nextopt("p:rt:")) != '\0')
11494 while ((i = nextopt("p:r")) != '\0')
11499 prompt = optionarg;
11501 #if ENABLE_ASH_READ_NCHARS
11503 nchars = strtol(optionarg, &p, 10);
11505 ash_msg_and_raise_error("invalid count");
11506 nch_flag = (nchars > 0);
11512 #if ENABLE_ASH_READ_TIMEOUT
11514 ts.tv_sec = strtol(optionarg, &p, 10);
11520 ts.tv_usec = strtol(p, &p2, 10);
11522 ash_msg_and_raise_error("invalid timeout");
11524 /* normalize to usec */
11526 ash_msg_and_raise_error("invalid timeout");
11527 while (scale++ < 6)
11531 ash_msg_and_raise_error("invalid timeout");
11533 if ( ! ts.tv_sec && ! ts.tv_usec)
11534 ash_msg_and_raise_error("invalid timeout");
11544 if (prompt && isatty(0)) {
11549 ash_msg_and_raise_error("arg count");
11550 ifs = bltinlookup("IFS");
11553 #if ENABLE_ASH_READ_NCHARS
11554 if (nch_flag || silent) {
11555 tcgetattr(0, &tty);
11558 tty.c_lflag &= ~ICANON;
11559 tty.c_cc[VMIN] = nchars;
11562 tty.c_lflag &= ~(ECHO|ECHOK|ECHONL);
11565 tcsetattr(0, TCSANOW, &tty);
11568 #if ENABLE_ASH_READ_TIMEOUT
11569 if (ts.tv_sec || ts.tv_usec) {
11573 i = select(FD_SETSIZE, &set, NULL, NULL, &ts);
11575 #if ENABLE_ASH_READ_NCHARS
11577 tcsetattr(0, TCSANOW, &old_tty);
11587 #if ENABLE_ASH_READ_NCHARS
11588 while (!nch_flag || nchars--)
11593 if (read(0, &c, 1) != 1) {
11605 if (!rflag && c == '\\') {
11611 if (startword && *ifs == ' ' && strchr(ifs, c)) {
11615 if (ap[1] != NULL && strchr(ifs, c) != NULL) {
11617 setvar(*ap, stackblock(), 0);
11626 #if ENABLE_ASH_READ_NCHARS
11627 if (nch_flag || silent)
11628 tcsetattr(0, TCSANOW, &old_tty);
11632 /* Remove trailing blanks */
11633 while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL)
11635 setvar(*ap, stackblock(), 0);
11636 while (*++ap != NULL)
11637 setvar(*ap, nullstr, 0);
11642 umaskcmd(int argc, char **argv)
11644 static const char permuser[3] = "ugo";
11645 static const char permmode[3] = "rwx";
11646 static const short int permmask[] = {
11647 S_IRUSR, S_IWUSR, S_IXUSR,
11648 S_IRGRP, S_IWGRP, S_IXGRP,
11649 S_IROTH, S_IWOTH, S_IXOTH
11655 int symbolic_mode = 0;
11657 while (nextopt("S") != '\0') {
11668 if (symbolic_mode) {
11672 for (i = 0; i < 3; i++) {
11675 *p++ = permuser[i];
11677 for (j = 0; j < 3; j++) {
11678 if ((mask & permmask[3 * i + j]) == 0) {
11679 *p++ = permmode[j];
11687 out1fmt("%.4o\n", mask);
11690 if (isdigit((unsigned char) *ap)) {
11693 if (*ap >= '8' || *ap < '0')
11694 ash_msg_and_raise_error(illnum, argv[1]);
11695 mask = (mask << 3) + (*ap - '0');
11696 } while (*++ap != '\0');
11699 mask = ~mask & 0777;
11700 if (!bb_parse_mode(ap, &mask)) {
11701 ash_msg_and_raise_error("illegal mode: %s", ap);
11703 umask(~mask & 0777);
11712 * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
11713 * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
11714 * ash by J.T. Conklin.
11722 int factor; /* multiply by to get rlim_{cur,max} values */
11726 static const struct limits limits[] = {
11728 { "time(seconds)", RLIMIT_CPU, 1, 't' },
11730 #ifdef RLIMIT_FSIZE
11731 { "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
11734 { "data(kbytes)", RLIMIT_DATA, 1024, 'd' },
11736 #ifdef RLIMIT_STACK
11737 { "stack(kbytes)", RLIMIT_STACK, 1024, 's' },
11740 { "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
11743 { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' },
11745 #ifdef RLIMIT_MEMLOCK
11746 { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' },
11748 #ifdef RLIMIT_NPROC
11749 { "process", RLIMIT_NPROC, 1, 'p' },
11751 #ifdef RLIMIT_NOFILE
11752 { "nofiles", RLIMIT_NOFILE, 1, 'n' },
11755 { "vmemory(kbytes)", RLIMIT_AS, 1024, 'v' },
11757 #ifdef RLIMIT_LOCKS
11758 { "locks", RLIMIT_LOCKS, 1, 'w' },
11760 { NULL, 0, 0, '\0' }
11763 enum limtype { SOFT = 0x1, HARD = 0x2 };
11766 printlim(enum limtype how, const struct rlimit *limit,
11767 const struct limits *l)
11771 val = limit->rlim_max;
11773 val = limit->rlim_cur;
11775 if (val == RLIM_INFINITY)
11776 out1fmt("unlimited\n");
11779 out1fmt("%lld\n", (long long) val);
11784 ulimitcmd(int argc, char **argv)
11788 enum limtype how = SOFT | HARD;
11789 const struct limits *l;
11792 struct rlimit limit;
11795 while ((optc = nextopt("HSa"
11799 #ifdef RLIMIT_FSIZE
11805 #ifdef RLIMIT_STACK
11814 #ifdef RLIMIT_MEMLOCK
11817 #ifdef RLIMIT_NPROC
11820 #ifdef RLIMIT_NOFILE
11826 #ifdef RLIMIT_LOCKS
11844 for (l = limits; l->option != what; l++)
11847 set = *argptr ? 1 : 0;
11851 if (all || argptr[1])
11852 ash_msg_and_raise_error("too many arguments");
11853 if (strncmp(p, "unlimited\n", 9) == 0)
11854 val = RLIM_INFINITY;
11858 while ((c = *p++) >= '0' && c <= '9') {
11859 val = (val * 10) + (long)(c - '0');
11860 if (val < (rlim_t) 0)
11864 ash_msg_and_raise_error("bad number");
11869 for (l = limits; l->name; l++) {
11870 getrlimit(l->cmd, &limit);
11871 out1fmt("%-20s ", l->name);
11872 printlim(how, &limit, l);
11877 getrlimit(l->cmd, &limit);
11880 limit.rlim_max = val;
11882 limit.rlim_cur = val;
11883 if (setrlimit(l->cmd, &limit) < 0)
11884 ash_msg_and_raise_error("error setting limit (%m)");
11886 printlim(how, &limit, l);
11892 /* ============ Math support */
11894 #if ENABLE_ASH_MATH_SUPPORT
11896 /* Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
11898 Permission is hereby granted, free of charge, to any person obtaining
11899 a copy of this software and associated documentation files (the
11900 "Software"), to deal in the Software without restriction, including
11901 without limitation the rights to use, copy, modify, merge, publish,
11902 distribute, sublicense, and/or sell copies of the Software, and to
11903 permit persons to whom the Software is furnished to do so, subject to
11904 the following conditions:
11906 The above copyright notice and this permission notice shall be
11907 included in all copies or substantial portions of the Software.
11909 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11910 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11911 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
11912 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
11913 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
11914 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
11915 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
11918 /* This is my infix parser/evaluator. It is optimized for size, intended
11919 * as a replacement for yacc-based parsers. However, it may well be faster
11920 * than a comparable parser written in yacc. The supported operators are
11921 * listed in #defines below. Parens, order of operations, and error handling
11922 * are supported. This code is thread safe. The exact expression format should
11923 * be that which POSIX specifies for shells. */
11925 /* The code uses a simple two-stack algorithm. See
11926 * http://www.onthenet.com.au/~grahamis/int2008/week02/lect02.html
11927 * for a detailed explanation of the infix-to-postfix algorithm on which
11928 * this is based (this code differs in that it applies operators immediately
11929 * to the stack instead of adding them to a queue to end up with an
11932 /* To use the routine, call it with an expression string and error return
11936 * Aug 24, 2001 Manuel Novoa III
11938 * Reduced the generated code size by about 30% (i386) and fixed several bugs.
11940 * 1) In arith_apply():
11941 * a) Cached values of *numptr and &(numptr[-1]).
11942 * b) Removed redundant test for zero denominator.
11945 * a) Eliminated redundant code for processing operator tokens by moving
11946 * to a table-based implementation. Also folded handling of parens
11948 * b) Combined all 3 loops which called arith_apply to reduce generated
11949 * code size at the cost of speed.
11951 * 3) The following expressions were treated as valid by the original code:
11952 * 1() , 0! , 1 ( *3 ) .
11953 * These bugs have been fixed by internally enclosing the expression in
11954 * parens and then checking that all binary ops and right parens are
11955 * preceded by a valid expression (NUM_TOKEN).
11957 * Note: It may be desirable to replace Aaron's test for whitespace with
11958 * ctype's isspace() if it is used by another busybox applet or if additional
11959 * whitespace chars should be considered. Look below the "#include"s for a
11960 * precompiler test.
11964 * Aug 26, 2001 Manuel Novoa III
11966 * Return 0 for null expressions. Pointed out by Vladimir Oleynik.
11968 * Merge in Aaron's comments previously posted to the busybox list,
11969 * modified slightly to take account of my changes to the code.
11974 * (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
11976 * - allow access to variable,
11977 * used recursive find value indirection (c=2*2; a="c"; $((a+=2)) produce 6)
11978 * - realize assign syntax (VAR=expr, +=, *= etc)
11979 * - realize exponentiation (** operator)
11980 * - realize comma separated - expr, expr
11981 * - realise ++expr --expr expr++ expr--
11982 * - realise expr ? expr : expr (but, second expr calculate always)
11983 * - allow hexadecimal and octal numbers
11984 * - was restored loses XOR operator
11985 * - remove one goto label, added three ;-)
11986 * - protect $((num num)) as true zero expr (Manuel`s error)
11987 * - always use special isspace(), see comment from bash ;-)
11990 #define arith_isspace(arithval) \
11991 (arithval == ' ' || arithval == '\n' || arithval == '\t')
11993 typedef unsigned char operator;
11995 /* An operator's token id is a bit of a bitfield. The lower 5 bits are the
11996 * precedence, and 3 high bits are an ID unique across operators of that
11997 * precedence. The ID portion is so that multiple operators can have the
11998 * same precedence, ensuring that the leftmost one is evaluated first.
11999 * Consider * and /. */
12001 #define tok_decl(prec,id) (((id)<<5)|(prec))
12002 #define PREC(op) ((op) & 0x1F)
12004 #define TOK_LPAREN tok_decl(0,0)
12006 #define TOK_COMMA tok_decl(1,0)
12008 #define TOK_ASSIGN tok_decl(2,0)
12009 #define TOK_AND_ASSIGN tok_decl(2,1)
12010 #define TOK_OR_ASSIGN tok_decl(2,2)
12011 #define TOK_XOR_ASSIGN tok_decl(2,3)
12012 #define TOK_PLUS_ASSIGN tok_decl(2,4)
12013 #define TOK_MINUS_ASSIGN tok_decl(2,5)
12014 #define TOK_LSHIFT_ASSIGN tok_decl(2,6)
12015 #define TOK_RSHIFT_ASSIGN tok_decl(2,7)
12017 #define TOK_MUL_ASSIGN tok_decl(3,0)
12018 #define TOK_DIV_ASSIGN tok_decl(3,1)
12019 #define TOK_REM_ASSIGN tok_decl(3,2)
12021 /* all assign is right associativity and precedence eq, but (7+3)<<5 > 256 */
12022 #define convert_prec_is_assing(prec) do { if (prec == 3) prec = 2; } while (0)
12024 /* conditional is right associativity too */
12025 #define TOK_CONDITIONAL tok_decl(4,0)
12026 #define TOK_CONDITIONAL_SEP tok_decl(4,1)
12028 #define TOK_OR tok_decl(5,0)
12030 #define TOK_AND tok_decl(6,0)
12032 #define TOK_BOR tok_decl(7,0)
12034 #define TOK_BXOR tok_decl(8,0)
12036 #define TOK_BAND tok_decl(9,0)
12038 #define TOK_EQ tok_decl(10,0)
12039 #define TOK_NE tok_decl(10,1)
12041 #define TOK_LT tok_decl(11,0)
12042 #define TOK_GT tok_decl(11,1)
12043 #define TOK_GE tok_decl(11,2)
12044 #define TOK_LE tok_decl(11,3)
12046 #define TOK_LSHIFT tok_decl(12,0)
12047 #define TOK_RSHIFT tok_decl(12,1)
12049 #define TOK_ADD tok_decl(13,0)
12050 #define TOK_SUB tok_decl(13,1)
12052 #define TOK_MUL tok_decl(14,0)
12053 #define TOK_DIV tok_decl(14,1)
12054 #define TOK_REM tok_decl(14,2)
12056 /* exponent is right associativity */
12057 #define TOK_EXPONENT tok_decl(15,1)
12059 /* For now unary operators. */
12060 #define UNARYPREC 16
12061 #define TOK_BNOT tok_decl(UNARYPREC,0)
12062 #define TOK_NOT tok_decl(UNARYPREC,1)
12064 #define TOK_UMINUS tok_decl(UNARYPREC+1,0)
12065 #define TOK_UPLUS tok_decl(UNARYPREC+1,1)
12067 #define PREC_PRE (UNARYPREC+2)
12069 #define TOK_PRE_INC tok_decl(PREC_PRE, 0)
12070 #define TOK_PRE_DEC tok_decl(PREC_PRE, 1)
12072 #define PREC_POST (UNARYPREC+3)
12074 #define TOK_POST_INC tok_decl(PREC_POST, 0)
12075 #define TOK_POST_DEC tok_decl(PREC_POST, 1)
12077 #define SPEC_PREC (UNARYPREC+4)
12079 #define TOK_NUM tok_decl(SPEC_PREC, 0)
12080 #define TOK_RPAREN tok_decl(SPEC_PREC, 1)
12082 #define NUMPTR (*numstackptr)
12085 tok_have_assign(operator op)
12087 operator prec = PREC(op);
12089 convert_prec_is_assing(prec);
12090 return (prec == PREC(TOK_ASSIGN) ||
12091 prec == PREC_PRE || prec == PREC_POST);
12095 is_right_associativity(operator prec)
12097 return (prec == PREC(TOK_ASSIGN) || prec == PREC(TOK_EXPONENT)
12098 || prec == PREC(TOK_CONDITIONAL));
12101 typedef struct ARITCH_VAR_NUM {
12103 arith_t contidional_second_val;
12104 char contidional_second_val_initialized;
12105 char *var; /* if NULL then is regular number,
12106 else is variable name */
12109 typedef struct CHK_VAR_RECURSIVE_LOOPED {
12111 struct CHK_VAR_RECURSIVE_LOOPED *next;
12112 } chk_var_recursive_looped_t;
12114 static chk_var_recursive_looped_t *prev_chk_var_recursive;
12117 arith_lookup_val(v_n_t *t)
12120 const char * p = lookupvar(t->var);
12125 /* recursive try as expression */
12126 chk_var_recursive_looped_t *cur;
12127 chk_var_recursive_looped_t cur_save;
12129 for (cur = prev_chk_var_recursive; cur; cur = cur->next) {
12130 if (strcmp(cur->var, t->var) == 0) {
12131 /* expression recursion loop detected */
12135 /* save current lookuped var name */
12136 cur = prev_chk_var_recursive;
12137 cur_save.var = t->var;
12138 cur_save.next = cur;
12139 prev_chk_var_recursive = &cur_save;
12141 t->val = arith (p, &errcode);
12142 /* restore previous ptr after recursiving */
12143 prev_chk_var_recursive = cur;
12146 /* allow undefined var as 0 */
12152 /* "applying" a token means performing it on the top elements on the integer
12153 * stack. For a unary operator it will only change the top element, but a
12154 * binary operator will pop two arguments and push a result */
12156 arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
12159 arith_t numptr_val, rez;
12160 int ret_arith_lookup_val;
12162 /* There is no operator that can work without arguments */
12163 if (NUMPTR == numstack) goto err;
12164 numptr_m1 = NUMPTR - 1;
12166 /* check operand is var with noninteger value */
12167 ret_arith_lookup_val = arith_lookup_val(numptr_m1);
12168 if (ret_arith_lookup_val)
12169 return ret_arith_lookup_val;
12171 rez = numptr_m1->val;
12172 if (op == TOK_UMINUS)
12174 else if (op == TOK_NOT)
12176 else if (op == TOK_BNOT)
12178 else if (op == TOK_POST_INC || op == TOK_PRE_INC)
12180 else if (op == TOK_POST_DEC || op == TOK_PRE_DEC)
12182 else if (op != TOK_UPLUS) {
12183 /* Binary operators */
12185 /* check and binary operators need two arguments */
12186 if (numptr_m1 == numstack) goto err;
12188 /* ... and they pop one */
12191 if (op == TOK_CONDITIONAL) {
12192 if (! numptr_m1->contidional_second_val_initialized) {
12193 /* protect $((expr1 ? expr2)) without ": expr" */
12196 rez = numptr_m1->contidional_second_val;
12197 } else if (numptr_m1->contidional_second_val_initialized) {
12198 /* protect $((expr1 : expr2)) without "expr ? " */
12201 numptr_m1 = NUMPTR - 1;
12202 if (op != TOK_ASSIGN) {
12203 /* check operand is var with noninteger value for not '=' */
12204 ret_arith_lookup_val = arith_lookup_val(numptr_m1);
12205 if (ret_arith_lookup_val)
12206 return ret_arith_lookup_val;
12208 if (op == TOK_CONDITIONAL) {
12209 numptr_m1->contidional_second_val = rez;
12211 rez = numptr_m1->val;
12212 if (op == TOK_BOR || op == TOK_OR_ASSIGN)
12214 else if (op == TOK_OR)
12215 rez = numptr_val || rez;
12216 else if (op == TOK_BAND || op == TOK_AND_ASSIGN)
12218 else if (op == TOK_BXOR || op == TOK_XOR_ASSIGN)
12220 else if (op == TOK_AND)
12221 rez = rez && numptr_val;
12222 else if (op == TOK_EQ)
12223 rez = (rez == numptr_val);
12224 else if (op == TOK_NE)
12225 rez = (rez != numptr_val);
12226 else if (op == TOK_GE)
12227 rez = (rez >= numptr_val);
12228 else if (op == TOK_RSHIFT || op == TOK_RSHIFT_ASSIGN)
12229 rez >>= numptr_val;
12230 else if (op == TOK_LSHIFT || op == TOK_LSHIFT_ASSIGN)
12231 rez <<= numptr_val;
12232 else if (op == TOK_GT)
12233 rez = (rez > numptr_val);
12234 else if (op == TOK_LT)
12235 rez = (rez < numptr_val);
12236 else if (op == TOK_LE)
12237 rez = (rez <= numptr_val);
12238 else if (op == TOK_MUL || op == TOK_MUL_ASSIGN)
12240 else if (op == TOK_ADD || op == TOK_PLUS_ASSIGN)
12242 else if (op == TOK_SUB || op == TOK_MINUS_ASSIGN)
12244 else if (op == TOK_ASSIGN || op == TOK_COMMA)
12246 else if (op == TOK_CONDITIONAL_SEP) {
12247 if (numptr_m1 == numstack) {
12248 /* protect $((expr : expr)) without "expr ? " */
12251 numptr_m1->contidional_second_val_initialized = op;
12252 numptr_m1->contidional_second_val = numptr_val;
12253 } else if (op == TOK_CONDITIONAL) {
12255 numptr_val : numptr_m1->contidional_second_val;
12256 } else if (op == TOK_EXPONENT) {
12257 if (numptr_val < 0)
12258 return -3; /* exponent less than 0 */
12263 while (numptr_val--)
12267 } else if (numptr_val==0) /* zero divisor check */
12269 else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
12271 else if (op == TOK_REM || op == TOK_REM_ASSIGN)
12274 if (tok_have_assign(op)) {
12275 char buf[sizeof(arith_t_type)*3 + 2];
12277 if (numptr_m1->var == NULL) {
12281 /* save to shell variable */
12282 #if ENABLE_ASH_MATH_SUPPORT_64
12283 snprintf(buf, sizeof(buf), "%lld", (arith_t_type) rez);
12285 snprintf(buf, sizeof(buf), "%ld", (arith_t_type) rez);
12287 setvar(numptr_m1->var, buf, 0);
12288 /* after saving, make previous value for v++ or v-- */
12289 if (op == TOK_POST_INC)
12291 else if (op == TOK_POST_DEC)
12294 numptr_m1->val = rez;
12295 /* protect geting var value, is number now */
12296 numptr_m1->var = NULL;
12302 /* longest must be first */
12303 static const char op_tokens[] = {
12304 '<','<','=',0, TOK_LSHIFT_ASSIGN,
12305 '>','>','=',0, TOK_RSHIFT_ASSIGN,
12306 '<','<', 0, TOK_LSHIFT,
12307 '>','>', 0, TOK_RSHIFT,
12308 '|','|', 0, TOK_OR,
12309 '&','&', 0, TOK_AND,
12310 '!','=', 0, TOK_NE,
12311 '<','=', 0, TOK_LE,
12312 '>','=', 0, TOK_GE,
12313 '=','=', 0, TOK_EQ,
12314 '|','=', 0, TOK_OR_ASSIGN,
12315 '&','=', 0, TOK_AND_ASSIGN,
12316 '*','=', 0, TOK_MUL_ASSIGN,
12317 '/','=', 0, TOK_DIV_ASSIGN,
12318 '%','=', 0, TOK_REM_ASSIGN,
12319 '+','=', 0, TOK_PLUS_ASSIGN,
12320 '-','=', 0, TOK_MINUS_ASSIGN,
12321 '-','-', 0, TOK_POST_DEC,
12322 '^','=', 0, TOK_XOR_ASSIGN,
12323 '+','+', 0, TOK_POST_INC,
12324 '*','*', 0, TOK_EXPONENT,
12328 '=', 0, TOK_ASSIGN,
12340 '?', 0, TOK_CONDITIONAL,
12341 ':', 0, TOK_CONDITIONAL_SEP,
12342 ')', 0, TOK_RPAREN,
12343 '(', 0, TOK_LPAREN,
12347 #define endexpression &op_tokens[sizeof(op_tokens)-7]
12350 arith(const char *expr, int *perrcode)
12352 char arithval; /* Current character under analysis */
12353 operator lasttok, op;
12356 const char *p = endexpression;
12359 size_t datasizes = strlen(expr) + 2;
12361 /* Stack of integers */
12362 /* The proof that there can be no more than strlen(startbuf)/2+1 integers
12363 * in any given correct or incorrect expression is left as an exercise to
12365 v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
12366 *numstackptr = numstack;
12367 /* Stack of operator tokens */
12368 operator *stack = alloca((datasizes) * sizeof(operator)),
12371 *stackptr++ = lasttok = TOK_LPAREN; /* start off with a left paren */
12372 *perrcode = errcode = 0;
12376 if (arithval == 0) {
12377 if (p == endexpression) {
12378 /* Null expression. */
12382 /* This is only reached after all tokens have been extracted from the
12383 * input stream. If there are still tokens on the operator stack, they
12384 * are to be applied in order. At the end, there should be a final
12385 * result on the integer stack */
12387 if (expr != endexpression + 1) {
12388 /* If we haven't done so already, */
12389 /* append a closing right paren */
12390 expr = endexpression;
12391 /* and let the loop process it. */
12394 /* At this point, we're done with the expression. */
12395 if (numstackptr != numstack+1) {
12396 /* ... but if there isn't, it's bad */
12398 return (*perrcode = -1);
12400 if (numstack->var) {
12401 /* expression is $((var)) only, lookup now */
12402 errcode = arith_lookup_val(numstack);
12405 *perrcode = errcode;
12406 return numstack->val;
12409 /* Continue processing the expression. */
12410 if (arith_isspace(arithval)) {
12411 /* Skip whitespace */
12414 p = endofname(expr);
12416 size_t var_name_size = (p-expr) + 1; /* trailing zero */
12418 numstackptr->var = alloca(var_name_size);
12419 safe_strncpy(numstackptr->var, expr, var_name_size);
12422 numstackptr->contidional_second_val_initialized = 0;
12427 if (isdigit(arithval)) {
12428 numstackptr->var = NULL;
12429 #if ENABLE_ASH_MATH_SUPPORT_64
12430 numstackptr->val = strtoll(expr, (char **) &expr, 0);
12432 numstackptr->val = strtol(expr, (char **) &expr, 0);
12436 for (p = op_tokens; ; p++) {
12440 /* strange operator not found */
12443 for (o = expr; *p && *o == *p; p++)
12450 /* skip tail uncompared token */
12453 /* skip zero delim */
12458 /* post grammar: a++ reduce to num */
12459 if (lasttok == TOK_POST_INC || lasttok == TOK_POST_DEC)
12462 /* Plus and minus are binary (not unary) _only_ if the last
12463 * token was as number, or a right paren (which pretends to be
12464 * a number, since it evaluates to one). Think about it.
12465 * It makes sense. */
12466 if (lasttok != TOK_NUM) {
12482 /* We don't want a unary operator to cause recursive descent on the
12483 * stack, because there can be many in a row and it could cause an
12484 * operator to be evaluated before its argument is pushed onto the
12485 * integer stack. */
12486 /* But for binary operators, "apply" everything on the operator
12487 * stack until we find an operator with a lesser priority than the
12488 * one we have just extracted. */
12489 /* Left paren is given the lowest priority so it will never be
12490 * "applied" in this way.
12491 * if associativity is right and priority eq, applied also skip
12494 if ((prec > 0 && prec < UNARYPREC) || prec == SPEC_PREC) {
12495 /* not left paren or unary */
12496 if (lasttok != TOK_NUM) {
12497 /* binary op must be preceded by a num */
12500 while (stackptr != stack) {
12501 if (op == TOK_RPAREN) {
12502 /* The algorithm employed here is simple: while we don't
12503 * hit an open paren nor the bottom of the stack, pop
12504 * tokens and apply them */
12505 if (stackptr[-1] == TOK_LPAREN) {
12507 /* Any operator directly after a */
12509 /* close paren should consider itself binary */
12513 operator prev_prec = PREC(stackptr[-1]);
12515 convert_prec_is_assing(prec);
12516 convert_prec_is_assing(prev_prec);
12517 if (prev_prec < prec)
12519 /* check right assoc */
12520 if (prev_prec == prec && is_right_associativity(prec))
12523 errcode = arith_apply(*--stackptr, numstack, &numstackptr);
12524 if (errcode) goto ret;
12526 if (op == TOK_RPAREN) {
12531 /* Push this operator to the stack and remember it. */
12532 *stackptr++ = lasttok = op;
12537 #endif /* ASH_MATH_SUPPORT */
12540 /* ============ main() and helpers */
12543 * Called to exit the shell.
12545 static void exitshell(void) ATTRIBUTE_NORETURN;
12553 status = exitstatus;
12554 TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
12555 if (setjmp(loc.loc)) {
12556 if (exception == EXEXIT)
12557 /* dash bug: it just does _exit(exitstatus) here
12558 * but we have to do setjobctl(0) first!
12559 * (bug is still not fixed in dash-0.5.3 - if you run dash
12560 * under Midnight Commander, on exit from dash MC is backgrounded) */
12561 status = exitstatus;
12564 exception_handler = &loc;
12570 flush_stdout_stderr();
12580 /* from input.c: */
12581 basepf.nextc = basepf.buf = basebuf;
12584 signal(SIGCHLD, SIG_DFL);
12589 char ppid[sizeof(int)*3 + 1];
12591 struct stat st1, st2;
12594 for (envp = environ; envp && *envp; envp++) {
12595 if (strchr(*envp, '=')) {
12596 setvareq(*envp, VEXPORT|VTEXTFIXED);
12600 snprintf(ppid, sizeof(ppid), "%u", (unsigned) getppid());
12601 setvar("PPID", ppid, 0);
12603 p = lookupvar("PWD");
12605 if (*p != '/' || stat(p, &st1) || stat(".", &st2)
12606 || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)
12613 * Process the shell command line arguments.
12616 procargs(int argc, char **argv)
12619 const char *xminusc;
12626 for (i = 0; i < NOPTS; i++)
12632 if (*xargv == NULL) {
12634 ash_msg_and_raise_error(bb_msg_requires_arg, "-c");
12637 if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
12641 for (i = 0; i < NOPTS; i++)
12642 if (optlist[i] == 2)
12647 /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
12652 } else if (!sflag) {
12653 setinputfile(*xargv, 0);
12656 commandname = arg0;
12659 shellparam.p = xargv;
12660 #if ENABLE_ASH_GETOPTS
12661 shellparam.optind = 1;
12662 shellparam.optoff = -1;
12664 /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
12666 shellparam.nparam++;
12673 * Read /etc/profile or .profile.
12676 read_profile(const char *name)
12680 if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0)
12689 * This routine is called when an error or an interrupt occurs in an
12690 * interactive shell and control is returned to the main command loop.
12698 /* from input.c: */
12699 parselleft = parsenleft = 0; /* clear input buffer */
12701 /* from parser.c: */
12704 /* from redir.c: */
12709 static short profile_buf[16384];
12710 extern int etext();
12714 * Main routine. We initialize things, parse the arguments, execute
12715 * profiles if we're a login shell, and then call cmdloop to execute
12716 * commands. The setjmp call sets up the location to jump to when an
12717 * exception occurs. When an exception occurs the variable "state"
12718 * is used to figure out how far we had gotten.
12720 int ash_main(int argc, char **argv);
12721 int ash_main(int argc, char **argv)
12724 volatile int state;
12725 struct jmploc jmploc;
12726 struct stackmark smark;
12729 monitor(4, etext, profile_buf, sizeof(profile_buf), 50);
12732 #if ENABLE_FEATURE_EDITING
12733 line_input_state = new_line_input_t(FOR_SHELL | WITH_PATH_LOOKUP);
12736 if (setjmp(jmploc.loc)) {
12746 if (e == EXEXIT || s == 0 || iflag == 0 || shlvl)
12750 outcslow('\n', stderr);
12752 popstackmark(&smark);
12753 FORCE_INT_ON; /* enable interrupts */
12762 exception_handler = &jmploc;
12765 trace_puts("Shell args: ");
12766 trace_puts_args(argv);
12768 rootpid = getpid();
12770 #if ENABLE_ASH_RANDOM_SUPPORT
12771 rseed = rootpid + time(NULL);
12774 setstackmark(&smark);
12775 procargs(argc, argv);
12776 #if ENABLE_FEATURE_EDITING_SAVEHISTORY
12778 const char *hp = lookupvar("HISTFILE");
12781 hp = lookupvar("HOME");
12783 char *defhp = concat_path_file(hp, ".ash_history");
12784 setvar("HISTFILE", defhp, 0);
12790 if (argv[0] && argv[0][0] == '-')
12794 read_profile("/etc/profile");
12797 read_profile(".profile");
12803 getuid() == geteuid() && getgid() == getegid() &&
12807 shinit = lookupvar("ENV");
12808 if (shinit != NULL && *shinit != '\0') {
12809 read_profile(shinit);
12815 evalstring(minusc, 0);
12817 if (sflag || minusc == NULL) {
12818 #if ENABLE_FEATURE_EDITING_SAVEHISTORY
12820 const char *hp = lookupvar("HISTFILE");
12823 line_input_state->hist_file = hp;
12826 state4: /* XXX ??? - why isn't this before the "if" statement */
12834 extern void _mcleanup(void);
12843 const char *applet_name = "debug stuff usage";
12844 int main(int argc, char **argv)
12846 return ash_main(argc, argv);
12852 * Copyright (c) 1989, 1991, 1993, 1994
12853 * The Regents of the University of California. All rights reserved.
12855 * This code is derived from software contributed to Berkeley by
12856 * Kenneth Almquist.
12858 * Redistribution and use in source and binary forms, with or without
12859 * modification, are permitted provided that the following conditions
12861 * 1. Redistributions of source code must retain the above copyright
12862 * notice, this list of conditions and the following disclaimer.
12863 * 2. Redistributions in binary form must reproduce the above copyright
12864 * notice, this list of conditions and the following disclaimer in the
12865 * documentation and/or other materials provided with the distribution.
12866 * 3. Neither the name of the University nor the names of its contributors
12867 * may be used to endorse or promote products derived from this software
12868 * without specific prior written permission.
12870 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
12871 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12872 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12873 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
12874 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12875 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12876 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12877 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12878 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12879 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF