* Copyright (c) 1989, 1991, 1993, 1994
* The Regents of the University of California. All rights reserved.
*
+ * Copyright (c) 1997-2003 Herbert Xu <herbert@debian.org>
+ * was re-ported from NetBSD and debianized.
+ *
+ *
* This code is derived from software contributed to Berkeley by
* Kenneth Almquist.
*
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
- * This version of ash is adapted from the source in Debian's ash 0.3.8-5
- * package.
+ * Original BSD copyright notice is retained at the end of this file.
+ */
+
+/*
+ * rewrite arith.y to micro stack based cryptic algorithm by
+ * Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
*
- * Modified by Erik Andersen <andersee@debian.org> and
- * Vladimir Oleynik <dzo@simtreas.ru> to be used in busybox
+ * Modified by Paul Mundt <lethal@linux-sh.org> (c) 2004 to support
+ * dynamic variables.
*
+ * Modified by Vladimir Oleynik <dzo@simtreas.ru> (c) 2001-2004 to be
+ * used in busybox and size optimizations,
+ * rewrote arith (see notes to this), added locale support,
+ * rewrote dynamic variables.
*
- * Original copyright notice is retained at the end of this file.
*/
-/* These defines allow you to adjust the feature set to be compiled
- * into the ash shell. As a rule, enabling these options will make
- * ash get bigger... With all of these options off, ash adds about
- * 60k to busybox on an x86 system.*/
-
-
-/* Enable job control. This allows you to run jobs in the background,
- * which is great when ash is being used as an interactive shell, but
- * it completely useless for is all you are doing is running scripts.
- * This adds about 2.5k on an x86 system. */
-#undef JOBS
-
-/* This enables alias support in ash. If you want to support things
- * like "alias ls='ls -l'" with ash, enable this. This is only useful
- * when ash is used as an intractive shell. This adds about 1.5k */
-#define ASH_ALIAS
+/*
+ * The follow should be set to reflect the type of system you have:
+ * JOBS -> 1 if you have Berkeley job control, 0 otherwise.
+ * define SYSV if you are running under System V.
+ * define DEBUG=1 to compile in debugging ('set -o debug' to turn on)
+ * define DEBUG=2 to compile in and turn on debugging.
+ *
+ * When debugging is on, debugging info will be written to ./trace and
+ * a quit signal will generate a core dump.
+ */
-/* If you need ash to act as a full Posix shell, with full math
- * support, enable this. This option needs some work, since it
- * doesn't compile right now... */
-#undef ASH_MATH_SUPPORT
-/* Getopts is used by shell procedures to parse positional parameters.
- * You probably want to leave this disabled, and use the busybox getopt
- * applet if you want to do this sort of thing. There are some scripts
- * out there that use it, so it you need it, enable. Most people will
- * leave this disabled. This adds 1k on an x86 system. */
-#undef ASH_GETOPTS
-/* This allows you to override shell builtins and use whatever is on
- * the filesystem. This is most useful when ash is acting as a
- * standalone shell. Adds about 272 bytes. */
-#undef ASH_CMDCMD
+#define IFS_BROKEN
+#define PROFILE 0
-/* Optimize size vs speed as size */
-#define ASH_OPTIMIZE_FOR_SIZE
+#ifdef DEBUG
+#define _GNU_SOURCE
+#endif
-/* Enable this to compile in extra debugging noise. When debugging is
- * on, debugging info will be written to $HOME/trace and a quit signal
- * will generate a core dump. */
-#undef DEBUG
+#include <sys/types.h>
+#include <sys/cdefs.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>
-/* These are here to work with glibc -- Don't change these... */
-#undef FNMATCH_BROKEN
-#undef GLOB_BROKEN
-#undef _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stddef.h>
#include <assert.h>
#include <ctype.h>
#include <dirent.h>
#include <fcntl.h>
#include <limits.h>
#include <paths.h>
-#include <pwd.h>
#include <setjmp.h>
#include <signal.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <stdint.h>
#include <sysexits.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/cdefs.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/time.h>
-#include <sys/times.h>
-#include <sys/types.h>
-#include <sys/wait.h>
+#include <time.h>
+#include <fnmatch.h>
-#if !defined(FNMATCH_BROKEN)
-#include <fnmatch.h>
-#endif
-#if !defined(GLOB_BROKEN)
-#include <glob.h>
+#include "busybox.h"
+#include "pwd_.h"
+
+#ifdef CONFIG_ASH_JOB_CONTROL
+#define JOBS 1
+#else
+#undef JOBS
#endif
-#ifdef JOBS
+#if JOBS
#include <termios.h>
#endif
-#include "busybox.h"
#include "cmdedit.h"
-/*
- * This file was generated by the mksyntax program.
- */
-
-/* Syntax classes */
-#define CWORD 0 /* character is nothing special */
-#define CNL 1 /* newline character */
-#define CBACK 2 /* a backslash character */
-#define CSQUOTE 3 /* single quote */
-#define CDQUOTE 4 /* double quote */
-#define CENDQUOTE 5 /* a terminating quote */
-#define CBQUOTE 6 /* backwards single quote */
-#define CVAR 7 /* a dollar sign */
-#define CENDVAR 8 /* a '}' character */
-#define CLP 9 /* a left paren in arithmetic */
-#define CRP 10 /* a right paren in arithmetic */
-#define CENDFILE 11 /* end of file */
-#define CCTL 12 /* like CWORD, except it must be escaped */
-#define CSPCL 13 /* these terminate a word */
-#define CIGN 14 /* character should be ignored */
+#ifdef __GLIBC__
+/* glibc sucks */
+static int *dash_errno;
+#undef errno
+#define errno (*dash_errno)
+#endif
-/* Syntax classes for is_ functions */
-#define ISDIGIT 01 /* a digit */
-#define ISUPPER 02 /* an upper case letter */
-#define ISLOWER 04 /* a lower case letter */
-#define ISUNDER 010 /* an underscore */
-#define ISSPECL 020 /* the name of a special parameter */
+#if defined(__uClinux__)
+#error "Do not even bother, ash will not run on uClinux"
+#endif
-#define SYNBASE 130
-#define PEOF -130
+#ifdef DEBUG
+#define _DIAGASSERT(assert_expr) assert(assert_expr)
+#else
+#define _DIAGASSERT(assert_expr)
+#endif
-#define PEOA -129
-#define TEOF 0
-#define TNL 1
-#define TSEMI 2
-#define TBACKGND 3
-#define TAND 4
-#define TOR 5
-#define TPIPE 6
-#define TLP 7
-#define TRP 8
-#define TENDCASE 9
-#define TENDBQUOTE 10
-#define TREDIR 11
-#define TWORD 12
-#define TASSIGN 13
-#define TNOT 14
-#define TCASE 15
-#define TDO 16
-#define TDONE 17
-#define TELIF 18
-#define TELSE 19
-#define TESAC 20
-#define TFI 21
-#define TFOR 22
-#define TIF 23
-#define TIN 24
-#define TTHEN 25
-#define TUNTIL 26
-#define TWHILE 27
-#define TBEGIN 28
-#define TEND 29
-
-
-#define BASESYNTAX (basesyntax + SYNBASE)
-#define DQSYNTAX (dqsyntax + SYNBASE)
-#define SQSYNTAX (sqsyntax + SYNBASE)
-#define ARISYNTAX (arisyntax + SYNBASE)
+#ifdef CONFIG_ASH_ALIAS
+/* $NetBSD: alias.h,v 1.5 2002/11/24 22:35:38 christos Exp $ */
-/* control characters in argument strings */
-#define CTLESC '\201'
-#define CTLVAR '\202'
-#define CTLENDVAR '\203'
-#define CTLBACKQ '\204'
-#define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
-/* CTLBACKQ | CTLQUOTE == '\205' */
-#define CTLARI '\206'
-#define CTLENDARI '\207'
-#define CTLQUOTEMARK '\210'
+#define ALIASINUSE 1
+#define ALIASDEAD 2
-#define is_digit(c) ((c)>='0' && (c)<='9')
-#define is_alpha(c) (((c) < CTLESC || (c) > CTLENDARI) && isalpha((unsigned char) (c)))
-#define is_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c))))
-#define is_in_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c))))
-#define is_special(c) ((is_type+SYNBASE)[c] & (ISSPECL|ISDIGIT))
-#define digit_val(c) ((c) - '0')
+struct alias {
+ struct alias *next;
+ char *name;
+ char *val;
+ int flag;
+};
+static struct alias *lookupalias(const char *, int);
+static int aliascmd(int, char **);
+static int unaliascmd(int, char **);
+static void rmaliases(void);
+static int unalias(const char *);
+static void printalias(const struct alias *);
+#endif
-#define _DIAGASSERT(x)
+/* $NetBSD: cd.h,v 1.3 2002/11/24 22:35:39 christos Exp $ */
+static void setpwd(const char *, int);
-#define S_DFL 1 /* default signal handling (SIG_DFL) */
-#define S_CATCH 2 /* signal is caught */
-#define S_IGN 3 /* signal is ignored (SIG_IGN) */
-#define S_HARD_IGN 4 /* signal is ignored permenantly */
-#define S_RESET 5 /* temporary - to reset a hard ignored sig */
+/* $NetBSD: error.h,v 1.15 2002/11/24 22:35:39 christos Exp $ */
-/* variable substitution byte (follows CTLVAR) */
-#define VSTYPE 0x0f /* type of variable substitution */
-#define VSNUL 0x10 /* colon--treat the empty string as unset */
-#define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
+/*
+ * Types of operations (passed to the errmsg routine).
+ */
-/* values of VSTYPE field */
-#define VSNORMAL 0x1 /* normal variable: $var or ${var} */
-#define VSMINUS 0x2 /* ${var-text} */
-#define VSPLUS 0x3 /* ${var+text} */
-#define VSQUESTION 0x4 /* ${var?message} */
-#define VSASSIGN 0x5 /* ${var=text} */
-#define VSTRIMLEFT 0x6 /* ${var#pattern} */
-#define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */
-#define VSTRIMRIGHT 0x8 /* ${var%pattern} */
-#define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */
-#define VSLENGTH 0xa /* ${#var} */
-/* flags passed to redirect */
-#define REDIR_PUSH 01 /* save previous values of file descriptors */
-#define REDIR_BACKQ 02 /* save the command output to pipe */
+static const char not_found_msg[] = "%s: not found";
-/*
- * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
- * so we use _setjmp instead.
- */
-#if defined(BSD)
-#define setjmp(jmploc) _setjmp(jmploc)
-#define longjmp(jmploc, val) _longjmp(jmploc, val)
-#endif
+#define E_OPEN "No such file" /* opening a file */
+#define E_CREAT "Directory nonexistent" /* creating a file */
+#define E_EXEC not_found_msg+4 /* executing a program */
/*
- * Most machines require the value returned from malloc to be aligned
- * in some way. The following macro will get this right on many machines.
+ * We enclose jmp_buf in a structure so that we can declare pointers to
+ * jump locations. The global variable handler contains the location to
+ * jump to when an exception occurs, and the global variable exception
+ * contains a code identifying the exception. To implement nested
+ * exception handlers, the user should save the value of handler on entry
+ * to an inner scope, set handler to point to a jmploc structure for the
+ * inner scope, and restore handler on exit from the scope.
*/
-#ifndef ALIGN
-union align {
- int i;
- char *cp;
+struct jmploc {
+ jmp_buf loc;
};
-#define ALIGN(nbytes) (((nbytes) + sizeof(union align) - 1) & ~(sizeof(union align) - 1))
-#endif
+static struct jmploc *handler;
+static int exception;
+static volatile int suppressint;
+static volatile sig_atomic_t intpending;
+
+static int exerrno; /* Last exec error, error for EXEXEC */
+
+/* exceptions */
+#define EXINT 0 /* SIGINT received */
+#define EXERROR 1 /* a generic error */
+#define EXSHELLPROC 2 /* execute a shell procedure */
+#define EXEXEC 3 /* command execution failed */
+#define EXEXIT 4 /* exit the shell */
+#define EXSIG 5 /* trapped signal in wait(1) */
-#ifdef BB_LOCALE_SUPPORT
-#include <locale.h>
-static void change_lc_all(const char *value);
-static void change_lc_ctype(const char *value);
-#endif
+
+/* do we generate EXSIG events */
+static int exsig;
+/* last pending signal */
+static volatile sig_atomic_t pendingsigs;
/*
* These macros allow the user to suspend the handling of interrupt signals
* more fun than worrying about efficiency and portability. :-))
*/
-static void onint (void);
-static volatile int suppressint;
-static volatile int intpending;
-
-#define INTOFF suppressint++
-#ifndef ASH_OPTIMIZE_FOR_SIZE
-#define INTON { if (--suppressint == 0 && intpending) onint(); }
-#define FORCEINTON {suppressint = 0; if (intpending) onint();}
-#else
-static void __inton (void);
-static void forceinton (void);
-#define INTON __inton()
+#define xbarrier() ({ __asm__ __volatile__ ("": : :"memory"); })
+#define INTOFF \
+ ({ \
+ suppressint++; \
+ xbarrier(); \
+ 0; \
+ })
+#define SAVEINT(v) ((v) = suppressint)
+#define RESTOREINT(v) \
+ ({ \
+ xbarrier(); \
+ if ((suppressint = (v)) == 0 && intpending) onint(); \
+ 0; \
+ })
+#define EXSIGON() \
+ ({ \
+ exsig++; \
+ xbarrier(); \
+ if (pendingsigs) \
+ exraise(EXSIG); \
+ 0; \
+ })
+/* EXSIG is turned off by evalbltin(). */
+
+
+static void exraise(int) __attribute__((__noreturn__));
+static void onint(void) __attribute__((__noreturn__));
+
+static void error(const char *, ...) __attribute__((__noreturn__));
+static void exerror(int, const char *, ...) __attribute__((__noreturn__));
+
+static void sh_warnx(const char *, ...);
+
+#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+static void
+inton(void) {
+ if (--suppressint == 0 && intpending) {
+ onint();
+ }
+}
+#define INTON inton()
+static void forceinton(void)
+{
+ suppressint = 0;
+ if (intpending)
+ onint();
+}
#define FORCEINTON forceinton()
-#endif
-
-#define CLEAR_PENDING_INT intpending = 0
-#define int_pending() intpending
-
-
-typedef void *pointer;
-#ifndef NULL
-#define NULL (void *)0
-#endif
-
-static inline pointer ckmalloc (int sz) { return xmalloc(sz); }
-static inline pointer ckrealloc(void *p, int sz) { return xrealloc(p, sz); }
-static inline char * savestr (const char *s) { return xstrdup(s); }
-
-static pointer stalloc (int);
-static void stunalloc (pointer);
-static void ungrabstackstr (char *, char *);
-static char * growstackstr(void);
-static char * makestrspace(size_t newlen);
-static char *sstrdup (const char *);
+#else
+#define INTON \
+ ({ \
+ xbarrier(); \
+ if (--suppressint == 0 && intpending) onint(); \
+ 0; \
+ })
+#define FORCEINTON \
+ ({ \
+ xbarrier(); \
+ suppressint = 0; \
+ if (intpending) onint(); \
+ 0; \
+ })
+#endif /* CONFIG_ASH_OPTIMIZE_FOR_SIZE */
/*
- * Parse trees for commands are allocated in lifo order, so we use a stack
- * to make this more efficient, and also to avoid all sorts of exception
- * handling code to handle interrupts in the middle of a parse.
- *
- * The size 504 was chosen because the Ultrix malloc handles that size
- * well.
+ * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
+ * so we use _setjmp instead.
*/
-#define MINSIZE 504 /* minimum size of a block */
+#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__)
+#define setjmp(jmploc) _setjmp(jmploc)
+#define longjmp(jmploc, val) _longjmp(jmploc, val)
+#endif
+/* $NetBSD: expand.h,v 1.13 2002/11/24 22:35:40 christos Exp $ */
-struct stack_block {
- struct stack_block *prev;
- char space[MINSIZE];
+struct strlist {
+ struct strlist *next;
+ char *text;
};
-static struct stack_block stackbase;
-static struct stack_block *stackp = &stackbase;
-static struct stackmark *markp;
-static char *stacknxt = stackbase.space;
-static int stacknleft = MINSIZE;
+struct arglist {
+ struct strlist *list;
+ struct strlist **lastp;
+};
-#define equal(s1, s2) (strcmp(s1, s2) == 0)
+/*
+ * expandarg() flags
+ */
+#define EXP_FULL 0x1 /* perform word splitting & file globbing */
+#define EXP_TILDE 0x2 /* do normal tilde expansion */
+#define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
+#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
+#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
+#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
+#define EXP_VARTILDE2 0x40 /* expand tildes after colons only */
+#define EXP_WORD 0x80 /* expand word in parameter expansion */
+#define EXP_QWORD 0x100 /* expand word in quoted parameter expansion */
-#define stackblock() stacknxt
-#define stackblocksize() stacknleft
-#define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize()
-#define STPUTC(c, p) (--sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(), *p++ = (c)))
-#define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(n); }
-#define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), *p = '\0') : (*p = '\0'))
+union node;
+static void expandarg(union node *, struct arglist *, int);
+#define rmescapes(p) _rmescapes((p), 0)
+static char *_rmescapes(char *, int);
+static int casematch(union node *, char *);
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static void expari(int);
+#endif
-#define USTPUTC(c, p) (--sstrnleft, *p++ = (c))
-#define STUNPUTC(p) (++sstrnleft, --p)
-#define STTOPC(p) p[-1]
-#define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount))
-#define grabstackstr(p) stalloc(stackblocksize() - sstrnleft)
+/* $NetBSD: eval.h,v 1.13 2002/11/24 22:35:39 christos Exp $ */
-#define ckfree(p) free((pointer)(p))
+static char *commandname; /* currently executing command */
+static struct strlist *cmdenviron; /* environment for builtin command */
+static int exitstatus; /* exit status of last command */
+static int back_exitstatus; /* exit status of backquoted command */
-#ifdef DEBUG
-#define TRACE(param) trace param
-static void trace (const char *, ...);
-static void trargs (char **);
-static void showtree (union node *);
-static void trputc (int);
-static void trputs (const char *);
-static void opentrace (void);
-#else
-#define TRACE(param)
-#endif
+struct backcmd { /* result of evalbackcmd */
+ int fd; /* file descriptor to read from */
+ char *buf; /* buffer */
+ int nleft; /* number of chars in buffer */
+ struct job *jp; /* job structure for command */
+};
+
+/*
+ * This file was generated by the mknodes program.
+ */
-#define NSEMI 0
-#define NCMD 1
-#define NPIPE 2
-#define NREDIR 3
-#define NBACKGND 4
-#define NSUBSHELL 5
-#define NAND 6
-#define NOR 7
+#define NCMD 0
+#define NPIPE 1
+#define NREDIR 2
+#define NBACKGND 3
+#define NSUBSHELL 4
+#define NAND 5
+#define NOR 6
+#define NSEMI 7
#define NIF 8
#define NWHILE 9
#define NUNTIL 10
#define NDEFUN 14
#define NARG 15
#define NTO 16
-#define NFROM 17
-#define NFROMTO 18
-#define NAPPEND 19
-#define NTOOV 20
+#define NCLOBBER 17
+#define NFROM 18
+#define NFROMTO 19
+#define NAPPEND 20
#define NTOFD 21
#define NFROMFD 22
#define NHERE 23
#define NXHERE 24
#define NNOT 25
-/*
- * expandarg() flags
- */
-#define EXP_FULL 0x1 /* perform word splitting & file globbing */
-#define EXP_TILDE 0x2 /* do normal tilde expansion */
-#define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
-#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
-#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
-#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
-
-#define NOPTS 16
-static char optet_vals[NOPTS];
-
-static const char * const optlist[NOPTS] = {
- "e" "errexit",
- "f" "noglob",
- "I" "ignoreeof",
- "i" "interactive",
- "m" "monitor",
- "n" "noexec",
- "s" "stdin",
- "x" "xtrace",
- "v" "verbose",
- "V" "vi",
- "E" "emacs",
- "C" "noclobber",
- "a" "allexport",
- "b" "notify",
- "u" "nounset",
- "q" "quietprofile"
+struct ncmd {
+ int type;
+ union node *assign;
+ union node *args;
+ union node *redirect;
};
-#define optent_name(optent) (optent+1)
-#define optent_letter(optent) optent[0]
-#define optent_val(optent) optet_vals[optent]
-
-#define eflag optent_val(0)
-#define fflag optent_val(1)
-#define Iflag optent_val(2)
-#define iflag optent_val(3)
-#define mflag optent_val(4)
-#define nflag optent_val(5)
-#define sflag optent_val(6)
-#define xflag optent_val(7)
-#define vflag optent_val(8)
-#define Vflag optent_val(9)
-#define Eflag optent_val(10)
-#define Cflag optent_val(11)
-#define aflag optent_val(12)
-#define bflag optent_val(13)
-#define uflag optent_val(14)
-#define qflag optent_val(15)
-
-/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
-#define FORK_FG 0
-#define FORK_BG 1
-#define FORK_NOJOB 2
+struct npipe {
+ int type;
+ int backgnd;
+ struct nodelist *cmdlist;
+};
-struct nbinary {
- int type;
- union node *ch1;
- union node *ch2;
-};
-
-
-struct ncmd {
+struct nredir {
int type;
- int backgnd;
- union node *assign;
- union node *args;
+ union node *n;
union node *redirect;
};
-struct npipe {
- int type;
- int backgnd;
- struct nodelist *cmdlist;
-};
-
-
-struct nredir {
+struct nbinary {
int type;
- union node *n;
- union node *redirect;
+ union node *ch1;
+ union node *ch2;
};
union node {
int type;
- struct nbinary nbinary;
struct ncmd ncmd;
struct npipe npipe;
struct nredir nredir;
+ struct nbinary nbinary;
struct nif nif;
struct nfor nfor;
struct ncase ncase;
union node *n;
};
-struct backcmd { /* result of evalbackcmd */
- int fd; /* file descriptor to read from */
- char *buf; /* buffer */
- int nleft; /* number of chars in buffer */
- struct job *jp; /* job structure for command */
-};
-struct cmdentry {
- int cmdtype;
- union param {
- int index;
- union node *func;
- const struct builtincmd *cmd;
- } u;
+struct funcnode {
+ int count;
+ union node n;
};
-struct strlist {
- struct strlist *next;
- char *text;
-};
+static void freefunc(struct funcnode *);
+/* $NetBSD: parser.h,v 1.15 2002/11/24 22:35:42 christos Exp $ */
-struct arglist {
- struct strlist *list;
- struct strlist **lastp;
-};
+/* control characters in argument strings */
+#define CTL_FIRST '\201' /* first 'special' character */
+#define CTLESC '\201' /* escape next character */
+#define CTLVAR '\202' /* variable defn */
+#define CTLENDVAR '\203'
+#define CTLBACKQ '\204'
+#define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
+/* CTLBACKQ | CTLQUOTE == '\205' */
+#define CTLARI '\206' /* arithmetic expression */
+#define CTLENDARI '\207'
+#define CTLQUOTEMARK '\210'
+#define CTL_LAST '\210' /* last 'special' character */
+
+/* variable substitution byte (follows CTLVAR) */
+#define VSTYPE 0x0f /* type of variable substitution */
+#define VSNUL 0x10 /* colon--treat the empty string as unset */
+#define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
+
+/* values of VSTYPE field */
+#define VSNORMAL 0x1 /* normal variable: $var or ${var} */
+#define VSMINUS 0x2 /* ${var-text} */
+#define VSPLUS 0x3 /* ${var+text} */
+#define VSQUESTION 0x4 /* ${var?message} */
+#define VSASSIGN 0x5 /* ${var=text} */
+#define VSTRIMRIGHT 0x6 /* ${var%pattern} */
+#define VSTRIMRIGHTMAX 0x7 /* ${var%%pattern} */
+#define VSTRIMLEFT 0x8 /* ${var#pattern} */
+#define VSTRIMLEFTMAX 0x9 /* ${var##pattern} */
+#define VSLENGTH 0xa /* ${#var} */
+
+/* values of checkkwd variable */
+#define CHKALIAS 0x1
+#define CHKKWD 0x2
+#define CHKNL 0x4
+
+#define IBUFSIZ (BUFSIZ + 1)
+
+/*
+ * NEOF is returned by parsecmd when it encounters an end of file. It
+ * must be distinct from NULL, so we use the address of a variable that
+ * happens to be handy.
+ */
+static int plinno = 1; /* input line number */
+
+/* number of characters left in input buffer */
+static int parsenleft; /* copy of parsefile->nleft */
+static int parselleft; /* copy of parsefile->lleft */
+
+/* next character in input buffer */
+static char *parsenextc; /* copy of parsefile->nextc */
struct strpush {
struct strpush *prev; /* preceding string on stack */
char *prevstring;
int prevnleft;
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
struct alias *ap; /* if push was associated with an alias */
#endif
char *string; /* remember the string since it may change */
struct strpush basestrpush; /* so pushing one is fast */
};
-struct stackmark {
- struct stack_block *stackp;
- char *stacknxt;
- int stacknleft;
- struct stackmark *marknext;
-};
-
-struct shparam {
- int nparam; /* # of positional parameters (without $0) */
- unsigned char malloc; /* if parameter list dynamically allocated */
- char **p; /* parameter list */
- int optind; /* next parameter to be processed by getopts */
- int optoff; /* used by getopts */
-};
-
-/*
- * When commands are first encountered, they are entered in a hash table.
- * This ensures that a full path search will not have to be done for them
- * on each invocation.
- *
- * We should investigate converting to a linear search, even though that
- * would make the command name "hash" a misnomer.
- */
-#define CMDTABLESIZE 31 /* should be prime */
-#define ARB 1 /* actual size determined at run time */
-
+static struct parsefile basepf; /* top level input file */
+static char basebuf[IBUFSIZ]; /* buffer for top level input file */
+static struct parsefile *parsefile = &basepf; /* current input file */
-struct tblentry {
- struct tblentry *next; /* next entry in hash chain */
- union param param; /* definition of builtin function */
- short cmdtype; /* index identifying command */
- char rehash; /* if set, cd done since entry created */
- char cmdname[ARB]; /* name of command */
-};
+static int tokpushback; /* last token pushed back */
+#define NEOF ((union node *)&tokpushback)
+static int parsebackquote; /* nonzero if we are inside backquotes */
+static int doprompt; /* if set, prompt the user */
+static int needprompt; /* true if interactive and at start of line */
+static int lasttoken; /* last token read */
+static char *wordtext; /* text of last word returned by readtoken */
+static int checkkwd;
+static struct nodelist *backquotelist;
+static union node *redirnode;
+static struct heredoc *heredoc;
+static int quoteflag; /* set if (part of) last token was quoted */
+static int startlinno; /* line # where last token started */
+static union node *parsecmd(int);
+static void fixredir(union node *, const char *, int);
+static const char *const *findkwd(const char *);
+static char *endofname(const char *);
-static struct tblentry *cmdtable[CMDTABLESIZE];
-static int builtinloc = -1; /* index in path of %builtin, or -1 */
-static int exerrno = 0; /* Last exec error */
+/* $NetBSD: shell.h,v 1.16 2003/01/22 20:36:04 dsl Exp $ */
+typedef void *pointer;
-static void tryexec (char *, char **, char **);
-static void printentry (struct tblentry *, int);
-static void clearcmdentry (int);
-static struct tblentry *cmdlookup (const char *, int);
-static void delete_cmd_entry (void);
-static int path_change (const char *, int *);
+static char nullstr[1]; /* zero length string */
+static const char spcstr[] = " ";
+static const char snlfmt[] = "%s\n";
+static const char dolatstr[] = { CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' };
+static const char illnum[] = "Illegal number: %s";
+static const char homestr[] = "HOME";
+#ifdef DEBUG
+#define TRACE(param) trace param
+#define TRACEV(param) tracev param
+#else
+#define TRACE(param)
+#define TRACEV(param)
+#endif
-static void flushall (void);
-static void out2fmt (const char *, ...)
- __attribute__((__format__(__printf__,1,2)));
-static int xwrite (int, const char *, int);
+#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
+#define __builtin_expect(x, expected_value) (x)
+#endif
-static void outstr (const char *p, FILE *file) { fputs(p, file); }
-static void out1str(const char *p) { outstr(p, stdout); }
-static void out2str(const char *p) { outstr(p, stderr); }
+#define xlikely(x) __builtin_expect((x),1)
-#ifndef ASH_OPTIMIZE_FOR_SIZE
-#define out2c(c) putc((c), stderr)
-#else
-static void out2c(int c) { putc(c, stderr); }
-#endif
-
-/* syntax table used when not in quotes */
-static const char basesyntax[257] = {
- CENDFILE, CSPCL, CWORD, CCTL,
- CCTL, CCTL, CCTL, CCTL,
- CCTL, CCTL, CCTL, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CSPCL,
- CNL, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CSPCL, CWORD,
- CDQUOTE, CWORD, CVAR, CWORD,
- CSPCL, CSQUOTE, CSPCL, CSPCL,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CSPCL, CSPCL, CWORD,
- CSPCL, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CBACK, CWORD,
- CWORD, CWORD, CBQUOTE, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CSPCL, CENDVAR,
- CWORD
-};
-/* syntax table used when in double quotes */
-static const char dqsyntax[257] = {
- CENDFILE, CIGN, CWORD, CCTL,
- CCTL, CCTL, CCTL, CCTL,
- CCTL, CCTL, CCTL, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CNL, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CCTL,
- CENDQUOTE,CWORD, CVAR, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CCTL, CWORD, CWORD, CCTL,
- CWORD, CCTL, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CCTL, CWORD, CWORD, CCTL,
- CWORD, CCTL, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CCTL, CBACK, CCTL,
- CWORD, CWORD, CBQUOTE, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CENDVAR,
- CCTL
+#define TEOF 0
+#define TNL 1
+#define TREDIR 2
+#define TWORD 3
+#define TSEMI 4
+#define TBACKGND 5
+#define TAND 6
+#define TOR 7
+#define TPIPE 8
+#define TLP 9
+#define TRP 10
+#define TENDCASE 11
+#define TENDBQUOTE 12
+#define TNOT 13
+#define TCASE 14
+#define TDO 15
+#define TDONE 16
+#define TELIF 17
+#define TELSE 18
+#define TESAC 19
+#define TFI 20
+#define TFOR 21
+#define TIF 22
+#define TIN 23
+#define TTHEN 24
+#define TUNTIL 25
+#define TWHILE 26
+#define TBEGIN 27
+#define TEND 28
+
+/* first char is indicating which tokens mark the end of a list */
+static const char *const tokname_array[] = {
+ "\1end of file",
+ "\0newline",
+ "\0redirection",
+ "\0word",
+ "\0;",
+ "\0&",
+ "\0&&",
+ "\0||",
+ "\0|",
+ "\0(",
+ "\1)",
+ "\1;;",
+ "\1`",
+#define KWDOFFSET 13
+ /* the following are keywords */
+ "\0!",
+ "\0case",
+ "\1do",
+ "\1done",
+ "\1elif",
+ "\1else",
+ "\1esac",
+ "\1fi",
+ "\0for",
+ "\0if",
+ "\0in",
+ "\1then",
+ "\0until",
+ "\0while",
+ "\0{",
+ "\1}",
};
-/* syntax table used when in single quotes */
-static const char sqsyntax[257] = {
- CENDFILE, CIGN, CWORD, CCTL,
- CCTL, CCTL, CCTL, CCTL,
- CCTL, CCTL, CCTL, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CNL, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CCTL,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CENDQUOTE,CWORD, CWORD,
- CCTL, CWORD, CWORD, CCTL,
- CWORD, CCTL, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CCTL, CWORD, CWORD, CCTL,
- CWORD, CCTL, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CCTL, CCTL, CCTL,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CCTL
-};
+static const char *tokname(int tok)
+{
+ static char buf[16];
-/* syntax table used when in arithmetic */
-static const char arisyntax[257] = {
- CENDFILE, CIGN, CWORD, CCTL,
- CCTL, CCTL, CCTL, CCTL,
- CCTL, CCTL, CCTL, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CNL, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CDQUOTE, CWORD, CVAR, CWORD,
- CWORD, CSQUOTE, CLP, CRP,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CBACK, CWORD,
- CWORD, CWORD, CBQUOTE, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CWORD,
- CWORD, CWORD, CWORD, CENDVAR,
- CWORD
-};
+ if (tok >= TSEMI)
+ buf[0] = '"';
+ sprintf(buf + (tok >= TSEMI), "%s%c",
+ tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
+ return buf;
+}
-/* character classification table */
-static const char is_type[257] = {
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0, ISSPECL,
- 0, ISSPECL, ISSPECL, 0,
- 0, 0, 0, 0,
- ISSPECL, 0, 0, ISSPECL,
- 0, 0, ISDIGIT, ISDIGIT,
- ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT,
- ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT,
- 0, 0, 0, 0,
- 0, ISSPECL, ISSPECL, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, ISUPPER, ISUPPER, ISUPPER,
- ISUPPER, 0, 0, 0,
- 0, ISUNDER, 0, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, ISLOWER, ISLOWER, ISLOWER,
- ISLOWER, 0, 0, 0,
- 0
-};
+/* $NetBSD: machdep.h,v 1.10 2002/10/07 14:26:08 christos Exp $ */
-/* Array indicating which tokens mark the end of a list */
-static const char tokendlist[] = {
- 1,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 1,
- 1,
- 1,
- 0,
- 0,
- 0,
- 0,
- 0,
- 1,
- 1,
- 1,
- 1,
- 1,
- 1,
- 0,
- 0,
- 0,
- 1,
- 0,
- 0,
- 0,
- 1,
-};
+/*
+ * Most machines require the value returned from malloc to be aligned
+ * in some way. The following macro will get this right on many machines.
+ */
-static const char *const tokname[] = {
- "end of file",
- "newline",
- "\";\"",
- "\"&\"",
- "\"&&\"",
- "\"||\"",
- "\"|\"",
- "\"(\"",
- "\")\"",
- "\";;\"",
- "\"`\"",
- "redirection",
- "word",
- "assignment",
- "\"!\"",
- "\"case\"",
- "\"do\"",
- "\"done\"",
- "\"elif\"",
- "\"else\"",
- "\"esac\"",
- "\"fi\"",
- "\"for\"",
- "\"if\"",
- "\"in\"",
- "\"then\"",
- "\"until\"",
- "\"while\"",
- "\"{\"",
- "\"}\"",
-};
+#define SHELL_SIZE (sizeof(union {int i; char *cp; double d; }) - 1)
+/*
+ * It appears that grabstackstr() will barf with such alignments
+ * because stalloc() will return a string allocated in a new stackblock.
+ */
+#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
-#define KWDOFFSET 14
-
-static const char *const parsekwd[] = {
- "!",
- "case",
- "do",
- "done",
- "elif",
- "else",
- "esac",
- "fi",
- "for",
- "if",
- "in",
- "then",
- "until",
- "while",
- "{",
- "}"
-};
+/*
+ * This file was generated by the mksyntax program.
+ */
-static int plinno = 1; /* input line number */
+/* Syntax classes */
+#define CWORD 0 /* character is nothing special */
+#define CNL 1 /* newline character */
+#define CBACK 2 /* a backslash character */
+#define CSQUOTE 3 /* single quote */
+#define CDQUOTE 4 /* double quote */
+#define CENDQUOTE 5 /* a terminating quote */
+#define CBQUOTE 6 /* backwards single quote */
+#define CVAR 7 /* a dollar sign */
+#define CENDVAR 8 /* a '}' character */
+#define CLP 9 /* a left paren in arithmetic */
+#define CRP 10 /* a right paren in arithmetic */
+#define CENDFILE 11 /* end of file */
+#define CCTL 12 /* like CWORD, except it must be escaped */
+#define CSPCL 13 /* these terminate a word */
+#define CIGN 14 /* character should be ignored */
-static int parselleft; /* copy of parsefile->lleft */
+#ifdef CONFIG_ASH_ALIAS
+#define SYNBASE 130
+#define PEOF -130
+#define PEOA -129
+#define PEOA_OR_PEOF PEOA
+#else
+#define SYNBASE 129
+#define PEOF -129
+#define PEOA_OR_PEOF PEOF
+#endif
-static struct parsefile basepf; /* top level input file */
-static char basebuf[BUFSIZ]; /* buffer for top level input file */
-static struct parsefile *parsefile = &basepf; /* current input file */
+#define is_digit(c) ((unsigned)((c) - '0') <= 9)
+#define is_name(c) ((c) == '_' || isalpha((unsigned char)(c)))
+#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
/*
- * NEOF is returned by parsecmd when it encounters an end of file. It
- * must be distinct from NULL, so we use the address of a variable that
- * happens to be handy.
+ * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
+ * (assuming ascii char codes, as the original implementation did)
*/
+#define is_special(c) \
+ ( (((unsigned int)c) - 33 < 32) \
+ && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
-static int tokpushback; /* last token pushed back */
-#define NEOF ((union node *)&tokpushback)
-static int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
+#define digit_val(c) ((c) - '0')
+/*
+ * This file was generated by the mksyntax program.
+ */
-static void error (const char *, ...) __attribute__((__noreturn__));
-static void exerror (int, const char *, ...) __attribute__((__noreturn__));
-static void shellexec (char **, char **, const char *, int)
- __attribute__((noreturn));
-static void exitshell (int) __attribute__((noreturn));
+#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+#define USE_SIT_FUNCTION
+#endif
+
+/* number syntax index */
+#define BASESYNTAX 0 /* not in quotes */
+#define DQSYNTAX 1 /* in double quotes */
+#define SQSYNTAX 2 /* in single quotes */
+#define ARISYNTAX 3 /* in arithmetic */
+
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static const char S_I_T[][4] = {
+#ifdef CONFIG_ASH_ALIAS
+ {CSPCL, CIGN, CIGN, CIGN}, /* 0, PEOA */
+#endif
+ {CSPCL, CWORD, CWORD, CWORD}, /* 1, ' ' */
+ {CNL, CNL, CNL, CNL}, /* 2, \n */
+ {CWORD, CCTL, CCTL, CWORD}, /* 3, !*-/:=?[]~ */
+ {CDQUOTE, CENDQUOTE, CWORD, CWORD}, /* 4, '"' */
+ {CVAR, CVAR, CWORD, CVAR}, /* 5, $ */
+ {CSQUOTE, CWORD, CENDQUOTE, CWORD}, /* 6, "'" */
+ {CSPCL, CWORD, CWORD, CLP}, /* 7, ( */
+ {CSPCL, CWORD, CWORD, CRP}, /* 8, ) */
+ {CBACK, CBACK, CCTL, CBACK}, /* 9, \ */
+ {CBQUOTE, CBQUOTE, CWORD, CBQUOTE}, /* 10, ` */
+ {CENDVAR, CENDVAR, CWORD, CENDVAR}, /* 11, } */
+#ifndef USE_SIT_FUNCTION
+ {CENDFILE, CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */
+ {CWORD, CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */
+ {CCTL, CCTL, CCTL, CCTL} /* 14, CTLESC ... */
+#endif
+};
+#else
+static const char S_I_T[][3] = {
+#ifdef CONFIG_ASH_ALIAS
+ {CSPCL, CIGN, CIGN}, /* 0, PEOA */
+#endif
+ {CSPCL, CWORD, CWORD}, /* 1, ' ' */
+ {CNL, CNL, CNL}, /* 2, \n */
+ {CWORD, CCTL, CCTL}, /* 3, !*-/:=?[]~ */
+ {CDQUOTE, CENDQUOTE, CWORD}, /* 4, '"' */
+ {CVAR, CVAR, CWORD}, /* 5, $ */
+ {CSQUOTE, CWORD, CENDQUOTE}, /* 6, "'" */
+ {CSPCL, CWORD, CWORD}, /* 7, ( */
+ {CSPCL, CWORD, CWORD}, /* 8, ) */
+ {CBACK, CBACK, CCTL}, /* 9, \ */
+ {CBQUOTE, CBQUOTE, CWORD}, /* 10, ` */
+ {CENDVAR, CENDVAR, CWORD}, /* 11, } */
+#ifndef USE_SIT_FUNCTION
+ {CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */
+ {CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */
+ {CCTL, CCTL, CCTL} /* 14, CTLESC ... */
+#endif
+};
+#endif /* CONFIG_ASH_MATH_SUPPORT */
-static int goodname(const char *);
-static void ignoresig (int);
-static void onsig (int);
-static void dotrap (void);
-static int decode_signal (const char *, int);
+#ifdef USE_SIT_FUNCTION
-static void shprocvar(void);
-static void deletefuncs(void);
-static void setparam (char **);
-static void freeparam (volatile struct shparam *);
+#define U_C(c) ((unsigned char)(c))
-/* reasons for skipping commands (see comment on breakcmd routine) */
-#define SKIPBREAK 1
-#define SKIPCONT 2
-#define SKIPFUNC 3
-#define SKIPFILE 4
+static int SIT(int c, int syntax)
+{
+ static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
+#ifdef CONFIG_ASH_ALIAS
+ static const char syntax_index_table[] = {
+ 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
+ 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
+ 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */
+ 11, 3 /* "}~" */
+ };
+#else
+ static const char syntax_index_table[] = {
+ 0, 1, 0, 2, 3, 4, 0, 5, /* "\t\n !\"$&'" */
+ 6, 7, 2, 2, 2, 2, 0, 0, /* "()*-/:;<" */
+ 2, 0, 2, 2, 8, 2, 9, 0, /* "=>?[\\]`|" */
+ 10, 2 /* "}~" */
+ };
+#endif
+ const char *s;
+ int indx;
-/* values of cmdtype */
-#define CMDUNKNOWN -1 /* no entry in table for command */
-#define CMDNORMAL 0 /* command is an executable program */
-#define CMDBUILTIN 1 /* command is a shell builtin */
-#define CMDFUNCTION 2 /* command is a shell function */
+ if (c == PEOF) /* 2^8+2 */
+ return CENDFILE;
+#ifdef CONFIG_ASH_ALIAS
+ if (c == PEOA) /* 2^8+1 */
+ indx = 0;
+ else
+#endif
+ if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
+ return CCTL;
+ else {
+ s = strchr(spec_symbls, c);
+ if (s == 0 || *s == 0)
+ return CWORD;
+ indx = syntax_index_table[(s - spec_symbls)];
+ }
+ return S_I_T[indx][syntax];
+}
+
+#else /* USE_SIT_FUNCTION */
+
+#define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
+
+#ifdef CONFIG_ASH_ALIAS
+#define CSPCL_CIGN_CIGN_CIGN 0
+#define CSPCL_CWORD_CWORD_CWORD 1
+#define CNL_CNL_CNL_CNL 2
+#define CWORD_CCTL_CCTL_CWORD 3
+#define CDQUOTE_CENDQUOTE_CWORD_CWORD 4
+#define CVAR_CVAR_CWORD_CVAR 5
+#define CSQUOTE_CWORD_CENDQUOTE_CWORD 6
+#define CSPCL_CWORD_CWORD_CLP 7
+#define CSPCL_CWORD_CWORD_CRP 8
+#define CBACK_CBACK_CCTL_CBACK 9
+#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10
+#define CENDVAR_CENDVAR_CWORD_CENDVAR 11
+#define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12
+#define CWORD_CWORD_CWORD_CWORD 13
+#define CCTL_CCTL_CCTL_CCTL 14
+#else
+#define CSPCL_CWORD_CWORD_CWORD 0
+#define CNL_CNL_CNL_CNL 1
+#define CWORD_CCTL_CCTL_CWORD 2
+#define CDQUOTE_CENDQUOTE_CWORD_CWORD 3
+#define CVAR_CVAR_CWORD_CVAR 4
+#define CSQUOTE_CWORD_CENDQUOTE_CWORD 5
+#define CSPCL_CWORD_CWORD_CLP 6
+#define CSPCL_CWORD_CWORD_CRP 7
+#define CBACK_CBACK_CCTL_CBACK 8
+#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 9
+#define CENDVAR_CENDVAR_CWORD_CENDVAR 10
+#define CENDFILE_CENDFILE_CENDFILE_CENDFILE 11
+#define CWORD_CWORD_CWORD_CWORD 12
+#define CCTL_CCTL_CCTL_CCTL 13
+#endif
+
+static const char syntax_index_table[258] = {
+ /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
+ /* 0 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
+#ifdef CONFIG_ASH_ALIAS
+ /* 1 PEOA */ CSPCL_CIGN_CIGN_CIGN,
+#endif
+ /* 2 -128 0x80 */ CWORD_CWORD_CWORD_CWORD,
+ /* 3 -127 CTLESC */ CCTL_CCTL_CCTL_CCTL,
+ /* 4 -126 CTLVAR */ CCTL_CCTL_CCTL_CCTL,
+ /* 5 -125 CTLENDVAR */ CCTL_CCTL_CCTL_CCTL,
+ /* 6 -124 CTLBACKQ */ CCTL_CCTL_CCTL_CCTL,
+ /* 7 -123 CTLQUOTE */ CCTL_CCTL_CCTL_CCTL,
+ /* 8 -122 CTLARI */ CCTL_CCTL_CCTL_CCTL,
+ /* 9 -121 CTLENDARI */ CCTL_CCTL_CCTL_CCTL,
+ /* 10 -120 CTLQUOTEMARK */ CCTL_CCTL_CCTL_CCTL,
+ /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
+ /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
+ /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
+ /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
+ /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
+ /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
+ /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
+ /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
+ /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
+ /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
+ /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
+ /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
+ /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
+ /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
+ /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
+ /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
+ /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
+ /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
+ /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
+ /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
+ /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
+ /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
+ /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
+ /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
+ /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
+ /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
+ /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
+ /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
+ /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
+ /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
+ /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
+ /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
+ /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
+ /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
+ /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
+ /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
+ /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
+ /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
+ /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
+ /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
+ /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
+ /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
+ /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
+ /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
+ /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
+ /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
+ /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
+ /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
+ /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
+ /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
+ /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
+ /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
+ /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
+ /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
+ /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
+ /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
+ /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
+ /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
+ /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
+ /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
+ /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
+ /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
+ /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
+ /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
+ /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
+ /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
+ /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
+ /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
+ /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
+ /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
+ /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
+ /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
+ /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
+ /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
+ /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
+ /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
+ /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
+ /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
+ /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
+ /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
+ /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
+ /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
+ /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
+ /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
+ /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
+ /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
+ /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
+ /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
+ /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
+ /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
+ /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
+ /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
+ /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
+ /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
+ /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
+ /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
+ /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
+ /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
+ /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
+ /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
+ /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
+ /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
+ /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
+ /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
+ /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
+ /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
+ /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
+ /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
+ /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
+ /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
+ /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
+ /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
+ /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
+ /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
+ /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
+ /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
+ /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
+ /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
+ /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
+ /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
+ /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
+ /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
+ /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
+ /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
+ /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
+ /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
+ /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
+ /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
+ /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
+ /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
+ /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
+ /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
+ /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
+ /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
+ /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
+ /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
+ /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
+ /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
+ /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
+ /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
+ /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
+ /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
+ /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
+ /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
+ /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
+ /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
+ /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
+ /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
+ /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
+ /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
+ /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
+ /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
+ /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CWORD,
+ /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
+ /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
+ /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
+ /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CWORD,
+ /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
+ /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
+ /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
+ /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
+ /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
+ /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
+ /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
+ /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
+ /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
+ /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
+ /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
+ /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
+ /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
+ /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
+ /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
+ /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
+ /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
+ /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
+ /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
+ /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
+ /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
+ /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
+ /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
+ /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
+ /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
+ /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
+ /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
+ /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
+ /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
+ /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
+ /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
+ /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
+ /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
+ /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
+ /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
+ /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
+ /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
+ /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
+ /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
+ /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
+ /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
+ /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
+ /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
+ /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
+ /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
+ /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
+ /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
+ /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
+ /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
+ /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
+ /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
+ /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
+ /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
+ /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
+ /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
+ /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
+ /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
+ /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
+ /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
+ /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
+ /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
+ /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
+ /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
+ /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
+ /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
+ /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
+ /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
+ /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
+ /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
+ /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
+ /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
+ /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
+ /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
+ /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
+ /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
+ /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
+ /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
+ /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
+ /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
+ /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
+ /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
+ /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
+ /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
+ /* 257 127 */ CWORD_CWORD_CWORD_CWORD,
+};
-#define DO_ERR 1 /* find_command prints errors */
-#define DO_ABS 2 /* find_command checks absolute paths */
-#define DO_NOFUN 4 /* find_command ignores functions */
-#define DO_BRUTE 8 /* find_command ignores hash table */
+#endif /* USE_SIT_FUNCTION */
-/*
- * Shell variables.
- */
+/* $NetBSD: alias.c,v 1.11 2002/11/24 22:35:38 christos Exp $ */
-/* flags */
-#define VEXPORT 0x01 /* variable is exported */
-#define VREADONLY 0x02 /* variable cannot be modified */
-#define VSTRFIXED 0x04 /* variable struct is staticly allocated */
-#define VTEXTFIXED 0x08 /* text is staticly allocated */
-#define VSTACK 0x10 /* text is allocated on the stack */
-#define VUNSET 0x20 /* the variable is not set */
-#define VNOFUNC 0x40 /* don't call the callback function */
+#define ATABSIZE 39
-struct var {
- struct var *next; /* next entry in hash list */
- int flags; /* flags are defined above */
- char *text; /* name=value */
- void (*func) (const char *);
- /* function to be called when */
- /* the variable gets set/unset */
-};
+static int funcblocksize; /* size of structures in function */
+static int funcstringsize; /* size of strings in node */
+static pointer funcblock; /* block to allocate function from */
+static char *funcstring; /* block to allocate strings from */
-struct localvar {
- struct localvar *next; /* next local variable in list */
- struct var *vp; /* the variable that was made local */
- int flags; /* saved flags */
- char *text; /* saved text */
+static const short nodesize[26] = {
+ SHELL_ALIGN(sizeof (struct ncmd)),
+ SHELL_ALIGN(sizeof (struct npipe)),
+ SHELL_ALIGN(sizeof (struct nredir)),
+ SHELL_ALIGN(sizeof (struct nredir)),
+ SHELL_ALIGN(sizeof (struct nredir)),
+ SHELL_ALIGN(sizeof (struct nbinary)),
+ SHELL_ALIGN(sizeof (struct nbinary)),
+ SHELL_ALIGN(sizeof (struct nbinary)),
+ SHELL_ALIGN(sizeof (struct nif)),
+ SHELL_ALIGN(sizeof (struct nbinary)),
+ SHELL_ALIGN(sizeof (struct nbinary)),
+ SHELL_ALIGN(sizeof (struct nfor)),
+ SHELL_ALIGN(sizeof (struct ncase)),
+ SHELL_ALIGN(sizeof (struct nclist)),
+ SHELL_ALIGN(sizeof (struct narg)),
+ SHELL_ALIGN(sizeof (struct narg)),
+ SHELL_ALIGN(sizeof (struct nfile)),
+ SHELL_ALIGN(sizeof (struct nfile)),
+ SHELL_ALIGN(sizeof (struct nfile)),
+ SHELL_ALIGN(sizeof (struct nfile)),
+ SHELL_ALIGN(sizeof (struct nfile)),
+ SHELL_ALIGN(sizeof (struct ndup)),
+ SHELL_ALIGN(sizeof (struct ndup)),
+ SHELL_ALIGN(sizeof (struct nhere)),
+ SHELL_ALIGN(sizeof (struct nhere)),
+ SHELL_ALIGN(sizeof (struct nnot)),
};
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-#define rmescapes(p) _rmescapes((p), 0)
-static char *_rmescapes (char *, int);
-#else
-static void rmescapes (char *);
-#endif
-
-static int casematch (union node *, const char *);
-static void clearredir(void);
-static void popstring(void);
-static void readcmdfile (const char *);
+static void calcsize(union node *);
+static void sizenodelist(struct nodelist *);
+static union node *copynode(union node *);
+static struct nodelist *copynodelist(struct nodelist *);
+static char *nodesavestr(char *);
-static int number (const char *);
-static int is_number (const char *, int *num);
-static char *single_quote (const char *);
-static int nextopt (const char *);
-static void redirect (union node *, int);
-static void popredir (void);
-static int dup_as_newfd (int, int);
-static void changepath(const char *newval);
-static void getoptsreset(const char *value);
+static void evalstring(char *);
+union node; /* BLETCH for ansi C */
+static void evaltree(union node *, int);
+static void evalbackcmd(union node *, struct backcmd *);
+/* in_function returns nonzero if we are currently evaluating a function */
+#define in_function() funcnest
+static int evalskip; /* set if we are skipping commands */
+static int skipcount; /* number of levels to skip */
+static int funcnest; /* depth of function calls */
-static int parsenleft; /* copy of parsefile->nleft */
-static char *parsenextc; /* copy of parsefile->nextc */
-static int rootpid; /* pid of main shell */
-static int rootshell; /* true if we aren't a child of the main shell */
+/* reasons for skipping commands (see comment on breakcmd routine) */
+#define SKIPBREAK 1
+#define SKIPCONT 2
+#define SKIPFUNC 3
+#define SKIPFILE 4
-static const char spcstr[] = " ";
-static const char snlfmt[] = "%s\n";
+/*
+ * This file was generated by the mkbuiltins program.
+ */
-static int sstrnleft;
-static int herefd = -1;
+#ifdef JOBS
+static int bgcmd(int, char **);
+#endif
+static int breakcmd(int, char **);
+static int cdcmd(int, char **);
+#ifdef CONFIG_ASH_CMDCMD
+static int commandcmd(int, char **);
+#endif
+static int dotcmd(int, char **);
+static int evalcmd(int, char **);
+static int execcmd(int, char **);
+static int exitcmd(int, char **);
+static int exportcmd(int, char **);
+static int falsecmd(int, char **);
+#ifdef JOBS
+static int fgcmd(int, char **);
+#endif
+#ifdef CONFIG_ASH_GETOPTS
+static int getoptscmd(int, char **);
+#endif
+static int hashcmd(int, char **);
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+static int helpcmd(int argc, char **argv);
+#endif
+#ifdef JOBS
+static int jobscmd(int, char **);
+#endif
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static int letcmd(int, char **);
+#endif
+static int localcmd(int, char **);
+static int pwdcmd(int, char **);
+static int readcmd(int, char **);
+static int returncmd(int, char **);
+static int setcmd(int, char **);
+static int shiftcmd(int, char **);
+static int timescmd(int, char **);
+static int trapcmd(int, char **);
+static int truecmd(int, char **);
+static int typecmd(int, char **);
+static int umaskcmd(int, char **);
+static int unsetcmd(int, char **);
+static int waitcmd(int, char **);
+static int ulimitcmd(int, char **);
+#ifdef JOBS
+static int killcmd(int, char **);
+#endif
-static struct localvar *localvars;
+/* $NetBSD: mail.h,v 1.9 2002/11/24 22:35:40 christos Exp $ */
-static struct var vifs;
-static struct var vmail;
-static struct var vmpath;
-static struct var vpath;
-static struct var vps1;
-static struct var vps2;
-static struct var voptind;
-#ifdef BB_LOCALE_SUPPORT
-static struct var vlc_all;
-static struct var vlc_ctype;
+#ifdef CONFIG_ASH_MAIL
+static void chkmail(void);
+static void changemail(const char *);
#endif
-struct varinit {
- struct var *var;
- int flags;
- const char *text;
- void (*func) (const char *);
-};
+/* $NetBSD: exec.h,v 1.20 2003/01/22 20:36:04 dsl Exp $ */
-static const char defpathvar[] =
- "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
-#define defpath (defpathvar + 5)
+/* values of cmdtype */
+#define CMDUNKNOWN -1 /* no entry in table for command */
+#define CMDNORMAL 0 /* command is an executable program */
+#define CMDFUNCTION 1 /* command is a shell function */
+#define CMDBUILTIN 2 /* command is a shell builtin */
-#ifdef IFS_BROKEN
-static const char defifsvar[] = "IFS= \t\n";
+struct builtincmd {
+ const char *name;
+ int (*builtin)(int, char **);
+ /* unsigned flags; */
+};
+
+#ifdef CONFIG_ASH_CMDCMD
+# ifdef JOBS
+# ifdef CONFIG_ASH_ALIAS
+# define COMMANDCMD (builtincmd + 7)
+# define EXECCMD (builtincmd + 10)
+# else
+# define COMMANDCMD (builtincmd + 6)
+# define EXECCMD (builtincmd + 9)
+# endif
+# else /* ! JOBS */
+# ifdef CONFIG_ASH_ALIAS
+# define COMMANDCMD (builtincmd + 6)
+# define EXECCMD (builtincmd + 9)
+# else
+# define COMMANDCMD (builtincmd + 5)
+# define EXECCMD (builtincmd + 8)
+# endif
+# endif /* JOBS */
+#else /* ! CONFIG_ASH_CMDCMD */
+# ifdef JOBS
+# ifdef CONFIG_ASH_ALIAS
+# define EXECCMD (builtincmd + 9)
+# else
+# define EXECCMD (builtincmd + 8)
+# endif
+# else /* ! JOBS */
+# ifdef CONFIG_ASH_ALIAS
+# define EXECCMD (builtincmd + 8)
+# else
+# define EXECCMD (builtincmd + 7)
+# endif
+# endif /* JOBS */
+#endif /* CONFIG_ASH_CMDCMD */
+
+#define BUILTIN_NOSPEC "0"
+#define BUILTIN_SPECIAL "1"
+#define BUILTIN_REGULAR "2"
+#define BUILTIN_SPEC_REG "3"
+#define BUILTIN_ASSIGN "4"
+#define BUILTIN_SPEC_ASSG "5"
+#define BUILTIN_REG_ASSG "6"
+#define BUILTIN_SPEC_REG_ASSG "7"
+
+#define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
+#define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
+
+static const struct builtincmd builtincmd[] = {
+ { BUILTIN_SPEC_REG ".", dotcmd },
+ { BUILTIN_SPEC_REG ":", truecmd },
+#ifdef CONFIG_ASH_ALIAS
+ { BUILTIN_REG_ASSG "alias", aliascmd },
+#endif
+#ifdef JOBS
+ { BUILTIN_REGULAR "bg", bgcmd },
+#endif
+ { BUILTIN_SPEC_REG "break", breakcmd },
+ { BUILTIN_REGULAR "cd", cdcmd },
+ { BUILTIN_NOSPEC "chdir", cdcmd },
+#ifdef CONFIG_ASH_CMDCMD
+ { BUILTIN_REGULAR "command", commandcmd },
+#endif
+ { BUILTIN_SPEC_REG "continue", breakcmd },
+ { BUILTIN_SPEC_REG "eval", evalcmd },
+ { BUILTIN_SPEC_REG "exec", execcmd },
+ { BUILTIN_SPEC_REG "exit", exitcmd },
+ { BUILTIN_SPEC_REG_ASSG "export", exportcmd },
+ { BUILTIN_REGULAR "false", falsecmd },
+#ifdef JOBS
+ { BUILTIN_REGULAR "fg", fgcmd },
+#endif
+#ifdef CONFIG_ASH_GETOPTS
+ { BUILTIN_REGULAR "getopts", getoptscmd },
+#endif
+ { BUILTIN_NOSPEC "hash", hashcmd },
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+ { BUILTIN_NOSPEC "help", helpcmd },
+#endif
+#ifdef JOBS
+ { BUILTIN_REGULAR "jobs", jobscmd },
+ { BUILTIN_REGULAR "kill", killcmd },
+#endif
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ { BUILTIN_NOSPEC "let", letcmd },
+#endif
+ { BUILTIN_ASSIGN "local", localcmd },
+ { BUILTIN_NOSPEC "pwd", pwdcmd },
+ { BUILTIN_REGULAR "read", readcmd },
+ { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd },
+ { BUILTIN_SPEC_REG "return", returncmd },
+ { BUILTIN_SPEC_REG "set", setcmd },
+ { BUILTIN_SPEC_REG "shift", shiftcmd },
+ { BUILTIN_SPEC_REG "times", timescmd },
+ { BUILTIN_SPEC_REG "trap", trapcmd },
+ { BUILTIN_REGULAR "true", truecmd },
+ { BUILTIN_NOSPEC "type", typecmd },
+ { BUILTIN_NOSPEC "ulimit", ulimitcmd },
+ { BUILTIN_REGULAR "umask", umaskcmd },
+#ifdef CONFIG_ASH_ALIAS
+ { BUILTIN_REGULAR "unalias", unaliascmd },
+#endif
+ { BUILTIN_SPEC_REG "unset", unsetcmd },
+ { BUILTIN_REGULAR "wait", waitcmd },
+};
+
+#define NUMBUILTINS (sizeof (builtincmd) / sizeof (struct builtincmd) )
+
+
+
+struct cmdentry {
+ int cmdtype;
+ union param {
+ int index;
+ const struct builtincmd *cmd;
+ struct funcnode *func;
+ } u;
+};
+
+
+/* action to find_command() */
+#define DO_ERR 0x01 /* prints errors */
+#define DO_ABS 0x02 /* checks absolute paths */
+#define DO_NOFUNC 0x04 /* don't return shell functions, for command */
+#define DO_ALTPATH 0x08 /* using alternate path */
+#define DO_ALTBLTIN 0x20 /* %builtin in alt. path */
+
+static const char *pathopt; /* set by padvance */
+
+static void shellexec(char **, const char *, int)
+ __attribute__((__noreturn__));
+static char *padvance(const char **, const char *);
+static void find_command(char *, struct cmdentry *, int, const char *);
+static struct builtincmd *find_builtin(const char *);
+static void hashcd(void);
+static void changepath(const char *);
+static void defun(char *, union node *);
+static void unsetfunc(const char *);
+
+#ifdef CONFIG_ASH_MATH_SUPPORT_64
+typedef int64_t arith_t;
+#else
+typedef long arith_t;
+#endif
+
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static arith_t dash_arith(const char *);
+static arith_t arith(const char *expr, int *perrcode);
+#endif
+
+#ifdef CONFIG_ASH_RANDOM_SUPPORT
+static unsigned long rseed;
+static void change_random(const char *);
+# ifndef DYNAMIC_VAR
+# define DYNAMIC_VAR
+# endif
+#endif
+
+/* $NetBSD: init.h,v 1.9 2002/11/24 22:35:40 christos Exp $ */
+
+static void reset(void);
+
+/* $NetBSD: var.h,v 1.21 2003/01/22 20:36:04 dsl Exp $ */
+
+/*
+ * Shell variables.
+ */
+
+/* flags */
+#define VEXPORT 0x01 /* variable is exported */
+#define VREADONLY 0x02 /* variable cannot be modified */
+#define VSTRFIXED 0x04 /* variable struct is statically allocated */
+#define VTEXTFIXED 0x08 /* text is statically allocated */
+#define VSTACK 0x10 /* text is allocated on the stack */
+#define VUNSET 0x20 /* the variable is not set */
+#define VNOFUNC 0x40 /* don't call the callback function */
+#define VNOSET 0x80 /* do not set variable - just readonly test */
+#define VNOSAVE 0x100 /* when text is on the heap before setvareq */
+#ifdef DYNAMIC_VAR
+# define VDYNAMIC 0x200 /* dynamic variable */
+# else
+# define VDYNAMIC 0
+#endif
+
+struct var {
+ struct var *next; /* next entry in hash list */
+ int flags; /* flags are defined above */
+ const char *text; /* name=value */
+ void (*func)(const char *); /* function to be called when */
+ /* the variable gets set/unset */
+};
+
+struct localvar {
+ struct localvar *next; /* next local variable in list */
+ struct var *vp; /* the variable that was made local */
+ int flags; /* saved flags */
+ const char *text; /* saved text */
+};
+
+
+static struct localvar *localvars;
+
+/*
+ * Shell variables.
+ */
+
+#ifdef CONFIG_ASH_GETOPTS
+static void getoptsreset(const char *);
+#endif
+
+#ifdef CONFIG_LOCALE_SUPPORT
+#include <locale.h>
+static void change_lc_all(const char *value);
+static void change_lc_ctype(const char *value);
+#endif
+
+
+#define VTABSIZE 39
+
+static const char defpathvar[] = "PATH=/usr/local/bin:/usr/bin:/sbin:/bin";
+#ifdef IFS_BROKEN
+static const char defifsvar[] = "IFS= \t\n";
#define defifs (defifsvar + 4)
#else
static const char defifs[] = " \t\n";
#endif
-static const struct varinit varinit[] = {
+
+static struct var varinit[] = {
#ifdef IFS_BROKEN
- { &vifs, VSTRFIXED|VTEXTFIXED, defifsvar,
+ { 0, VSTRFIXED|VTEXTFIXED, defifsvar, 0 },
#else
- { &vifs, VSTRFIXED|VTEXTFIXED|VUNSET, "IFS=",
-#endif
- NULL },
- { &vmail, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL=",
- NULL },
- { &vmpath, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH=",
- NULL },
- { &vpath, VSTRFIXED|VTEXTFIXED, defpathvar,
- changepath },
- /*
- * vps1 depends on uid
- */
- { &vps2, VSTRFIXED|VTEXTFIXED, "PS2=> ",
- NULL },
- { &voptind, VSTRFIXED|VTEXTFIXED, "OPTIND=1",
- getoptsreset },
-#ifdef BB_LOCALE_SUPPORT
- { &vlc_all, VSTRFIXED|VTEXTFIXED|VUNSET, "LC_ALL=",
- change_lc_all },
- { &vlc_ctype, VSTRFIXED|VTEXTFIXED|VUNSET, "LC_CTYPE=",
- change_lc_ctype },
-#endif
- { NULL, 0, NULL,
- NULL }
-};
+ { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "IFS\0", 0 },
+#endif
-#define VTABSIZE 39
+#ifdef CONFIG_ASH_MAIL
+ { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL\0", changemail },
+ { 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH\0", changemail },
+#endif
-static struct var *vartab[VTABSIZE];
+ { 0, VSTRFIXED|VTEXTFIXED, defpathvar, changepath },
+ { 0, VSTRFIXED|VTEXTFIXED, "PS1=$ ", 0 },
+ { 0, VSTRFIXED|VTEXTFIXED, "PS2=> ", 0 },
+ { 0, VSTRFIXED|VTEXTFIXED, "PS4=+ ", 0 },
+#ifdef CONFIG_ASH_GETOPTS
+ { 0, VSTRFIXED|VTEXTFIXED, "OPTIND=1", getoptsreset },
+#endif
+#ifdef CONFIG_ASH_RANDOM_SUPPORT
+ {0, VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM\0", change_random },
+#endif
+#ifdef CONFIG_LOCALE_SUPPORT
+ {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL\0", change_lc_all },
+ {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE\0", change_lc_ctype },
+#endif
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+ {0, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE\0", NULL },
+#endif
+};
+
+#define vifs varinit[0]
+#ifdef CONFIG_ASH_MAIL
+#define vmail (&vifs)[1]
+#define vmpath (&vmail)[1]
+#else
+#define vmpath vifs
+#endif
+#define vpath (&vmpath)[1]
+#define vps1 (&vpath)[1]
+#define vps2 (&vps1)[1]
+#define vps4 (&vps2)[1]
+#define voptind (&vps4)[1]
+#ifdef CONFIG_ASH_GETOPTS
+#define vrandom (&voptind)[1]
+#else
+#define vrandom (&vps4)[1]
+#endif
+#define defpath (defpathvar + 5)
/*
* The following macros access the values of the above variables.
#define pathval() (vpath.text + 5)
#define ps1val() (vps1.text + 4)
#define ps2val() (vps2.text + 4)
+#define ps4val() (vps4.text + 4)
#define optindval() (voptind.text + 7)
#define mpathset() ((vmpath.flags & VUNSET) == 0)
-static void initvar (void);
-static void setvar (const char *, const char *, int);
-static void setvareq (char *, int);
-static void listsetvar (struct strlist *);
-static const char *lookupvar (const char *);
-static const char *bltinlookup (const char *);
-static char **environment (void);
-static int showvarscmd (int, char **);
-static void mklocal (char *);
-static void poplocalvars (void);
-static int unsetvar (const char *);
-static int varequal (const char *, const char *);
+static void setvar(const char *, const char *, int);
+static void setvareq(char *, int);
+static void listsetvar(struct strlist *, int);
+static char *lookupvar(const char *);
+static char *bltinlookup(const char *);
+static char **listvars(int, int, char ***);
+#define environment() listvars(VEXPORT, VUNSET, 0)
+static int showvars(const char *, int, int);
+static void poplocalvars(void);
+static int unsetvar(const char *);
+#ifdef CONFIG_ASH_GETOPTS
+static int setvarsafe(const char *, const char *, int);
+#endif
+static int varcmp(const char *, const char *);
+static struct var **hashvar(const char *);
-static char *arg0; /* value of $0 */
-static struct shparam shellparam; /* current positional parameters */
-static char **argptr; /* argument list for builtin commands */
-static char *optionarg; /* set by nextopt (like getopt) */
-static char *optptr; /* used by nextopt */
-static char *minusc; /* argument to -c option */
+static inline int varequal(const char *a, const char *b) {
+ return !varcmp(a, b);
+}
-#ifdef ASH_ALIAS
+static int loopnest; /* current loop nesting level */
-#define ALIASINUSE 1
-#define ALIASDEAD 2
+/*
+ * The parsefile structure pointed to by the global variable parsefile
+ * contains information about the current file being read.
+ */
-#define ATABSIZE 39
-struct alias {
- struct alias *next;
- char *name;
- char *val;
- int flag;
+struct redirtab {
+ struct redirtab *next;
+ int renamed[10];
+ int nullredirs;
};
-static struct alias *atab[ATABSIZE];
+static struct redirtab *redirlist;
+static int nullredirs;
-static void setalias (char *, char *);
-static struct alias **hashalias (const char *);
-static struct alias *freealias (struct alias *);
-static struct alias **__lookupalias (const char *);
+extern char **environ;
-static void
-setalias(name, val)
- char *name, *val;
-{
- struct alias *ap, **app;
+/* $NetBSD: output.h,v 1.16 2002/11/24 22:35:42 christos Exp $ */
- app = __lookupalias(name);
- ap = *app;
- INTOFF;
- if (ap) {
- if (!(ap->flag & ALIASINUSE)) {
- ckfree(ap->val);
- }
- ap->val = savestr(val);
- ap->flag &= ~ALIASDEAD;
- } else {
- /* not found */
- ap = ckmalloc(sizeof (struct alias));
- ap->name = savestr(name);
- ap->val = savestr(val);
- ap->flag = 0;
- ap->next = 0;
- *app = ap;
- }
- INTON;
-}
-static int
-unalias(char *name)
-{
- struct alias **app;
+static void outstr(const char *, FILE *);
+static void outcslow(int, FILE *);
+static void flushall(void);
+static void flusherr(void);
+static int out1fmt(const char *, ...)
+ __attribute__((__format__(__printf__,1,2)));
+static int fmtstr(char *, size_t, const char *, ...)
+ __attribute__((__format__(__printf__,3,4)));
- app = __lookupalias(name);
+static int preverrout_fd; /* save fd2 before print debug if xflag is set. */
- if (*app) {
- INTOFF;
- *app = freealias(*app);
- INTON;
- return (0);
- }
- return (1);
+static void out1str(const char *p)
+{
+ outstr(p, stdout);
}
-static void
-rmaliases(void)
+static void out2str(const char *p)
{
- struct alias *ap, **app;
- int i;
-
- INTOFF;
- for (i = 0; i < ATABSIZE; i++) {
- app = &atab[i];
- for (ap = *app; ap; ap = *app) {
- *app = freealias(*app);
- if (ap == *app) {
- app = &ap->next;
- }
- }
- }
- INTON;
+ outstr(p, stderr);
+ flusherr();
}
-static struct alias *
-lookupalias(const char *name, int check)
+/*
+ * Initialization code.
+ */
+
+/*
+ * This routine initializes the builtin variables.
+ */
+
+static inline void
+initvar(void)
{
- struct alias *ap = *__lookupalias(name);
+ struct var *vp;
+ struct var *end;
+ struct var **vpp;
- if (check && ap && (ap->flag & ALIASINUSE))
- return (NULL);
- return (ap);
+ /*
+ * PS1 depends on uid
+ */
+#if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ vps1.text = "PS1=\\w \\$ ";
+#else
+ if (!geteuid())
+ vps1.text = "PS1=# ";
+#endif
+ vp = varinit;
+ end = vp + sizeof(varinit) / sizeof(varinit[0]);
+ do {
+ vpp = hashvar(vp->text);
+ vp->next = *vpp;
+ *vpp = vp;
+ } while (++vp < end);
}
-static void
-printalias(const struct alias *ap) {
- char *p;
+static inline void
+init(void)
+{
+
+ /* from input.c: */
+ {
+ basepf.nextc = basepf.buf = basebuf;
+ }
+
+ /* from trap.c: */
+ {
+ signal(SIGCHLD, SIG_DFL);
+ }
+
+ /* from var.c: */
+ {
+ char **envp;
+ char ppid[32];
+
+ initvar();
+ for (envp = environ ; *envp ; envp++) {
+ if (strchr(*envp, '=')) {
+ setvareq(*envp, VEXPORT|VTEXTFIXED);
+ }
+ }
- p = single_quote(ap->val);
- printf("alias %s=%s\n", ap->name, p);
- stunalloc(p);
+ snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
+ setvar("PPID", ppid, 0);
+ setpwd(0, 0);
+ }
}
+/* PEOF (the end of file marker) */
/*
- * TODO - sort output
+ * The input line number. Input.c just defines this variable, and saves
+ * and restores it when files are pushed and popped. The user of this
+ * package must set its value.
*/
-static int
-aliascmd(int argc, char **argv)
-{
- char *n, *v;
- int ret = 0;
- struct alias *ap;
- if (argc == 1) {
- int i;
+static int pgetc(void);
+static int pgetc2(void);
+static int preadbuffer(void);
+static void pungetc(void);
+static void pushstring(char *, void *);
+static void popstring(void);
+static void setinputfile(const char *, int);
+static void setinputfd(int, int);
+static void setinputstring(char *);
+static void popfile(void);
+static void popallfiles(void);
+static void closescript(void);
- for (i = 0; i < ATABSIZE; i++)
- for (ap = atab[i]; ap; ap = ap->next) {
- printalias(ap);
- }
- return (0);
- }
- while ((n = *++argv) != NULL) {
- if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
- if ((ap = *__lookupalias(n)) == NULL) {
- out2fmt("%s: %s not found\n", "alias", n);
- ret = 1;
- } else
- printalias(ap);
- }
- else {
- *v++ = '\0';
- setalias(n, v);
- }
- }
-
- return (ret);
-}
-
-static int
-unaliascmd(int argc, char **argv)
-{
- int i;
- while ((i = nextopt("a")) != '\0') {
- if (i == 'a') {
- rmaliases();
- return (0);
- }
- }
- for (i = 0; *argptr; argptr++) {
- if (unalias(*argptr)) {
- out2fmt("%s: %s not found\n", "unalias", *argptr);
- i = 1;
- }
- }
+/* $NetBSD: jobs.h,v 1.17 2003/01/22 20:36:04 dsl Exp $ */
- return (i);
-}
-static struct alias **
-hashalias(p)
- const char *p;
- {
- unsigned int hashval;
+/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
+#define FORK_FG 0
+#define FORK_BG 1
+#define FORK_NOJOB 2
- hashval = *p << 4;
- while (*p)
- hashval+= *p++;
- return &atab[hashval % ATABSIZE];
-}
+/* mode flags for showjob(s) */
+#define SHOW_PGID 0x01 /* only show pgid - for jobs -p */
+#define SHOW_PID 0x04 /* include process pid */
+#define SHOW_CHANGED 0x08 /* only jobs whose state has changed */
-static struct alias *
-freealias(struct alias *ap) {
- struct alias *next;
- if (ap->flag & ALIASINUSE) {
- ap->flag |= ALIASDEAD;
- return ap;
- }
+/*
+ * A job structure contains information about a job. A job is either a
+ * single process or a set of processes contained in a pipeline. In the
+ * latter case, pidlist will be non-NULL, and will point to a -1 terminated
+ * array of pids.
+ */
- next = ap->next;
- ckfree(ap->name);
- ckfree(ap->val);
- ckfree(ap);
- return next;
-}
+struct procstat {
+ pid_t pid; /* process id */
+ int status; /* last process status from wait() */
+ char *cmd; /* text of command being run */
+};
+struct job {
+ struct procstat ps0; /* status of process */
+ struct procstat *ps; /* status or processes when more than one */
+#if JOBS
+ int stopstatus; /* status of a stopped job */
+#endif
+ uint32_t
+ nprocs: 16, /* number of processes */
+ state: 8,
+#define JOBRUNNING 0 /* at least one proc running */
+#define JOBSTOPPED 1 /* all procs are stopped */
+#define JOBDONE 2 /* all procs are completed */
+#if JOBS
+ sigint: 1, /* job was killed by SIGINT */
+ jobctl: 1, /* job running under job control */
+#endif
+ waited: 1, /* true if this entry has been waited for */
+ used: 1, /* true if this entry is in used */
+ changed: 1; /* true if status has changed */
+ struct job *prev_job; /* previous job */
+};
-static struct alias **
-__lookupalias(const char *name) {
- struct alias **app = hashalias(name);
+static pid_t backgndpid; /* pid of last background process */
+static int job_warning; /* user was warned about stopped jobs */
+#if JOBS
+static int jobctl; /* true if doing job control */
+#endif
- for (; *app; app = &(*app)->next) {
- if (equal(name, (*app)->name)) {
- break;
- }
- }
+static struct job *makejob(union node *, int);
+static int forkshell(struct job *, union node *, int);
+static int waitforjob(struct job *);
+static int stoppedjobs(void);
- return app;
-}
+#if ! JOBS
+#define setjobctl(on) /* do nothing */
+#else
+static void setjobctl(int);
+static void showjobs(FILE *, int);
#endif
-#ifdef ASH_MATH_SUPPORT
-/* The generated file arith.c has been snipped. If you want this
- * stuff back in, feel free to add it to your own copy. */
-#define ARITH_NUM 257
-#define ARITH_LPAREN 258
-#define ARITH_RPAREN 259
-#define ARITH_OR 260
-#define ARITH_AND 261
-#define ARITH_BOR 262
-#define ARITH_BXOR 263
-#define ARITH_BAND 264
-#define ARITH_EQ 265
-#define ARITH_NE 266
-#define ARITH_LT 267
-#define ARITH_GT 268
-#define ARITH_GE 269
-#define ARITH_LE 270
-#define ARITH_LSHIFT 271
-#define ARITH_RSHIFT 272
-#define ARITH_ADD 273
-#define ARITH_SUB 274
-#define ARITH_MUL 275
-#define ARITH_DIV 276
-#define ARITH_REM 277
-#define ARITH_UNARYMINUS 278
-#define ARITH_UNARYPLUS 279
-#define ARITH_NOT 280
-#define ARITH_BNOT 281
-
-static void expari (int);
-/* From arith.y */
-static int arith (const char *);
-static int expcmd (int , char **);
-static void arith_lex_reset (void);
-static int yylex (void);
-
-#endif
-
-static char *trap[NSIG]; /* trap handler commands */
-static char sigmode[NSIG - 1]; /* current value of signal */
-static char gotsig[NSIG - 1]; /* indicates specified signal received */
-static int pendingsigs; /* indicates some signal received */
+/* $NetBSD: main.h,v 1.9 2002/11/24 22:35:41 christos Exp $ */
-/*
- * This file was generated by the mkbuiltins program.
- */
-#ifdef JOBS
-static int bgcmd (int, char **);
-static int fgcmd (int, char **);
-static int killcmd (int, char **);
-#endif
-static int bltincmd (int, char **);
-static int cdcmd (int, char **);
-static int breakcmd (int, char **);
-#ifdef ASH_CMDCMD
-static int commandcmd (int, char **);
-#endif
-static int dotcmd (int, char **);
-static int evalcmd (int, char **);
-static int execcmd (int, char **);
-static int exitcmd (int, char **);
-static int exportcmd (int, char **);
-static int histcmd (int, char **);
-static int hashcmd (int, char **);
-static int helpcmd (int, char **);
-static int jobscmd (int, char **);
-static int localcmd (int, char **);
-#ifndef BB_PWD
-static int pwdcmd (int, char **);
-#endif
-static int readcmd (int, char **);
-static int returncmd (int, char **);
-static int setcmd (int, char **);
-static int setvarcmd (int, char **);
-static int shiftcmd (int, char **);
-static int trapcmd (int, char **);
-static int umaskcmd (int, char **);
-#ifdef ASH_ALIAS
-static int aliascmd (int, char **);
-static int unaliascmd (int, char **);
-#endif
-static int unsetcmd (int, char **);
-static int waitcmd (int, char **);
-static int ulimitcmd (int, char **);
-static int timescmd (int, char **);
-#ifdef ASH_MATH_SUPPORT
-static int expcmd (int, char **);
-#endif
-static int typecmd (int, char **);
-#ifdef ASH_GETOPTS
-static int getoptscmd (int, char **);
-#endif
-
-#ifndef BB_TRUE_FALSE
-static int true_main (int, char **);
-static int false_main (int, char **);
-#endif
-
-static void setpwd (const char *, int);
+/* pid of main shell */
+static int rootpid;
+/* true if we aren't a child of the main shell */
+static int rootshell;
+static void readcmdfile(char *);
+static void cmdloop(int);
-#define BUILTIN_NOSPEC "0"
-#define BUILTIN_SPECIAL "1"
-#define BUILTIN_REGULAR "2"
-#define BUILTIN_ASSIGN "4"
-#define BUILTIN_SPEC_ASSG "5"
-#define BUILTIN_REG_ASSG "6"
+/* $NetBSD: memalloc.h,v 1.13 2003/01/22 20:36:04 dsl Exp $ */
-#define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
-#define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
-#define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
-struct builtincmd {
- const char *name;
- int (*const builtinfunc) (int, char **);
- //unsigned flags;
+struct stackmark {
+ struct stack_block *stackp;
+ char *stacknxt;
+ size_t stacknleft;
+ struct stackmark *marknext;
};
+/* minimum size of a block */
+#define MINSIZE SHELL_ALIGN(504)
-/* It is CRUCIAL that this listing be kept in ascii order, otherwise
- * the binary search in find_builtin() will stop working. If you value
- * your kneecaps, you'll be sure to *make sure* that any changes made
- * to this array result in the listing remaining in ascii order. You
- * have been warned.
- */
-static const struct builtincmd builtincmds[] = {
- { BUILTIN_SPECIAL ".", dotcmd }, /* first, see declare DOTCMD */
- { BUILTIN_SPECIAL ":", true_main },
-#ifdef ASH_ALIAS
- { BUILTIN_REG_ASSG "alias", aliascmd },
-#endif
-#ifdef JOBS
- { BUILTIN_REGULAR "bg", bgcmd },
-#endif
- { BUILTIN_SPECIAL "break", breakcmd },
- { BUILTIN_SPECIAL "builtin", bltincmd },
- { BUILTIN_REGULAR "cd", cdcmd },
- { BUILTIN_NOSPEC "chdir", cdcmd },
-#ifdef ASH_CMDCMD
- { BUILTIN_REGULAR "command", commandcmd },
-#endif
- { BUILTIN_SPECIAL "continue", breakcmd },
- { BUILTIN_SPECIAL "eval", evalcmd },
- { BUILTIN_SPECIAL "exec", execcmd },
- { BUILTIN_SPECIAL "exit", exitcmd },
-#ifdef ASH_MATH_SUPPORT
- { BUILTIN_NOSPEC "exp", expcmd },
-#endif
- { BUILTIN_SPEC_ASSG "export", exportcmd },
- { BUILTIN_REGULAR "false", false_main },
- { BUILTIN_REGULAR "fc", histcmd },
-#ifdef JOBS
- { BUILTIN_REGULAR "fg", fgcmd },
-#endif
-#ifdef ASH_GETOPTS
- { BUILTIN_REGULAR "getopts", getoptscmd },
-#endif
- { BUILTIN_NOSPEC "hash", hashcmd },
- { BUILTIN_NOSPEC "help", helpcmd },
- { BUILTIN_REGULAR "jobs", jobscmd },
-#ifdef JOBS
- { BUILTIN_REGULAR "kill", killcmd },
-#endif
-#ifdef ASH_MATH_SUPPORT
- { BUILTIN_NOSPEC "let", expcmd },
-#endif
- { BUILTIN_ASSIGN "local", localcmd },
-#ifndef BB_PWD
- { BUILTIN_NOSPEC "pwd", pwdcmd },
-#endif
- { BUILTIN_REGULAR "read", readcmd },
- { BUILTIN_SPEC_ASSG "readonly", exportcmd },
- { BUILTIN_SPECIAL "return", returncmd },
- { BUILTIN_SPECIAL "set", setcmd },
- { BUILTIN_NOSPEC "setvar", setvarcmd },
- { BUILTIN_SPECIAL "shift", shiftcmd },
- { BUILTIN_SPECIAL "times", timescmd },
- { BUILTIN_SPECIAL "trap", trapcmd },
- { BUILTIN_REGULAR "true", true_main },
- { BUILTIN_NOSPEC "type", typecmd },
- { BUILTIN_NOSPEC "ulimit", ulimitcmd },
- { BUILTIN_REGULAR "umask", umaskcmd },
-#ifdef ASH_ALIAS
- { BUILTIN_REGULAR "unalias", unaliascmd },
-#endif
- { BUILTIN_SPECIAL "unset", unsetcmd },
- { BUILTIN_REGULAR "wait", waitcmd },
+struct stack_block {
+ struct stack_block *prev;
+ char space[MINSIZE];
};
-#define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) )
-static const struct builtincmd *DOTCMD = &builtincmds[0];
-static struct builtincmd *BLTINCMD;
-static struct builtincmd *EXECCMD;
-static struct builtincmd *EVALCMD;
+static struct stack_block stackbase;
+static struct stack_block *stackp = &stackbase;
+static struct stackmark *markp;
+static char *stacknxt = stackbase.space;
+static size_t stacknleft = MINSIZE;
+static char *sstrend = stackbase.space + MINSIZE;
+static int herefd = -1;
-/* states */
-#define JOBSTOPPED 1 /* all procs are stopped */
-#define JOBDONE 2 /* all procs are completed */
-/*
- * A job structure contains information about a job. A job is either a
- * single process or a set of processes contained in a pipeline. In the
- * latter case, pidlist will be non-NULL, and will point to a -1 terminated
- * array of pids.
- */
+static pointer ckmalloc(size_t);
+static pointer ckrealloc(pointer, size_t);
+static char *savestr(const char *);
+static pointer stalloc(size_t);
+static void stunalloc(pointer);
+static void setstackmark(struct stackmark *);
+static void popstackmark(struct stackmark *);
+static void growstackblock(void);
+static void *growstackstr(void);
+static char *makestrspace(size_t, char *);
+static char *stnputs(const char *, size_t, char *);
+static char *stputs(const char *, char *);
-struct procstat {
- pid_t pid; /* process id */
- int status; /* status flags (defined above) */
- char *cmd; /* text of command being run */
-};
+static inline char *_STPUTC(char c, char *p) {
+ if (p == sstrend)
+ p = growstackstr();
+ *p++ = c;
+ return p;
+}
-static int job_warning; /* user was warned about stopped jobs */
+#define stackblock() ((void *)stacknxt)
+#define stackblocksize() stacknleft
+#define STARTSTACKSTR(p) ((p) = stackblock())
+#define STPUTC(c, p) ((p) = _STPUTC((c), (p)))
+#define CHECKSTRSPACE(n, p) \
+ ({ \
+ char *q = (p); \
+ size_t l = (n); \
+ size_t m = sstrend - q; \
+ if (l > m) \
+ (p) = makestrspace(l, q); \
+ 0; \
+ })
+#define USTPUTC(c, p) (*p++ = (c))
+#define STACKSTRNUL(p) ((p) == sstrend? (p = growstackstr(), *p = '\0') : (*p = '\0'))
+#define STUNPUTC(p) (--p)
+#define STTOPC(p) p[-1]
+#define STADJUST(amount, p) (p += (amount))
-#ifdef JOBS
-static void setjobctl(int enable);
-#else
-#define setjobctl(on) /* do nothing */
-#endif
+#define grabstackstr(p) stalloc((char *)(p) - (char *)stackblock())
+#define ungrabstackstr(s, p) stunalloc((s))
+#define stackstrend() ((void *)sstrend)
+#define ckfree(p) free((pointer)(p))
-struct job {
- struct procstat ps0; /* status of process */
- struct procstat *ps; /* status or processes when more than one */
- short nprocs; /* number of processes */
- short pgrp; /* process group of this job */
- char state; /* true if job is finished */
- char used; /* true if this entry is in used */
- char changed; /* true if status has changed */
-#ifdef JOBS
- char jobctl; /* job running under job control */
-#endif
-};
+/* $NetBSD: mystring.h,v 1.10 2002/11/24 22:35:42 christos Exp $ */
-static struct job *jobtab; /* array of jobs */
-static int njobs; /* size of array */
-static int backgndpid = -1; /* pid of last background process */
-#ifdef JOBS
-static int initialpgrp; /* pgrp of shell on invocation */
-static int curjob; /* current job */
-static int jobctl;
-#endif
-static int intreceived;
-static struct job *makejob (const union node *, int);
-static int forkshell (struct job *, const union node *, int);
-static int waitforjob (struct job *);
+#define DOLATSTRLEN 4
-static int docd (char *, int);
-static char *getcomponent (void);
-static void updatepwd (const char *);
-static void getpwd (void);
+static char *prefix(const char *, const char *);
+static int number(const char *);
+static int is_number(const char *);
+static char *single_quote(const char *);
+static char *sstrdup(const char *);
-static char *padvance (const char **, const char *);
+#define equal(s1, s2) (strcmp(s1, s2) == 0)
+#define scopy(s1, s2) ((void)strcpy(s2, s1))
-static char nullstr[1]; /* zero length string */
-static char *curdir = nullstr; /* current working directory */
-static char *cdcomppath;
+/* $NetBSD: options.h,v 1.16 2003/01/22 20:36:04 dsl Exp $ */
-static int
-cdcmd(argc, argv)
- int argc;
- char **argv;
-{
- const char *dest;
- const char *path;
- char *p;
- struct stat statb;
- int print = 0;
+struct shparam {
+ int nparam; /* # of positional parameters (without $0) */
+ unsigned char malloc; /* if parameter list dynamically allocated */
+ char **p; /* parameter list */
+#ifdef CONFIG_ASH_GETOPTS
+ int optind; /* next parameter to be processed by getopts */
+ int optoff; /* used by getopts */
+#endif
+};
- nextopt(nullstr);
- if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL)
- error("HOME not set");
- if (*dest == '\0')
- dest = ".";
- if (dest[0] == '-' && dest[1] == '\0') {
- dest = bltinlookup("OLDPWD");
- if (!dest || !*dest) {
- dest = curdir;
- }
- print = 1;
- if (dest)
- print = 1;
- else
- dest = ".";
- }
- if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL)
- path = nullstr;
- while ((p = padvance(&path, dest)) != NULL) {
- if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
- if (!print) {
- /*
- * XXX - rethink
- */
- if (p[0] == '.' && p[1] == '/' && p[2] != '\0')
- p += 2;
- print = strcmp(p, dest);
- }
- if (docd(p, print) >= 0)
- return 0;
- }
- }
- error("can't cd to %s", dest);
- /* NOTREACHED */
-}
+#define eflag optlist[0]
+#define fflag optlist[1]
+#define Iflag optlist[2]
+#define iflag optlist[3]
+#define mflag optlist[4]
+#define nflag optlist[5]
+#define sflag optlist[6]
+#define xflag optlist[7]
+#define vflag optlist[8]
+#define Cflag optlist[9]
+#define aflag optlist[10]
+#define bflag optlist[11]
+#define uflag optlist[12]
+#define qflag optlist[13]
+#ifdef DEBUG
+#define nolog optlist[14]
+#define debug optlist[15]
+#define NOPTS 16
+#else
+#define NOPTS 14
+#endif
+
+/* $NetBSD: options.c,v 1.33 2003/01/22 20:36:04 dsl Exp $ */
+
+
+static const char *const optletters_optnames[NOPTS] = {
+ "e" "errexit",
+ "f" "noglob",
+ "I" "ignoreeof",
+ "i" "interactive",
+ "m" "monitor",
+ "n" "noexec",
+ "s" "stdin",
+ "x" "xtrace",
+ "v" "verbose",
+ "C" "noclobber",
+ "a" "allexport",
+ "b" "notify",
+ "u" "nounset",
+ "q" "quietprofile",
+#ifdef DEBUG
+ "\0" "nolog",
+ "\0" "debug",
+#endif
+};
-/*
- * Actually do the chdir. In an interactive shell, print the
- * directory name if "print" is nonzero.
- */
+#define optletters(n) optletters_optnames[(n)][0]
+#define optnames(n) (&optletters_optnames[(n)][1])
-static int
-docd(dest, print)
- char *dest;
- int print;
-{
- char *p;
- char *q;
- char *component;
- struct stat statb;
- int first;
- int badstat;
- TRACE(("docd(\"%s\", %d) called\n", dest, print));
+static char optlist[NOPTS];
- /*
- * Check each component of the path. If we find a symlink or
- * something we can't stat, clear curdir to force a getcwd()
- * next time we get the value of the current directory.
- */
- badstat = 0;
- cdcomppath = sstrdup(dest);
- STARTSTACKSTR(p);
- if (*dest == '/') {
- STPUTC('/', p);
- cdcomppath++;
- }
- first = 1;
- while ((q = getcomponent()) != NULL) {
- if (q[0] == '\0' || (q[0] == '.' && q[1] == '\0'))
- continue;
- if (! first)
- STPUTC('/', p);
- first = 0;
- component = q;
- while (*q)
- STPUTC(*q++, p);
- if (equal(component, ".."))
- continue;
- STACKSTRNUL(p);
- if ((lstat(stackblock(), &statb) < 0)
- || (S_ISLNK(statb.st_mode))) {
- /* print = 1; */
- badstat = 1;
- break;
- }
- }
- INTOFF;
- if (chdir(dest) < 0) {
- INTON;
- return -1;
- }
- updatepwd(badstat ? NULL : dest);
- INTON;
- if (print && iflag)
- printf(snlfmt, curdir);
- return 0;
-}
+static char *arg0; /* value of $0 */
+static struct shparam shellparam; /* $@ current positional parameters */
+static char **argptr; /* argument list for builtin commands */
+static char *optionarg; /* set by nextopt (like getopt) */
+static char *optptr; /* used by nextopt */
+static char *minusc; /* argument to -c option */
-/*
- * Get the next component of the path name pointed to by cdcomppath.
- * This routine overwrites the string pointed to by cdcomppath.
- */
-static char *
-getcomponent() {
- char *p;
- char *start;
+static void procargs(int, char **);
+static void optschanged(void);
+static void setparam(char **);
+static void freeparam(volatile struct shparam *);
+static int shiftcmd(int, char **);
+static int setcmd(int, char **);
+static int nextopt(const char *);
- if ((p = cdcomppath) == NULL)
- return NULL;
- start = cdcomppath;
- while (*p != '/' && *p != '\0')
- p++;
- if (*p == '\0') {
- cdcomppath = NULL;
- } else {
- *p++ = '\0';
- cdcomppath = p;
- }
- return start;
-}
+/* $NetBSD: redir.h,v 1.14 2002/11/24 22:35:43 christos Exp $ */
+/* flags passed to redirect */
+#define REDIR_PUSH 01 /* save previous values of file descriptors */
+#define REDIR_SAVEFD2 03 /* set preverrout */
+union node;
+static void redirect(union node *, int);
+static void popredir(int);
+static void clearredir(int);
+static int copyfd(int, int);
+static int redirectsafe(union node *, int);
-/*
- * Update curdir (the name of the current directory) in response to a
- * cd command. We also call hashcd to let the routines in exec.c know
- * that the current directory has changed.
- */
+/* $NetBSD: show.h,v 1.6 2003/01/22 20:36:04 dsl Exp $ */
-static void hashcd (void);
-static void
-updatepwd(const char *dir)
-{
- char *new;
- char *p;
- size_t len;
+#ifdef DEBUG
+static void showtree(union node *);
+static void trace(const char *, ...);
+static void tracev(const char *, va_list);
+static void trargs(char **);
+static void trputc(int);
+static void trputs(const char *);
+static void opentrace(void);
+#endif
- hashcd(); /* update command hash table */
+/* $NetBSD: trap.h,v 1.16 2002/11/24 22:35:43 christos Exp $ */
- /*
- * If our argument is NULL, we don't know the current directory
- * any more because we traversed a symbolic link or something
- * we couldn't stat().
- */
- if (dir == NULL || curdir == nullstr) {
- setpwd(0, 1);
- return;
- }
- len = strlen(dir);
- cdcomppath = sstrdup(dir);
- STARTSTACKSTR(new);
- if (*dir != '/') {
- p = curdir;
- while (*p)
- STPUTC(*p++, new);
- if (p[-1] == '/')
- STUNPUTC(new);
- }
- while ((p = getcomponent()) != NULL) {
- if (equal(p, "..")) {
- while (new > stackblock() && (STUNPUTC(new), *new) != '/');
- } else if (*p != '\0' && ! equal(p, ".")) {
- STPUTC('/', new);
- while (*p)
- STPUTC(*p++, new);
- }
- }
- if (new == stackblock())
- STPUTC('/', new);
- STACKSTRNUL(new);
- setpwd(stackblock(), 1);
-}
+/* trap handler commands */
+static char *trap[NSIG];
+/* current value of signal */
+static char sigmode[NSIG - 1];
+/* indicates specified signal received */
+static char gotsig[NSIG - 1];
-#ifndef BB_PWD
-static int
-pwdcmd(argc, argv)
- int argc;
- char **argv;
-{
- printf(snlfmt, curdir);
- return 0;
-}
-#endif
+static void clear_traps(void);
+static void setsignal(int);
+static void ignoresig(int);
+static void onsig(int);
+static void dotrap(void);
+static void setinteractive(int);
+static void exitshell(void) __attribute__((__noreturn__));
+static int decode_signal(const char *, int);
/*
- * Find out what the current directory is. If we already know the current
- * directory, this routine returns immediately.
+ * This routine is called when an error or an interrupt occurs in an
+ * interactive shell and control is returned to the main command loop.
*/
-static void
-getpwd(void)
-{
- curdir = xgetcwd(0);
- if(curdir==0)
- curdir = nullstr;
-}
static void
-setpwd(const char *val, int setold)
+reset(void)
{
- if (setold) {
- setvar("OLDPWD", curdir, VEXPORT);
- }
- INTOFF;
- if (curdir != nullstr) {
- free(curdir);
- curdir = nullstr;
- }
- if (!val) {
- getpwd();
- } else {
- curdir = savestr(val);
- }
- INTON;
- setvar("PWD", curdir, VEXPORT);
-}
+ /* from eval.c: */
+ {
+ evalskip = 0;
+ loopnest = 0;
+ funcnest = 0;
+ }
-/*
- * Errors and exceptions.
- */
+ /* from input.c: */
+ {
+ parselleft = parsenleft = 0; /* clear input buffer */
+ popallfiles();
+ }
-/*
- * Code to handle exceptions in C.
- */
+ /* from parser.c: */
+ {
+ tokpushback = 0;
+ checkkwd = 0;
+ }
-/*
- * We enclose jmp_buf in a structure so that we can declare pointers to
- * jump locations. The global variable handler contains the location to
- * jump to when an exception occurs, and the global variable exception
- * contains a code identifying the exeception. To implement nested
- * exception handlers, the user should save the value of handler on entry
- * to an inner scope, set handler to point to a jmploc structure for the
- * inner scope, and restore handler on exit from the scope.
- */
+ /* from redir.c: */
+ {
+ clearredir(0);
+ }
-struct jmploc {
- jmp_buf loc;
-};
+}
-/* exceptions */
-#define EXINT 0 /* SIGINT received */
-#define EXERROR 1 /* a generic error */
-#define EXSHELLPROC 2 /* execute a shell procedure */
-#define EXEXEC 3 /* command execution failed */
+#ifdef CONFIG_ASH_ALIAS
+static struct alias *atab[ATABSIZE];
-static struct jmploc *handler;
-static int exception;
+static void setalias(const char *, const char *);
+static struct alias *freealias(struct alias *);
+static struct alias **__lookupalias(const char *);
-static void exverror (int, const char *, va_list)
- __attribute__((__noreturn__));
+static void
+setalias(const char *name, const char *val)
+{
+ struct alias *ap, **app;
-/*
- * Called to raise an exception. Since C doesn't include exceptions, we
- * just do a longjmp to the exception handler. The type of exception is
- * stored in the global variable "exception".
- */
+ app = __lookupalias(name);
+ ap = *app;
+ INTOFF;
+ if (ap) {
+ if (!(ap->flag & ALIASINUSE)) {
+ ckfree(ap->val);
+ }
+ ap->val = savestr(val);
+ ap->flag &= ~ALIASDEAD;
+ } else {
+ /* not found */
+ ap = ckmalloc(sizeof (struct alias));
+ ap->name = savestr(name);
+ ap->val = savestr(val);
+ ap->flag = 0;
+ ap->next = 0;
+ *app = ap;
+ }
+ INTON;
+}
-static void exraise (int) __attribute__((__noreturn__));
+static int
+unalias(const char *name)
+{
+ struct alias **app;
+
+ app = __lookupalias(name);
+
+ if (*app) {
+ INTOFF;
+ *app = freealias(*app);
+ INTON;
+ return (0);
+ }
+
+ return (1);
+}
static void
-exraise(int e)
+rmaliases(void)
{
-#ifdef DEBUG
- if (handler == NULL)
- abort();
-#endif
- flushall();
- exception = e;
- longjmp(handler->loc, 1);
+ struct alias *ap, **app;
+ int i;
+
+ INTOFF;
+ for (i = 0; i < ATABSIZE; i++) {
+ app = &atab[i];
+ for (ap = *app; ap; ap = *app) {
+ *app = freealias(*app);
+ if (ap == *app) {
+ app = &ap->next;
+ }
+ }
+ }
+ INTON;
}
+static struct alias *
+lookupalias(const char *name, int check)
+{
+ struct alias *ap = *__lookupalias(name);
+
+ if (check && ap && (ap->flag & ALIASINUSE))
+ return (NULL);
+ return (ap);
+}
/*
- * Called from trap.c when a SIGINT is received. (If the user specifies
- * that SIGINT is to be trapped or ignored using the trap builtin, then
- * this routine is not called.) Suppressint is nonzero when interrupts
- * are held using the INTOFF macro. The call to _exit is necessary because
- * there is a short period after a fork before the signal handlers are
- * set to the appropriate value for the child. (The test for iflag is
- * just defensive programming.)
+ * TODO - sort output
*/
+static int
+aliascmd(int argc, char **argv)
+{
+ char *n, *v;
+ int ret = 0;
+ struct alias *ap;
-static void
-onint(void) {
- sigset_t mysigset;
+ if (argc == 1) {
+ int i;
- if (suppressint) {
- intpending++;
- return;
+ for (i = 0; i < ATABSIZE; i++)
+ for (ap = atab[i]; ap; ap = ap->next) {
+ printalias(ap);
+ }
+ return (0);
}
- intpending = 0;
- sigemptyset(&mysigset);
- sigprocmask(SIG_SETMASK, &mysigset, NULL);
- if (rootshell && iflag)
- exraise(EXINT);
- else {
- signal(SIGINT, SIG_DFL);
- raise(SIGINT);
+ while ((n = *++argv) != NULL) {
+ if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
+ if ((ap = *__lookupalias(n)) == NULL) {
+ fprintf(stderr, "%s: %s not found\n", "alias", n);
+ ret = 1;
+ } else
+ printalias(ap);
+ } else {
+ *v++ = '\0';
+ setalias(n, v);
+ }
}
- /* NOTREACHED */
-}
-
-static char *commandname; /* currently executing command */
+ return (ret);
+}
-/*
- * Exverror is called to raise the error exception. If the first argument
- * is not NULL then error prints an error message using printf style
- * formatting. It then raises the error exception.
- */
-static void
-exverror(int cond, const char *msg, va_list ap)
+static int
+unaliascmd(int argc, char **argv)
{
- CLEAR_PENDING_INT;
- INTOFF;
+ int i;
-#ifdef DEBUG
- if (msg)
- TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
- else
- TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
-#endif
- if (msg) {
- if (commandname)
- out2fmt("%s: ", commandname);
- vfprintf(stderr, msg, ap);
- out2c('\n');
+ while ((i = nextopt("a")) != '\0') {
+ if (i == 'a') {
+ rmaliases();
+ return (0);
+ }
}
- exraise(cond);
- /* NOTREACHED */
+ for (i = 0; *argptr; argptr++) {
+ if (unalias(*argptr)) {
+ fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
+ i = 1;
+ }
+ }
+
+ return (i);
}
+static struct alias *
+freealias(struct alias *ap) {
+ struct alias *next;
+
+ if (ap->flag & ALIASINUSE) {
+ ap->flag |= ALIASDEAD;
+ return ap;
+ }
+
+ next = ap->next;
+ ckfree(ap->name);
+ ckfree(ap->val);
+ ckfree(ap);
+ return next;
+}
-#ifdef __STDC__
-static void
-error(const char *msg, ...)
-#else
static void
-error(va_alist)
- va_dcl
-#endif
-{
-#ifndef __STDC__
- const char *msg;
-#endif
- va_list ap;
-#ifdef __STDC__
- va_start(ap, msg);
-#else
- va_start(ap);
- msg = va_arg(ap, const char *);
-#endif
- exverror(EXERROR, msg, ap);
- /* NOTREACHED */
- va_end(ap);
+printalias(const struct alias *ap) {
+ out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
}
+static struct alias **
+__lookupalias(const char *name) {
+ unsigned int hashval;
+ struct alias **app;
+ const char *p;
+ unsigned int ch;
-#ifdef __STDC__
-static void
-exerror(int cond, const char *msg, ...)
-#else
-static void
-exerror(va_alist)
- va_dcl
-#endif
-{
-#ifndef __STDC__
- int cond;
- const char *msg;
-#endif
- va_list ap;
-#ifdef __STDC__
- va_start(ap, msg);
-#else
- va_start(ap);
- cond = va_arg(ap, int);
- msg = va_arg(ap, const char *);
-#endif
- exverror(cond, msg, ap);
- /* NOTREACHED */
- va_end(ap);
+ p = name;
+
+ ch = (unsigned char)*p;
+ hashval = ch << 4;
+ while (ch) {
+ hashval += ch;
+ ch = (unsigned char)*++p;
+ }
+ app = &atab[hashval % ATABSIZE];
+
+ for (; *app; app = &(*app)->next) {
+ if (equal(name, (*app)->name)) {
+ break;
+ }
+ }
+
+ return app;
}
+#endif /* CONFIG_ASH_ALIAS */
+/* $NetBSD: cd.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */
/*
- * Table of error messages.
+ * The cd and pwd commands.
*/
-struct errname {
- short errcode; /* error number */
- char action; /* operation which encountered the error */
-};
+#define CD_PHYSICAL 1
+#define CD_PRINT 2
+
+static int docd(const char *, int);
+static int cdopt(void);
+
+static char *curdir = nullstr; /* current working directory */
+static char *physdir = nullstr; /* physical working directory */
+
+static int
+cdopt(void)
+{
+ int flags = 0;
+ int i, j;
+
+ j = 'L';
+ while ((i = nextopt("LP"))) {
+ if (i != j) {
+ flags ^= CD_PHYSICAL;
+ j = i;
+ }
+ }
+
+ return flags;
+}
+
+static int
+cdcmd(int argc, char **argv)
+{
+ const char *dest;
+ const char *path;
+ const char *p;
+ char c;
+ struct stat statb;
+ int flags;
+
+ flags = cdopt();
+ dest = *argptr;
+ if (!dest)
+ dest = bltinlookup(homestr);
+ else if (dest[0] == '-' && dest[1] == '\0') {
+ dest = bltinlookup("OLDPWD");
+ if ( !dest ) goto out;
+ flags |= CD_PRINT;
+ goto step7;
+ }
+ if (!dest)
+ dest = nullstr;
+ if (*dest == '/')
+ goto step7;
+ if (*dest == '.') {
+ c = dest[1];
+dotdot:
+ switch (c) {
+ case '\0':
+ case '/':
+ goto step6;
+ case '.':
+ c = dest[2];
+ if (c != '.')
+ goto dotdot;
+ }
+ }
+ if (!*dest)
+ dest = ".";
+ if (!(path = bltinlookup("CDPATH"))) {
+step6:
+step7:
+ p = dest;
+ goto docd;
+ }
+ do {
+ c = *path;
+ p = padvance(&path, dest);
+ if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
+ if (c && c != ':')
+ flags |= CD_PRINT;
+docd:
+ if (!docd(p, flags))
+ goto out;
+ break;
+ }
+ } while (path);
+ error("can't cd to %s", dest);
+ /* NOTREACHED */
+out:
+ if (flags & CD_PRINT)
+ out1fmt(snlfmt, curdir);
+ return 0;
+}
+
/*
- * Types of operations (passed to the errmsg routine).
+ * Update curdir (the name of the current directory) in response to a
+ * cd command.
*/
-#define E_OPEN 01 /* opening a file */
-#define E_CREAT 02 /* creating a file */
-#define E_EXEC 04 /* executing a program */
+static inline const char *
+updatepwd(const char *dir)
+{
+ char *new;
+ char *p;
+ char *cdcomppath;
+ const char *lim;
-#define ALL (E_OPEN|E_CREAT|E_EXEC)
+ cdcomppath = sstrdup(dir);
+ STARTSTACKSTR(new);
+ if (*dir != '/') {
+ if (curdir == nullstr)
+ return 0;
+ new = stputs(curdir, new);
+ }
+ new = makestrspace(strlen(dir) + 2, new);
+ lim = stackblock() + 1;
+ if (*dir != '/') {
+ if (new[-1] != '/')
+ USTPUTC('/', new);
+ if (new > lim && *lim == '/')
+ lim++;
+ } else {
+ USTPUTC('/', new);
+ cdcomppath++;
+ if (dir[1] == '/' && dir[2] != '/') {
+ USTPUTC('/', new);
+ cdcomppath++;
+ lim++;
+ }
+ }
+ p = strtok(cdcomppath, "/");
+ while (p) {
+ switch(*p) {
+ case '.':
+ if (p[1] == '.' && p[2] == '\0') {
+ while (new > lim) {
+ STUNPUTC(new);
+ if (new[-1] == '/')
+ break;
+ }
+ break;
+ } else if (p[1] == '\0')
+ break;
+ /* fall through */
+ default:
+ new = stputs(p, new);
+ USTPUTC('/', new);
+ }
+ p = strtok(0, "/");
+ }
+ if (new > lim)
+ STUNPUTC(new);
+ *new = 0;
+ return stackblock();
+}
-static const struct errname errormsg[] = {
- { EINTR, ALL },
- { EACCES, ALL },
- { EIO, ALL },
- { ENOENT, E_OPEN },
- { ENOENT, E_CREAT },
- { ENOENT, E_EXEC },
- { ENOTDIR, E_OPEN },
- { ENOTDIR, E_CREAT },
- { ENOTDIR, E_EXEC },
- { EISDIR, ALL },
- { EEXIST, E_CREAT },
-#ifdef EMFILE
- { EMFILE, ALL },
-#endif
- { ENFILE, ALL },
- { ENOSPC, ALL },
-#ifdef EDQUOT
- { EDQUOT, ALL },
-#endif
-#ifdef ENOSR
- { ENOSR, ALL },
-#endif
- { ENXIO, ALL },
- { EROFS, ALL },
- { ETXTBSY, ALL },
-#ifdef EAGAIN
- { EAGAIN, E_EXEC },
-#endif
- { ENOMEM, ALL },
-#ifdef ENOLINK
- { ENOLINK, ALL },
-#endif
-#ifdef EMULTIHOP
- { EMULTIHOP, ALL },
-#endif
-#ifdef ECOMM
- { ECOMM, ALL },
-#endif
-#ifdef ESTALE
- { ESTALE, ALL },
-#endif
-#ifdef ETIMEDOUT
- { ETIMEDOUT, ALL },
-#endif
-#ifdef ELOOP
- { ELOOP, ALL },
-#endif
- { E2BIG, E_EXEC },
-#ifdef ELIBACC
- { ELIBACC, E_EXEC },
-#endif
-};
+/*
+ * Actually do the chdir. We also call hashcd to let the routines in exec.c
+ * know that the current directory has changed.
+ */
+
+static int
+docd(const char *dest, int flags)
+{
+ const char *dir = 0;
+ int err;
-#define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname))
+ TRACE(("docd(\"%s\", %d) called\n", dest, flags));
+
+ INTOFF;
+ if (!(flags & CD_PHYSICAL)) {
+ dir = updatepwd(dest);
+ if (dir)
+ dest = dir;
+ }
+ err = chdir(dest);
+ if (err)
+ goto out;
+ setpwd(dir, 1);
+ hashcd();
+out:
+ INTON;
+ return err;
+}
/*
- * Return a string describing an error. The returned string may be a
- * pointer to a static buffer that will be overwritten on the next call.
- * Action describes the operation that got the error.
+ * Find out what the current directory is. If we already know the current
+ * directory, this routine returns immediately.
*/
+static inline char *
+getpwd(void)
+{
+ char *dir = getcwd(0, 0);
+ return dir ? dir : nullstr;
+}
-static const char *
-errmsg(int e, int action)
+static int
+pwdcmd(int argc, char **argv)
{
- struct errname const *ep;
- static char buf[12];
+ int flags;
+ const char *dir = curdir;
- for (ep = errormsg ; ep < errormsg+ERRNAME_SIZE; ep++) {
- if (ep->errcode == e && (ep->action & action) != 0)
- return strerror(e);
+ flags = cdopt();
+ if (flags) {
+ if (physdir == nullstr)
+ setpwd(dir, 0);
+ dir = physdir;
}
+ out1fmt(snlfmt, dir);
+ return 0;
+}
- snprintf(buf, sizeof buf, "error %d", e);
- return buf;
+static void
+setpwd(const char *val, int setold)
+{
+ char *oldcur, *dir;
+
+ oldcur = dir = curdir;
+
+ if (setold) {
+ setvar("OLDPWD", oldcur, VEXPORT);
+ }
+ INTOFF;
+ if (physdir != nullstr) {
+ if (physdir != oldcur)
+ free(physdir);
+ physdir = nullstr;
+ }
+ if (oldcur == val || !val) {
+ char *s = getpwd();
+ physdir = s;
+ if (!val)
+ dir = s;
+ } else
+ dir = savestr(val);
+ if (oldcur != dir && oldcur != nullstr) {
+ free(oldcur);
+ }
+ curdir = dir;
+ INTON;
+ setvar("PWD", dir, VEXPORT);
+}
+
+/* $NetBSD: error.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */
+
+/*
+ * Errors and exceptions.
+ */
+
+/*
+ * Code to handle exceptions in C.
+ */
+
+
+
+static void exverror(int, const char *, va_list)
+ __attribute__((__noreturn__));
+
+/*
+ * Called to raise an exception. Since C doesn't include exceptions, we
+ * just do a longjmp to the exception handler. The type of exception is
+ * stored in the global variable "exception".
+ */
+
+static void
+exraise(int e)
+{
+#ifdef DEBUG
+ if (handler == NULL)
+ abort();
+#endif
+ INTOFF;
+
+ exception = e;
+ longjmp(handler->loc, 1);
}
-#ifdef ASH_OPTIMIZE_FOR_SIZE
+/*
+ * Called from trap.c when a SIGINT is received. (If the user specifies
+ * that SIGINT is to be trapped or ignored using the trap builtin, then
+ * this routine is not called.) Suppressint is nonzero when interrupts
+ * are held using the INTOFF macro. (The test for iflag is just
+ * defensive programming.)
+ */
+
static void
-__inton() {
- if (--suppressint == 0 && intpending) {
- onint();
+onint(void) {
+ int i;
+
+ intpending = 0;
+ sigsetmask(0);
+ i = EXSIG;
+ if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
+ if (!(rootshell && iflag)) {
+ signal(SIGINT, SIG_DFL);
+ raise(SIGINT);
+ }
+ i = EXINT;
}
+ exraise(i);
+ /* NOTREACHED */
}
-static void forceinton (void) {
- suppressint = 0;
- if (intpending)
- onint();
+
+static void
+exvwarning(const char *msg, va_list ap)
+{
+ FILE *errs;
+ const char *name;
+ const char *fmt;
+
+ errs = stderr;
+ name = arg0;
+ fmt = "%s: ";
+ if (commandname) {
+ name = commandname;
+ fmt = "%s: %d: ";
+ }
+ fprintf(errs, fmt, name, startlinno);
+ vfprintf(errs, msg, ap);
+ outcslow('\n', errs);
}
+
+/*
+ * Exverror is called to raise the error exception. If the second argument
+ * is not NULL then error prints an error message using printf style
+ * formatting. It then raises the error exception.
+ */
+static void
+exverror(int cond, const char *msg, va_list ap)
+{
+#ifdef DEBUG
+ if (msg) {
+ TRACE(("exverror(%d, \"", cond));
+ TRACEV((msg, ap));
+ TRACE(("\") pid=%d\n", getpid()));
+ } else
+ TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
+ if (msg)
#endif
+ exvwarning(msg, ap);
+
+ flushall();
+ exraise(cond);
+ /* NOTREACHED */
+}
+
+
+static void
+error(const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ exverror(EXERROR, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+
+static void
+exerror(int cond, const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ exverror(cond, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+/*
+ * error/warning routines for external builtins
+ */
+
+static void
+sh_warnx(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ exvwarning(fmt, ap);
+ va_end(ap);
+}
+
+
+/*
+ * Return a string describing an error. The returned string may be a
+ * pointer to a static buffer that will be overwritten on the next call.
+ * Action describes the operation that got the error.
+ */
+
+static const char *
+errmsg(int e, const char *em)
+{
+ if(e == ENOENT || e == ENOTDIR) {
+
+ return em;
+ }
+ return strerror(e);
+}
+
+
+/* $NetBSD: eval.c,v 1.71 2003/01/23 03:33:16 rafal Exp $ */
+
+/*
+ * Evaluate a command.
+ */
/* flags in argument to evaltree */
#define EV_EXIT 01 /* exit after evaluating tree */
#define EV_TESTED 02 /* exit status is checked; ignore -e flag */
#define EV_BACKCMD 04 /* command executing within back quotes */
-static int evalskip; /* set if we are skipping commands */
-static int skipcount; /* number of levels to skip */
-static int loopnest; /* current loop nesting level */
-static int funcnest; /* depth of function calls */
+
+static void evalloop(union node *, int);
+static void evalfor(union node *, int);
+static void evalcase(union node *, int);
+static void evalsubshell(union node *, int);
+static void expredir(union node *);
+static void evalpipe(union node *, int);
+static void evalcommand(union node *, int);
+static int evalbltin(const struct builtincmd *, int, char **);
+static int evalfun(struct funcnode *, int, char **, int);
+static void prehash(union node *);
+static int bltincmd(int, char **);
-static struct strlist *cmdenviron; /* environment for builtin command */
-static int exitstatus; /* exit status of last command */
-static int oexitstatus; /* saved exit status */
+static const struct builtincmd bltin = {
+ "\0\0", bltincmd
+};
-static void evalsubshell (const union node *, int);
-static void expredir (union node *);
-static void prehash (union node *);
-static void eprintlist (struct strlist *);
-static union node *parsecmd(int);
/*
* Called to reset things after an exception.
*/
/*
- * The eval commmand.
+ * The eval command.
*/
-static void evalstring (char *, int);
static int
-evalcmd(argc, argv)
- int argc;
- char **argv;
+evalcmd(int argc, char **argv)
{
char *p;
char *concat;
STARTSTACKSTR(concat);
ap = argv + 2;
for (;;) {
- while (*p)
- STPUTC(*p++, concat);
+ concat = stputs(p, concat);
if ((p = *ap++) == NULL)
break;
STPUTC(' ', concat);
STPUTC('\0', concat);
p = grabstackstr(concat);
}
- evalstring(p, EV_TESTED);
+ evalstring(p);
}
return exitstatus;
}
+
/*
* Execute a command or commands contained in a string.
*/
-static void evaltree (union node *, int);
-static void setinputstring (char *);
-static void popfile (void);
-static void setstackmark(struct stackmark *mark);
-static void popstackmark(struct stackmark *mark);
-
-
static void
-evalstring(char *s, int flag)
+evalstring(char *s)
{
union node *n;
struct stackmark smark;
setstackmark(&smark);
setinputstring(s);
+
while ((n = parsecmd(0)) != NEOF) {
- evaltree(n, flag);
+ evaltree(n, 0);
popstackmark(&smark);
+ if (evalskip)
+ break;
}
popfile();
popstackmark(&smark);
}
-static struct builtincmd *find_builtin (const char *);
-static void expandarg (union node *, struct arglist *, int);
-static void calcsize (const union node *);
-static union node *copynode (const union node *);
+
/*
- * Make a copy of a parse tree.
- */
-
-static int funcblocksize; /* size of structures in function */
-static int funcstringsize; /* size of strings in node */
-static pointer funcblock; /* block to allocate function from */
-static char *funcstring; /* block to allocate strings from */
-
-
-static inline union node *
-copyfunc(union node *n)
-{
- if (n == NULL)
- return NULL;
- funcblocksize = 0;
- funcstringsize = 0;
- calcsize(n);
- funcblock = ckmalloc(funcblocksize + funcstringsize);
- funcstring = (char *) funcblock + funcblocksize;
- return copynode(n);
-}
-
-/*
- * Free a parse tree.
+ * Evaluate a parse tree. The value is left in the global variable
+ * exitstatus.
*/
static void
-freefunc(union node *n)
+evaltree(union node *n, int flags)
{
- if (n)
- ckfree(n);
+ int checkexit = 0;
+ void (*evalfn)(union node *, int);
+ unsigned isor;
+ int status;
+ if (n == NULL) {
+ TRACE(("evaltree(NULL) called\n"));
+ goto out;
+ }
+ TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
+ getpid(), n, n->type, flags));
+ switch (n->type) {
+ default:
+#ifdef DEBUG
+ out1fmt("Node type = %d\n", n->type);
+ fflush(stdout);
+ break;
+#endif
+ case NNOT:
+ evaltree(n->nnot.com, EV_TESTED);
+ status = !exitstatus;
+ goto setstatus;
+ case NREDIR:
+ expredir(n->nredir.redirect);
+ status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
+ if (!status) {
+ evaltree(n->nredir.n, flags & EV_TESTED);
+ status = exitstatus;
+ }
+ popredir(0);
+ goto setstatus;
+ case NCMD:
+ evalfn = evalcommand;
+checkexit:
+ if (eflag && !(flags & EV_TESTED))
+ checkexit = ~0;
+ goto calleval;
+ case NFOR:
+ evalfn = evalfor;
+ goto calleval;
+ case NWHILE:
+ case NUNTIL:
+ evalfn = evalloop;
+ goto calleval;
+ case NSUBSHELL:
+ case NBACKGND:
+ evalfn = evalsubshell;
+ goto calleval;
+ case NPIPE:
+ evalfn = evalpipe;
+ goto checkexit;
+ case NCASE:
+ evalfn = evalcase;
+ goto calleval;
+ case NAND:
+ case NOR:
+ case NSEMI:
+#if NAND + 1 != NOR
+#error NAND + 1 != NOR
+#endif
+#if NOR + 1 != NSEMI
+#error NOR + 1 != NSEMI
+#endif
+ isor = n->type - NAND;
+ evaltree(
+ n->nbinary.ch1,
+ (flags | ((isor >> 1) - 1)) & EV_TESTED
+ );
+ if (!exitstatus == isor)
+ break;
+ if (!evalskip) {
+ n = n->nbinary.ch2;
+evaln:
+ evalfn = evaltree;
+calleval:
+ evalfn(n, flags);
+ break;
+ }
+ break;
+ case NIF:
+ evaltree(n->nif.test, EV_TESTED);
+ if (evalskip)
+ break;
+ if (exitstatus == 0) {
+ n = n->nif.ifpart;
+ goto evaln;
+ } else if (n->nif.elsepart) {
+ n = n->nif.elsepart;
+ goto evaln;
+ }
+ goto success;
+ case NDEFUN:
+ defun(n->narg.text, n->narg.next);
+success:
+ status = 0;
+setstatus:
+ exitstatus = status;
+ break;
+ }
+out:
+ if (pendingsigs)
+ dotrap();
+ if (flags & EV_EXIT || checkexit & exitstatus)
+ exraise(EXEXIT);
}
-/*
- * Add a new command entry, replacing any existing command entry for
- * the same name.
- */
-
-static inline void
-addcmdentry(char *name, struct cmdentry *entry)
-{
- struct tblentry *cmdp;
+#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
+static
+#endif
+void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
- INTOFF;
- cmdp = cmdlookup(name, 1);
- if (cmdp->cmdtype == CMDFUNCTION) {
- freefunc(cmdp->param.func);
- }
- cmdp->cmdtype = entry->cmdtype;
- cmdp->param = entry->u;
- INTON;
-}
-static inline void
-evalloop(const union node *n, int flags)
+static void
+evalloop(union node *n, int flags)
{
int status;
loopnest++;
status = 0;
+ flags &= EV_TESTED;
for (;;) {
+ int i;
+
evaltree(n->nbinary.ch1, EV_TESTED);
if (evalskip) {
skipping: if (evalskip == SKIPCONT && --skipcount <= 0) {
evalskip = 0;
break;
}
- if (n->type == NWHILE) {
- if (exitstatus != 0)
- break;
- } else {
- if (exitstatus == 0)
- break;
- }
- evaltree(n->nbinary.ch2, flags & EV_TESTED);
+ i = exitstatus;
+ if (n->type != NWHILE)
+ i = !i;
+ if (i != 0)
+ break;
+ evaltree(n->nbinary.ch2, flags);
status = exitstatus;
if (evalskip)
goto skipping;
exitstatus = status;
}
+
+
static void
-evalfor(const union node *n, int flags)
+evalfor(union node *n, int flags)
{
struct arglist arglist;
union node *argp;
setstackmark(&smark);
arglist.lastp = &arglist.list;
for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
- oexitstatus = exitstatus;
expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
+ /* XXX */
if (evalskip)
goto out;
}
exitstatus = 0;
loopnest++;
+ flags &= EV_TESTED;
for (sp = arglist.list ; sp ; sp = sp->next) {
setvar(n->nfor.var, sp->text, 0);
- evaltree(n->nfor.body, flags & EV_TESTED);
+ evaltree(n->nfor.body, flags);
if (evalskip) {
if (evalskip == SKIPCONT && --skipcount <= 0) {
evalskip = 0;
popstackmark(&smark);
}
-static inline void
-evalcase(const union node *n, int flags)
+
+
+static void
+evalcase(union node *n, int flags)
{
union node *cp;
union node *patp;
setstackmark(&smark);
arglist.lastp = &arglist.list;
- oexitstatus = exitstatus;
expandarg(n->ncase.expr, &arglist, EXP_TILDE);
+ exitstatus = 0;
for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
if (casematch(patp, arglist.list->text)) {
popstackmark(&smark);
}
+
+
+/*
+ * Kick off a subshell to evaluate a tree.
+ */
+
+static void
+evalsubshell(union node *n, int flags)
+{
+ struct job *jp;
+ int backgnd = (n->type == NBACKGND);
+ int status;
+
+ expredir(n->nredir.redirect);
+ if (!backgnd && flags & EV_EXIT && !trap[0])
+ goto nofork;
+ INTOFF;
+ jp = makejob(n, 1);
+ if (forkshell(jp, n, backgnd) == 0) {
+ INTON;
+ flags |= EV_EXIT;
+ if (backgnd)
+ flags &=~ EV_TESTED;
+nofork:
+ redirect(n->nredir.redirect, 0);
+ evaltreenr(n->nredir.n, flags);
+ /* never returns */
+ }
+ status = 0;
+ if (! backgnd)
+ status = waitforjob(jp);
+ exitstatus = status;
+ INTON;
+}
+
+
+
+/*
+ * Compute the names of the files in a redirection list.
+ */
+
+static void
+expredir(union node *n)
+{
+ union node *redir;
+
+ for (redir = n ; redir ; redir = redir->nfile.next) {
+ struct arglist fn;
+ fn.lastp = &fn.list;
+ switch (redir->type) {
+ case NFROMTO:
+ case NFROM:
+ case NTO:
+ case NCLOBBER:
+ case NAPPEND:
+ expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
+ redir->nfile.expfname = fn.list->text;
+ break;
+ case NFROMFD:
+ case NTOFD:
+ if (redir->ndup.vname) {
+ expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
+ fixredir(redir, fn.list->text, 1);
+ }
+ break;
+ }
+ }
+}
+
+
+
/*
* Evaluate a pipeline. All the processes in the pipeline are children
* of the process creating the pipeline. (This differs from some versions
* of all the rest.)
*/
-static inline void
-evalpipe(n)
- union node *n;
+static void
+evalpipe(union node *n, int flags)
{
struct job *jp;
struct nodelist *lp;
pipelen = 0;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
pipelen++;
+ flags |= EV_EXIT;
INTOFF;
jp = makejob(n, pipelen);
prevfd = -1;
}
if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
INTON;
+ if (pip[1] >= 0) {
+ close(pip[0]);
+ }
if (prevfd > 0) {
- close(0);
- dup_as_newfd(prevfd, 0);
+ dup2(prevfd, 0);
close(prevfd);
- if (pip[0] == 0) {
- pip[0] = -1;
- }
}
- if (pip[1] >= 0) {
- if (pip[0] >= 0) {
- close(pip[0]);
- }
- if (pip[1] != 1) {
- close(1);
- dup_as_newfd(pip[1], 1);
- close(pip[1]);
- }
+ if (pip[1] > 1) {
+ dup2(pip[1], 1);
+ close(pip[1]);
}
- evaltree(lp->n, EV_EXIT);
+ evaltreenr(lp->n, flags);
+ /* never returns */
}
if (prevfd >= 0)
close(prevfd);
prevfd = pip[0];
close(pip[1]);
}
- INTON;
if (n->npipe.backgnd == 0) {
- INTOFF;
exitstatus = waitforjob(jp);
TRACE(("evalpipe: job done exit status %d\n", exitstatus));
- INTON;
}
+ INTON;
}
-static void find_command (const char *, struct cmdentry *, int, const char *);
-static int
-isassignment(const char *word) {
- if (!is_name(*word)) {
- return 0;
+
+/*
+ * Execute a command inside back quotes. If it's a builtin command, we
+ * want to save its output in a block obtained from malloc. Otherwise
+ * we fork off a subprocess and get the output of the command via a pipe.
+ * Should be called with interrupts off.
+ */
+
+static void
+evalbackcmd(union node *n, struct backcmd *result)
+{
+ int saveherefd;
+
+ result->fd = -1;
+ result->buf = NULL;
+ result->nleft = 0;
+ result->jp = NULL;
+ if (n == NULL) {
+ goto out;
}
- do {
- word++;
- } while (is_in_name(*word));
- return *word == '=';
+
+ saveherefd = herefd;
+ herefd = -1;
+
+ {
+ int pip[2];
+ struct job *jp;
+
+ if (pipe(pip) < 0)
+ error("Pipe call failed");
+ jp = makejob(n, 1);
+ if (forkshell(jp, n, FORK_NOJOB) == 0) {
+ FORCEINTON;
+ close(pip[0]);
+ if (pip[1] != 1) {
+ close(1);
+ copyfd(pip[1], 1);
+ close(pip[1]);
+ }
+ eflag = 0;
+ evaltreenr(n, EV_EXIT);
+ /* NOTREACHED */
+ }
+ close(pip[1]);
+ result->fd = pip[0];
+ result->jp = jp;
+ }
+ herefd = saveherefd;
+out:
+ TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
+ result->fd, result->buf, result->nleft, result->jp));
+}
+
+#ifdef CONFIG_ASH_CMDCMD
+static inline char **
+parse_command_args(char **argv, const char **path)
+{
+ char *cp, c;
+
+ for (;;) {
+ cp = *++argv;
+ if (!cp)
+ return 0;
+ if (*cp++ != '-')
+ break;
+ if (!(c = *cp++))
+ break;
+ if (c == '-' && !*cp) {
+ argv++;
+ break;
+ }
+ do {
+ switch (c) {
+ case 'p':
+ *path = defpath;
+ break;
+ default:
+ /* run 'typecmd' for other options */
+ return 0;
+ }
+ } while ((c = *cp++));
+ }
+ return argv;
}
+#endif
+
+/*
+ * Execute a simple command.
+ */
+
static void
evalcommand(union node *cmd, int flags)
{
struct arglist varlist;
char **argv;
int argc;
- char **envp;
- struct strlist *sp;
- int mode;
+ const struct strlist *sp;
struct cmdentry cmdentry;
struct job *jp;
- char *volatile savecmdname;
- volatile struct shparam saveparam;
- struct localvar *volatile savelocalvars;
- volatile int e;
char *lastarg;
const char *path;
- const struct builtincmd *firstbltin;
- struct jmploc *volatile savehandler;
- struct jmploc jmploc;
-#if __GNUC__
- /* Avoid longjmp clobbering */
- (void) &argv;
- (void) &argc;
- (void) &lastarg;
- (void) &flags;
-#endif
+ int spclbltin;
+ int cmd_is_exec;
+ int status;
+ char **nargv;
/* First expand the arguments. */
TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
setstackmark(&smark);
- arglist.lastp = &arglist.list;
+ back_exitstatus = 0;
+
+ cmdentry.cmdtype = CMDBUILTIN;
+ cmdentry.u.cmd = &bltin;
varlist.lastp = &varlist.list;
- arglist.list = 0;
- oexitstatus = exitstatus;
- exitstatus = 0;
- path = pathval();
- for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
- expandarg(argp, &varlist, EXP_VARTILDE);
- }
- for (
- argp = cmd->ncmd.args; argp && !arglist.list;
- argp = argp->narg.next
- ) {
- expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
- }
- if (argp) {
- struct builtincmd *bcmd;
- int pseudovarflag;
- bcmd = find_builtin(arglist.list->text);
- pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
- for (; argp; argp = argp->narg.next) {
- if (pseudovarflag && isassignment(argp->narg.text)) {
- expandarg(argp, &arglist, EXP_VARTILDE);
- continue;
- }
- expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
- }
- }
- *arglist.lastp = NULL;
*varlist.lastp = NULL;
- expredir(cmd->ncmd.redirect);
+ arglist.lastp = &arglist.list;
+ *arglist.lastp = NULL;
+
argc = 0;
- for (sp = arglist.list ; sp ; sp = sp->next)
- argc++;
- argv = stalloc(sizeof (char *) * (argc + 1));
+ for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
+ struct strlist **spp;
+
+ spp = arglist.lastp;
+ expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
+ for (sp = *spp; sp; sp = sp->next)
+ argc++;
+ }
+ argv = nargv = stalloc(sizeof (char *) * (argc + 1));
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE(("evalcommand arg: %s\n", sp->text));
- *argv++ = sp->text;
+ *nargv++ = sp->text;
}
- *argv = NULL;
+ *nargv = NULL;
+
lastarg = NULL;
if (iflag && funcnest == 0 && argc > 0)
- lastarg = argv[-1];
- argv -= argc;
+ lastarg = nargv[-1];
- /* Print the command if xflag is set. */
- if (xflag) {
- out2c('+');
- eprintlist(varlist.list);
- eprintlist(arglist.list);
- out2c('\n');
- }
+ preverrout_fd = 2;
+ expredir(cmd->ncmd.redirect);
+ status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH|REDIR_SAVEFD2);
- /* Now locate the command. */
- if (argc == 0) {
- cmdentry.cmdtype = CMDBUILTIN;
- firstbltin = cmdentry.u.cmd = BLTINCMD;
- } else {
- const char *oldpath;
- int findflag = DO_ERR;
- int oldfindflag;
+ path = vpath.text;
+ for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
+ struct strlist **spp;
+ char *p;
+
+ spp = varlist.lastp;
+ expandarg(argp, &varlist, EXP_VARTILDE);
/*
* Modify the command lookup path, if a PATH= assignment
* is present
*/
- for (sp = varlist.list ; sp ; sp = sp->next)
- if (varequal(sp->text, defpathvar)) {
- path = sp->text + 5;
- findflag |= DO_BRUTE;
+ p = (*spp)->text;
+ if (varequal(p, path))
+ path = p;
+ }
+
+ /* Print the command if xflag is set. */
+ if (xflag) {
+ int n;
+ const char *p = " %s";
+
+ p++;
+ dprintf(preverrout_fd, p, ps4val());
+
+ sp = varlist.list;
+ for(n = 0; n < 2; n++) {
+ while (sp) {
+ dprintf(preverrout_fd, p, sp->text);
+ sp = sp->next;
+ if(*p == '%') {
+ p--;
+ }
}
+ sp = arglist.list;
+ }
+ bb_full_write(preverrout_fd, "\n", 1);
+ }
+
+ cmd_is_exec = 0;
+ spclbltin = -1;
+
+ /* Now locate the command. */
+ if (argc) {
+ const char *oldpath;
+ int cmd_flag = DO_ERR;
+
+ path += 5;
oldpath = path;
- oldfindflag = findflag;
- firstbltin = 0;
- for(;;) {
- find_command(argv[0], &cmdentry, findflag, path);
- if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
- exitstatus = 127;
- goto out;
+ for (;;) {
+ find_command(argv[0], &cmdentry, cmd_flag, path);
+ if (cmdentry.cmdtype == CMDUNKNOWN) {
+ status = 127;
+ flusherr();
+ goto bail;
}
+
/* implement bltin and command here */
- if (cmdentry.cmdtype != CMDBUILTIN) {
+ if (cmdentry.cmdtype != CMDBUILTIN)
+ break;
+ if (spclbltin < 0)
+ spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
+ if (cmdentry.u.cmd == EXECCMD)
+ cmd_is_exec++;
+#ifdef CONFIG_ASH_CMDCMD
+ if (cmdentry.u.cmd == COMMANDCMD) {
+
+ path = oldpath;
+ nargv = parse_command_args(argv, &path);
+ if (!nargv)
+ break;
+ argc -= nargv - argv;
+ argv = nargv;
+ cmd_flag |= DO_NOFUNC;
+ } else
+#endif
break;
- }
- if (!firstbltin) {
- firstbltin = cmdentry.u.cmd;
- }
- if (cmdentry.u.cmd == BLTINCMD) {
- for(;;) {
- struct builtincmd *bcmd;
-
- argv++;
- if (--argc == 0)
- goto found;
- if (!(bcmd = find_builtin(*argv))) {
- out2fmt("%s: not found\n", *argv);
- exitstatus = 127;
- goto out;
- }
- cmdentry.u.cmd = bcmd;
- if (bcmd != BLTINCMD)
- break;
- }
- }
- if (cmdentry.u.cmd == find_builtin("command")) {
- argv++;
- if (--argc == 0) {
- goto found;
- }
- if (*argv[0] == '-') {
- if (!equal(argv[0], "-p")) {
- argv--;
- argc++;
- break;
- }
- argv++;
- if (--argc == 0) {
- goto found;
- }
- path = defpath;
- findflag |= DO_BRUTE;
- } else {
- path = oldpath;
- findflag = oldfindflag;
- }
- findflag |= DO_NOFUN;
- continue;
- }
-found:
- break;
}
}
- /* Fork off a child process if necessary. */
- if (cmd->ncmd.backgnd
- || (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
- ) {
- jp = makejob(cmd, 1);
- mode = cmd->ncmd.backgnd;
- if (forkshell(jp, cmd, mode) != 0)
- goto parent; /* at end of routine */
- flags |= EV_EXIT;
+ if (status) {
+ /* We have a redirection error. */
+ if (spclbltin > 0)
+ exraise(EXERROR);
+bail:
+ exitstatus = status;
+ goto out;
}
- /* This is the child process if a fork occurred. */
/* Execute the command. */
- if (cmdentry.cmdtype == CMDFUNCTION) {
-#ifdef DEBUG
- trputs("Shell function: "); trargs(argv);
-#endif
- exitstatus = oexitstatus;
- redirect(cmd->ncmd.redirect, REDIR_PUSH);
- saveparam = shellparam;
- shellparam.malloc = 0;
- shellparam.nparam = argc - 1;
- shellparam.p = argv + 1;
- INTOFF;
- savelocalvars = localvars;
- localvars = NULL;
- INTON;
- if (setjmp(jmploc.loc)) {
- if (exception == EXSHELLPROC) {
- freeparam((volatile struct shparam *)
- &saveparam);
- } else {
- saveparam.optind = shellparam.optind;
- saveparam.optoff = shellparam.optoff;
- freeparam(&shellparam);
- shellparam = saveparam;
+ switch (cmdentry.cmdtype) {
+ default:
+ /* Fork off a child process if necessary. */
+ if (!(flags & EV_EXIT) || trap[0]) {
+ INTOFF;
+ jp = makejob(cmd, 1);
+ if (forkshell(jp, cmd, FORK_FG) != 0) {
+ exitstatus = waitforjob(jp);
+ INTON;
+ break;
}
- poplocalvars();
- localvars = savelocalvars;
- handler = savehandler;
- longjmp(handler->loc, 1);
- }
- savehandler = handler;
- handler = &jmploc;
- for (sp = varlist.list ; sp ; sp = sp->next)
- mklocal(sp->text);
- funcnest++;
- evaltree(cmdentry.u.func, flags & EV_TESTED);
- funcnest--;
- INTOFF;
- poplocalvars();
- localvars = savelocalvars;
- saveparam.optind = shellparam.optind;
- saveparam.optoff = shellparam.optoff;
- freeparam(&shellparam);
- shellparam = saveparam;
- handler = savehandler;
- popredir();
- INTON;
- if (evalskip == SKIPFUNC) {
- evalskip = 0;
- skipcount = 0;
- }
- if (flags & EV_EXIT)
- exitshell(exitstatus);
- } else if (cmdentry.cmdtype == CMDBUILTIN) {
-#ifdef DEBUG
- trputs("builtin command: "); trargs(argv);
-#endif
- mode = (cmdentry.u.cmd == EXECCMD)? 0 : REDIR_PUSH;
- redirect(cmd->ncmd.redirect, mode);
- savecmdname = commandname;
- if (IS_BUILTIN_SPECIAL(firstbltin)) {
- listsetvar(varlist.list);
- } else {
- cmdenviron = varlist.list;
- }
- e = -1;
- if (setjmp(jmploc.loc)) {
- e = exception;
- exitstatus = (e == EXINT)? SIGINT+128 : 2;
- goto cmddone;
- }
- savehandler = handler;
- handler = &jmploc;
- commandname = argv[0];
- argptr = argv + 1;
- optptr = NULL; /* initialize nextopt */
- exitstatus = (*cmdentry.u.cmd->builtinfunc)(argc, argv);
- flushall();
-cmddone:
- cmdenviron = NULL;
- if (e != EXSHELLPROC) {
- commandname = savecmdname;
- if (flags & EV_EXIT)
- exitshell(exitstatus);
+ FORCEINTON;
}
- handler = savehandler;
- if (e != -1) {
- if ((e != EXERROR && e != EXEXEC)
- || cmdentry.u.cmd == BLTINCMD
- || cmdentry.u.cmd == DOTCMD
- || cmdentry.u.cmd == EVALCMD
- || cmdentry.u.cmd == EXECCMD)
- exraise(e);
+ listsetvar(varlist.list, VEXPORT|VSTACK);
+ shellexec(argv, path, cmdentry.u.index);
+ /* NOTREACHED */
+
+ case CMDBUILTIN:
+ cmdenviron = varlist.list;
+ if (cmdenviron) {
+ struct strlist *list = cmdenviron;
+ int i = VNOSET;
+ if (spclbltin > 0 || argc == 0) {
+ i = 0;
+ if (cmd_is_exec && argc > 1)
+ i = VEXPORT;
+ }
+ listsetvar(list, i);
+ }
+ if (evalbltin(cmdentry.u.cmd, argc, argv)) {
+ int exit_status;
+ int i, j;
+
+ i = exception;
+ if (i == EXEXIT)
+ goto raise;
+
+ exit_status = 2;
+ j = 0;
+ if (i == EXINT)
+ j = SIGINT;
+ if (i == EXSIG)
+ j = pendingsigs;
+ if (j)
+ exit_status = j + 128;
+ exitstatus = exit_status;
+
+ if (i == EXINT || spclbltin > 0) {
+raise:
+ longjmp(handler->loc, 1);
+ }
FORCEINTON;
}
- if (cmdentry.u.cmd != EXECCMD)
- popredir();
- } else {
-#ifdef DEBUG
- trputs("normal command: "); trargs(argv);
-#endif
- redirect(cmd->ncmd.redirect, 0);
- clearredir();
- for (sp = varlist.list ; sp ; sp = sp->next)
- setvareq(sp->text, VEXPORT|VSTACK);
- envp = environment();
- shellexec(argv, envp, path, cmdentry.u.index);
- }
- goto out;
+ break;
-parent: /* parent process gets here (if we forked) */
- if (mode == 0) { /* argument to fork */
- INTOFF;
- exitstatus = waitforjob(jp);
- INTON;
+ case CMDFUNCTION:
+ listsetvar(varlist.list, 0);
+ if (evalfun(cmdentry.u.func, argc, argv, flags))
+ goto raise;
+ break;
}
out:
+ popredir(cmd_is_exec);
if (lastarg)
+ /* dsl: I think this is intended to be used to support
+ * '_' in 'vi' command mode during line editing...
+ * However I implemented that within libedit itself.
+ */
setvar("_", lastarg, 0);
popstackmark(&smark);
}
-/*
- * Evaluate a parse tree. The value is left in the global variable
- * exitstatus.
- */
-static void
-evaltree(n, flags)
- union node *n;
- int flags;
+static int
+evalbltin(const struct builtincmd *cmd, int argc, char **argv) {
+ char *volatile savecmdname;
+ struct jmploc *volatile savehandler;
+ struct jmploc jmploc;
+ int i;
+
+ savecmdname = commandname;
+ if ((i = setjmp(jmploc.loc)))
+ goto cmddone;
+ savehandler = handler;
+ handler = &jmploc;
+ commandname = argv[0];
+ argptr = argv + 1;
+ optptr = NULL; /* initialize nextopt */
+ exitstatus = (*cmd->builtin)(argc, argv);
+ flushall();
+cmddone:
+ exitstatus |= ferror(stdout);
+ commandname = savecmdname;
+ exsig = 0;
+ handler = savehandler;
+
+ return i;
+}
+
+static int
+evalfun(struct funcnode *func, int argc, char **argv, int flags)
{
- int checkexit = 0;
- if (n == NULL) {
- TRACE(("evaltree(NULL) called\n"));
- goto out;
- }
- TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type));
- switch (n->type) {
- case NSEMI:
- evaltree(n->nbinary.ch1, flags & EV_TESTED);
- if (evalskip)
- goto out;
- evaltree(n->nbinary.ch2, flags);
- break;
- case NAND:
- evaltree(n->nbinary.ch1, EV_TESTED);
- if (evalskip || exitstatus != 0)
- goto out;
- evaltree(n->nbinary.ch2, flags);
- break;
- case NOR:
- evaltree(n->nbinary.ch1, EV_TESTED);
- if (evalskip || exitstatus == 0)
- goto out;
- evaltree(n->nbinary.ch2, flags);
- break;
- case NREDIR:
- expredir(n->nredir.redirect);
- redirect(n->nredir.redirect, REDIR_PUSH);
- evaltree(n->nredir.n, flags);
- popredir();
- break;
- case NSUBSHELL:
- evalsubshell(n, flags);
- break;
- case NBACKGND:
- evalsubshell(n, flags);
- break;
- case NIF: {
- evaltree(n->nif.test, EV_TESTED);
- if (evalskip)
- goto out;
- if (exitstatus == 0)
- evaltree(n->nif.ifpart, flags);
- else if (n->nif.elsepart)
- evaltree(n->nif.elsepart, flags);
- else
- exitstatus = 0;
- break;
- }
- case NWHILE:
- case NUNTIL:
- evalloop(n, flags);
- break;
- case NFOR:
- evalfor(n, flags);
- break;
- case NCASE:
- evalcase(n, flags);
- break;
- case NDEFUN: {
- struct builtincmd *bcmd;
- struct cmdentry entry;
- if (
- (bcmd = find_builtin(n->narg.text)) &&
- IS_BUILTIN_SPECIAL(bcmd)
- ) {
- out2fmt("%s is a special built-in\n", n->narg.text);
- exitstatus = 1;
- break;
- }
- entry.cmdtype = CMDFUNCTION;
- entry.u.func = copyfunc(n->narg.next);
- addcmdentry(n->narg.text, &entry);
- exitstatus = 0;
- break;
- }
- case NNOT:
- evaltree(n->nnot.com, EV_TESTED);
- exitstatus = !exitstatus;
- break;
+ volatile struct shparam saveparam;
+ struct localvar *volatile savelocalvars;
+ struct jmploc *volatile savehandler;
+ struct jmploc jmploc;
+ int e;
- case NPIPE:
- evalpipe(n);
- checkexit = 1;
- break;
- case NCMD:
- evalcommand(n, flags);
- checkexit = 1;
- break;
-#ifdef DEBUG
- default:
- printf("Node type = %d\n", n->type);
- break;
+ saveparam = shellparam;
+ savelocalvars = localvars;
+ if ((e = setjmp(jmploc.loc))) {
+ goto funcdone;
+ }
+ INTOFF;
+ savehandler = handler;
+ handler = &jmploc;
+ localvars = NULL;
+ shellparam.malloc = 0;
+ func->count++;
+ INTON;
+ shellparam.nparam = argc - 1;
+ shellparam.p = argv + 1;
+#ifdef CONFIG_ASH_GETOPTS
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
#endif
+ funcnest++;
+ evaltree(&func->n, flags & EV_TESTED);
+ funcnest--;
+funcdone:
+ INTOFF;
+ freefunc(func);
+ poplocalvars();
+ localvars = savelocalvars;
+ freeparam(&shellparam);
+ shellparam = saveparam;
+ handler = savehandler;
+ INTON;
+ if (evalskip == SKIPFUNC) {
+ evalskip = 0;
+ skipcount = 0;
}
-out:
- if (pendingsigs)
- dotrap();
- if (
- flags & EV_EXIT ||
- (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
- )
- exitshell(exitstatus);
+ return e;
}
-/*
- * Kick off a subshell to evaluate a tree.
- */
-static void
-evalsubshell(const union node *n, int flags)
+static inline int
+goodname(const char *p)
{
- struct job *jp;
- int backgnd = (n->type == NBACKGND);
-
- expredir(n->nredir.redirect);
- jp = makejob(n, 1);
- if (forkshell(jp, n, backgnd) == 0) {
- if (backgnd)
- flags &=~ EV_TESTED;
- redirect(n->nredir.redirect, 0);
- evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */
- }
- if (! backgnd) {
- INTOFF;
- exitstatus = waitforjob(jp);
- INTON;
- }
+ return !*endofname(p);
}
/*
- * Compute the names of the files in a redirection list.
+ * Search for a command. This is called before we fork so that the
+ * location of the command will be available in the parent as well as
+ * the child. The check for "goodname" is an overly conservative
+ * check that the name will not be subject to expansion.
*/
-static void fixredir(union node *n, const char *text, int err);
-
static void
-expredir(union node *n)
+prehash(union node *n)
{
- union node *redir;
+ struct cmdentry entry;
- for (redir = n ; redir ; redir = redir->nfile.next) {
- struct arglist fn;
- fn.lastp = &fn.list;
- oexitstatus = exitstatus;
- switch (redir->type) {
- case NFROMTO:
- case NFROM:
- case NTO:
- case NAPPEND:
- case NTOOV:
- expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
- redir->nfile.expfname = fn.list->text;
- break;
- case NFROMFD:
- case NTOFD:
- if (redir->ndup.vname) {
- expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
- fixredir(redir, fn.list->text, 1);
- }
- break;
- }
- }
-}
-
-
-/*
- * Execute a command inside back quotes. If it's a builtin command, we
- * want to save its output in a block obtained from malloc. Otherwise
- * we fork off a subprocess and get the output of the command via a pipe.
- * Should be called with interrupts off.
- */
-
-static void
-evalbackcmd(union node *n, struct backcmd *result)
-{
- int pip[2];
- struct job *jp;
- struct stackmark smark; /* unnecessary */
-
- setstackmark(&smark);
- result->fd = -1;
- result->buf = NULL;
- result->nleft = 0;
- result->jp = NULL;
- if (n == NULL) {
- exitstatus = 0;
- goto out;
- }
- exitstatus = 0;
- if (pipe(pip) < 0)
- error("Pipe call failed");
- jp = makejob(n, 1);
- if (forkshell(jp, n, FORK_NOJOB) == 0) {
- FORCEINTON;
- close(pip[0]);
- if (pip[1] != 1) {
- close(1);
- dup_as_newfd(pip[1], 1);
- close(pip[1]);
- }
- eflag = 0;
- evaltree(n, EV_EXIT);
- }
- close(pip[1]);
- result->fd = pip[0];
- result->jp = jp;
-out:
- popstackmark(&smark);
- TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
- result->fd, result->buf, result->nleft, result->jp));
-}
-
-
-/*
- * Execute a simple command.
- */
-
-/*
- * Search for a command. This is called before we fork so that the
- * location of the command will be available in the parent as well as
- * the child. The check for "goodname" is an overly conservative
- * check that the name will not be subject to expansion.
- */
-
-static void
-prehash(n)
- union node *n;
-{
- struct cmdentry entry;
-
- if (n->type == NCMD && n->ncmd.args)
- if (goodname(n->ncmd.args->narg.text))
- find_command(n->ncmd.args->narg.text, &entry, 0,
- pathval());
+ if (n->type == NCMD && n->ncmd.args)
+ if (goodname(n->ncmd.args->narg.text))
+ find_command(n->ncmd.args->narg.text, &entry, 0,
+ pathval());
}
+
/*
* Builtin commands. Builtin commands whose functions are closely
* tied to evaluation are implemented here.
*/
/*
- * No command given, or a bltin command with no arguments. Set the
- * specified variables.
+ * No command given.
*/
-int
-bltincmd(argc, argv)
- int argc;
- char **argv;
+static int
+bltincmd(int argc, char **argv)
{
/*
* Preserve exitstatus of a previous possible redirection
* as POSIX mandates
*/
- return exitstatus;
+ return back_exitstatus;
}
*/
static int
-breakcmd(argc, argv)
- int argc;
- char **argv;
+breakcmd(int argc, char **argv)
{
int n = argc > 1 ? number(argv[1]) : 1;
+ if (n <= 0)
+ error(illnum, argv[1]);
if (n > loopnest)
n = loopnest;
if (n > 0) {
*/
static int
-returncmd(argc, argv)
- int argc;
- char **argv;
+returncmd(int argc, char **argv)
{
- int ret = argc > 1 ? number(argv[1]) : oexitstatus;
+ int ret = argc > 1 ? number(argv[1]) : exitstatus;
if (funcnest) {
evalskip = SKIPFUNC;
}
-#ifndef BB_TRUE_FALSE
static int
-false_main(argc, argv)
- int argc;
- char **argv;
+falsecmd(int argc, char **argv)
{
return 1;
}
static int
-true_main(argc, argv)
- int argc;
- char **argv;
+truecmd(int argc, char **argv)
{
return 0;
}
-#endif
-
-/*
- * Controls whether the shell is interactive or not.
- */
-
-static void setsignal(int signo);
-static void chkmail(int silent);
-
-
-static void
-setinteractive(int on)
-{
- static int is_interactive;
- static int do_banner=0;
-
- if (on == is_interactive)
- return;
- setsignal(SIGINT);
- setsignal(SIGQUIT);
- setsignal(SIGTERM);
- chkmail(1);
- is_interactive = on;
- if (do_banner==0 && is_interactive) {
- /* Looks like they want an interactive shell */
- printf( "\n\n" BB_BANNER " Built-in shell (ash)\n");
- printf( "Enter 'help' for a list of built-in commands.\n\n");
- do_banner=1;
- }
-}
-
-static void
-optschanged(void)
-{
- setinteractive(iflag);
- setjobctl(mflag);
-}
static int
-execcmd(argc, argv)
- int argc;
- char **argv;
+execcmd(int argc, char **argv)
{
if (argc > 1) {
- struct strlist *sp;
-
iflag = 0; /* exit on error */
mflag = 0;
optschanged();
- for (sp = cmdenviron; sp ; sp = sp->next)
- setvareq(sp->text, VEXPORT|VSTACK);
- shellexec(argv + 1, environment(), pathval(), 0);
+ shellexec(argv + 1, pathval(), 0);
}
return 0;
}
-static void
-eprintlist(struct strlist *sp)
-{
- for (; sp; sp = sp->next) {
- out2fmt(" %s",sp->text);
- }
-}
+
+/* $NetBSD: exec.c,v 1.35 2003/01/22 20:36:04 dsl Exp $ */
+
+/*
+ * When commands are first encountered, they are entered in a hash table.
+ * This ensures that a full path search will not have to be done for them
+ * on each invocation.
+ *
+ * We should investigate converting to a linear search, even though that
+ * would make the command name "hash" a misnomer.
+ */
+
+#define CMDTABLESIZE 31 /* should be prime */
+#define ARB 1 /* actual size determined at run time */
+
+
+
+struct tblentry {
+ struct tblentry *next; /* next entry in hash chain */
+ union param param; /* definition of builtin function */
+ short cmdtype; /* index identifying command */
+ char rehash; /* if set, cd done since entry created */
+ char cmdname[ARB]; /* name of command */
+};
+
+
+static struct tblentry *cmdtable[CMDTABLESIZE];
+static int builtinloc = -1; /* index in path of %builtin, or -1 */
+
+
+static void tryexec(char *, char **, char **);
+static void clearcmdentry(int);
+static struct tblentry *cmdlookup(const char *, int);
+static void delete_cmd_entry(void);
+
/*
* Exec a program. Never returns. If you change this routine, you may
* have to change the find_command routine as well.
*/
-static const char *pathopt; /* set by padvance */
-
static void
-shellexec(argv, envp, path, idx)
- char **argv, **envp;
- const char *path;
- int idx;
+shellexec(char **argv, const char *path, int idx)
{
char *cmdname;
int e;
+ char **envp;
- if (strchr(argv[0], '/') != NULL) {
+ clearredir(1);
+ envp = environment();
+ if (strchr(argv[0], '/') != NULL
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ || find_applet_by_name(argv[0])
+#endif
+ ) {
tryexec(argv[0], argv, envp);
e = errno;
} else {
exerrno = 2;
break;
}
+ TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
+ argv[0], e, suppressint ));
exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
/* NOTREACHED */
}
-/*
- * Clear traps on a fork.
- */
+
static void
-clear_traps(void) {
- char **tp;
+tryexec(char *cmd, char **argv, char **envp)
+{
+ int repeated = 0;
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ int flg_bb = 0;
+ char *name = cmd;
- for (tp = trap ; tp < &trap[NSIG] ; tp++) {
- if (*tp && **tp) { /* trap not NULL or SIG_IGN */
- INTOFF;
- ckfree(*tp);
- *tp = NULL;
- if (tp != &trap[0])
- setsignal(tp - trap);
- INTON;
+ if(strchr(name, '/') == NULL && find_applet_by_name(name) != NULL) {
+ flg_bb = 1;
+ }
+ if(flg_bb) {
+ char **ap;
+ char **new;
+
+ *argv = name;
+ if(strcmp(name, "busybox")) {
+ for (ap = argv; *ap; ap++);
+ ap = new = xmalloc((ap - argv + 2) * sizeof(char *));
+ *ap++ = cmd = "/bin/busybox";
+ while ((*ap++ = *argv++));
+ argv = new;
+ repeated++;
+ } else {
+ cmd = "/bin/busybox";
}
}
-}
-
-
-static void
-initshellproc(void) {
-
-#ifdef ASH_ALIAS
- /* from alias.c: */
- {
- rmaliases();
- }
#endif
- /* from eval.c: */
- {
- exitstatus = 0;
- }
-
- /* from exec.c: */
- {
- deletefuncs();
- }
- /* from jobs.c: */
- {
- backgndpid = -1;
-#ifdef JOBS
- jobctl = 0;
+repeat:
+#ifdef SYSV
+ do {
+ execve(cmd, argv, envp);
+ } while (errno == EINTR);
+#else
+ execve(cmd, argv, envp);
#endif
- }
-
- /* from options.c: */
- {
- int i;
+ if (repeated++) {
+ ckfree(argv);
+ } else if (errno == ENOEXEC) {
+ char **ap;
+ char **new;
- for (i = 0; i < NOPTS; i++)
- optent_val(i) = 0;
- optschanged();
+ for (ap = argv; *ap; ap++)
+ ;
+ ap = new = ckmalloc((ap - argv + 2) * sizeof(char *));
+ ap[1] = cmd;
+ *ap = cmd = (char *)DEFAULT_SHELL;
+ ap += 2;
+ argv++;
+ while ((*ap++ = *argv++))
+ ;
+ argv = new;
+ goto repeat;
+ }
+}
- }
- /* from redir.c: */
- {
- clearredir();
- }
- /* from trap.c: */
- {
- char *sm;
+/*
+ * Do a path search. The variable path (passed by reference) should be
+ * set to the start of the path before the first call; padvance will update
+ * this value as it proceeds. Successive calls to padvance will return
+ * the possible path expansions in sequence. If an option (indicated by
+ * a percent sign) appears in the path entry then the global variable
+ * pathopt will be set to point to it; otherwise pathopt will be set to
+ * NULL.
+ */
- clear_traps();
- for (sm = sigmode ; sm < sigmode + NSIG - 1; sm++) {
- if (*sm == S_IGN)
- *sm = S_HARD_IGN;
- }
- }
+static char *
+padvance(const char **path, const char *name)
+{
+ const char *p;
+ char *q;
+ const char *start;
+ size_t len;
- /* from var.c: */
- {
- shprocvar();
- }
+ if (*path == NULL)
+ return NULL;
+ start = *path;
+ for (p = start ; *p && *p != ':' && *p != '%' ; p++);
+ len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
+ while (stackblocksize() < len)
+ growstackblock();
+ q = stackblock();
+ if (p != start) {
+ memcpy(q, start, p - start);
+ q += p - start;
+ *q++ = '/';
+ }
+ strcpy(q, name);
+ pathopt = NULL;
+ if (*p == '%') {
+ pathopt = ++p;
+ while (*p && *p != ':') p++;
+ }
+ if (*p == ':')
+ *path = p + 1;
+ else
+ *path = NULL;
+ return stalloc(len);
}
-static int preadbuffer(void);
-static void pushfile (void);
-/*
- * Read a character from the script, returning PEOF on end of file.
- * Nul characters in the input are silently discarded.
- */
+/*** Command hashing code ***/
-#ifndef ASH_OPTIMIZE_FOR_SIZE
-#define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
-static int
-pgetc(void)
+static void
+printentry(struct tblentry *cmdp)
{
- return pgetc_macro();
+ int idx;
+ const char *path;
+ char *name;
+
+ idx = cmdp->param.index;
+ path = pathval();
+ do {
+ name = padvance(&path, cmdp->cmdname);
+ stunalloc(name);
+ } while (--idx >= 0);
+ out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr));
}
-#else
+
+
static int
-pgetc_macro(void)
-{
- return --parsenleft >= 0? *parsenextc++ : preadbuffer();
-}
-
-static inline int
-pgetc(void)
-{
- return pgetc_macro();
-}
-#endif
-
-
-/*
- * Undo the last call to pgetc. Only one character may be pushed back.
- * PEOF may be pushed back.
- */
-
-static void
-pungetc() {
- parsenleft++;
- parsenextc--;
-}
-
-
-static void
-popfile(void) {
- struct parsefile *pf = parsefile;
-
- INTOFF;
- if (pf->fd >= 0)
- close(pf->fd);
- if (pf->buf)
- ckfree(pf->buf);
- while (pf->strpush)
- popstring();
- parsefile = pf->prev;
- ckfree(pf);
- parsenleft = parsefile->nleft;
- parselleft = parsefile->lleft;
- parsenextc = parsefile->nextc;
- plinno = parsefile->linno;
- INTON;
-}
-
-
-/*
- * Return to top level.
- */
-
-static void
-popallfiles(void) {
- while (parsefile != &basepf)
- popfile();
-}
-
-/*
- * Close the file(s) that the shell is reading commands from. Called
- * after a fork is done.
- */
-
-static void
-closescript() {
- popallfiles();
- if (parsefile->fd > 0) {
- close(parsefile->fd);
- parsefile->fd = 0;
- }
-}
-
-
-/*
- * Like setinputfile, but takes an open file descriptor. Call this with
- * interrupts off.
- */
-
-static void
-setinputfd(fd, push)
- int fd, push;
-{
- (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
- if (push) {
- pushfile();
- parsefile->buf = 0;
- } else {
- closescript();
- while (parsefile->strpush)
- popstring();
- }
- parsefile->fd = fd;
- if (parsefile->buf == NULL)
- parsefile->buf = ckmalloc(BUFSIZ);
- parselleft = parsenleft = 0;
- plinno = 1;
-}
-
-
-/*
- * Set the input to take input from a file. If push is set, push the
- * old input onto the stack first.
- */
-
-static void
-setinputfile(const char *fname, int push)
-{
- int fd;
- int myfileno2;
-
- INTOFF;
- if ((fd = open(fname, O_RDONLY)) < 0)
- error("Can't open %s", fname);
- if (fd < 10) {
- myfileno2 = dup_as_newfd(fd, 10);
- close(fd);
- if (myfileno2 < 0)
- error("Out of file descriptors");
- fd = myfileno2;
- }
- setinputfd(fd, push);
- INTON;
-}
-
-
-static void
-tryexec(char *cmd, char **argv, char **envp)
-{
- int e;
-
-#ifdef BB_FEATURE_SH_STANDALONE_SHELL
- char *name = cmd;
- char** argv_l=argv;
- int argc_l;
-#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
- name = get_last_path_component(name);
-#endif
- argv_l=envp;
- for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
- putenv(*argv_l);
- argv_l=argv;
- for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
- optind = 1;
- run_applet_by_name(name, argc_l, argv);
-#endif
- execve(cmd, argv, envp);
- e = errno;
- if (e == ENOEXEC) {
- INTOFF;
- initshellproc();
- setinputfile(cmd, 0);
- commandname = arg0 = savestr(argv[0]);
- setparam(argv + 1);
- exraise(EXSHELLPROC);
- }
- errno = e;
-}
-
-static char *commandtext (const union node *);
-
-/*
- * Do a path search. The variable path (passed by reference) should be
- * set to the start of the path before the first call; padvance will update
- * this value as it proceeds. Successive calls to padvance will return
- * the possible path expansions in sequence. If an option (indicated by
- * a percent sign) appears in the path entry then the global variable
- * pathopt will be set to point to it; otherwise pathopt will be set to
- * NULL.
- */
-
-static const char *pathopt;
-
-static void growstackblock(void);
-
-
-static char *
-padvance(const char **path, const char *name)
-{
- const char *p;
- char *q;
- const char *start;
- int len;
-
- if (*path == NULL)
- return NULL;
- start = *path;
- for (p = start ; *p && *p != ':' && *p != '%' ; p++);
- len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
- while (stackblocksize() < len)
- growstackblock();
- q = stackblock();
- if (p != start) {
- memcpy(q, start, p - start);
- q += p - start;
- *q++ = '/';
- }
- strcpy(q, name);
- pathopt = NULL;
- if (*p == '%') {
- pathopt = ++p;
- while (*p && *p != ':') p++;
- }
- if (*p == ':')
- *path = p + 1;
- else
- *path = NULL;
- return stalloc(len);
-}
-
-/*
- * Wrapper around strcmp for qsort/bsearch/...
- */
-static int
-pstrcmp(const void *a, const void *b)
-{
- return strcmp((const char *) a, *(const char *const *) b);
-}
-
-/*
- * Find a keyword is in a sorted array.
- */
-
-static const char *const *
-findkwd(const char *s)
-{
- return bsearch(s, parsekwd, sizeof(parsekwd) / sizeof(const char *),
- sizeof(const char *), pstrcmp);
-}
-
-
-/*** Command hashing code ***/
-
-
-static int
-hashcmd(argc, argv)
- int argc;
- char **argv;
+hashcmd(int argc, char **argv)
{
struct tblentry **pp;
struct tblentry *cmdp;
int c;
- int verbose;
struct cmdentry entry;
char *name;
-#ifdef ASH_ALIAS
- const struct alias *ap;
-#endif
- verbose = 0;
- while ((c = nextopt("rvV")) != '\0') {
- if (c == 'r') {
- clearcmdentry(0);
- return 0;
- } else if (c == 'v' || c == 'V') {
- verbose = c;
- }
+ while ((c = nextopt("r")) != '\0') {
+ clearcmdentry(0);
+ return 0;
}
if (*argptr == NULL) {
for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
- if (cmdp->cmdtype != CMDBUILTIN) {
- printentry(cmdp, verbose);
- }
+ if (cmdp->cmdtype == CMDNORMAL)
+ printentry(cmdp);
}
}
return 0;
}
c = 0;
- while ((name = *argptr++) != NULL) {
+ while ((name = *argptr) != NULL) {
if ((cmdp = cmdlookup(name, 0)) != NULL
&& (cmdp->cmdtype == CMDNORMAL
|| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
delete_cmd_entry();
-#ifdef ASH_ALIAS
- /* Then look at the aliases */
- if ((ap = lookupalias(name, 0)) != NULL) {
- if (verbose=='v')
- printf("%s is an alias for %s\n", name, ap->val);
- else
- printalias(ap);
- continue;
- }
-#endif
- /* First look at the keywords */
- if (findkwd(name)!=0) {
- if (verbose=='v')
- printf("%s is a shell keyword\n", name);
- else
- printf(snlfmt, name);
- continue;
- }
-
find_command(name, &entry, DO_ERR, pathval());
- if (entry.cmdtype == CMDUNKNOWN) c = 1;
- else if (verbose) {
- cmdp = cmdlookup(name, 0);
- if (cmdp) printentry(cmdp, verbose=='v');
- flushall();
- }
+ if (entry.cmdtype == CMDUNKNOWN)
+ c = 1;
+ argptr++;
}
return c;
}
-static void
-printentry(cmdp, verbose)
- struct tblentry *cmdp;
- int verbose;
- {
- int idx;
- const char *path;
- char *name;
-
- printf("%s%s", cmdp->cmdname, (verbose ? " is " : ""));
- if (cmdp->cmdtype == CMDNORMAL) {
- idx = cmdp->param.index;
- path = pathval();
- do {
- name = padvance(&path, cmdp->cmdname);
- stunalloc(name);
- } while (--idx >= 0);
- if(verbose)
- out1str(name);
- } else if (cmdp->cmdtype == CMDBUILTIN) {
- if(verbose)
- out1str("a shell builtin");
- } else if (cmdp->cmdtype == CMDFUNCTION) {
- if (verbose) {
- INTOFF;
- out1str("a function\n");
- name = commandtext(cmdp->param.func);
- printf("%s() {\n %s\n}", cmdp->cmdname, name);
- ckfree(name);
- INTON;
- }
-#ifdef DEBUG
- } else {
- error("internal error: cmdtype %d", cmdp->cmdtype);
-#endif
- }
- printf(snlfmt, cmdp->rehash ? "*" : nullstr);
-}
-
-
-
-/*** List the available builtins ***/
-
-
-static int helpcmd(int argc, char** argv)
-{
- int col, i;
-
- printf("\nBuilt-in commands:\n-------------------\n");
- for (col=0, i=0; i < NUMBUILTINS; i++) {
- col += printf("%c%s", ((col == 0) ? '\t' : ' '),
- builtincmds[i].name+1);
- if (col > 60) {
- printf("\n");
- col = 0;
- }
- }
-#ifdef BB_FEATURE_SH_STANDALONE_SHELL
- {
- extern const struct BB_applet applets[];
- extern const size_t NUM_APPLETS;
-
- for (i=0; i < NUM_APPLETS; i++) {
-
- col += printf("%c%s", ((col == 0) ? '\t' : ' '),
- applets[i].name);
- if (col > 60) {
- printf("\n");
- col = 0;
- }
- }
- }
-#endif
- printf("\n\n");
- return EXIT_SUCCESS;
-}
/*
* Resolve a command name. If you change this routine, you may have to
* change the shellexec routine as well.
*/
-static int prefix (const char *, const char *);
-
static void
-find_command(const char *name, struct cmdentry *entry, int act, const char *path)
+find_command(char *name, struct cmdentry *entry, int act, const char *path)
{
struct tblentry *cmdp;
int idx;
char *fullname;
struct stat statb;
int e;
- int bltin;
- int firstchange;
int updatetbl;
- int regular;
struct builtincmd *bcmd;
- /* If name contains a slash, don't use the hash table */
+ /* If name contains a slash, don't use PATH or hash table */
if (strchr(name, '/') != NULL) {
+ entry->u.index = -1;
if (act & DO_ABS) {
while (stat(name, &statb) < 0) {
- if (errno != ENOENT && errno != ENOTDIR)
- e = errno;
+#ifdef SYSV
+ if (errno == EINTR)
+ continue;
+#endif
entry->cmdtype = CMDUNKNOWN;
- entry->u.index = -1;
return;
}
- entry->cmdtype = CMDNORMAL;
- entry->u.index = -1;
- return;
}
entry->cmdtype = CMDNORMAL;
- entry->u.index = 0;
return;
}
- updatetbl = 1;
- if (act & DO_BRUTE) {
- firstchange = path_change(path, &bltin);
- } else {
- bltin = builtinloc;
- firstchange = 9999;
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ if (find_applet_by_name(name)) {
+ entry->cmdtype = CMDNORMAL;
+ entry->u.index = -1;
+ return;
}
+#endif
- /* If name is in the table, and not invalidated by cd, we're done */
- if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
- if (cmdp->cmdtype == CMDFUNCTION) {
- if (act & DO_NOFUN) {
- updatetbl = 0;
- } else {
- goto success;
- }
- } else if (act & DO_BRUTE) {
- if ((cmdp->cmdtype == CMDNORMAL &&
- cmdp->param.index >= firstchange) ||
- (cmdp->cmdtype == CMDBUILTIN &&
- ((builtinloc < 0 && bltin >= 0) ?
- bltin : builtinloc) >= firstchange)) {
- /* need to recompute the entry */
- } else {
- goto success;
- }
- } else {
- goto success;
- }
+ updatetbl = (path == pathval());
+ if (!updatetbl) {
+ act |= DO_ALTPATH;
+ if (strstr(path, "%builtin") != NULL)
+ act |= DO_ALTBLTIN;
}
- bcmd = find_builtin(name);
- regular = bcmd && IS_BUILTIN_REGULAR(bcmd);
+ /* If name is in the table, check answer will be ok */
+ if ((cmdp = cmdlookup(name, 0)) != NULL) {
+ int bit;
- if (regular) {
- if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
- goto success;
+ switch (cmdp->cmdtype) {
+ default:
+#if DEBUG
+ abort();
+#endif
+ case CMDNORMAL:
+ bit = DO_ALTPATH;
+ break;
+ case CMDFUNCTION:
+ bit = DO_NOFUNC;
+ break;
+ case CMDBUILTIN:
+ bit = DO_ALTBLTIN;
+ break;
}
- } else if (act & DO_BRUTE) {
- if (firstchange == 0) {
+ if (act & bit) {
updatetbl = 0;
- }
+ cmdp = NULL;
+ } else if (cmdp->rehash == 0)
+ /* if not invalidated by cd, we're done */
+ goto success;
}
/* If %builtin not in path, check for builtin next */
- if (regular || (bltin < 0 && bcmd)) {
-builtin:
- if (!updatetbl) {
- entry->cmdtype = CMDBUILTIN;
- entry->u.cmd = bcmd;
- return;
- }
- INTOFF;
- cmdp = cmdlookup(name, 1);
- cmdp->cmdtype = CMDBUILTIN;
- cmdp->param.cmd = bcmd;
- INTON;
- goto success;
- }
+ bcmd = find_builtin(name);
+ if (bcmd && (IS_BUILTIN_REGULAR(bcmd) || (
+ act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc <= 0
+ )))
+ goto builtin_success;
/* We have to search path. */
prev = -1; /* where to start */
while ((fullname = padvance(&path, name)) != NULL) {
stunalloc(fullname);
idx++;
- if (idx >= firstchange) {
- updatetbl = 0;
- }
if (pathopt) {
- if (prefix("builtin", pathopt)) {
- if ((bcmd = find_builtin(name))) {
- goto builtin;
- }
+ if (prefix(pathopt, "builtin")) {
+ if (bcmd)
+ goto builtin_success;
continue;
- } else if (!(act & DO_NOFUN) &&
- prefix("func", pathopt)) {
+ } else if (!(act & DO_NOFUNC) &&
+ prefix(pathopt, "func")) {
/* handled below */
} else {
- continue; /* ignore unimplemented options */
+ /* ignore unimplemented options */
+ continue;
}
}
/* if rehash, don't redo absolute path names */
- if (fullname[0] == '/' && idx <= prev &&
- idx < firstchange) {
+ if (fullname[0] == '/' && idx <= prev) {
if (idx < prev)
continue;
TRACE(("searchexec \"%s\": no change\n", name));
goto success;
}
while (stat(fullname, &statb) < 0) {
+#ifdef SYSV
+ if (errno == EINTR)
+ continue;
+#endif
if (errno != ENOENT && errno != ENOTDIR)
e = errno;
goto loop;
if (pathopt) { /* this is a %func directory */
stalloc(strlen(fullname) + 1);
readcmdfile(fullname);
- if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
+ if ((cmdp = cmdlookup(name, 0)) == NULL ||
+ cmdp->cmdtype != CMDFUNCTION)
error("%s not defined in %s", name, fullname);
stunalloc(fullname);
goto success;
}
TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
- /* If we aren't called with DO_BRUTE and cmdp is set, it must
- be a function and we're being called with DO_NOFUN */
if (!updatetbl) {
entry->cmdtype = CMDNORMAL;
entry->u.index = idx;
if (cmdp && updatetbl)
delete_cmd_entry();
if (act & DO_ERR)
- out2fmt("%s: %s\n", name, errmsg(e, E_EXEC));
+ sh_warnx("%s: %s", name, errmsg(e, E_EXEC));
entry->cmdtype = CMDUNKNOWN;
return;
+builtin_success:
+ if (!updatetbl) {
+ entry->cmdtype = CMDBUILTIN;
+ entry->u.cmd = bcmd;
+ return;
+ }
+ INTOFF;
+ cmdp = cmdlookup(name, 1);
+ cmdp->cmdtype = CMDBUILTIN;
+ cmdp->param.cmd = bcmd;
+ INTON;
success:
cmdp->rehash = 0;
entry->cmdtype = cmdp->cmdtype;
}
-
/*
- * Search the table of builtin commands.
+ * Wrapper around strcmp for qsort/bsearch/...
*/
-
-static int
-bstrcmp(const void *name, const void *b)
+static int pstrcmp(const void *a, const void *b)
{
- return strcmp((const char *)name, (*(const char *const *) b)+1);
+ return strcmp((const char *) a, (*(const char *const *) b) + 1);
}
+/*
+ * Search the table of builtin commands.
+ */
+
static struct builtincmd *
find_builtin(const char *name)
{
struct builtincmd *bp;
- bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
- bstrcmp
+ bp = bsearch(
+ name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd),
+ pstrcmp
);
return bp;
}
+
/*
* Called when a cd is done. Marks all commands so the next time they
* are executed they will be rehashed.
*/
static void
-hashcd(void) {
+hashcd(void)
+{
struct tblentry **pp;
struct tblentry *cmdp;
for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
- if (cmdp->cmdtype == CMDNORMAL
- || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
+ if (cmdp->cmdtype == CMDNORMAL || (
+ cmdp->cmdtype == CMDBUILTIN &&
+ !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) &&
+ builtinloc > 0
+ ))
cmdp->rehash = 1;
}
}
/*
+ * Fix command hash table when PATH changed.
* Called before PATH is changed. The argument is the new value of PATH;
- * pathval() still returns the old value at this point. Called with
- * interrupts off.
+ * pathval() still returns the old value at this point.
+ * Called with interrupts off.
*/
static void
changepath(const char *newval)
{
+ const char *old, *new;
+ int idx;
int firstchange;
- int bltin;
+ int idx_bltin;
- firstchange = path_change(newval, &bltin);
- if (builtinloc < 0 && bltin >= 0)
- builtinloc = bltin; /* zap builtins */
+ old = pathval();
+ new = newval;
+ firstchange = 9999; /* assume no change */
+ idx = 0;
+ idx_bltin = -1;
+ for (;;) {
+ if (*old != *new) {
+ firstchange = idx;
+ if ((*old == '\0' && *new == ':')
+ || (*old == ':' && *new == '\0'))
+ firstchange++;
+ old = new; /* ignore subsequent differences */
+ }
+ if (*new == '\0')
+ break;
+ if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
+ idx_bltin = idx;
+ if (*new == ':') {
+ idx++;
+ }
+ new++, old++;
+ }
+ if (builtinloc < 0 && idx_bltin >= 0)
+ builtinloc = idx_bltin; /* zap builtins */
+ if (builtinloc >= 0 && idx_bltin < 0)
+ firstchange = 0;
clearcmdentry(firstchange);
- builtinloc = bltin;
+ builtinloc = idx_bltin;
}
*/
static void
-clearcmdentry(firstchange)
- int firstchange;
+clearcmdentry(int firstchange)
{
struct tblentry **tblp;
struct tblentry **pp;
}
-/*
- * Delete all functions.
- */
-
-static void
-deletefuncs(void) {
- struct tblentry **tblp;
- struct tblentry **pp;
- struct tblentry *cmdp;
-
- INTOFF;
- for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
- pp = tblp;
- while ((cmdp = *pp) != NULL) {
- if (cmdp->cmdtype == CMDFUNCTION) {
- *pp = cmdp->next;
- freefunc(cmdp->param.func);
- ckfree(cmdp);
- } else {
- pp = &cmdp->next;
- }
- }
- }
- INTON;
-}
-
-
/*
* Locate a command in the command hash table. If "add" is nonzero,
* variable "lastcmdentry" is set to point to the address of the link
* pointing to the entry, so that delete_cmd_entry can delete the
* entry.
+ *
+ * Interrupts must be off if called with add != 0.
*/
static struct tblentry **lastcmdentry;
+
static struct tblentry *
cmdlookup(const char *name, int add)
{
- int hashval;
+ unsigned int hashval;
const char *p;
struct tblentry *cmdp;
struct tblentry **pp;
p = name;
- hashval = *p << 4;
+ hashval = (unsigned char)*p << 4;
while (*p)
- hashval += *p++;
+ hashval += (unsigned char)*p++;
hashval &= 0x7FFF;
pp = &cmdtable[hashval % CMDTABLESIZE];
for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
pp = &cmdp->next;
}
if (add && cmdp == NULL) {
- INTOFF;
cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
+ strlen(name) + 1);
cmdp->next = NULL;
cmdp->cmdtype = CMDUNKNOWN;
- cmdp->rehash = 0;
strcpy(cmdp->cmdname, name);
- INTON;
}
lastcmdentry = pp;
return cmdp;
*/
static void
-delete_cmd_entry() {
+delete_cmd_entry(void)
+{
struct tblentry *cmdp;
INTOFF;
cmdp = *lastcmdentry;
*lastcmdentry = cmdp->next;
+ if (cmdp->cmdtype == CMDFUNCTION)
+ freefunc(cmdp->param.func);
ckfree(cmdp);
INTON;
}
+/*
+ * Add a new command entry, replacing any existing command entry for
+ * the same name - except special builtins.
+ */
+
+static inline void
+addcmdentry(char *name, struct cmdentry *entry)
+{
+ struct tblentry *cmdp;
+
+ cmdp = cmdlookup(name, 1);
+ if (cmdp->cmdtype == CMDFUNCTION) {
+ freefunc(cmdp->param.func);
+ }
+ cmdp->cmdtype = entry->cmdtype;
+ cmdp->param = entry->u;
+ cmdp->rehash = 0;
+}
+/*
+ * Make a copy of a parse tree.
+ */
+static inline struct funcnode *
+copyfunc(union node *n)
+{
+ struct funcnode *f;
+ size_t blocksize;
-static const short nodesize[26] = {
- ALIGN(sizeof (struct nbinary)),
- ALIGN(sizeof (struct ncmd)),
- ALIGN(sizeof (struct npipe)),
- ALIGN(sizeof (struct nredir)),
- ALIGN(sizeof (struct nredir)),
- ALIGN(sizeof (struct nredir)),
- ALIGN(sizeof (struct nbinary)),
- ALIGN(sizeof (struct nbinary)),
- ALIGN(sizeof (struct nif)),
- ALIGN(sizeof (struct nbinary)),
- ALIGN(sizeof (struct nbinary)),
- ALIGN(sizeof (struct nfor)),
- ALIGN(sizeof (struct ncase)),
- ALIGN(sizeof (struct nclist)),
- ALIGN(sizeof (struct narg)),
- ALIGN(sizeof (struct narg)),
- ALIGN(sizeof (struct nfile)),
- ALIGN(sizeof (struct nfile)),
- ALIGN(sizeof (struct nfile)),
- ALIGN(sizeof (struct nfile)),
- ALIGN(sizeof (struct nfile)),
- ALIGN(sizeof (struct ndup)),
- ALIGN(sizeof (struct ndup)),
- ALIGN(sizeof (struct nhere)),
- ALIGN(sizeof (struct nhere)),
- ALIGN(sizeof (struct nnot)),
-};
+ funcblocksize = offsetof(struct funcnode, n);
+ funcstringsize = 0;
+ calcsize(n);
+ blocksize = funcblocksize;
+ f = ckmalloc(blocksize + funcstringsize);
+ funcblock = (char *) f + offsetof(struct funcnode, n);
+ funcstring = (char *) f + blocksize;
+ copynode(n);
+ f->count = 0;
+ return f;
+}
+
+/*
+ * Define a shell function.
+ */
+
+static void
+defun(char *name, union node *func)
+{
+ struct cmdentry entry;
+ INTOFF;
+ entry.cmdtype = CMDFUNCTION;
+ entry.u.func = copyfunc(func);
+ addcmdentry(name, &entry);
+ INTON;
+}
/*
*/
static void
-unsetfunc(char *name)
+unsetfunc(const char *name)
{
struct tblentry *cmdp;
- if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
- freefunc(cmdp->param.func);
+ if ((cmdp = cmdlookup(name, 0)) != NULL &&
+ cmdp->cmdtype == CMDFUNCTION)
delete_cmd_entry();
- }
}
-
/*
* Locate and print what a word is...
*/
+
+#ifdef CONFIG_ASH_CMDCMD
+static int
+describe_command(char *command, int describe_command_verbose)
+#else
+#define describe_command_verbose 1
+static int
+describe_command(char *command)
+#endif
+{
+ struct cmdentry entry;
+ struct tblentry *cmdp;
+#ifdef CONFIG_ASH_ALIAS
+ const struct alias *ap;
+#endif
+ const char *path = pathval();
+
+ if (describe_command_verbose) {
+ out1str(command);
+ }
+
+ /* First look at the keywords */
+ if (findkwd(command)) {
+ out1str(describe_command_verbose ? " is a shell keyword" : command);
+ goto out;
+ }
+
+#ifdef CONFIG_ASH_ALIAS
+ /* Then look at the aliases */
+ if ((ap = lookupalias(command, 0)) != NULL) {
+ if (describe_command_verbose) {
+ out1fmt(" is an alias for %s", ap->val);
+ } else {
+ out1str("alias ");
+ printalias(ap);
+ return 0;
+ }
+ goto out;
+ }
+#endif
+ /* Then check if it is a tracked alias */
+ if ((cmdp = cmdlookup(command, 0)) != NULL) {
+ entry.cmdtype = cmdp->cmdtype;
+ entry.u = cmdp->param;
+ } else {
+ /* Finally use brute force */
+ find_command(command, &entry, DO_ABS, path);
+ }
+
+ switch (entry.cmdtype) {
+ case CMDNORMAL: {
+ int j = entry.u.index;
+ char *p;
+ if (j == -1) {
+ p = command;
+ } else {
+ do {
+ p = padvance(&path, command);
+ stunalloc(p);
+ } while (--j >= 0);
+ }
+ if (describe_command_verbose) {
+ out1fmt(" is%s %s",
+ (cmdp ? " a tracked alias for" : nullstr), p
+ );
+ } else {
+ out1str(p);
+ }
+ break;
+ }
+
+ case CMDFUNCTION:
+ if (describe_command_verbose) {
+ out1str(" is a shell function");
+ } else {
+ out1str(command);
+ }
+ break;
+
+ case CMDBUILTIN:
+ if (describe_command_verbose) {
+ out1fmt(" is a %sshell builtin",
+ IS_BUILTIN_SPECIAL(entry.u.cmd) ?
+ "special " : nullstr
+ );
+ } else {
+ out1str(command);
+ }
+ break;
+
+ default:
+ if (describe_command_verbose) {
+ out1str(": not found\n");
+ }
+ return 127;
+ }
+
+out:
+ outstr("\n", stdout);
+ return 0;
+}
+
static int
typecmd(int argc, char **argv)
{
int i;
int err = 0;
- char *argv_a[2];
-
- argv_a[1] = 0;
for (i = 1; i < argc; i++) {
- argv_a[0] = argv[i];
- argptr = argv_a;
- optptr = "v";
- err |= hashcmd(argc, argv);
+#ifdef CONFIG_ASH_CMDCMD
+ err |= describe_command(argv[i], 1);
+#else
+ err |= describe_command(argv[i]);
+#endif
}
return err;
}
-#ifdef ASH_CMDCMD
+#ifdef CONFIG_ASH_CMDCMD
static int
-commandcmd(argc, argv)
- int argc;
- char **argv;
+commandcmd(int argc, char **argv)
{
int c;
int default_path = 0;
while ((c = nextopt("pvV")) != '\0')
switch (c) {
+ default:
+#ifdef DEBUG
+ fprintf(stderr,
+"command: nextopt returned character code 0%o\n", c);
+ return EX_SOFTWARE;
+#endif
case 'p':
default_path = 1;
break;
if (default_path + verify_only + verbose_verify_only > 1 ||
!*argptr) {
- out2str(
+ fprintf(stderr,
"command [-p] command [arg ...]\n"
"command {-v|-V} command\n");
return EX_USAGE;
}
if (verify_only || verbose_verify_only) {
- char *argv_a[2];
-
- argv_a[1] = 0;
- argv_a[0] = *argptr;
- argptr = argv_a;
- optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
- return hashcmd(argc, argv);
+ return describe_command(*argptr, verbose_verify_only);
}
return 0;
}
#endif
-static int
-path_change(newval, bltin)
- const char *newval;
- int *bltin;
-{
- const char *old, *new;
- int idx;
- int firstchange;
+/* $NetBSD: expand.c,v 1.56 2002/11/24 22:35:39 christos Exp $ */
- old = pathval();
- new = newval;
- firstchange = 9999; /* assume no change */
- idx = 0;
- *bltin = -1;
- for (;;) {
- if (*old != *new) {
- firstchange = idx;
- if ((*old == '\0' && *new == ':')
- || (*old == ':' && *new == '\0'))
- firstchange++;
- old = new; /* ignore subsequent differences */
- }
- if (*new == '\0')
- break;
- if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
- *bltin = idx;
- if (*new == ':') {
- idx++;
- }
- new++, old++;
- }
- if (builtinloc >= 0 && *bltin < 0)
- firstchange = 0;
- return firstchange;
-}
/*
* Routines to expand arguments to commands. We have to deal with
* backquotes, shell variables, and file metacharacters.
*/
+
/*
* _rmescape() flags
*/
#define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
+#define RMESCAPE_QUOTED 0x4 /* Remove CTLESC unless in quotes */
+#define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */
+#define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */
/*
* Structure specifying which parts of the string should be searched
int nulonly; /* search for nul bytes only */
};
+/* output of current string */
+static char *expdest;
+/* list of back quote expressions */
+static struct nodelist *argbackq;
+/* first struct in list of ifs regions */
+static struct ifsregion ifsfirst;
+/* last struct in list */
+static struct ifsregion *ifslastp;
+/* holds expanded arg list */
+static struct arglist exparg;
+
+static void argstr(char *, int);
+static char *exptilde(char *, char *, int);
+static void expbackq(union node *, int, int);
+static const char *subevalvar(char *, char *, int, int, int, int, int);
+static char *evalvar(char *, int);
+static void strtodest(const char *, int, int);
+static void memtodest(const char *p, size_t len, int syntax, int quotes);
+static ssize_t varvalue(char *, int, int);
+static void recordregion(int, int, int);
+static void removerecordregions(int);
+static void ifsbreakup(char *, struct arglist *);
+static void ifsfree(void);
+static void expandmeta(struct strlist *, int);
+static int patmatch(char *, const char *);
+
+static int cvtnum(arith_t);
+static size_t esclen(const char *, const char *);
+static char *scanleft(char *, char *, char *, char *, int, int);
+static char *scanright(char *, char *, char *, char *, int, int);
+static void varunset(const char *, const char *, const char *, int)
+ __attribute__((__noreturn__));
+
+
+#define pmatch(a, b) !fnmatch((a), (b), 0)
+/*
+ * Prepare a pattern for a expmeta (internal glob(3)) call.
+ *
+ * Returns an stalloced string.
+ */
+
+static inline char *
+preglob(const char *pattern, int quoted, int flag) {
+ flag |= RMESCAPE_GLOB;
+ if (quoted) {
+ flag |= RMESCAPE_QUOTED;
+ }
+ return _rmescapes((char *)pattern, flag);
+}
+
+
+static size_t
+esclen(const char *start, const char *p) {
+ size_t esc = 0;
+
+ while (p > start && *--p == CTLESC) {
+ esc++;
+ }
+ return esc;
+}
-static char *expdest; /* output of current string */
-static struct nodelist *argbackq; /* list of back quote expressions */
-static struct ifsregion ifsfirst; /* first struct in list of ifs regions */
-static struct ifsregion *ifslastp; /* last struct in list */
-static struct arglist exparg; /* holds expanded arg list */
-
-static void argstr (char *, int);
-static char *exptilde (char *, int);
-static void expbackq (union node *, int, int);
-static int subevalvar (char *, char *, int, int, int, int, int);
-static int varisset (char *, int);
-static void strtodest (const char *, const char *, int);
-static void varvalue (char *, int, int);
-static void recordregion (int, int, int);
-static void removerecordregions (int);
-static void ifsbreakup (char *, struct arglist *);
-static void ifsfree (void);
-static void expandmeta (struct strlist *, int);
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-#define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
-#if !defined(GLOB_BROKEN)
-static void addglob (const glob_t *);
-#endif
-#endif
-#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
-static void expmeta (char *, char *);
-#endif
-#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
-static struct strlist *expsort (struct strlist *);
-static struct strlist *msort (struct strlist *, int);
-#endif
-static int patmatch (char *, char *, int);
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-static int patmatch2 (char *, char *, int);
-#else
-static int pmatch (char *, char *, int);
-#define patmatch2 patmatch
-#endif
-static char *cvtnum (int, char *);
/*
* Expand shell variables and backquotes inside a here document.
*/
-/* arg: the document, fd: where to write the expanded version */
static inline void
expandhere(union node *arg, int fd)
{
herefd = fd;
expandarg(arg, (struct arglist *)NULL, 0);
- xwrite(fd, stackblock(), expdest - stackblock());
+ bb_full_write(fd, stackblock(), expdest - (char *)stackblock());
}
* here document expansion.
*/
-static void
-expandarg(arg, arglist, flag)
- union node *arg;
- struct arglist *arglist;
- int flag;
+void
+expandarg(union node *arg, struct arglist *arglist, int flag)
{
struct strlist *sp;
char *p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
- ifsfree();
+ if (ifsfirst.next)
+ ifsfree();
*exparg.lastp = NULL;
if (exparg.list) {
*arglist->lastp = exparg.list;
/*
- * Expand a variable, and return a pointer to the next character in the
- * input string.
+ * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
+ * characters to allow for further processing. Otherwise treat
+ * $@ like $* since no splitting will be performed.
*/
-static inline char *
-evalvar(p, flag)
- char *p;
- int flag;
-{
- int subtype;
- int varflags;
- char *var;
- const char *val;
- int patloc;
+static void
+argstr(char *p, int flag)
+{
+ static const char spclchars[] = {
+ '=',
+ ':',
+ CTLQUOTEMARK,
+ CTLENDVAR,
+ CTLESC,
+ CTLVAR,
+ CTLBACKQ,
+ CTLBACKQ | CTLQUOTE,
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ CTLENDARI,
+#endif
+ 0
+ };
+ const char *reject = spclchars;
int c;
- int set;
- int special;
+ int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
+ int breakall = flag & EXP_WORD;
+ int inquotes;
+ size_t length;
int startloc;
- int varlen;
- int easy;
- int quotes = flag & (EXP_FULL | EXP_CASE);
- varflags = *p++;
- subtype = varflags & VSTYPE;
- var = p;
- special = 0;
- if (! is_name(*p))
- special = 1;
- p = strchr(p, '=') + 1;
-again: /* jump here after setting a variable with ${var=text} */
- if (special) {
- set = varisset(var, varflags & VSNUL);
- val = NULL;
- } else {
- val = lookupvar(var);
- if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
- val = NULL;
- set = 0;
- } else
- set = 1;
- }
- varlen = 0;
- startloc = expdest - stackblock();
- if (set && subtype != VSPLUS) {
- /* insert the value of the variable */
- if (special) {
- varvalue(var, varflags & VSQUOTE, flag);
- if (subtype == VSLENGTH) {
- varlen = expdest - stackblock() - startloc;
- STADJUST(-varlen, expdest);
- }
- } else {
- if (subtype == VSLENGTH) {
- varlen = strlen(val);
- } else {
- strtodest(
- val,
- varflags & VSQUOTE ?
- DQSYNTAX : BASESYNTAX,
- quotes
- );
- }
- }
+ if (!(flag & EXP_VARTILDE)) {
+ reject += 2;
+ } else if (flag & EXP_VARTILDE2) {
+ reject++;
}
+ inquotes = 0;
+ length = 0;
+ if (flag & EXP_TILDE) {
+ char *q;
- if (subtype == VSPLUS)
- set = ! set;
-
- easy = ((varflags & VSQUOTE) == 0 ||
- (*var == '@' && shellparam.nparam != 1));
-
-
- switch (subtype) {
- case VSLENGTH:
- expdest = cvtnum(varlen, expdest);
- goto record;
-
- case VSNORMAL:
- if (!easy)
- break;
-record:
- recordregion(startloc, expdest - stackblock(),
- varflags & VSQUOTE);
- break;
-
- case VSPLUS:
- case VSMINUS:
- if (!set) {
- argstr(p, flag);
- break;
- }
- if (easy)
- goto record;
- break;
-
- case VSTRIMLEFT:
- case VSTRIMLEFTMAX:
- case VSTRIMRIGHT:
- case VSTRIMRIGHTMAX:
- if (!set)
- break;
- /*
- * Terminate the string and start recording the pattern
- * right after it
- */
- STPUTC('\0', expdest);
- patloc = expdest - stackblock();
- if (subevalvar(p, NULL, patloc, subtype,
- startloc, varflags, quotes) == 0) {
- int amount = (expdest - stackblock() - patloc) + 1;
- STADJUST(-amount, expdest);
- }
- /* Remove any recorded regions beyond start of variable */
- removerecordregions(startloc);
- goto record;
-
- case VSASSIGN:
- case VSQUESTION:
- if (!set) {
- if (subevalvar(p, var, 0, subtype, startloc,
- varflags, quotes)) {
- varflags &= ~VSNUL;
- /*
- * Remove any recorded regions beyond
- * start of variable
- */
- removerecordregions(startloc);
- goto again;
+ flag &= ~EXP_TILDE;
+tilde:
+ q = p;
+ if (*q == CTLESC && (flag & EXP_QWORD))
+ q++;
+ if (*q == '~')
+ p = exptilde(p, q, flag);
+ }
+start:
+ startloc = expdest - (char *)stackblock();
+ for (;;) {
+ length += strcspn(p + length, reject);
+ c = p[length];
+ if (c && (!(c & 0x80)
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ || c == CTLENDARI
+#endif
+ )) {
+ /* c == '=' || c == ':' || c == CTLENDARI */
+ length++;
+ }
+ if (length > 0) {
+ int newloc;
+ expdest = stnputs(p, length, expdest);
+ newloc = expdest - (char *)stackblock();
+ if (breakall && !inquotes && newloc > startloc) {
+ recordregion(startloc, newloc, 0);
}
- break;
+ startloc = newloc;
}
- if (easy)
- goto record;
- break;
-
-#ifdef DEBUG
- default:
- abort();
-#endif
- }
+ p += length + 1;
+ length = 0;
- if (subtype != VSNORMAL) { /* skip to end of alternative */
- int nesting = 1;
- for (;;) {
- if ((c = *p++) == CTLESC)
- p++;
- else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
- if (set)
- argbackq = argbackq->next;
- } else if (c == CTLVAR) {
- if ((*p++ & VSTYPE) != VSNORMAL)
- nesting++;
- } else if (c == CTLENDVAR) {
- if (--nesting == 0)
- break;
+ switch (c) {
+ case '\0':
+ goto breakloop;
+ case '=':
+ if (flag & EXP_VARTILDE2) {
+ p--;
+ continue;
+ }
+ flag |= EXP_VARTILDE2;
+ reject++;
+ /* fall through */
+ case ':':
+ /*
+ * sort of a hack - expand tildes in variable
+ * assignments (after the first '=' and after ':'s).
+ */
+ if (*--p == '~') {
+ goto tilde;
}
+ continue;
}
- }
- return p;
-}
-
-
-/*
- * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
- * characters to allow for further processing. Otherwise treat
- * $@ like $* since no splitting will be performed.
- */
-static void
-argstr(p, flag)
- char *p;
- int flag;
-{
- char c;
- int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
- int firsteq = 1;
-
- if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
- p = exptilde(p, flag);
- for (;;) {
- switch (c = *p++) {
- case '\0':
+ switch (c) {
case CTLENDVAR: /* ??? */
goto breakloop;
case CTLQUOTEMARK:
/* "$@" syntax adherence hack */
- if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
- break;
- if ((flag & EXP_FULL) != 0)
- STPUTC(c, expdest);
+ if (
+ !inquotes &&
+ !memcmp(p, dolatstr, DOLATSTRLEN) &&
+ (p[4] == CTLQUOTEMARK || (
+ p[4] == CTLENDVAR &&
+ p[5] == CTLQUOTEMARK
+ ))
+ ) {
+ p = evalvar(p + 1, flag) + 1;
+ goto start;
+ }
+ inquotes = !inquotes;
+addquote:
+ if (quotes) {
+ p--;
+ length++;
+ startloc++;
+ }
break;
case CTLESC:
- if (quotes)
- STPUTC(c, expdest);
- c = *p++;
- STPUTC(c, expdest);
- break;
+ startloc++;
+ length++;
+ goto addquote;
case CTLVAR:
p = evalvar(p, flag);
- break;
+ goto start;
case CTLBACKQ:
+ c = 0;
case CTLBACKQ|CTLQUOTE:
- expbackq(argbackq->n, c & CTLQUOTE, flag);
+ expbackq(argbackq->n, c, quotes);
argbackq = argbackq->next;
- break;
-#ifdef ASH_MATH_SUPPORT
+ goto start;
+#ifdef CONFIG_ASH_MATH_SUPPORT
case CTLENDARI:
- expari(flag);
- break;
+ p--;
+ expari(quotes);
+ goto start;
#endif
- case ':':
- case '=':
- /*
- * sort of a hack - expand tildes in variable
- * assignments (after the first '=' and after ':'s).
- */
- STPUTC(c, expdest);
- if (flag & EXP_VARTILDE && *p == '~') {
- if (c == '=') {
- if (firsteq)
- firsteq = 0;
- else
- break;
- }
- p = exptilde(p, flag);
- }
- break;
- default:
- STPUTC(c, expdest);
}
}
-breakloop:;
- return;
+breakloop:
+ ;
}
static char *
-exptilde(p, flag)
- char *p;
- int flag;
+exptilde(char *startp, char *p, int flag)
{
- char c, *startp = p;
+ char c;
+ char *name;
struct passwd *pw;
const char *home;
int quotes = flag & (EXP_FULL | EXP_CASE);
+ int startloc;
+
+ name = p + 1;
- while ((c = *p) != '\0') {
+ while ((c = *++p) != '\0') {
switch(c) {
case CTLESC:
return (startp);
goto done;
break;
case '/':
+ case CTLENDVAR:
goto done;
}
- p++;
}
done:
*p = '\0';
- if (*(startp+1) == '\0') {
- if ((home = lookupvar("HOME")) == NULL)
+ if (*name == '\0') {
+ if ((home = lookupvar(homestr)) == NULL)
goto lose;
} else {
- if ((pw = getpwnam(startp+1)) == NULL)
+ if ((pw = getpwnam(name)) == NULL)
goto lose;
home = pw->pw_dir;
}
if (*home == '\0')
goto lose;
*p = c;
+ startloc = expdest - (char *)stackblock();
strtodest(home, SQSYNTAX, quotes);
+ recordregion(startloc, expdest - (char *)stackblock(), 0);
return (p);
lose:
*p = c;
}
-#ifdef ASH_MATH_SUPPORT
+#ifdef CONFIG_ASH_MATH_SUPPORT
/*
* Expand arithmetic expression. Backup to start of expression,
* evaluate, place result in (backed up) result, adjust string position.
*/
-static void
-expari(int flag)
+void
+expari(int quotes)
{
char *p, *start;
- int result;
int begoff;
- int quotes = flag & (EXP_FULL | EXP_CASE);
- int quoted;
+ int flag;
+ int len;
/* ifsfree(); */
/*
* This routine is slightly over-complicated for
- * efficiency. First we make sure there is
- * enough space for the result, which may be bigger
- * than the expression if we add exponentation. Next we
- * scan backwards looking for the start of arithmetic. If the
- * next previous character is a CTLESC character, then we
- * have to rescan starting from the beginning since CTLESC
- * characters have to be processed left to right.
+ * efficiency. Next we scan backwards looking for the
+ * start of arithmetic.
*/
- CHECKSTRSPACE(10, expdest);
- USTPUTC('\0', expdest);
start = stackblock();
p = expdest - 1;
- while (*p != CTLARI && p >= start)
- --p;
- if (*p != CTLARI)
- error("missing CTLARI (shouldn't happen)");
- if (p > start && *(p-1) == CTLESC)
- for (p = start; *p != CTLARI; p++)
- if (*p == CTLESC)
- p++;
+ *p = '\0';
+ p--;
+ do {
+ int esc;
+
+ while (*p != CTLARI) {
+ p--;
+#ifdef DEBUG
+ if (p < start) {
+ error("missing CTLARI (shouldn't happen)");
+ }
+#endif
+ }
+
+ esc = esclen(start, p);
+ if (!(esc % 2)) {
+ break;
+ }
+
+ p -= esc + 1;
+ } while (1);
- if (p[1] == '"')
- quoted=1;
- else
- quoted=0;
begoff = p - start;
+
removerecordregions(begoff);
+
+ flag = p[1];
+
+ expdest = p;
+
if (quotes)
- rmescapes(p+2);
- result = arith(p+2);
- snprintf(p, 12, "%d", result);
+ rmescapes(p + 2);
- while (*p++)
- ;
+ len = cvtnum(dash_arith(p + 2));
- if (quoted == 0)
- recordregion(begoff, p - 1 - start, 0);
- result = expdest - p + 1;
- STADJUST(-result, expdest);
+ if (flag != '"')
+ recordregion(begoff, begoff + len, 0);
}
#endif
*/
static void
-expbackq(cmd, quoted, flag)
- union node *cmd;
- int quoted;
- int flag;
+expbackq(union node *cmd, int quoted, int quotes)
{
- volatile struct backcmd in;
+ struct backcmd in;
int i;
char buf[128];
char *p;
- char *dest = expdest;
- volatile struct ifsregion saveifs;
- struct ifsregion *volatile savelastp;
- struct nodelist *volatile saveargbackq;
- char lastc;
- int startloc = dest - stackblock();
- char const *syntax = quoted? DQSYNTAX : BASESYNTAX;
- volatile int saveherefd;
- int quotes = flag & (EXP_FULL | EXP_CASE);
- struct jmploc jmploc;
- struct jmploc *volatile savehandler;
- int ex;
-
-#if __GNUC__
- /* Avoid longjmp clobbering */
- (void) &dest;
- (void) &syntax;
-#endif
-
- in.fd = -1;
- in.buf = 0;
- in.jp = 0;
+ char *dest;
+ int startloc;
+ int syntax = quoted? DQSYNTAX : BASESYNTAX;
+ struct stackmark smark;
INTOFF;
- saveifs = ifsfirst;
- savelastp = ifslastp;
- saveargbackq = argbackq;
- saveherefd = herefd;
- herefd = -1;
- if ((ex = setjmp(jmploc.loc))) {
- goto err1;
- }
- savehandler = handler;
- handler = &jmploc;
- INTON;
- p = grabstackstr(dest);
+ setstackmark(&smark);
+ dest = expdest;
+ startloc = dest - (char *)stackblock();
+ grabstackstr(dest);
evalbackcmd(cmd, (struct backcmd *) &in);
- ungrabstackstr(p, dest);
-err1:
- INTOFF;
- ifsfirst = saveifs;
- ifslastp = savelastp;
- argbackq = saveargbackq;
- herefd = saveherefd;
- if (ex) {
- goto err2;
- }
+ popstackmark(&smark);
p = in.buf;
- lastc = '\0';
+ i = in.nleft;
+ if (i == 0)
+ goto read;
for (;;) {
- if (--in.nleft < 0) {
- if (in.fd < 0)
- break;
- i = safe_read(in.fd, buf, sizeof buf);
- TRACE(("expbackq: read returns %d\n", i));
- if (i <= 0)
- break;
- p = buf;
- in.nleft = i - 1;
- }
- lastc = *p++;
- if (lastc != '\0') {
- if (quotes && syntax[(int)lastc] == CCTL)
- STPUTC(CTLESC, dest);
- STPUTC(lastc, dest);
- }
+ memtodest(p, i, syntax, quotes);
+read:
+ if (in.fd < 0)
+ break;
+ i = safe_read(in.fd, buf, sizeof buf);
+ TRACE(("expbackq: read returns %d\n", i));
+ if (i <= 0)
+ break;
+ p = buf;
}
- /* Eat all trailing newlines */
- for (; dest > stackblock() && dest[-1] == '\n';)
- STUNPUTC(dest);
-
-err2:
- if (in.fd >= 0)
- close(in.fd);
if (in.buf)
ckfree(in.buf);
- if (in.jp)
- exitstatus = waitforjob(in.jp);
- handler = savehandler;
- if (ex) {
- longjmp(handler->loc, 1);
+ if (in.fd >= 0) {
+ close(in.fd);
+ back_exitstatus = waitforjob(in.jp);
}
+ INTON;
+
+ /* Eat all trailing newlines */
+ dest = expdest;
+ for (; dest > (char *)stackblock() && dest[-1] == '\n';)
+ STUNPUTC(dest);
+ expdest = dest;
+
if (quoted == 0)
- recordregion(startloc, dest - stackblock(), 0);
+ recordregion(startloc, dest - (char *)stackblock(), 0);
TRACE(("evalbackq: size=%d: \"%.*s\"\n",
- (dest - stackblock()) - startloc,
- (dest - stackblock()) - startloc,
+ (dest - (char *)stackblock()) - startloc,
+ (dest - (char *)stackblock()) - startloc,
stackblock() + startloc));
- expdest = dest;
- INTON;
}
-static int
-subevalvar(p, str, strloc, subtype, startloc, varflags, quotes)
- char *p;
- char *str;
- int strloc;
- int subtype;
- int startloc;
- int varflags;
- int quotes;
-{
- char *startp;
- char *loc = NULL;
- char *q;
- int c = 0;
- int saveherefd = herefd;
- struct nodelist *saveargbackq = argbackq;
- int amount;
- herefd = -1;
- argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
- STACKSTRNUL(expdest);
- herefd = saveherefd;
- argbackq = saveargbackq;
- startp = stackblock() + startloc;
- if (str == NULL)
- str = stackblock() + strloc;
+static char *
+scanleft(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
+ int zero)
+{
+ char *loc;
+ char *loc2;
+ char c;
- switch (subtype) {
+ loc = startp;
+ loc2 = rmesc;
+ do {
+ int match;
+ const char *s = loc2;
+ c = *loc2;
+ if (zero) {
+ *loc2 = '\0';
+ s = rmesc;
+ }
+ match = pmatch(str, s);
+ *loc2 = c;
+ if (match)
+ return loc;
+ if (quotes && *loc == CTLESC)
+ loc++;
+ loc++;
+ loc2++;
+ } while (c);
+ return 0;
+}
+
+
+static char *
+scanright(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
+ int zero)
+{
+ int esc = 0;
+ char *loc;
+ char *loc2;
+
+ for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
+ int match;
+ char c = *loc2;
+ const char *s = loc2;
+ if (zero) {
+ *loc2 = '\0';
+ s = rmesc;
+ }
+ match = pmatch(str, s);
+ *loc2 = c;
+ if (match)
+ return loc;
+ loc--;
+ if (quotes) {
+ if (--esc < 0) {
+ esc = esclen(startp, loc);
+ }
+ if (esc % 2) {
+ esc--;
+ loc--;
+ }
+ }
+ }
+ return 0;
+}
+
+static const char *
+subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
+{
+ char *startp;
+ char *loc;
+ int saveherefd = herefd;
+ struct nodelist *saveargbackq = argbackq;
+ int amount;
+ char *rmesc, *rmescend;
+ int zero;
+ char *(*scan)(char *, char *, char *, char *, int , int);
+
+ herefd = -1;
+ argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
+ STPUTC('\0', expdest);
+ herefd = saveherefd;
+ argbackq = saveargbackq;
+ startp = stackblock() + startloc;
+
+ switch (subtype) {
case VSASSIGN:
setvar(str, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
- varflags &= ~VSNUL;
- if (c != 0)
- *loc = c;
- return 1;
+ return startp;
case VSQUESTION:
- if (*p != CTLENDVAR) {
- out2fmt(snlfmt, startp);
- error((char *)NULL);
- }
- error("%.*s: parameter %snot set", p - str - 1,
- str, (varflags & VSNUL) ? "null or "
- : nullstr);
+ varunset(p, str, startp, varflags);
/* NOTREACHED */
+ }
- case VSTRIMLEFT:
- for (loc = startp; loc < str; loc++) {
- c = *loc;
- *loc = '\0';
- if (patmatch2(str, startp, quotes))
- goto recordleft;
- *loc = c;
- if (quotes && *loc == CTLESC)
- loc++;
+ subtype -= VSTRIMRIGHT;
+#ifdef DEBUG
+ if (subtype < 0 || subtype > 3)
+ abort();
+#endif
+
+ rmesc = startp;
+ rmescend = stackblock() + strloc;
+ if (quotes) {
+ rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
+ if (rmesc != startp) {
+ rmescend = expdest;
+ startp = stackblock() + startloc;
}
- return 0;
+ }
+ rmescend--;
+ str = stackblock() + strloc;
+ preglob(str, varflags & VSQUOTE, 0);
- case VSTRIMLEFTMAX:
- for (loc = str - 1; loc >= startp;) {
- c = *loc;
- *loc = '\0';
- if (patmatch2(str, startp, quotes))
- goto recordleft;
- *loc = c;
- loc--;
- if (quotes && loc > startp && *(loc - 1) == CTLESC) {
- for (q = startp; q < loc; q++)
- if (*q == CTLESC)
- q++;
- if (q > loc)
- loc--;
- }
+ /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
+ zero = subtype >> 1;
+ /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
+ scan = (subtype & 1) ^ zero ? scanleft : scanright;
+
+ loc = scan(startp, rmesc, rmescend, str, quotes, zero);
+ if (loc) {
+ if (zero) {
+ memmove(startp, loc, str - loc);
+ loc = startp + (str - loc) - 1;
}
- return 0;
+ *loc = '\0';
+ amount = loc - expdest;
+ STADJUST(amount, expdest);
+ }
+ return loc;
+}
- case VSTRIMRIGHT:
- for (loc = str - 1; loc >= startp;) {
- if (patmatch2(str, loc, quotes))
- goto recordright;
- loc--;
- if (quotes && loc > startp && *(loc - 1) == CTLESC) {
- for (q = startp; q < loc; q++)
- if (*q == CTLESC)
- q++;
- if (q > loc)
- loc--;
- }
+
+/*
+ * Expand a variable, and return a pointer to the next character in the
+ * input string.
+ */
+static char *
+evalvar(char *p, int flag)
+{
+ int subtype;
+ int varflags;
+ char *var;
+ int patloc;
+ int c;
+ int startloc;
+ ssize_t varlen;
+ int easy;
+ int quotes;
+ int quoted;
+
+ quotes = flag & (EXP_FULL | EXP_CASE);
+ varflags = *p++;
+ subtype = varflags & VSTYPE;
+ quoted = varflags & VSQUOTE;
+ var = p;
+ easy = (!quoted || (*var == '@' && shellparam.nparam));
+ startloc = expdest - (char *)stackblock();
+ p = strchr(p, '=') + 1;
+
+again:
+ varlen = varvalue(var, varflags, flag);
+ if (varflags & VSNUL)
+ varlen--;
+
+ if (subtype == VSPLUS) {
+ varlen = -1 - varlen;
+ goto vsplus;
+ }
+
+ if (subtype == VSMINUS) {
+vsplus:
+ if (varlen < 0) {
+ argstr(
+ p, flag | EXP_TILDE |
+ (quoted ? EXP_QWORD : EXP_WORD)
+ );
+ goto end;
}
- return 0;
+ if (easy)
+ goto record;
+ goto end;
+ }
- case VSTRIMRIGHTMAX:
- for (loc = startp; loc < str - 1; loc++) {
- if (patmatch2(str, loc, quotes))
- goto recordright;
- if (quotes && *loc == CTLESC)
- loc++;
+ if (subtype == VSASSIGN || subtype == VSQUESTION) {
+ if (varlen < 0) {
+ if (subevalvar(p, var, 0, subtype, startloc,
+ varflags, 0)) {
+ varflags &= ~VSNUL;
+ /*
+ * Remove any recorded regions beyond
+ * start of variable
+ */
+ removerecordregions(startloc);
+ goto again;
+ }
+ goto end;
}
- return 0;
+ if (easy)
+ goto record;
+ goto end;
+ }
+
+ if (varlen < 0 && uflag)
+ varunset(p, var, 0, 0);
+
+ if (subtype == VSLENGTH) {
+ cvtnum(varlen > 0 ? varlen : 0);
+ goto record;
+ }
+
+ if (subtype == VSNORMAL) {
+ if (!easy)
+ goto end;
+record:
+ recordregion(startloc, expdest - (char *)stackblock(), quoted);
+ goto end;
+ }
#ifdef DEBUG
+ switch (subtype) {
+ case VSTRIMLEFT:
+ case VSTRIMLEFTMAX:
+ case VSTRIMRIGHT:
+ case VSTRIMRIGHTMAX:
+ break;
default:
abort();
-#endif
}
+#endif
-recordleft:
- *loc = c;
- amount = ((str - 1) - (loc - startp)) - expdest;
- STADJUST(amount, expdest);
- while (loc != str - 1)
- *startp++ = *loc++;
- return 1;
+ if (varlen >= 0) {
+ /*
+ * Terminate the string and start recording the pattern
+ * right after it
+ */
+ STPUTC('\0', expdest);
+ patloc = expdest - (char *)stackblock();
+ if (subevalvar(p, NULL, patloc, subtype,
+ startloc, varflags, quotes) == 0) {
+ int amount = expdest - (
+ (char *)stackblock() + patloc - 1
+ );
+ STADJUST(-amount, expdest);
+ }
+ /* Remove any recorded regions beyond start of variable */
+ removerecordregions(startloc);
+ goto record;
+ }
-recordright:
- amount = loc - expdest;
- STADJUST(amount, expdest);
- STPUTC('\0', expdest);
- STADJUST(-1, expdest);
- return 1;
+end:
+ if (subtype != VSNORMAL) { /* skip to end of alternative */
+ int nesting = 1;
+ for (;;) {
+ if ((c = *p++) == CTLESC)
+ p++;
+ else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
+ if (varlen >= 0)
+ argbackq = argbackq->next;
+ } else if (c == CTLVAR) {
+ if ((*p++ & VSTYPE) != VSNORMAL)
+ nesting++;
+ } else if (c == CTLENDVAR) {
+ if (--nesting == 0)
+ break;
+ }
+ }
+ }
+ return p;
}
/*
- * Test whether a specialized variable is set.
+ * Put a string on the stack.
*/
-static int
-varisset(name, nulok)
- char *name;
- int nulok;
-{
- if (*name == '!')
- return backgndpid != -1;
- else if (*name == '@' || *name == '*') {
- if (*shellparam.p == NULL)
- return 0;
-
- if (nulok) {
- char **av;
-
- for (av = shellparam.p; *av; av++)
- if (**av != '\0')
- return 1;
- return 0;
- }
- } else if (is_digit(*name)) {
- char *ap;
- int num = atoi(name);
-
- if (num > shellparam.nparam)
- return 0;
+static void
+memtodest(const char *p, size_t len, int syntax, int quotes) {
+ char *q = expdest;
- if (num == 0)
- ap = arg0;
- else
- ap = shellparam.p[num - 1];
+ q = makestrspace(len * 2, q);
- if (nulok && (ap == NULL || *ap == '\0'))
- return 0;
+ while (len--) {
+ int c = *p++;
+ if (!c)
+ continue;
+ if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK))
+ USTPUTC(CTLESC, q);
+ USTPUTC(c, q);
}
- return 1;
+
+ expdest = q;
}
-/*
- * Put a string on the stack.
- */
static void
-strtodest(p, syntax, quotes)
- const char *p;
- const char *syntax;
- int quotes;
+strtodest(const char *p, int syntax, int quotes)
{
- while (*p) {
- if (quotes && syntax[(int) *p] == CCTL)
- STPUTC(CTLESC, expdest);
- STPUTC(*p++, expdest);
- }
+ memtodest(p, strlen(p), syntax, quotes);
}
+
/*
* Add the value of a specialized variable to the stack string.
*/
-static void
-varvalue(name, quoted, flags)
- char *name;
- int quoted;
- int flags;
+static ssize_t
+varvalue(char *name, int varflags, int flags)
{
int num;
char *p;
int i;
- int sep;
+ int sep = 0;
int sepq = 0;
+ ssize_t len = 0;
char **ap;
- char const *syntax;
- int allow_split = flags & EXP_FULL;
+ int syntax;
+ int quoted = varflags & VSQUOTE;
+ int subtype = varflags & VSTYPE;
int quotes = flags & (EXP_FULL | EXP_CASE);
+ if (quoted && (flags & EXP_FULL))
+ sep = 1 << CHAR_BIT;
+
syntax = quoted ? DQSYNTAX : BASESYNTAX;
switch (*name) {
case '$':
num = rootpid;
goto numvar;
case '?':
- num = oexitstatus;
+ num = exitstatus;
goto numvar;
case '#':
num = shellparam.nparam;
goto numvar;
case '!':
num = backgndpid;
+ if (num == 0)
+ return -1;
numvar:
- expdest = cvtnum(num, expdest);
+ len = cvtnum(num);
break;
case '-':
- for (i = 0 ; i < NOPTS ; i++) {
- if (optent_val(i))
- STPUTC(optent_letter(optlist[i]), expdest);
+ p = makestrspace(NOPTS, expdest);
+ for (i = NOPTS - 1; i >= 0; i--) {
+ if (optlist[i]) {
+ USTPUTC(optletters(i), p);
+ len++;
+ }
}
+ expdest = p;
break;
case '@':
- if (allow_split && quoted) {
- sep = 1 << CHAR_BIT;
+ if (sep)
goto param;
- }
/* fall through */
case '*':
sep = ifsset() ? ifsval()[0] : ' ';
- if (quotes) {
- sepq = syntax[(int) sep] == CCTL;
- }
+ if (quotes && (SIT(sep, syntax) == CCTL || SIT(sep, syntax) == CBACK))
+ sepq = 1;
param:
- for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
- strtodest(p, syntax, quotes);
- if (*ap && sep) {
+ if (!(ap = shellparam.p))
+ return -1;
+ while ((p = *ap++)) {
+ size_t partlen;
+
+ partlen = strlen(p);
+
+ len += partlen;
+ if (len > partlen && sep) {
+ char *q;
+
+ len++;
+ if (subtype == VSPLUS || subtype == VSLENGTH) {
+ continue;
+ }
+ q = expdest;
if (sepq)
- STPUTC(CTLESC, expdest);
- STPUTC(sep, expdest);
+ STPUTC(CTLESC, q);
+ STPUTC(sep, q);
+ expdest = q;
}
+
+ if (!(subtype == VSPLUS || subtype == VSLENGTH))
+ memtodest(p, partlen, syntax, quotes);
}
- break;
+ return len;
case '0':
- strtodest(arg0, syntax, quotes);
- break;
- default:
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
num = atoi(name);
- if (num > 0 && num <= shellparam.nparam) {
- strtodest(shellparam.p[num - 1], syntax, quotes);
- }
- break;
+ if (num < 0 || num > shellparam.nparam)
+ return -1;
+ p = num ? shellparam.p[num - 1] : arg0;
+ goto value;
+ default:
+ p = lookupvar(name);
+value:
+ if (!p)
+ return -1;
+
+ len = strlen(p);
+ if (!(subtype == VSPLUS || subtype == VSLENGTH))
+ memtodest(p, len, syntax, quotes);
+ return len;
}
+
+ if (subtype == VSPLUS || subtype == VSLENGTH)
+ STADJUST(-len, expdest);
+ return len;
}
*/
static void
-recordregion(start, end, nulonly)
- int start;
- int end;
- int nulonly;
+recordregion(int start, int end, int nulonly)
{
struct ifsregion *ifsp;
}
-
/*
* Break the argument string into pieces based upon IFS and add the
* strings to the argument list. The regions of the string to be
* searched for IFS characters have been stored by recordregion.
*/
static void
-ifsbreakup(string, arglist)
- char *string;
- struct arglist *arglist;
- {
+ifsbreakup(char *string, struct arglist *arglist)
+{
struct ifsregion *ifsp;
struct strlist *sp;
char *start;
start = string;
- ifsspc = 0;
- nulonly = 0;
- realifs = ifsset() ? ifsval() : defifs;
if (ifslastp != NULL) {
+ ifsspc = 0;
+ nulonly = 0;
+ realifs = ifsset() ? ifsval() : defifs;
ifsp = &ifsfirst;
do {
p = string + ifsp->begoff;
p++;
}
} while ((ifsp = ifsp->next) != NULL);
- if (!(*start || (!ifsspc && start > string && nulonly))) {
- return;
- }
+ if (nulonly)
+ goto add;
}
+ if (!*start)
+ return;
+
+add:
sp = (struct strlist *)stalloc(sizeof *sp);
sp->text = start;
*arglist->lastp = sp;
}
static void
-ifsfree()
+ifsfree(void)
{
- while (ifsfirst.next != NULL) {
+ struct ifsregion *p;
+
+ INTOFF;
+ p = ifsfirst.next;
+ do {
struct ifsregion *ifsp;
- INTOFF;
- ifsp = ifsfirst.next->next;
- ckfree(ifsfirst.next);
- ifsfirst.next = ifsp;
- INTON;
- }
+ ifsp = p->next;
+ ckfree(p);
+ p = ifsp;
+ } while (p);
ifslastp = NULL;
ifsfirst.next = NULL;
+ INTON;
}
-/*
- * Add a file name to the list.
- */
-
-static void
-addfname(const char *name)
-{
- char *p;
- struct strlist *sp;
+static void expmeta(char *, char *);
+static struct strlist *expsort(struct strlist *);
+static struct strlist *msort(struct strlist *, int);
- p = sstrdup(name);
- sp = (struct strlist *)stalloc(sizeof *sp);
- sp->text = p;
- *exparg.lastp = sp;
- exparg.lastp = &sp->next;
-}
+static char *expdir;
-/*
- * Expand shell metacharacters. At this point, the only control characters
- * should be escapes. The results are stored in the list exparg.
- */
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
static void
-expandmeta(str, flag)
- struct strlist *str;
- int flag;
+expandmeta(struct strlist *str, int flag)
{
- const char *p;
- glob_t pglob;
+ static const char metachars[] = {
+ '*', '?', '[', 0
+ };
/* TODO - EXP_REDIR */
while (str) {
+ struct strlist **savelastp;
+ struct strlist *sp;
+ char *p;
+
if (fflag)
goto nometa;
- p = preglob(str->text);
+ if (!strpbrk(str->text, metachars))
+ goto nometa;
+ savelastp = exparg.lastp;
+
INTOFF;
- switch (glob(p, GLOB_NOMAGIC, 0, &pglob)) {
- case 0:
- if (!(pglob.gl_flags & GLOB_MAGCHAR))
- goto nometa2;
- addglob(&pglob);
- globfree(&pglob);
- INTON;
- break;
- case GLOB_NOMATCH:
-nometa2:
- globfree(&pglob);
- INTON;
-nometa:
- *exparg.lastp = str;
- rmescapes(str->text);
- exparg.lastp = &str->next;
- break;
- default: /* GLOB_NOSPACE */
- error("Out of space");
- }
- str = str->next;
- }
-}
-
-
-/*
- * Add the result of glob(3) to the list.
- */
-
-static void
-addglob(pglob)
- const glob_t *pglob;
-{
- char **p = pglob->gl_pathv;
-
- do {
- addfname(*p);
- } while (*++p);
-}
-
-
-#else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
-static char *expdir;
-
-
-static void
-expandmeta(str, flag)
- struct strlist *str;
- int flag;
-{
- char *p;
- struct strlist **savelastp;
- struct strlist *sp;
- char c;
- /* TODO - EXP_REDIR */
-
- while (str) {
- if (fflag)
- goto nometa;
- p = str->text;
- for (;;) { /* fast check for meta chars */
- if ((c = *p++) == '\0')
- goto nometa;
- if (c == '*' || c == '?' || c == '[' || c == '!')
- break;
- }
- savelastp = exparg.lastp;
- INTOFF;
- if (expdir == NULL) {
- int i = strlen(str->text);
- expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
- }
-
- expmeta(expdir, str->text);
- ckfree(expdir);
- expdir = NULL;
- INTON;
- if (exparg.lastp == savelastp) {
- /*
- * no matches
- */
+ p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ {
+ int i = strlen(str->text);
+ expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
+ }
+
+ expmeta(expdir, p);
+ ckfree(expdir);
+ if (p != str->text)
+ ckfree(p);
+ INTON;
+ if (exparg.lastp == savelastp) {
+ /*
+ * no matches
+ */
nometa:
*exparg.lastp = str;
rmescapes(str->text);
}
}
+/*
+ * Add a file name to the list.
+ */
+
+static void
+addfname(const char *name)
+{
+ struct strlist *sp;
+
+ sp = (struct strlist *)stalloc(sizeof *sp);
+ sp->text = sstrdup(name);
+ *exparg.lastp = sp;
+ exparg.lastp = &sp->next;
+}
+
/*
* Do metacharacter (i.e. *, ?, [...]) expansion.
*/
static void
-expmeta(enddir, name)
- char *enddir;
- char *name;
- {
+expmeta(char *enddir, char *name)
+{
char *p;
const char *cp;
- char *q;
char *start;
char *endname;
int metaflag;
metaflag = 0;
start = name;
- for (p = name ; ; p++) {
+ for (p = name; *p; p++) {
if (*p == '*' || *p == '?')
metaflag = 1;
else if (*p == '[') {
- q = p + 1;
+ char *q = p + 1;
if (*q == '!')
q++;
for (;;) {
- while (*q == CTLQUOTEMARK)
- q++;
- if (*q == CTLESC)
+ if (*q == '\\')
q++;
if (*q == '/' || *q == '\0')
break;
break;
}
}
- } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
- metaflag = 1;
- } else if (*p == '\0')
- break;
- else if (*p == CTLQUOTEMARK)
- continue;
- else if (*p == CTLESC)
+ } else if (*p == '\\')
p++;
- if (*p == '/') {
+ else if (*p == '/') {
if (metaflag)
- break;
+ goto out;
start = p + 1;
}
}
+out:
if (metaflag == 0) { /* we've reached the end of the file name */
if (enddir != expdir)
metaflag++;
- for (p = name ; ; p++) {
- if (*p == CTLQUOTEMARK)
- continue;
- if (*p == CTLESC)
+ p = name;
+ do {
+ if (*p == '\\')
p++;
*enddir++ = *p;
- if (*p == '\0')
- break;
- }
+ } while (*p++);
if (metaflag == 0 || lstat(expdir, &statb) >= 0)
addfname(expdir);
return;
}
endname = p;
- if (start != name) {
+ if (name < start) {
p = name;
- while (p < start) {
- while (*p == CTLQUOTEMARK)
- p++;
- if (*p == CTLESC)
+ do {
+ if (*p == '\\')
p++;
*enddir++ = *p++;
- }
+ } while (p < start);
}
if (enddir == expdir) {
cp = ".";
}
matchdot = 0;
p = start;
- while (*p == CTLQUOTEMARK)
- p++;
- if (*p == CTLESC)
+ if (*p == '\\')
p++;
if (*p == '.')
matchdot++;
- while (! int_pending() && (dp = readdir(dirp)) != NULL) {
+ while (! intpending && (dp = readdir(dirp)) != NULL) {
if (dp->d_name[0] == '.' && ! matchdot)
continue;
- if (patmatch(start, dp->d_name, 0)) {
+ if (pmatch(start, dp->d_name)) {
if (atend) {
- strcpy(enddir, dp->d_name);
+ scopy(dp->d_name, enddir);
addfname(expdir);
} else {
for (p = enddir, cp = dp->d_name;
if (! atend)
endname[-1] = '/';
}
-#endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
-
-
-#if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
/*
* Sort the results of file name expansion. It calculates the number of
* strings to sort and then calls msort (short for merge sort) to do the
*/
static struct strlist *
-expsort(str)
- struct strlist *str;
- {
+expsort(struct strlist *str)
+{
int len;
struct strlist *sp;
static struct strlist *
-msort(list, len)
- struct strlist *list;
- int len;
+msort(struct strlist *list, int len)
{
struct strlist *p, *q = NULL;
struct strlist **lpp;
p = msort(p, len - half); /* sort second half */
lpp = &list;
for (;;) {
- if (strcmp(p->text, q->text) < 0) {
+#ifdef CONFIG_LOCALE_SUPPORT
+ if (strcoll(p->text, q->text) < 0)
+#else
+ if (strcmp(p->text, q->text) < 0)
+#endif
+ {
*lpp = p;
lpp = &p->next;
if ((p = *lpp) == NULL) {
}
return list;
}
-#endif
-
/*
* Returns true if the pattern matches the string.
*/
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-/* squoted: string might have quote chars */
-static int
-patmatch(char *pattern, char *string, int squoted)
-{
- const char *p;
- char *q;
-
- p = preglob(pattern);
- q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string;
-
- return !fnmatch(p, q, 0);
-}
-
-
-static int
-patmatch2(char *pattern, char *string, int squoted)
-{
- char *p;
- int res;
-
- sstrnleft--;
- p = grabstackstr(expdest);
- res = patmatch(pattern, string, squoted);
- ungrabstackstr(p, expdest);
- return res;
-}
-#else
-static int
-patmatch(char *pattern, char *string, int squoted) {
- return pmatch(pattern, string, squoted);
-}
-
-
-static int
-pmatch(char *pattern, char *string, int squoted)
+static inline int
+patmatch(char *pattern, const char *string)
{
- char *p, *q;
- char c;
-
- p = pattern;
- q = string;
- for (;;) {
- switch (c = *p++) {
- case '\0':
- goto breakloop;
- case CTLESC:
- if (squoted && *q == CTLESC)
- q++;
- if (*q++ != *p++)
- return 0;
- break;
- case CTLQUOTEMARK:
- continue;
- case '?':
- if (squoted && *q == CTLESC)
- q++;
- if (*q++ == '\0')
- return 0;
- break;
- case '*':
- c = *p;
- while (c == CTLQUOTEMARK || c == '*')
- c = *++p;
- if (c != CTLESC && c != CTLQUOTEMARK &&
- c != '?' && c != '*' && c != '[') {
- while (*q != c) {
- if (squoted && *q == CTLESC &&
- q[1] == c)
- break;
- if (*q == '\0')
- return 0;
- if (squoted && *q == CTLESC)
- q++;
- q++;
- }
- }
- do {
- if (pmatch(p, q, squoted))
- return 1;
- if (squoted && *q == CTLESC)
- q++;
- } while (*q++ != '\0');
- return 0;
- case '[': {
- char *endp;
- int invert, found;
- char chr;
-
- endp = p;
- if (*endp == '!')
- endp++;
- for (;;) {
- while (*endp == CTLQUOTEMARK)
- endp++;
- if (*endp == '\0')
- goto dft; /* no matching ] */
- if (*endp == CTLESC)
- endp++;
- if (*++endp == ']')
- break;
- }
- invert = 0;
- if (*p == '!') {
- invert++;
- p++;
- }
- found = 0;
- chr = *q++;
- if (squoted && chr == CTLESC)
- chr = *q++;
- if (chr == '\0')
- return 0;
- c = *p++;
- do {
- if (c == CTLQUOTEMARK)
- continue;
- if (c == CTLESC)
- c = *p++;
- if (*p == '-' && p[1] != ']') {
- p++;
- while (*p == CTLQUOTEMARK)
- p++;
- if (*p == CTLESC)
- p++;
- if (chr >= c && chr <= *p)
- found = 1;
- p++;
- } else {
- if (chr == c)
- found = 1;
- }
- } while ((c = *p++) != ']');
- if (found == invert)
- return 0;
- break;
- }
-dft: default:
- if (squoted && *q == CTLESC)
- q++;
- if (*q++ != c)
- return 0;
- break;
- }
- }
-breakloop:
- if (*q != '\0')
- return 0;
- return 1;
+ return pmatch(preglob(pattern, 0, 0), string);
}
-#endif
-
/*
* Remove any CTLESC characters from a string.
*/
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
static char *
_rmescapes(char *str, int flag)
{
char *p, *q, *r;
static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
+ unsigned inquotes;
+ int notescaped;
+ int globbing;
p = strpbrk(str, qchars);
if (!p) {
r = str;
if (flag & RMESCAPE_ALLOC) {
size_t len = p - str;
- q = r = stalloc(strlen(p) + len + 1);
+ size_t fulllen = len + strlen(p) + 1;
+
+ if (flag & RMESCAPE_GROW) {
+ r = makestrspace(fulllen, expdest);
+ } else if (flag & RMESCAPE_HEAP) {
+ r = ckmalloc(fulllen);
+ } else {
+ r = stalloc(fulllen);
+ }
+ q = r;
if (len > 0) {
- memcpy(q, str, len);
- q += len;
+ q = mempcpy(q, str, len);
}
}
+ inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
+ globbing = flag & RMESCAPE_GLOB;
+ notescaped = globbing;
while (*p) {
if (*p == CTLQUOTEMARK) {
+ inquotes = ~inquotes;
p++;
+ notescaped = globbing;
continue;
}
+ if (*p == '\\') {
+ /* naked back slash */
+ notescaped = 0;
+ goto copy;
+ }
if (*p == CTLESC) {
p++;
- if (flag & RMESCAPE_GLOB && *p != '/') {
+ if (notescaped && inquotes && *p != '/') {
*q++ = '\\';
}
}
+ notescaped = globbing;
+copy:
*q++ = *p++;
}
*q = '\0';
- return r;
-}
-#else
-static void
-rmescapes(str)
- char *str;
-{
- char *p, *q;
-
- p = str;
- while (*p != CTLESC && *p != CTLQUOTEMARK) {
- if (*p++ == '\0')
- return;
- }
- q = p;
- while (*p) {
- if (*p == CTLQUOTEMARK) {
- p++;
- continue;
- }
- if (*p == CTLESC)
- p++;
- *q++ = *p++;
+ if (flag & RMESCAPE_GROW) {
+ expdest = r;
+ STADJUST(q - r + 1, expdest);
}
- *q = '\0';
+ return r;
}
-#endif
-
/*
* See if a pattern matches in a case statement.
*/
-static int
-casematch(union node *pattern, const char *val)
+int
+casematch(union node *pattern, char *val)
{
struct stackmark smark;
int result;
- char *p;
setstackmark(&smark);
argbackq = pattern->narg.backquote;
STARTSTACKSTR(expdest);
ifslastp = NULL;
argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
- STPUTC('\0', expdest);
- p = grabstackstr(expdest);
- result = patmatch(p, (char *)val, 0);
+ STACKSTRNUL(expdest);
+ result = patmatch(stackblock(), val);
popstackmark(&smark);
return result;
}
* Our own itoa().
*/
-static char *
-cvtnum(num, buf)
- int num;
- char *buf;
- {
+static int
+cvtnum(arith_t num)
+{
int len;
- CHECKSTRSPACE(32, buf);
- len = sprintf(buf, "%d", num);
- STADJUST(len, buf);
- return buf;
+ expdest = makestrspace(32, expdest);
+#ifdef CONFIG_ASH_MATH_SUPPORT_64
+ len = fmtstr(expdest, 32, "%lld", (long long) num);
+#else
+ len = fmtstr(expdest, 32, "%ld", num);
+#endif
+ STADJUST(len, expdest);
+ return len;
}
-/*
- * Editline and history functions (and glue).
- */
-static int histcmd(argc, argv)
- int argc;
- char **argv;
+
+static void
+varunset(const char *end, const char *var, const char *umsg, int varflags)
{
- error("not compiled with history support");
- /* NOTREACHED */
+ const char *msg;
+ const char *tail;
+
+ tail = nullstr;
+ msg = "parameter not set";
+ if (umsg) {
+ if (*end == CTLENDVAR) {
+ if (varflags & VSNUL)
+ tail = " or null";
+ } else
+ msg = umsg;
+ }
+ error("%.*s: %s%s", end - var - 1, var, msg, tail);
}
-struct redirtab {
- struct redirtab *next;
- /* short renamed[10]; *//* Current ash support only 0-9 descriptors */
- char renamed[10];
-};
-
-static struct redirtab *redirlist;
-
-extern char **environ;
-
-
+/* $NetBSD: input.c,v 1.37 2002/11/24 22:35:40 christos Exp $ */
/*
- * Initialization code.
+ * This implements the input routines used by the parser.
*/
-static void
-init(void) {
-
- /* from cd.c: */
- {
- setpwd(0, 0);
- }
+#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
+#define IBUFSIZ (BUFSIZ + 1)
- /* from input.c: */
- {
- basepf.nextc = basepf.buf = basebuf;
- }
+static void pushfile(void);
- /* from var.c: */
- {
- char **envp;
- char ppid[32];
+/*
+ * Read a character from the script, returning PEOF on end of file.
+ * Nul characters in the input are silently discarded.
+ */
- initvar();
- for (envp = environ ; *envp ; envp++) {
- if (strchr(*envp, '=')) {
- setvareq(*envp, VEXPORT|VTEXTFIXED);
- }
- }
+#define pgetc_as_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
- snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
- setvar("PPID", ppid, 0);
- }
+#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+#define pgetc_macro() pgetc()
+static int
+pgetc(void)
+{
+ return pgetc_as_macro();
+}
+#else
+#define pgetc_macro() pgetc_as_macro()
+static int
+pgetc(void)
+{
+ return pgetc_macro();
}
-
-
-
-/*
- * This routine is called when an error or an interrupt occurs in an
- * interactive shell and control is returned to the main command loop.
- */
-
-/* 1 == check for aliases, 2 == also check for assignments */
-static int checkalias; /* also used in no alias mode for check assignments */
-
-static void
-reset(void) {
-
- /* from eval.c: */
- {
- evalskip = 0;
- loopnest = 0;
- funcnest = 0;
- }
-
- /* from input.c: */
- {
- if (exception != EXSHELLPROC)
- parselleft = parsenleft = 0; /* clear input buffer */
- popallfiles();
- }
-
- /* from parser.c: */
- {
- tokpushback = 0;
- checkkwd = 0;
- checkalias = 0;
- }
-
- /* from redir.c: */
- {
- while (redirlist)
- popredir();
- }
-
-}
-
-
-
-/*
- * This file implements the input routines used by the parser.
- */
-
-#ifdef BB_FEATURE_COMMAND_EDITING
-static const char * cmdedit_prompt;
-static inline void putprompt(const char *s) {
- cmdedit_prompt = s;
-}
-#else
-static inline void putprompt(const char *s) {
- out2str(s);
-}
-#endif
-
-#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
-
+#endif
/*
* Same as pgetc(), but ignores PEOA.
*/
-
-#ifdef ASH_ALIAS
-static int
-pgetc2()
+#ifdef CONFIG_ASH_ALIAS
+static int pgetc2(void)
{
int c;
+
do {
c = pgetc_macro();
} while (c == PEOA);
return c;
}
#else
-static inline int pgetc2() { return pgetc_macro(); }
+static inline int pgetc2(void)
+{
+ return pgetc_macro();
+}
#endif
/*
return line;
}
+
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+static const char *cmdedit_prompt;
+static inline void putprompt(const char *s)
+{
+ cmdedit_prompt = s;
+}
+#else
+static inline void putprompt(const char *s)
+{
+ out2str(s);
+}
+#endif
+
static inline int
preadfd(void)
{
- int nr;
- char *buf = parsefile->buf;
- parsenextc = buf;
+ int nr;
+ char *buf = parsefile->buf;
+ parsenextc = buf;
retry:
-#ifdef BB_FEATURE_COMMAND_EDITING
- {
- if (!iflag)
- nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
- else {
- nr = cmdedit_read_input((char*)cmdedit_prompt, buf);
- }
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ if (!iflag || parsefile->fd)
+ nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
+ else {
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+ cmdedit_path_lookup = pathval();
+#endif
+ nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
+ if(nr == 0) {
+ /* Ctrl+C presend */
+ if(trap[SIGINT]) {
+ buf[0] = '\n';
+ buf[1] = 0;
+ raise(SIGINT);
+ return 1;
+ }
+ goto retry;
+ }
+ if(nr < 0 && errno == 0) {
+ /* Ctrl+D presend */
+ nr = 0;
+ }
}
#else
nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
return nr;
}
-static void
-popstring(void)
-{
- struct strpush *sp = parsefile->strpush;
-
- INTOFF;
-#ifdef ASH_ALIAS
- if (sp->ap) {
- if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
- if (!checkalias) {
- checkalias = 1;
- }
- }
- if (sp->string != sp->ap->val) {
- ckfree(sp->string);
- }
-
- sp->ap->flag &= ~ALIASINUSE;
- if (sp->ap->flag & ALIASDEAD) {
- unalias(sp->ap->name);
- }
- }
-#endif
- parsenextc = sp->prevstring;
- parsenleft = sp->prevnleft;
-/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
- parsefile->strpush = sp->prev;
- if (sp != &(parsefile->basestrpush))
- ckfree(sp);
- INTON;
-}
-
-
/*
* Refill the input buffer and return the next input character:
*
* 4) Process input up to the next newline, deleting nul characters.
*/
-static int
+int
preadbuffer(void)
{
char *p, *q;
char savec;
while (parsefile->strpush) {
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
if (parsenleft == -1 && parsefile->strpush->ap &&
parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
return PEOA;
p++; /* Skip nul */
goto check;
-
case '\n':
parsenleft = q - parsenextc;
more = 0; /* Stop processing here */
break;
+
}
*q++ = *p++;
return *parsenextc++;
}
+/*
+ * Undo the last call to pgetc. Only one character may be pushed back.
+ * PEOF may be pushed back.
+ */
+
+void
+pungetc(void)
+{
+ parsenleft++;
+ parsenextc--;
+}
/*
* Push a string back onto the input at this current parsefile level.
* We handle aliases this way.
*/
-static void
-pushstring(char *s, int len, void *ap)
+void
+pushstring(char *s, void *ap)
{
struct strpush *sp;
+ size_t len;
+ len = strlen(s);
INTOFF;
/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
if (parsefile->strpush) {
sp = parsefile->strpush = &(parsefile->basestrpush);
sp->prevstring = parsenextc;
sp->prevnleft = parsenleft;
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
sp->ap = (struct alias *)ap;
if (ap) {
((struct alias *)ap)->flag |= ALIASINUSE;
INTON;
}
+void
+popstring(void)
+{
+ struct strpush *sp = parsefile->strpush;
+
+ INTOFF;
+#ifdef CONFIG_ASH_ALIAS
+ if (sp->ap) {
+ if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
+ checkkwd |= CHKALIAS;
+ }
+ if (sp->string != sp->ap->val) {
+ ckfree(sp->string);
+ }
+ sp->ap->flag &= ~ALIASINUSE;
+ if (sp->ap->flag & ALIASDEAD) {
+ unalias(sp->ap->name);
+ }
+ }
+#endif
+ parsenextc = sp->prevstring;
+ parsenleft = sp->prevnleft;
+/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
+ parsefile->strpush = sp->prev;
+ if (sp != &(parsefile->basestrpush))
+ ckfree(sp);
+ INTON;
+}
+
+/*
+ * Set the input to take input from a file. If push is set, push the
+ * old input onto the stack first.
+ */
+
+void
+setinputfile(const char *fname, int push)
+{
+ int fd;
+ int fd2;
+
+ INTOFF;
+ if ((fd = open(fname, O_RDONLY)) < 0)
+ error("Can't open %s", fname);
+ if (fd < 10) {
+ fd2 = copyfd(fd, 10);
+ close(fd);
+ if (fd2 < 0)
+ error("Out of file descriptors");
+ fd = fd2;
+ }
+ setinputfd(fd, push);
+ INTON;
+}
+
+
+/*
+ * Like setinputfile, but takes an open file descriptor. Call this with
+ * interrupts off.
+ */
+
+static void
+setinputfd(int fd, int push)
+{
+ (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
+ if (push) {
+ pushfile();
+ parsefile->buf = 0;
+ }
+ parsefile->fd = fd;
+ if (parsefile->buf == NULL)
+ parsefile->buf = ckmalloc(IBUFSIZ);
+ parselleft = parsenleft = 0;
+ plinno = 1;
+}
+
/*
* Like setinputfile, but takes input from a string.
}
-
/*
* To handle the "." command, a stack of input files is used. Pushfile
* adds a new entry to the stack and popfile restores the previous level.
*/
static void
-pushfile(void) {
+pushfile(void)
+{
struct parsefile *pf;
parsefile->nleft = parsenleft;
parsefile = pf;
}
-#ifdef JOBS
-static void restartjob (struct job *);
-#endif
-static void freejob (struct job *);
-static struct job *getjob (const char *);
-static int dowait (int, struct job *);
-static void waitonint(int);
+
+static void
+popfile(void)
+{
+ struct parsefile *pf = parsefile;
+
+ INTOFF;
+ if (pf->fd >= 0)
+ close(pf->fd);
+ if (pf->buf)
+ ckfree(pf->buf);
+ while (pf->strpush)
+ popstring();
+ parsefile = pf->prev;
+ ckfree(pf);
+ parsenleft = parsefile->nleft;
+ parselleft = parsefile->lleft;
+ parsenextc = parsefile->nextc;
+ plinno = parsefile->linno;
+ INTON;
+}
/*
- * We keep track of whether or not fd0 has been redirected. This is for
- * background commands, where we want to redirect fd0 to /dev/null only
- * if it hasn't already been redirected.
-*/
-static int fd0_redirected = 0;
+ * Return to top level.
+ */
-/* Return true if fd 0 has already been redirected at least once. */
-static inline int
-fd0_redirected_p () {
- return fd0_redirected != 0;
+static void
+popallfiles(void)
+{
+ while (parsefile != &basepf)
+ popfile();
+}
+
+
+/*
+ * Close the file(s) that the shell is reading commands from. Called
+ * after a fork is done.
+ */
+
+static void
+closescript(void)
+{
+ popallfiles();
+ if (parsefile->fd > 0) {
+ close(parsefile->fd);
+ parsefile->fd = 0;
+ }
}
-static void dupredirect (const union node *, int, int fd1dup);
+/* $NetBSD: jobs.c,v 1.56 2002/11/25 12:13:03 agc Exp $ */
+
+/* mode flags for set_curjob */
+#define CUR_DELETE 2
+#define CUR_RUNNING 1
+#define CUR_STOPPED 0
+
+/* mode flags for dowait */
+#define DOWAIT_NORMAL 0
+#define DOWAIT_BLOCK 1
+
+/* array of jobs */
+static struct job *jobtab;
+/* size of array */
+static unsigned njobs;
+#if JOBS
+/* pgrp of shell on invocation */
+static int initialpgrp;
+static int ttyfd = -1;
+#endif
+/* current job */
+static struct job *curjob;
+/* number of presumed living untracked jobs */
+static int jobless;
+
+static void set_curjob(struct job *, unsigned);
+#if JOBS
+static int restartjob(struct job *, int);
+static void xtcsetpgrp(int, pid_t);
+static char *commandtext(union node *);
+static void cmdlist(union node *, int);
+static void cmdtxt(union node *);
+static void cmdputs(const char *);
+static void showpipe(struct job *, FILE *);
+#endif
+static int sprint_status(char *, int, int);
+static void freejob(struct job *);
+static struct job *getjob(const char *, int);
+static struct job *growjobtab(void);
+static void forkchild(struct job *, union node *, int);
+static void forkparent(struct job *, union node *, int, pid_t);
+static int dowait(int, struct job *);
+static int getstatus(struct job *);
+
+static void
+set_curjob(struct job *jp, unsigned mode)
+{
+ struct job *jp1;
+ struct job **jpp, **curp;
+
+ /* first remove from list */
+ jpp = curp = &curjob;
+ do {
+ jp1 = *jpp;
+ if (jp1 == jp)
+ break;
+ jpp = &jp1->prev_job;
+ } while (1);
+ *jpp = jp1->prev_job;
+ /* Then re-insert in correct position */
+ jpp = curp;
+ switch (mode) {
+ default:
+#ifdef DEBUG
+ abort();
+#endif
+ case CUR_DELETE:
+ /* job being deleted */
+ break;
+ case CUR_RUNNING:
+ /* newly created job or backgrounded job,
+ put after all stopped jobs. */
+ do {
+ jp1 = *jpp;
+#ifdef JOBS
+ if (!jp1 || jp1->state != JOBSTOPPED)
+#endif
+ break;
+ jpp = &jp1->prev_job;
+ } while (1);
+ /* FALLTHROUGH */
#ifdef JOBS
+ case CUR_STOPPED:
+#endif
+ /* newly stopped job - becomes curjob */
+ jp->prev_job = *jpp;
+ *jpp = jp;
+ break;
+ }
+}
+
+#if JOBS
/*
* Turn job control on and off.
*
* Note: This code assumes that the third arg to ioctl is a character
* pointer, which is true on Berkeley systems but not System V. Since
* System V doesn't have job control yet, this isn't a problem now.
+ *
+ * Called with interrupts off.
*/
-
-
-static void setjobctl(int enable)
+void
+setjobctl(int on)
{
-#ifdef OLD_TTY_DRIVER
- int ldisc;
-#endif
+ int fd;
+ int pgrp;
- if (enable == jobctl || rootshell == 0)
+ if (on == jobctl || rootshell == 0)
return;
- if (enable) {
+ if (on) {
+ int ofd;
+ ofd = fd = open(_PATH_TTY, O_RDWR);
+ if (fd < 0) {
+ fd += 3;
+ while (!isatty(fd) && --fd >= 0)
+ ;
+ }
+ fd = fcntl(fd, F_DUPFD, 10);
+ close(ofd);
+ if (fd < 0)
+ goto out;
+ fcntl(fd, F_SETFD, FD_CLOEXEC);
do { /* while we are in the background */
-#ifdef OLD_TTY_DRIVER
- if (ioctl(2, TIOCGPGRP, (char *)&initialpgrp) < 0) {
-#else
- initialpgrp = tcgetpgrp(2);
- if (initialpgrp < 0) {
-#endif
- out2str("sh: can't access tty; job control turned off\n");
- mflag = 0;
- return;
- }
- if (initialpgrp == -1)
- initialpgrp = getpgrp();
- else if (initialpgrp != getpgrp()) {
- killpg(initialpgrp, SIGTTIN);
- continue;
+ if ((pgrp = tcgetpgrp(fd)) < 0) {
+out:
+ sh_warnx("can't access tty; job control turned off");
+ mflag = on = 0;
+ goto close;
}
- } while (0);
-#ifdef OLD_TTY_DRIVER
- if (ioctl(2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) {
- out2str("sh: need new tty driver to run job control; job control turned off\n");
- mflag = 0;
- return;
- }
-#endif
+ if (pgrp == getpgrp())
+ break;
+ killpg(0, SIGTTIN);
+ } while (1);
+ initialpgrp = pgrp;
+
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
- setpgid(0, rootpid);
-#ifdef OLD_TTY_DRIVER
- ioctl(2, TIOCSPGRP, (char *)&rootpid);
-#else
- tcsetpgrp(2, rootpid);
-#endif
- } else { /* turning job control off */
- setpgid(0, initialpgrp);
-#ifdef OLD_TTY_DRIVER
- ioctl(2, TIOCSPGRP, (char *)&initialpgrp);
-#else
- tcsetpgrp(2, initialpgrp);
-#endif
+ pgrp = rootpid;
+ setpgid(0, pgrp);
+ xtcsetpgrp(fd, pgrp);
+ } else {
+ /* turning job control off */
+ fd = ttyfd;
+ pgrp = initialpgrp;
+ xtcsetpgrp(fd, pgrp);
+ setpgid(0, pgrp);
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
+close:
+ close(fd);
+ fd = -1;
}
- jobctl = enable;
-}
-#endif
-
-
-/* A translation list so we can be polite to our users. */
-static char *signal_names[NSIG + 2] = {
- "EXIT",
- "SIGHUP",
- "SIGINT",
- "SIGQUIT",
- "SIGILL",
- "SIGTRAP",
- "SIGABRT",
- "SIGBUS",
- "SIGFPE",
- "SIGKILL",
- "SIGUSR1",
- "SIGSEGV",
- "SIGUSR2",
- "SIGPIPE",
- "SIGALRM",
- "SIGTERM",
- "SIGJUNK(16)",
- "SIGCHLD",
- "SIGCONT",
- "SIGSTOP",
- "SIGTSTP",
- "SIGTTIN",
- "SIGTTOU",
- "SIGURG",
- "SIGXCPU",
- "SIGXFSZ",
- "SIGVTALRM",
- "SIGPROF",
- "SIGWINCH",
- "SIGIO",
- "SIGPWR",
- "SIGSYS",
-#ifdef SIGRTMIN
- "SIGRTMIN",
- "SIGRTMIN+1",
- "SIGRTMIN+2",
- "SIGRTMIN+3",
- "SIGRTMIN+4",
- "SIGRTMIN+5",
- "SIGRTMIN+6",
- "SIGRTMIN+7",
- "SIGRTMIN+8",
- "SIGRTMIN+9",
- "SIGRTMIN+10",
- "SIGRTMIN+11",
- "SIGRTMIN+12",
- "SIGRTMIN+13",
- "SIGRTMIN+14",
- "SIGRTMIN+15",
- "SIGRTMAX-15",
- "SIGRTMAX-14",
- "SIGRTMAX-13",
- "SIGRTMAX-12",
- "SIGRTMAX-11",
- "SIGRTMAX-10",
- "SIGRTMAX-9",
- "SIGRTMAX-8",
- "SIGRTMAX-7",
- "SIGRTMAX-6",
- "SIGRTMAX-5",
- "SIGRTMAX-4",
- "SIGRTMAX-3",
- "SIGRTMAX-2",
- "SIGRTMAX-1",
- "SIGRTMAX",
-#endif
- "DEBUG",
- (char *)0x0,
-};
-
-
+ ttyfd = fd;
+ jobctl = on;
+}
-#ifdef JOBS
static int
-killcmd(argc, argv)
- int argc;
- char **argv;
+killcmd(int argc, char **argv)
{
int signo = -1;
int list = 0;
);
}
- if (*argv[1] == '-') {
- signo = decode_signal(argv[1] + 1, 1);
+ if (**++argv == '-') {
+ signo = decode_signal(*argv + 1, 1);
if (signo < 0) {
int c;
while ((c = nextopt("ls:")) != '\0')
switch (c) {
+ default:
+#ifdef DEBUG
+ abort();
+#endif
case 'l':
list = 1;
break;
);
}
break;
-#ifdef DEBUG
- default:
- error(
- "nextopt returned character code 0%o", c);
-#endif
- }
+ }
+ argv = argptr;
} else
- argptr++;
+ argv++;
}
if (!list && signo < 0)
signo = SIGTERM;
- if ((signo < 0 || !*argptr) ^ list) {
+ if ((signo < 0 || !*argv) ^ list) {
goto usage;
}
if (list) {
- if (!*argptr) {
- out1str("0\n");
+ const char *name;
+
+ if (!*argv) {
for (i = 1; i < NSIG; i++) {
- printf(snlfmt, signal_names[i] + 3);
+ name = u_signal_names(0, &i, 1);
+ if (name)
+ out1fmt(snlfmt, name);
}
return 0;
}
- signo = atoi(*argptr);
- if (signo > 128)
- signo -= 128;
- if (0 < signo && signo < NSIG)
- printf(snlfmt, signal_names[signo] + 3);
+ name = u_signal_names(*argptr, &signo, -1);
+ if (name)
+ out1fmt(snlfmt, name);
else
- error("invalid signal number or exit status: %s",
- *argptr);
+ error("invalid signal number or exit status: %s", *argptr);
return 0;
}
+ i = 0;
do {
- if (**argptr == '%') {
- jp = getjob(*argptr);
- if (jp->jobctl == 0)
- error("job %s not created under job control",
- *argptr);
+ if (**argv == '%') {
+ jp = getjob(*argv, 0);
pid = -jp->ps[0].pid;
} else
- pid = atoi(*argptr);
- if (kill(pid, signo) != 0)
- error("%s: %m", *argptr);
- } while (*++argptr);
+ pid = number(*argv);
+ if (kill(pid, signo) != 0) {
+ sh_warnx("%m\n");
+ i = 1;
+ }
+ } while (*++argv);
- return 0;
+ return i;
}
+#endif /* JOBS */
+#if defined(JOBS) || defined(DEBUG)
static int
-fgcmd(argc, argv)
- int argc;
- char **argv;
+jobno(const struct job *jp)
{
- struct job *jp;
- int pgrp;
- int status;
-
- jp = getjob(argv[1]);
- if (jp->jobctl == 0)
- error("job not created under job control");
- pgrp = jp->ps[0].pid;
-#ifdef OLD_TTY_DRIVER
- ioctl(2, TIOCSPGRP, (char *)&pgrp);
-#else
- tcsetpgrp(2, pgrp);
-#endif
- restartjob(jp);
- INTOFF;
- status = waitforjob(jp);
- INTON;
- return status;
+ return jp - jobtab + 1;
}
+#endif
-
+#ifdef JOBS
static int
-bgcmd(argc, argv)
- int argc;
- char **argv;
+fgcmd(int argc, char **argv)
{
struct job *jp;
+ FILE *out;
+ int mode;
+ int retval;
+ mode = (**argv == 'f') ? FORK_FG : FORK_BG;
+ nextopt(nullstr);
+ argv = argptr;
+ out = stdout;
do {
- jp = getjob(*++argv);
- if (jp->jobctl == 0)
- error("job not created under job control");
- restartjob(jp);
- } while (--argc > 1);
- return 0;
+ jp = getjob(*argv, 1);
+ if (mode == FORK_BG) {
+ set_curjob(jp, CUR_RUNNING);
+ fprintf(out, "[%d] ", jobno(jp));
+ }
+ outstr(jp->ps->cmd, out);
+ showpipe(jp, out);
+ retval = restartjob(jp, mode);
+ } while (*argv && *++argv);
+ return retval;
}
+static int bgcmd(int, char **) __attribute__((__alias__("fgcmd")));
-static void
-restartjob(jp)
- struct job *jp;
+
+static int
+restartjob(struct job *jp, int mode)
{
struct procstat *ps;
int i;
+ int status;
+ pid_t pgid;
- if (jp->state == JOBDONE)
- return;
INTOFF;
- killpg(jp->ps[0].pid, SIGCONT);
- for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
+ if (jp->state == JOBDONE)
+ goto out;
+ jp->state = JOBRUNNING;
+ pgid = jp->ps->pid;
+ if (mode == FORK_FG)
+ xtcsetpgrp(ttyfd, pgid);
+ killpg(pgid, SIGCONT);
+ ps = jp->ps;
+ i = jp->nprocs;
+ do {
if (WIFSTOPPED(ps->status)) {
ps->status = -1;
- jp->state = 0;
}
- }
+ } while (ps++, --i);
+out:
+ status = (mode == FORK_FG) ? waitforjob(jp) : 0;
INTON;
+ return status;
+}
+#endif
+
+static int
+sprint_status(char *s, int status, int sigonly)
+{
+ int col;
+ int st;
+
+ col = 0;
+ if (!WIFEXITED(status)) {
+#if JOBS
+ if (WIFSTOPPED(status))
+ st = WSTOPSIG(status);
+ else
+#endif
+ st = WTERMSIG(status);
+ if (sigonly) {
+ if (st == SIGINT || st == SIGPIPE)
+ goto out;
+#if JOBS
+ if (WIFSTOPPED(status))
+ goto out;
+#endif
+ }
+ st &= 0x7f;
+ col = fmtstr(s, 32, strsignal(st));
+ if (WCOREDUMP(status)) {
+ col += fmtstr(s + col, 16, " (core dumped)");
+ }
+ } else if (!sigonly) {
+ st = WEXITSTATUS(status);
+ if (st)
+ col = fmtstr(s, 16, "Done(%d)", st);
+ else
+ col = fmtstr(s, 16, "Done");
+ }
+
+out:
+ return col;
}
+
+#if JOBS
+static void
+showjob(FILE *out, struct job *jp, int mode)
+{
+ struct procstat *ps;
+ struct procstat *psend;
+ int col;
+ int indent;
+ char s[80];
+
+ ps = jp->ps;
+
+ if (mode & SHOW_PGID) {
+ /* just output process (group) id of pipeline */
+ fprintf(out, "%d\n", ps->pid);
+ return;
+ }
+
+ col = fmtstr(s, 16, "[%d] ", jobno(jp));
+ indent = col;
+
+ if (jp == curjob)
+ s[col - 2] = '+';
+ else if (curjob && jp == curjob->prev_job)
+ s[col - 2] = '-';
+
+ if (mode & SHOW_PID)
+ col += fmtstr(s + col, 16, "%d ", ps->pid);
+
+ psend = ps + jp->nprocs;
+
+ if (jp->state == JOBRUNNING) {
+ scopy("Running", s + col);
+ col += strlen("Running");
+ } else {
+ int status = psend[-1].status;
+#if JOBS
+ if (jp->state == JOBSTOPPED)
+ status = jp->stopstatus;
#endif
+ col += sprint_status(s + col, status, 0);
+ }
+
+ goto start;
+
+ do {
+ /* for each process */
+ col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3;
+
+start:
+ fprintf(out, "%s%*c%s",
+ s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd
+ );
+ if (!(mode & SHOW_PID)) {
+ showpipe(jp, out);
+ break;
+ }
+ if (++ps == psend) {
+ outcslow('\n', out);
+ break;
+ }
+ } while (1);
+
+ jp->changed = 0;
-static void showjobs(int change);
+ if (jp->state == JOBDONE) {
+ TRACE(("showjob: freeing job %d\n", jobno(jp)));
+ freejob(jp);
+ }
+}
static int
-jobscmd(argc, argv)
- int argc;
- char **argv;
+jobscmd(int argc, char **argv)
{
- showjobs(0);
+ int mode, m;
+ FILE *out;
+
+ mode = 0;
+ while ((m = nextopt("lp")))
+ if (m == 'l')
+ mode = SHOW_PID;
+ else
+ mode = SHOW_PGID;
+
+ out = stdout;
+ argv = argptr;
+ if (*argv)
+ do
+ showjob(out, getjob(*argv,0), mode);
+ while (*++argv);
+ else
+ showjobs(out, mode);
+
return 0;
}
/*
* Print a list of jobs. If "change" is nonzero, only print jobs whose
* statuses have changed since the last call to showjobs.
- *
- * If the shell is interrupted in the process of creating a job, the
- * result may be a job structure containing zero processes. Such structures
- * will be freed here.
*/
static void
-showjobs(change)
- int change;
+showjobs(FILE *out, int mode)
{
- int jobno;
- int procno;
- int i;
struct job *jp;
- struct procstat *ps;
- int col;
- char s[64];
- TRACE(("showjobs(%d) called\n", change));
- while (dowait(0, (struct job *)NULL) > 0);
- for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
- if (! jp->used)
- continue;
- if (jp->nprocs == 0) {
- freejob(jp);
- continue;
- }
- if (change && ! jp->changed)
- continue;
- procno = jp->nprocs;
- for (ps = jp->ps ; ; ps++) { /* for each process */
- if (ps == jp->ps)
- snprintf(s, 64, "[%d] %ld ", jobno,
- (long)ps->pid);
- else
- snprintf(s, 64, " %ld ",
- (long)ps->pid);
- out1str(s);
- col = strlen(s);
- s[0] = '\0';
- if (ps->status == -1) {
- /* don't print anything */
- } else if (WIFEXITED(ps->status)) {
- snprintf(s, 64, "Exit %d",
- WEXITSTATUS(ps->status));
- } else {
-#ifdef JOBS
- if (WIFSTOPPED(ps->status))
- i = WSTOPSIG(ps->status);
- else /* WIFSIGNALED(ps->status) */
-#endif
- i = WTERMSIG(ps->status);
- if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
- strcpy(s, sys_siglist[i & 0x7F]);
- else
- snprintf(s, 64, "Signal %d", i & 0x7F);
- if (WCOREDUMP(ps->status))
- strcat(s, " (core dumped)");
- }
- out1str(s);
- col += strlen(s);
- printf(
- "%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ',
- ps->cmd
- );
- if (--procno <= 0)
- break;
- }
- jp->changed = 0;
- if (jp->state == JOBDONE) {
- freejob(jp);
- }
+ TRACE(("showjobs(%x) called\n", mode));
+
+ /* If not even one one job changed, there is nothing to do */
+ while (dowait(DOWAIT_NORMAL, NULL) > 0)
+ continue;
+
+ for (jp = curjob; jp; jp = jp->prev_job) {
+ if (!(mode & SHOW_CHANGED) || jp->changed)
+ showjob(out, jp, mode);
}
}
-
+#endif /* JOBS */
/*
* Mark a job structure as unused.
static void
freejob(struct job *jp)
{
- const struct procstat *ps;
+ struct procstat *ps;
int i;
INTOFF;
if (jp->ps != &jp->ps0)
ckfree(jp->ps);
jp->used = 0;
-#ifdef JOBS
- if (curjob == jp - jobtab + 1)
- curjob = 0;
-#endif
+ set_curjob(jp, CUR_DELETE);
INTON;
}
-
static int
-waitcmd(argc, argv)
- int argc;
- char **argv;
+waitcmd(int argc, char **argv)
{
struct job *job;
- int status, retval;
+ int retval;
struct job *jp;
- if (--argc > 0) {
-start:
- job = getjob(*++argv);
- } else {
- job = NULL;
- }
- for (;;) { /* loop until process terminated or stopped */
- if (job != NULL) {
- if (job->state) {
- status = job->ps[job->nprocs - 1].status;
- if (! iflag)
- freejob(job);
- if (--argc) {
- goto start;
- }
- if (WIFEXITED(status))
- retval = WEXITSTATUS(status);
-#ifdef JOBS
- else if (WIFSTOPPED(status))
- retval = WSTOPSIG(status) + 128;
-#endif
- else {
- /* XXX: limits number of signals */
- retval = WTERMSIG(status) + 128;
- }
- return retval;
- }
- } else {
- for (jp = jobtab ; ; jp++) {
- if (jp >= jobtab + njobs) { /* no running procs */
- return 0;
+ EXSIGON();
+
+ nextopt(nullstr);
+ retval = 0;
+
+ argv = argptr;
+ if (!*argv) {
+ /* wait for all jobs */
+ for (;;) {
+ jp = curjob;
+ while (1) {
+ if (!jp) {
+ /* no running procs */
+ goto out;
}
- if (jp->used && jp->state == 0)
+ if (jp->state == JOBRUNNING)
break;
+ jp->waited = 1;
+ jp = jp->prev_job;
}
- }
- if (dowait(2, 0) < 0 && errno == EINTR) {
- return 129;
+ dowait(DOWAIT_BLOCK, 0);
}
}
-}
+ retval = 127;
+ do {
+ if (**argv != '%') {
+ pid_t pid = number(*argv);
+ job = curjob;
+ goto start;
+ do {
+ if (job->ps[job->nprocs - 1].pid == pid)
+ break;
+ job = job->prev_job;
+start:
+ if (!job)
+ goto repeat;
+ } while (1);
+ } else
+ job = getjob(*argv, 0);
+ /* loop until process terminated or stopped */
+ while (job->state == JOBRUNNING)
+ dowait(DOWAIT_BLOCK, 0);
+ job->waited = 1;
+ retval = getstatus(job);
+repeat:
+ ;
+ } while (*++argv);
+
+out:
+ return retval;
+}
/*
*/
static struct job *
-getjob(const char *name)
+getjob(const char *name, int getctl)
{
- int jobno;
struct job *jp;
- int pid;
- int i;
+ struct job *found;
+ const char *err_msg = "No such job: %s";
+ unsigned num;
+ int c;
+ const char *p;
+ char *(*match)(const char *, const char *);
- if (name == NULL) {
-#ifdef JOBS
+ jp = curjob;
+ p = name;
+ if (!p)
+ goto currentjob;
+
+ if (*p != '%')
+ goto err;
+
+ c = *++p;
+ if (!c)
+ goto currentjob;
+
+ if (!p[1]) {
+ if (c == '+' || c == '%') {
currentjob:
- if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
- error("No current job");
- return &jobtab[jobno - 1];
-#else
- error("No current job");
-#endif
- } else if (name[0] == '%') {
- if (is_digit(name[1])) {
- jobno = number(name + 1);
- if (jobno > 0 && jobno <= njobs
- && jobtab[jobno - 1].used != 0)
- return &jobtab[jobno - 1];
-#ifdef JOBS
- } else if (name[1] == '%' && name[2] == '\0') {
- goto currentjob;
-#endif
- } else {
- struct job *found = NULL;
- for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
- if (jp->used && jp->nprocs > 0
- && prefix(name + 1, jp->ps[0].cmd)) {
- if (found)
- error("%s: ambiguous", name);
- found = jp;
- }
- }
- if (found)
- return found;
+ err_msg = "No current job";
+ goto check;
+ } else if (c == '-') {
+ if (jp)
+ jp = jp->prev_job;
+ err_msg = "No previous job";
+check:
+ if (!jp)
+ goto err;
+ goto gotit;
}
- } else if (is_number(name, &pid)) {
- for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
- if (jp->used && jp->nprocs > 0
- && jp->ps[jp->nprocs - 1].pid == pid)
- return jp;
+ }
+
+ if (is_number(p)) {
+ num = atoi(p);
+ if (num < njobs) {
+ jp = jobtab + num - 1;
+ if (jp->used)
+ goto gotit;
+ goto err;
}
}
- error("No such job: %s", name);
- /* NOTREACHED */
-}
+ match = prefix;
+ if (*p == '?') {
+ match = strstr;
+ p++;
+ }
+
+ found = 0;
+ while (1) {
+ if (!jp)
+ goto err;
+ if (match(jp->ps[0].cmd, p)) {
+ if (found)
+ goto err;
+ found = jp;
+ err_msg = "%s: ambiguous";
+ }
+ jp = jp->prev_job;
+ }
+
+gotit:
+#if JOBS
+ err_msg = "job %s not created under job control";
+ if (getctl && jp->jobctl == 0)
+ goto err;
+#endif
+ return jp;
+err:
+ error(err_msg, name);
+}
/*
- * Return a new job structure,
+ * Return a new job structure.
+ * Called with interrupts off.
*/
static struct job *
-makejob(const union node *node, int nprocs)
+makejob(union node *node, int nprocs)
{
int i;
struct job *jp;
for (i = njobs, jp = jobtab ; ; jp++) {
if (--i < 0) {
- INTOFF;
- if (njobs == 0) {
- jobtab = ckmalloc(4 * sizeof jobtab[0]);
- } else {
- jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
- memcpy(jp, jobtab, njobs * sizeof jp[0]);
- /* Relocate `ps' pointers */
- for (i = 0; i < njobs; i++)
- if (jp[i].ps == &jobtab[i].ps0)
- jp[i].ps = &jp[i].ps0;
- ckfree(jobtab);
- jobtab = jp;
- }
- jp = jobtab + njobs;
- for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
- INTON;
+ jp = growjobtab();
break;
}
if (jp->used == 0)
break;
+ if (jp->state != JOBDONE || !jp->waited)
+ continue;
+#if JOBS
+ if (jobctl)
+ continue;
+#endif
+ freejob(jp);
+ break;
}
- INTOFF;
- jp->state = 0;
- jp->used = 1;
- jp->changed = 0;
- jp->nprocs = 0;
-#ifdef JOBS
- jp->jobctl = jobctl;
+ memset(jp, 0, sizeof(*jp));
+#if JOBS
+ if (jobctl)
+ jp->jobctl = 1;
#endif
+ jp->prev_job = curjob;
+ curjob = jp;
+ jp->used = 1;
+ jp->ps = &jp->ps0;
if (nprocs > 1) {
jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
- } else {
- jp->ps = &jp->ps0;
}
- INTON;
TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
- jp - jobtab + 1));
+ jobno(jp)));
+ return jp;
+}
+
+static struct job *
+growjobtab(void)
+{
+ size_t len;
+ ptrdiff_t offset;
+ struct job *jp, *jq;
+
+ len = njobs * sizeof(*jp);
+ jq = jobtab;
+ jp = ckrealloc(jq, len + 4 * sizeof(*jp));
+
+ offset = (char *)jp - (char *)jq;
+ if (offset) {
+ /* Relocate pointers */
+ size_t l = len;
+
+ jq = (struct job *)((char *)jq + l);
+ while (l) {
+ l -= sizeof(*jp);
+ jq--;
+#define joff(p) ((struct job *)((char *)(p) + l))
+#define jmove(p) (p) = (void *)((char *)(p) + offset)
+ if (xlikely(joff(jp)->ps == &jq->ps0))
+ jmove(joff(jp)->ps);
+ if (joff(jp)->prev_job)
+ jmove(joff(jp)->prev_job);
+ }
+ if (curjob)
+ jmove(curjob);
+#undef joff
+#undef jmove
+ }
+
+ njobs += 4;
+ jobtab = jp;
+ jp = (struct job *)((char *)jp + len);
+ jq = jp + 3;
+ do {
+ jq->used = 0;
+ } while (--jq >= jp);
return jp;
}
/*
- * Fork of a subshell. If we are doing job control, give the subshell its
+ * Fork off a subshell. If we are doing job control, give the subshell its
* own process group. Jp is a job structure that the job is to be added to.
* N is the command that will be evaluated by the child. Both jp and n may
* be NULL. The mode parameter can be one of the following:
* When job control is turned off, background processes have their standard
* input redirected to /dev/null (except for the second and later processes
* in a pipeline).
+ *
+ * Called with interrupts off.
*/
+static inline void
+forkchild(struct job *jp, union node *n, int mode)
+{
+ int wasroot;
+ TRACE(("Child shell %d\n", getpid()));
+ wasroot = rootshell;
+ rootshell = 0;
-static int
-forkshell(struct job *jp, const union node *n, int mode)
-{
- int pid;
-#ifdef JOBS
- int pgrp;
+ closescript();
+ clear_traps();
+#if JOBS
+ /* do job control only in root shell */
+ jobctl = 0;
+ if (mode != FORK_NOJOB && jp->jobctl && wasroot) {
+ pid_t pgrp;
+
+ if (jp->nprocs == 0)
+ pgrp = getpid();
+ else
+ pgrp = jp->ps[0].pid;
+ /* This can fail because we are doing it in the parent also */
+ (void)setpgid(0, pgrp);
+ if (mode == FORK_FG)
+ xtcsetpgrp(ttyfd, pgrp);
+ setsignal(SIGTSTP);
+ setsignal(SIGTTOU);
+ } else
#endif
- const char *devnull = _PATH_DEVNULL;
- const char *nullerr = "Can't open %s";
+ if (mode == FORK_BG) {
+ ignoresig(SIGINT);
+ ignoresig(SIGQUIT);
+ if (jp->nprocs == 0) {
+ close(0);
+ if (open(_PATH_DEVNULL, O_RDONLY) != 0)
+ error("Can't open %s", _PATH_DEVNULL);
+ }
+ }
+ if (wasroot && iflag) {
+ setsignal(SIGINT);
+ setsignal(SIGQUIT);
+ setsignal(SIGTERM);
+ }
+ for (jp = curjob; jp; jp = jp->prev_job)
+ freejob(jp);
+ jobless = 0;
+}
- TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long)n,
- mode));
- INTOFF;
- pid = fork();
- if (pid == -1) {
- TRACE(("Fork failed, errno=%d\n", errno));
- INTON;
- error("Cannot fork");
+static inline void
+forkparent(struct job *jp, union node *n, int mode, pid_t pid)
+{
+ TRACE(("In parent shell: child = %d\n", pid));
+ if (!jp) {
+ while (jobless && dowait(DOWAIT_NORMAL, 0) > 0);
+ jobless++;
+ return;
}
- if (pid == 0) {
- struct job *p;
- int wasroot;
- int i;
+#if JOBS
+ if (mode != FORK_NOJOB && jp->jobctl) {
+ int pgrp;
- TRACE(("Child shell %d\n", getpid()));
- wasroot = rootshell;
- rootshell = 0;
- closescript();
- INTON;
- clear_traps();
-#ifdef JOBS
- jobctl = 0; /* do job control only in root shell */
- if (wasroot && mode != FORK_NOJOB && mflag) {
- if (jp == NULL || jp->nprocs == 0)
- pgrp = getpid();
- else
- pgrp = jp->ps[0].pid;
- setpgid(0, pgrp);
- if (mode == FORK_FG) {
- /*** this causes superfluous TIOCSPGRPS ***/
-#ifdef OLD_TTY_DRIVER
- if (ioctl(2, TIOCSPGRP, (char *)&pgrp) < 0)
- error("TIOCSPGRP failed, errno=%d", errno);
-#else
- if (tcsetpgrp(2, pgrp) < 0)
- error("tcsetpgrp failed, errno=%d", errno);
-#endif
- }
- setsignal(SIGTSTP);
- setsignal(SIGTTOU);
- } else if (mode == FORK_BG) {
- ignoresig(SIGINT);
- ignoresig(SIGQUIT);
- if ((jp == NULL || jp->nprocs == 0) &&
- ! fd0_redirected_p ()) {
- close(0);
- if (open(devnull, O_RDONLY) != 0)
- error(nullerr, devnull);
- }
- }
-#else
- if (mode == FORK_BG) {
- ignoresig(SIGINT);
- ignoresig(SIGQUIT);
- if ((jp == NULL || jp->nprocs == 0) &&
- ! fd0_redirected_p ()) {
- close(0);
- if (open(devnull, O_RDONLY) != 0)
- error(nullerr, devnull);
- }
- }
-#endif
- for (i = njobs, p = jobtab ; --i >= 0 ; p++)
- if (p->used)
- freejob(p);
- if (wasroot && iflag) {
- setsignal(SIGINT);
- setsignal(SIGQUIT);
- setsignal(SIGTERM);
- }
- return pid;
- }
-#ifdef JOBS
- if (rootshell && mode != FORK_NOJOB && mflag) {
- if (jp == NULL || jp->nprocs == 0)
+ if (jp->nprocs == 0)
pgrp = pid;
else
pgrp = jp->ps[0].pid;
- setpgid(pid, pgrp);
+ /* This can fail because we are doing it in the child also */
+ (void)setpgid(pid, pgrp);
}
#endif
- if (mode == FORK_BG)
+ if (mode == FORK_BG) {
backgndpid = pid; /* set $! */
+ set_curjob(jp, CUR_RUNNING);
+ }
if (jp) {
struct procstat *ps = &jp->ps[jp->nprocs++];
ps->pid = pid;
ps->status = -1;
ps->cmd = nullstr;
- if (iflag && rootshell && n)
+#if JOBS
+ if (jobctl && n)
ps->cmd = commandtext(n);
+#endif
}
- INTON;
- TRACE(("In parent shell: child = %d\n", pid));
- return pid;
}
+static int
+forkshell(struct job *jp, union node *n, int mode)
+{
+ int pid;
+ TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
+ pid = fork();
+ if (pid < 0) {
+ TRACE(("Fork failed, errno=%d", errno));
+ if (jp)
+ freejob(jp);
+ error("Cannot fork");
+ }
+ if (pid == 0)
+ forkchild(jp, n, mode);
+ else
+ forkparent(jp, n, mode, pid);
+ return pid;
+}
/*
* Wait for job to finish.
* the interactive program catches interrupts, the user doesn't want
* these interrupts to also abort the loop. The approach we take here
* is to have the shell ignore interrupt signals while waiting for a
- * forground process to terminate, and then send itself an interrupt
+ * foreground process to terminate, and then send itself an interrupt
* signal if the child process was terminated by an interrupt signal.
* Unfortunately, some programs want to do a bit of cleanup and then
* exit on interrupt; unless these processes terminate themselves by
* sending a signal to themselves (instead of calling exit) they will
* confuse this approach.
+ *
+ * Called with interrupts off.
*/
-static int
+int
waitforjob(struct job *jp)
{
-#ifdef JOBS
- int mypgrp = getpgrp();
-#endif
- int status;
int st;
- struct sigaction act, oact;
- INTOFF;
- intreceived = 0;
-#ifdef JOBS
- if (!jobctl) {
-#else
- if (!iflag) {
-#endif
- sigaction(SIGINT, 0, &act);
- act.sa_handler = waitonint;
- sigaction(SIGINT, &act, &oact);
- }
- TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
- while (jp->state == 0) {
- dowait(1, jp);
- }
-#ifdef JOBS
- if (!jobctl) {
-#else
- if (!iflag) {
-#endif
- sigaction(SIGINT, &oact, 0);
- if (intreceived && trap[SIGINT]) kill(getpid(), SIGINT);
+ TRACE(("waitforjob(%%%d) called\n", jobno(jp)));
+ while (jp->state == JOBRUNNING) {
+ dowait(DOWAIT_BLOCK, jp);
}
-#ifdef JOBS
- if (jp->jobctl) {
-#ifdef OLD_TTY_DRIVER
- if (ioctl(2, TIOCSPGRP, (char *)&mypgrp) < 0)
- error("TIOCSPGRP failed, errno=%d\n", errno);
-#else
- if (tcsetpgrp(2, mypgrp) < 0)
- error("tcsetpgrp failed, errno=%d\n", errno);
-#endif
- }
- if (jp->state == JOBSTOPPED)
- curjob = jp - jobtab + 1;
-#endif
- status = jp->ps[jp->nprocs - 1].status;
- /* convert to 8 bits */
- if (WIFEXITED(status))
- st = WEXITSTATUS(status);
-#ifdef JOBS
- else if (WIFSTOPPED(status))
- st = WSTOPSIG(status) + 128;
-#endif
- else
- st = WTERMSIG(status) + 128;
-#ifdef JOBS
+ st = getstatus(jp);
+#if JOBS
if (jp->jobctl) {
+ xtcsetpgrp(ttyfd, rootpid);
/*
* This is truly gross.
* If we're doing job control, then we did a TIOCSPGRP which
* caused us (the shell) to no longer be in the controlling
* session -- so we wouldn't have seen any ^C/SIGINT. So, we
* intuit from the subprocess exit status whether a SIGINT
- * occured, and if so interrupt ourselves. Yuck. - mycroft
+ * occurred, and if so interrupt ourselves. Yuck. - mycroft
*/
- if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
+ if (jp->sigint)
raise(SIGINT);
}
if (jp->state == JOBDONE)
-
#endif
freejob(jp);
- INTON;
return st;
}
-
-/*
- * Wait for a process to terminate.
- */
-
/*
* Do a wait system call. If job control is compiled in, we accept
* stopped processes. If block is zero, we return a value of zero
* then checking to see whether it was called. If there are any
* children to be waited for, it will be.
*
+ * If neither SYSV nor BSD is defined, we don't implement nonblocking
+ * waits at all. In this case, the user will not be informed when
+ * a background process until the next time she runs a real program
+ * (as opposed to running a builtin command or just typing return),
+ * and the jobs command may give out of date information.
*/
static inline int
waitproc(int block, int *status)
{
- int flags;
+ int flags = 0;
- flags = 0;
-#ifdef JOBS
+#if JOBS
if (jobctl)
flags |= WUNTRACED;
#endif
return wait3(status, flags, (struct rusage *)NULL);
}
+/*
+ * Wait for a process to terminate.
+ */
+
static int
dowait(int block, struct job *job)
{
int pid;
int status;
- struct procstat *sp;
struct job *jp;
struct job *thisjob;
- int done;
- int stopped;
- int core;
- int sig;
+ int state;
TRACE(("dowait(%d) called\n", block));
- do {
- pid = waitproc(block, &status);
- TRACE(("wait returns %d, status=%d\n", pid, status));
- } while (!(block & 2) && pid == -1 && errno == EINTR);
+ pid = waitproc(block, &status);
+ TRACE(("wait returns pid %d, status=%d\n", pid, status));
if (pid <= 0)
return pid;
INTOFF;
thisjob = NULL;
- for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
- if (jp->used) {
- done = 1;
- stopped = 1;
- for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
- if (sp->pid == -1)
- continue;
- if (sp->pid == pid) {
- TRACE(("Changing status of proc %d from 0x%x to 0x%x\n", pid, sp->status, status));
- sp->status = status;
- thisjob = jp;
- }
- if (sp->status == -1)
- stopped = 0;
- else if (WIFSTOPPED(sp->status))
- done = 0;
+ for (jp = curjob; jp; jp = jp->prev_job) {
+ struct procstat *sp;
+ struct procstat *spend;
+ if (jp->state == JOBDONE)
+ continue;
+ state = JOBDONE;
+ spend = jp->ps + jp->nprocs;
+ sp = jp->ps;
+ do {
+ if (sp->pid == pid) {
+ TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n", jobno(jp), pid, sp->status, status));
+ sp->status = status;
+ thisjob = jp;
}
- if (stopped) { /* stopped or done */
- int state = done? JOBDONE : JOBSTOPPED;
- if (jp->state != state) {
- TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
- jp->state = state;
+ if (sp->status == -1)
+ state = JOBRUNNING;
#ifdef JOBS
- if (done && curjob == jp - jobtab + 1)
- curjob = 0; /* no current job */
-#endif
- }
+ if (state == JOBRUNNING)
+ continue;
+ if (WIFSTOPPED(sp->status)) {
+ jp->stopstatus = sp->status;
+ state = JOBSTOPPED;
}
- }
+#endif
+ } while (++sp < spend);
+ if (thisjob)
+ goto gotjob;
}
- INTON;
- if (! rootshell || ! iflag || (job && thisjob == job)) {
- core = WCOREDUMP(status);
#ifdef JOBS
- if (WIFSTOPPED(status)) sig = WSTOPSIG(status);
- else
+ if (!WIFSTOPPED(status))
#endif
- if (WIFEXITED(status)) sig = 0;
- else sig = WTERMSIG(status);
- if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
- if (thisjob != job)
- out2fmt("%d: ", pid);
+ jobless--;
+ goto out;
+
+gotjob:
+ if (state != JOBRUNNING) {
+ thisjob->changed = 1;
+
+ if (thisjob->state != state) {
+ TRACE(("Job %d: changing state from %d to %d\n", jobno(thisjob), thisjob->state, state));
+ thisjob->state = state;
#ifdef JOBS
- if (sig == SIGTSTP && rootshell && iflag)
- out2fmt("%%%ld ",
- (long)(job - jobtab + 1));
+ if (state == JOBSTOPPED) {
+ set_curjob(thisjob, CUR_STOPPED);
+ }
#endif
- if (sig < NSIG && sys_siglist[sig])
- out2str(sys_siglist[sig]);
- else
- out2fmt("Signal %d", sig);
- if (core)
- out2str(" - core dumped");
- out2c('\n');
- } else {
- TRACE(("Not printing status: status=%d, sig=%d\n",
- status, sig));
}
- } else {
- TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell, job));
- if (thisjob)
- thisjob->changed = 1;
}
- return pid;
-}
+out:
+ INTON;
+
+ if (thisjob && thisjob == job) {
+ char s[48 + 1];
+ int len;
+ len = sprint_status(s, status, 1);
+ if (len) {
+ s[len] = '\n';
+ s[len + 1] = 0;
+ out2str(s);
+ }
+ }
+ return pid;
+}
/*
* return 1 if there are stopped jobs, otherwise 0
*/
-static int
+
+int
stoppedjobs(void)
{
- int jobno;
struct job *jp;
+ int retval;
+ retval = 0;
if (job_warning)
- return (0);
- for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
- if (jp->used == 0)
- continue;
- if (jp->state == JOBSTOPPED) {
- out2str("You have stopped jobs.\n");
- job_warning = 2;
- return (1);
- }
+ goto out;
+ jp = curjob;
+ if (jp && jp->state == JOBSTOPPED) {
+ out2str("You have stopped jobs.\n");
+ job_warning = 2;
+ retval++;
}
- return (0);
+out:
+ return retval;
}
/*
* Return a string identifying a command (to be printed by the
- * jobs command.
+ * jobs command).
*/
+#if JOBS
static char *cmdnextc;
-static int cmdnleft;
-#define MAXCMDTEXT 200
-static void
-cmdputs(const char *s)
+static char *
+commandtext(union node *n)
{
- const char *p;
- char *q;
- char c;
- int subtype = 0;
+ char *name;
- if (cmdnleft <= 0)
- return;
- p = s;
- q = cmdnextc;
- while ((c = *p++) != '\0') {
- if (c == CTLESC)
- *q++ = *p++;
- else if (c == CTLVAR) {
- *q++ = '$';
- if (--cmdnleft > 0)
- *q++ = '{';
- subtype = *p++;
- } else if (c == '=' && subtype != 0) {
- *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
- subtype = 0;
- } else if (c == CTLENDVAR) {
- *q++ = '}';
- } else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE)
- cmdnleft++; /* ignore it */
- else
- *q++ = c;
- if (--cmdnleft <= 0) {
- *q++ = '.';
- *q++ = '.';
- *q++ = '.';
- break;
- }
- }
- cmdnextc = q;
+ STARTSTACKSTR(cmdnextc);
+ cmdtxt(n);
+ name = stackblock();
+ TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
+ name, cmdnextc, cmdnextc));
+ return savestr(name);
}
-
static void
-cmdtxt(const union node *n)
+cmdtxt(union node *n)
{
union node *np;
struct nodelist *lp;
const char *p;
- int i;
char s[2];
- if (n == NULL)
+ if (!n)
return;
switch (n->type) {
- case NSEMI:
- cmdtxt(n->nbinary.ch1);
- cmdputs("; ");
- cmdtxt(n->nbinary.ch2);
- break;
- case NAND:
- cmdtxt(n->nbinary.ch1);
- cmdputs(" && ");
- cmdtxt(n->nbinary.ch2);
- break;
- case NOR:
- cmdtxt(n->nbinary.ch1);
- cmdputs(" || ");
- cmdtxt(n->nbinary.ch2);
- break;
+ default:
+#if DEBUG
+ abort();
+#endif
case NPIPE:
- for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+ lp = n->npipe.cmdlist;
+ for (;;) {
cmdtxt(lp->n);
- if (lp->next)
- cmdputs(" | ");
+ lp = lp->next;
+ if (!lp)
+ break;
+ cmdputs(" | ");
}
break;
- case NSUBSHELL:
- cmdputs("(");
- cmdtxt(n->nredir.n);
- cmdputs(")");
- break;
+ case NSEMI:
+ p = "; ";
+ goto binop;
+ case NAND:
+ p = " && ";
+ goto binop;
+ case NOR:
+ p = " || ";
+binop:
+ cmdtxt(n->nbinary.ch1);
+ cmdputs(p);
+ n = n->nbinary.ch2;
+ goto donode;
case NREDIR:
case NBACKGND:
- cmdtxt(n->nredir.n);
+ n = n->nredir.n;
+ goto donode;
+ case NNOT:
+ cmdputs("!");
+ n = n->nnot.com;
+donode:
+ cmdtxt(n);
break;
case NIF:
cmdputs("if ");
cmdtxt(n->nif.test);
cmdputs("; then ");
- cmdtxt(n->nif.ifpart);
- cmdputs("...");
- break;
+ n = n->nif.ifpart;
+ if (n->nif.elsepart) {
+ cmdtxt(n);
+ cmdputs("; else ");
+ n = n->nif.elsepart;
+ }
+ p = "; fi";
+ goto dotail;
+ case NSUBSHELL:
+ cmdputs("(");
+ n = n->nredir.n;
+ p = ")";
+ goto dotail;
case NWHILE:
- cmdputs("while ");
+ p = "while ";
goto until;
case NUNTIL:
- cmdputs("until ");
+ p = "until ";
until:
+ cmdputs(p);
cmdtxt(n->nbinary.ch1);
+ n = n->nbinary.ch2;
+ p = "; done";
+dodo:
cmdputs("; do ");
- cmdtxt(n->nbinary.ch2);
- cmdputs("; done");
- break;
+dotail:
+ cmdtxt(n);
+ goto dotail2;
case NFOR:
cmdputs("for ");
cmdputs(n->nfor.var);
- cmdputs(" in ...");
- break;
- case NCASE:
- cmdputs("case ");
- cmdputs(n->ncase.expr->narg.text);
- cmdputs(" in ...");
- break;
+ cmdputs(" in ");
+ cmdlist(n->nfor.args, 1);
+ n = n->nfor.body;
+ p = "; done";
+ goto dodo;
case NDEFUN:
cmdputs(n->narg.text);
- cmdputs("() ...");
- break;
+ p = "() { ... }";
+ goto dotail2;
case NCMD:
- for (np = n->ncmd.args ; np ; np = np->narg.next) {
- cmdtxt(np);
- if (np->narg.next)
- cmdputs(spcstr);
- }
- for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
- cmdputs(spcstr);
- cmdtxt(np);
- }
+ cmdlist(n->ncmd.args, 1);
+ cmdlist(n->ncmd.redirect, 0);
break;
case NARG:
- cmdputs(n->narg.text);
+ p = n->narg.text;
+dotail2:
+ cmdputs(p);
break;
+ case NHERE:
+ case NXHERE:
+ p = "<<...";
+ goto dotail2;
+ case NCASE:
+ cmdputs("case ");
+ cmdputs(n->ncase.expr->narg.text);
+ cmdputs(" in ");
+ for (np = n->ncase.cases; np; np = np->nclist.next) {
+ cmdtxt(np->nclist.pattern);
+ cmdputs(") ");
+ cmdtxt(np->nclist.body);
+ cmdputs(";; ");
+ }
+ p = "esac";
+ goto dotail2;
case NTO:
- p = ">"; i = 1; goto redir;
+ p = ">";
+ goto redir;
+ case NCLOBBER:
+ p = ">|";
+ goto redir;
case NAPPEND:
- p = ">>"; i = 1; goto redir;
+ p = ">>";
+ goto redir;
case NTOFD:
- p = ">&"; i = 1; goto redir;
- case NTOOV:
- p = ">|"; i = 1; goto redir;
+ p = ">&";
+ goto redir;
case NFROM:
- p = "<"; i = 0; goto redir;
+ p = "<";
+ goto redir;
case NFROMFD:
- p = "<&"; i = 0; goto redir;
+ p = "<&";
+ goto redir;
case NFROMTO:
- p = "<>"; i = 0; goto redir;
+ p = "<>";
redir:
- if (n->nfile.fd != i) {
- s[0] = n->nfile.fd + '0';
- s[1] = '\0';
- cmdputs(s);
- }
+ s[0] = n->nfile.fd + '0';
+ s[1] = '\0';
+ cmdputs(s);
cmdputs(p);
if (n->type == NTOFD || n->type == NFROMFD) {
s[0] = n->ndup.dupfd + '0';
- s[1] = '\0';
- cmdputs(s);
+ p = s;
+ goto dotail2;
} else {
- cmdtxt(n->nfile.fname);
+ n = n->nfile.fname;
+ goto donode;
}
- break;
- case NHERE:
- case NXHERE:
- cmdputs("<<...");
- break;
- default:
- cmdputs("???");
- break;
}
}
-
-static char *
-commandtext(const union node *n)
+static void
+cmdlist(union node *np, int sep)
{
- char *name;
-
- cmdnextc = name = ckmalloc(MAXCMDTEXT);
- cmdnleft = MAXCMDTEXT - 4;
- cmdtxt(n);
- *cmdnextc = '\0';
- return name;
+ for (; np; np = np->narg.next) {
+ if (!sep)
+ cmdputs(spcstr);
+ cmdtxt(np);
+ if (sep && np->narg.next)
+ cmdputs(spcstr);
+ }
}
+static void
+cmdputs(const char *s)
+{
+ const char *p, *str;
+ char c, cc[2] = " ";
+ char *nextc;
+ int subtype = 0;
+ int quoted = 0;
+ static const char *const vstype[16] = {
+ nullstr, "}", "-", "+", "?", "=",
+ "%", "%%", "#", "##", nullstr
+ };
-static void waitonint(int sig) {
- intreceived = 1;
- return;
+ nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
+ p = s;
+ while ((c = *p++) != 0) {
+ str = 0;
+ switch (c) {
+ case CTLESC:
+ c = *p++;
+ break;
+ case CTLVAR:
+ subtype = *p++;
+ if ((subtype & VSTYPE) == VSLENGTH)
+ str = "${#";
+ else
+ str = "${";
+ if (!(subtype & VSQUOTE) != !(quoted & 1)) {
+ quoted ^= 1;
+ c = '"';
+ } else
+ goto dostr;
+ break;
+ case CTLENDVAR:
+ quoted >>= 1;
+ subtype = 0;
+ if (quoted & 1) {
+ str = "\"}";
+ goto dostr;
+ }
+ c = '}';
+ break;
+ case CTLBACKQ:
+ str = "$(...)";
+ goto dostr;
+ case CTLBACKQ+CTLQUOTE:
+ str = "\"$(...)\"";
+ goto dostr;
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ case CTLARI:
+ str = "$((";
+ goto dostr;
+ case CTLENDARI:
+ str = "))";
+ goto dostr;
+#endif
+ case CTLQUOTEMARK:
+ quoted ^= 1;
+ c = '"';
+ break;
+ case '=':
+ if (subtype == 0)
+ break;
+ str = vstype[subtype & VSTYPE];
+ if (subtype & VSNUL)
+ c = ':';
+ else
+ c = *str++;
+ if (c != '}')
+ quoted <<= 1;
+ break;
+ case '\'':
+ case '\\':
+ case '"':
+ case '$':
+ /* These can only happen inside quotes */
+ cc[0] = c;
+ str = cc;
+ c = '\\';
+ break;
+ default:
+ break;
+ }
+ USTPUTC(c, nextc);
+ if (!str)
+ continue;
+dostr:
+ while ((c = *str++)) {
+ USTPUTC(c, nextc);
+ }
+ }
+ if (quoted & 1) {
+ USTPUTC('"', nextc);
+ }
+ *nextc = 0;
+ cmdnextc = nextc;
}
-/*
- * Routines to check for mail. (Perhaps make part of main.c?)
- */
-#define MAXMBOXES 10
+static void
+showpipe(struct job *jp, FILE *out)
+{
+ struct procstat *sp;
+ struct procstat *spend;
+ spend = jp->ps + jp->nprocs;
+ for (sp = jp->ps + 1; sp < spend; sp++)
+ fprintf(out, " | %s", sp->cmd);
+ outcslow('\n', out);
+ flushall();
+}
-static int nmboxes; /* number of mailboxes */
-static time_t mailtime[MAXMBOXES]; /* times of mailboxes */
+static void
+xtcsetpgrp(int fd, pid_t pgrp)
+{
+ if (tcsetpgrp(fd, pgrp))
+ error("Cannot set tty process group (%m)");
+}
+#endif /* JOBS */
+
+static int
+getstatus(struct job *job) {
+ int status;
+ int retval;
+
+ status = job->ps[job->nprocs - 1].status;
+ retval = WEXITSTATUS(status);
+ if (!WIFEXITED(status)) {
+#if JOBS
+ retval = WSTOPSIG(status);
+ if (!WIFSTOPPED(status))
+#endif
+ {
+ /* XXX: limits number of signals */
+ retval = WTERMSIG(status);
+#if JOBS
+ if (retval == SIGINT)
+ job->sigint = 1;
+#endif
+ }
+ retval += 128;
+ }
+ TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
+ jobno(job), job->nprocs, status, retval));
+ return retval;
+}
+
+#ifdef CONFIG_ASH_MAIL
+/* $NetBSD: mail.c,v 1.15 2002/11/24 22:35:40 christos Exp $ */
+
+/*
+ * Routines to check for mail. (Perhaps make part of main.c?)
+ */
+
+#define MAXMBOXES 10
+
+/* times of mailboxes */
+static time_t mailtime[MAXMBOXES];
+/* Set if MAIL or MAILPATH is changed. */
+static int mail_var_path_changed;
/*
- * Print appropriate message(s) if mail has arrived. If the argument is
- * nozero, then the value of MAIL has changed, so we just update the
- * values.
+ * Print appropriate message(s) if mail has arrived.
+ * If mail_var_path_changed is set,
+ * then the value of MAIL has mail_var_path_changed,
+ * so we just update the values.
*/
static void
-chkmail(int silent)
+chkmail(void)
{
- int i;
const char *mpath;
char *p;
char *q;
+ time_t *mtp;
struct stackmark smark;
struct stat statb;
- if (silent)
- nmboxes = 10;
- if (nmboxes == 0)
- return;
setstackmark(&smark);
- mpath = mpathset()? mpathval() : mailval();
- for (i = 0 ; i < nmboxes ; i++) {
+ mpath = mpathset() ? mpathval() : mailval();
+ for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) {
p = padvance(&mpath, nullstr);
if (p == NULL)
break;
abort();
#endif
q[-1] = '\0'; /* delete trailing '/' */
- if (stat(p, &statb) < 0)
- statb.st_size = 0;
- if (statb.st_size > mailtime[i] && ! silent) {
- out2fmt(snlfmt,
- pathopt? pathopt : "you have mail");
+ if (stat(p, &statb) < 0) {
+ *mtp = 0;
+ continue;
}
- mailtime[i] = statb.st_size;
+ if (!mail_var_path_changed && statb.st_mtime != *mtp) {
+ fprintf(
+ stderr, snlfmt,
+ pathopt ? pathopt : "you have mail"
+ );
+ }
+ *mtp = statb.st_mtime;
}
- nmboxes = i;
+ mail_var_path_changed = 0;
popstackmark(&smark);
}
-#define PROFILE 0
+
+static void
+changemail(const char *val)
+{
+ mail_var_path_changed++;
+}
+
+#endif /* CONFIG_ASH_MAIL */
+
+/* $NetBSD: main.c,v 1.46 2002/12/11 19:12:18 christos Exp $ */
+
#if PROFILE
static short profile_buf[16384];
extern int etext();
#endif
-static void read_profile (const char *);
-static void cmdloop (int);
-static void options (int);
-static void setoption (int, int);
-static void procargs (int, char **);
+static int isloginsh;
+static void read_profile(const char *);
/*
* Main routine. We initialize things, parse the arguments, execute
*/
int
-shell_main(argc, argv)
- int argc;
- char **argv;
+ash_main(int argc, char **argv)
{
+ char *shinit;
+ volatile int state;
struct jmploc jmploc;
struct stackmark smark;
- volatile int state;
- const char *shinit;
- BLTINCMD = find_builtin("builtin");
- EXECCMD = find_builtin("exec");
- EVALCMD = find_builtin("eval");
-
-#ifndef BB_FEATURE_SH_FANCY_PROMPT
- unsetenv("PS1");
- unsetenv("PS2");
+#ifdef __GLIBC__
+ dash_errno = __errno_location();
#endif
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
-#endif
-#if defined(linux) || defined(__GNU__)
- signal(SIGCHLD, SIG_DFL);
#endif
state = 0;
if (setjmp(jmploc.loc)) {
- INTOFF;
- /*
- * When a shell procedure is executed, we raise the
- * exception EXSHELLPROC to clean up before executing
- * the shell procedure.
- */
- switch (exception) {
- case EXSHELLPROC:
- rootpid = getpid();
- rootshell = 1;
- minusc = NULL;
- state = 3;
- break;
+ int status;
+ int e;
+
+ reset();
+ e = exception;
+ switch (exception) {
case EXEXEC:
- exitstatus = exerrno;
+ status = exerrno;
break;
case EXERROR:
- exitstatus = 2;
+ status = 2;
break;
default:
+ status = exitstatus;
break;
}
+ exitstatus = status;
- if (exception != EXSHELLPROC) {
- if (state == 0 || iflag == 0 || ! rootshell)
- exitshell(exitstatus);
- }
- reset();
- if (exception == EXINT) {
- out2c('\n');
+ if (e == EXEXIT || state == 0 || iflag == 0 || ! rootshell)
+ exitshell();
+
+ if (e == EXINT) {
+ outcslow('\n', stderr);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
+
+#ifdef CONFIG_ASH_RANDOM_SUPPORT
+ rseed = rootpid + ((time_t)time((time_t *)0));
+#endif
rootshell = 1;
init();
setstackmark(&smark);
procargs(argc, argv);
- if (argv[0] && argv[0][0] == '-') {
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+ if ( iflag ) {
+ const char *hp = lookupvar("HISTFILE");
+
+ if(hp == NULL ) {
+ hp = lookupvar("HOME");
+ if(hp != NULL) {
+ char *defhp = concat_path_file(hp, ".ash_history");
+ setvar("HISTFILE", defhp, 0);
+ free(defhp);
+ }
+ }
+ }
+#endif
+ if (argv[0] && argv[0][0] == '-')
+ isloginsh = 1;
+ if (isloginsh) {
state = 1;
read_profile("/etc/profile");
state1:
}
state2:
state = 3;
+ if (
#ifndef linux
- if (getuid() == geteuid() && getgid() == getegid()) {
+ getuid() == geteuid() && getgid() == getegid() &&
#endif
+ iflag
+ ) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
- state = 3;
read_profile(shinit);
}
-#ifndef linux
}
-#endif
state3:
state = 4;
- if (sflag == 0 || minusc) {
- static int sigs[] = {
- SIGINT, SIGQUIT, SIGHUP,
-#ifdef SIGTSTP
- SIGTSTP,
-#endif
- SIGPIPE
- };
-#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
- int i;
-
- for (i = 0; i < SIGSSIZE; i++)
- setsignal(sigs[i]);
- }
-
if (minusc)
- evalstring(minusc, 0);
+ evalstring(minusc);
if (sflag || minusc == NULL) {
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+ if ( iflag ) {
+ const char *hp = lookupvar("HISTFILE");
+
+ if(hp != NULL )
+ load_history ( hp );
+ }
+#endif
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
}
#if PROFILE
monitor(0);
#endif
- exitshell(exitstatus);
+#if GPROF
+ {
+ extern void _mcleanup(void);
+ _mcleanup();
+ }
+#endif
+ exitshell();
/* NOTREACHED */
}
int numeof = 0;
TRACE(("cmdloop(%d) called\n", top));
- setstackmark(&smark);
for (;;) {
+ setstackmark(&smark);
if (pendingsigs)
dotrap();
+#if JOBS
+ if (jobctl)
+ showjobs(stderr, SHOW_CHANGED);
+#endif
inter = 0;
if (iflag && top) {
inter++;
- showjobs(1);
- chkmail(0);
- flushall();
+#ifdef CONFIG_ASH_MAIL
+ chkmail();
+#endif
}
n = parsecmd(inter);
/* showtree(n); DEBUG */
evaltree(n, 0);
}
popstackmark(&smark);
- setstackmark(&smark);
- if (evalskip == SKIPFILE) {
+ if (evalskip) {
evalskip = 0;
break;
}
}
- popstackmark(&smark);
}
-
/*
* Read /etc/profile or .profile. Return on error.
*/
static void
-read_profile(name)
- const char *name;
+read_profile(const char *name)
{
int fd;
int xflag_set = 0;
}
-
/*
* Read a file containing shell functions.
*/
static void
-readcmdfile(const char *name)
+readcmdfile(char *name)
{
int fd;
}
-
/*
- * Take commands from a file. To be compatable we should do a path
+ * Take commands from a file. To be compatible we should do a path
* search for the file, which is necessary to find sub-commands.
*/
-
static inline char *
-find_dot_file(mybasename)
- char *mybasename;
+find_dot_file(char *name)
{
char *fullname;
const char *path = pathval();
struct stat statb;
/* don't try this for absolute or relative paths */
- if (strchr(mybasename, '/'))
- return mybasename;
+ if (strchr(name, '/'))
+ return name;
- while ((fullname = padvance(&path, mybasename)) != NULL) {
+ while ((fullname = padvance(&path, name)) != NULL) {
if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
/*
* Don't bother freeing here, since it will
}
/* not found in the PATH */
- error("%s: not found", mybasename);
+ error(not_found_msg, name);
/* NOTREACHED */
}
-static int
-dotcmd(argc, argv)
- int argc;
- char **argv;
+static int dotcmd(int argc, char **argv)
{
struct strlist *sp;
+ volatile struct shparam saveparam;
+
exitstatus = 0;
- for (sp = cmdenviron; sp ; sp = sp->next)
- setvareq(savestr(sp->text), VSTRFIXED|VTEXTFIXED);
+ for (sp = cmdenviron; sp; sp = sp->next)
+ setvareq(bb_xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
- if (argc >= 2) { /* That's what SVR2 does */
+ if (argc >= 2) { /* That's what SVR2 does */
char *fullname;
struct stackmark smark;
setstackmark(&smark);
fullname = find_dot_file(argv[1]);
+
+ if (argc > 2) {
+ saveparam = shellparam;
+ shellparam.malloc = 0;
+ shellparam.nparam = argc - 2;
+ shellparam.p = argv + 2;
+ };
+
setinputfile(fullname, 1);
commandname = fullname;
cmdloop(0);
popfile();
+
+ if (argc > 2) {
+ freeparam(&shellparam);
+ shellparam = saveparam;
+ };
+
popstackmark(&smark);
}
return exitstatus;
static int
-exitcmd(argc, argv)
- int argc;
- char **argv;
+exitcmd(int argc, char **argv)
{
if (stoppedjobs())
return 0;
if (argc > 1)
exitstatus = number(argv[1]);
- else
- exitstatus = oexitstatus;
- exitshell(exitstatus);
+ exraise(EXEXIT);
/* NOTREACHED */
}
+/* $NetBSD: memalloc.c,v 1.27 2003/01/22 20:36:04 dsl Exp $ */
+
+/*
+ * Same for malloc, realloc, but returns an error when out of space.
+ */
+
+static pointer
+ckrealloc(pointer p, size_t nbytes)
+{
+ p = realloc(p, nbytes);
+ if (p == NULL)
+ error(bb_msg_memory_exhausted);
+ return p;
+}
+
+static pointer
+ckmalloc(size_t nbytes)
+{
+ return ckrealloc(NULL, nbytes);
+}
+
+/*
+ * Make a copy of a string in safe storage.
+ */
+
+static char *
+savestr(const char *s)
+{
+ char *p = strdup(s);
+ if (!p)
+ error(bb_msg_memory_exhausted);
+ return p;
+}
+
+
+/*
+ * Parse trees for commands are allocated in lifo order, so we use a stack
+ * to make this more efficient, and also to avoid all sorts of exception
+ * handling code to handle interrupts in the middle of a parse.
+ *
+ * The size 504 was chosen because the Ultrix malloc handles that size
+ * well.
+ */
+
+
static pointer
-stalloc(int nbytes)
+stalloc(size_t nbytes)
{
char *p;
+ size_t aligned;
- nbytes = ALIGN(nbytes);
- if (nbytes > stacknleft) {
- int blocksize;
+ aligned = SHELL_ALIGN(nbytes);
+ if (aligned > stacknleft) {
+ size_t len;
+ size_t blocksize;
struct stack_block *sp;
- blocksize = nbytes;
+ blocksize = aligned;
if (blocksize < MINSIZE)
blocksize = MINSIZE;
+ len = sizeof(struct stack_block) - MINSIZE + blocksize;
+ if (len < blocksize)
+ error(bb_msg_memory_exhausted);
INTOFF;
- sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
+ sp = ckmalloc(len);
sp->prev = stackp;
stacknxt = sp->space;
stacknleft = blocksize;
+ sstrend = stacknxt + blocksize;
stackp = sp;
INTON;
}
p = stacknxt;
- stacknxt += nbytes;
- stacknleft -= nbytes;
+ stacknxt += aligned;
+ stacknleft -= aligned;
return p;
}
-static void
+void
stunalloc(pointer p)
{
#ifdef DEBUG
- if (p == NULL) { /*DEBUG */
+ if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
write(2, "stunalloc\n", 10);
abort();
}
#endif
- if (!(stacknxt >= (char *)p && (char *)p >= stackp->space)) {
- p = stackp->space;
- }
stacknleft += stacknxt - (char *)p;
stacknxt = p;
}
-static void
+void
setstackmark(struct stackmark *mark)
{
mark->stackp = stackp;
}
-static void
+void
popstackmark(struct stackmark *mark)
{
struct stack_block *sp;
}
stacknxt = mark->stacknxt;
stacknleft = mark->stacknleft;
+ sstrend = mark->stacknxt + mark->stacknleft;
INTON;
}
* part of the block that has been used.
*/
-static void
-growstackblock(void) {
- char *p;
- int newlen = ALIGN(stacknleft * 2 + 100);
- char *oldspace = stacknxt;
- int oldlen = stacknleft;
- struct stack_block *sp;
- struct stack_block *oldstackp;
+void
+growstackblock(void)
+{
+ size_t newlen;
+
+ newlen = stacknleft * 2;
+ if (newlen < stacknleft)
+ error(bb_msg_memory_exhausted);
+ if (newlen < 128)
+ newlen += 128;
if (stacknxt == stackp->space && stackp != &stackbase) {
+ struct stack_block *oldstackp;
+ struct stackmark *xmark;
+ struct stack_block *sp;
+ struct stack_block *prevstackp;
+ size_t grosslen;
+
INTOFF;
oldstackp = stackp;
sp = stackp;
- stackp = sp->prev;
- sp = ckrealloc((pointer)sp, sizeof(struct stack_block) - MINSIZE + newlen);
- sp->prev = stackp;
+ prevstackp = sp->prev;
+ grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
+ sp = ckrealloc((pointer)sp, grosslen);
+ sp->prev = prevstackp;
stackp = sp;
stacknxt = sp->space;
stacknleft = newlen;
- {
- /* Stack marks pointing to the start of the old block
- * must be relocated to point to the new block
- */
- struct stackmark *xmark;
- xmark = markp;
- while (xmark != NULL && xmark->stackp == oldstackp) {
- xmark->stackp = stackp;
- xmark->stacknxt = stacknxt;
- xmark->stacknleft = stacknleft;
- xmark = xmark->marknext;
- }
+ sstrend = sp->space + newlen;
+
+ /*
+ * Stack marks pointing to the start of the old block
+ * must be relocated to point to the new block
+ */
+ xmark = markp;
+ while (xmark != NULL && xmark->stackp == oldstackp) {
+ xmark->stackp = stackp;
+ xmark->stacknxt = stacknxt;
+ xmark->stacknleft = stacknleft;
+ xmark = xmark->marknext;
}
INTON;
} else {
- p = stalloc(newlen);
- memcpy(p, oldspace, oldlen);
- stacknxt = p; /* free the space */
- stacknleft += newlen; /* we just allocated */
+ char *oldspace = stacknxt;
+ int oldlen = stacknleft;
+ char *p = stalloc(newlen);
+
+ /* free the space we just allocated */
+ stacknxt = memcpy(p, oldspace, oldlen);
+ stacknleft += newlen;
}
}
-
-
static inline void
-grabstackblock(int len)
+grabstackblock(size_t len)
{
- len = ALIGN(len);
+ len = SHELL_ALIGN(len);
stacknxt += len;
stacknleft -= len;
}
-
-
/*
- * The following routines are somewhat easier to use that the above.
+ * The following routines are somewhat easier to use than the above.
* The user declares a variable of type STACKSTR, which may be declared
* to be a register. The macro STARTSTACKSTR initializes things. Then
* the user uses the macro STPUTC to add characters to the string. In
* is space for at least one character.
*/
-
-static char *
-growstackstr(void) {
- int len = stackblocksize();
+void *
+growstackstr(void)
+{
+ size_t len = stackblocksize();
if (herefd >= 0 && len >= 1024) {
- xwrite(herefd, stackblock(), len);
- sstrnleft = len - 1;
+ bb_full_write(herefd, stackblock(), len);
return stackblock();
}
growstackblock();
- sstrnleft = stackblocksize() - len - 1;
return stackblock() + len;
}
-
/*
* Called from CHECKSTRSPACE.
*/
-static char *
-makestrspace(size_t newlen) {
- int len = stackblocksize() - sstrnleft;
- do {
+char *
+makestrspace(size_t newlen, char *p)
+{
+ size_t len = p - stacknxt;
+ size_t size = stackblocksize();
+
+ for (;;) {
+ size_t nleft;
+
+ size = stackblocksize();
+ nleft = size - len;
+ if (nleft >= newlen)
+ break;
growstackblock();
- sstrnleft = stackblocksize() - len;
- } while (sstrnleft < newlen);
+ }
return stackblock() + len;
}
+char *
+stnputs(const char *s, size_t n, char *p)
+{
+ p = makestrspace(n, p);
+ p = mempcpy(p, s, n);
+ return p;
+}
-
-static void
-ungrabstackstr(char *s, char *p)
+char *
+stputs(const char *s, char *p)
{
- stacknleft += stacknxt - s;
- stacknxt = s;
- sstrnleft = stacknleft - (p - s);
+ return stnputs(s, strlen(s), p);
}
+
+/* $NetBSD: mystring.c,v 1.15 2002/11/24 22:35:42 christos Exp $ */
+
/*
- * Miscelaneous builtins.
+ * String functions.
+ *
+ * number(s) Convert a string of digits to an integer.
+ * is_number(s) Return true if s is a string of digits.
*/
+/*
+ * prefix -- see if pfx is a prefix of string.
+ */
-#undef rflag
+char *
+prefix(const char *string, const char *pfx)
+{
+ while (*pfx) {
+ if (*pfx++ != *string++)
+ return 0;
+ }
+ return (char *) string;
+}
-//#ifdef __GLIBC__
-static mode_t getmode(const void *, mode_t);
-static void *setmode(const char *);
-//#endif
-#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
-typedef long rlim_t;
-#endif
+/*
+ * Convert a string of digits to an integer, printing an error message on
+ * failure.
+ */
+int
+number(const char *s)
+{
+
+ if (! is_number(s))
+ error(illnum, s);
+ return atoi(s);
+}
/*
- * The read builtin. The -e option causes backslashes to escape the
- * following character.
- *
- * This uses unbuffered input, which may be avoidable in some cases.
+ * Check for a valid number. This should be elsewhere.
*/
-static int
-readcmd(argc, argv)
- int argc;
- char **argv;
+int
+is_number(const char *p)
{
- char **ap;
- int backslash;
- char c;
- int rflag;
- char *prompt;
- const char *ifs;
+ do {
+ if (! is_digit(*p))
+ return 0;
+ } while (*++p != '\0');
+ return 1;
+}
+
+
+/*
+ * Produce a possibly single quoted string suitable as input to the shell.
+ * The return string is allocated on the stack.
+ */
+
+char *
+single_quote(const char *s) {
char *p;
- int startword;
- int status;
- int i;
- rflag = 0;
- prompt = NULL;
- while ((i = nextopt("p:r")) != '\0') {
- if (i == 'p')
- prompt = optionarg;
- else
- rflag = 1;
- }
- if (prompt && isatty(0)) {
- putprompt(prompt);
- flushall();
- }
- if (*(ap = argptr) == NULL)
- error("arg count");
- if ((ifs = bltinlookup("IFS")) == NULL)
- ifs = defifs;
- status = 0;
- startword = 1;
- backslash = 0;
STARTSTACKSTR(p);
- for (;;) {
- if (read(0, &c, 1) != 1) {
- status = 1;
+
+ do {
+ char *q;
+ size_t len;
+
+ len = strchrnul(s, '\'') - s;
+
+ q = p = makestrspace(len + 3, p);
+
+ *q++ = '\'';
+ q = mempcpy(q, s, len);
+ *q++ = '\'';
+ s += len;
+
+ STADJUST(q - p, p);
+
+ len = strspn(s, "'");
+ if (!len)
break;
- }
- if (c == '\0')
- continue;
- if (backslash) {
- backslash = 0;
- if (c != '\n')
- STPUTC(c, p);
- continue;
- }
- if (!rflag && c == '\\') {
- backslash++;
- continue;
- }
- if (c == '\n')
- break;
- if (startword && *ifs == ' ' && strchr(ifs, c)) {
- continue;
- }
- startword = 0;
- if (backslash && c == '\\') {
- if (read(0, &c, 1) != 1) {
- status = 1;
- break;
- }
- STPUTC(c, p);
- } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
- STACKSTRNUL(p);
- setvar(*ap, stackblock(), 0);
- ap++;
- startword = 1;
- STARTSTACKSTR(p);
- } else {
- STPUTC(c, p);
- }
- }
- STACKSTRNUL(p);
- /* Remove trailing blanks */
- while (stackblock() <= --p && strchr(ifs, *p) != NULL)
- *p = '\0';
- setvar(*ap, stackblock(), 0);
- while (*++ap != NULL)
- setvar(*ap, nullstr, 0);
- return status;
-}
-
-
-
-static int
-umaskcmd(argc, argv)
- int argc;
- char **argv;
-{
- char *ap;
- int mask;
- int i;
- int symbolic_mode = 0;
- while (nextopt("S") != '\0') {
- symbolic_mode = 1;
- }
+ q = p = makestrspace(len + 3, p);
- INTOFF;
- mask = umask(0);
- umask(mask);
- INTON;
+ *q++ = '"';
+ q = mempcpy(q, s, len);
+ *q++ = '"';
+ s += len;
- if ((ap = *argptr) == NULL) {
- if (symbolic_mode) {
- char u[4], g[4], o[4];
-
- i = 0;
- if ((mask & S_IRUSR) == 0)
- u[i++] = 'r';
- if ((mask & S_IWUSR) == 0)
- u[i++] = 'w';
- if ((mask & S_IXUSR) == 0)
- u[i++] = 'x';
- u[i] = '\0';
-
- i = 0;
- if ((mask & S_IRGRP) == 0)
- g[i++] = 'r';
- if ((mask & S_IWGRP) == 0)
- g[i++] = 'w';
- if ((mask & S_IXGRP) == 0)
- g[i++] = 'x';
- g[i] = '\0';
-
- i = 0;
- if ((mask & S_IROTH) == 0)
- o[i++] = 'r';
- if ((mask & S_IWOTH) == 0)
- o[i++] = 'w';
- if ((mask & S_IXOTH) == 0)
- o[i++] = 'x';
- o[i] = '\0';
-
- printf("u=%s,g=%s,o=%s\n", u, g, o);
- } else {
- printf("%.4o\n", mask);
- }
- } else {
- if (is_digit((unsigned char)*ap)) {
- mask = 0;
- do {
- if (*ap >= '8' || *ap < '0')
- error("Illegal number: %s", argv[1]);
- mask = (mask << 3) + (*ap - '0');
- } while (*++ap != '\0');
- umask(mask);
- } else {
- void *set;
+ STADJUST(q - p, p);
+ } while (*s);
- INTOFF;
- if ((set = setmode(ap)) != 0) {
- mask = getmode(set, ~mask & 0777);
- ckfree(set);
- }
- INTON;
- if (!set)
- error("Illegal mode: %s", ap);
+ USTPUTC(0, p);
- umask(~mask & 0777);
- }
- }
- return 0;
+ return stackblock();
}
/*
- * ulimit builtin
- *
- * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
- * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
- * ash by J.T. Conklin.
- *
- * Public domain.
+ * Like strdup but works with the ash stack.
*/
-struct limits {
- const char *name;
- int cmd;
- int factor; /* multiply by to get rlim_{cur,max} values */
- char option;
-};
+char *
+sstrdup(const char *p)
+{
+ size_t len = strlen(p) + 1;
+ return memcpy(stalloc(len), p, len);
+}
-static const struct limits limits[] = {
-#ifdef RLIMIT_CPU
- { "time(seconds)", RLIMIT_CPU, 1, 't' },
-#endif
-#ifdef RLIMIT_FSIZE
- { "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
-#endif
-#ifdef RLIMIT_DATA
- { "data(kbytes)", RLIMIT_DATA, 1024, 'd' },
-#endif
-#ifdef RLIMIT_STACK
- { "stack(kbytes)", RLIMIT_STACK, 1024, 's' },
-#endif
-#ifdef RLIMIT_CORE
- { "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
-#endif
-#ifdef RLIMIT_RSS
- { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' },
-#endif
-#ifdef RLIMIT_MEMLOCK
- { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' },
-#endif
-#ifdef RLIMIT_NPROC
- { "process(processes)", RLIMIT_NPROC, 1, 'p' },
-#endif
-#ifdef RLIMIT_NOFILE
- { "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' },
-#endif
-#ifdef RLIMIT_VMEM
- { "vmemory(kbytes)", RLIMIT_VMEM, 1024, 'v' },
-#endif
-#ifdef RLIMIT_SWAP
- { "swap(kbytes)", RLIMIT_SWAP, 1024, 'w' },
-#endif
- { (char *) 0, 0, 0, '\0' }
-};
-static int
-ulimitcmd(argc, argv)
- int argc;
- char **argv;
+static void
+calcsize(union node *n)
{
- int c;
- rlim_t val = 0;
- enum { SOFT = 0x1, HARD = 0x2 }
- how = SOFT | HARD;
- const struct limits *l;
- int set, all = 0;
- int optc, what;
- struct rlimit limit;
+ if (n == NULL)
+ return;
+ funcblocksize += nodesize[n->type];
+ switch (n->type) {
+ case NCMD:
+ calcsize(n->ncmd.redirect);
+ calcsize(n->ncmd.args);
+ calcsize(n->ncmd.assign);
+ break;
+ case NPIPE:
+ sizenodelist(n->npipe.cmdlist);
+ break;
+ case NREDIR:
+ case NBACKGND:
+ case NSUBSHELL:
+ calcsize(n->nredir.redirect);
+ calcsize(n->nredir.n);
+ break;
+ case NAND:
+ case NOR:
+ case NSEMI:
+ case NWHILE:
+ case NUNTIL:
+ calcsize(n->nbinary.ch2);
+ calcsize(n->nbinary.ch1);
+ break;
+ case NIF:
+ calcsize(n->nif.elsepart);
+ calcsize(n->nif.ifpart);
+ calcsize(n->nif.test);
+ break;
+ case NFOR:
+ funcstringsize += strlen(n->nfor.var) + 1;
+ calcsize(n->nfor.body);
+ calcsize(n->nfor.args);
+ break;
+ case NCASE:
+ calcsize(n->ncase.cases);
+ calcsize(n->ncase.expr);
+ break;
+ case NCLIST:
+ calcsize(n->nclist.body);
+ calcsize(n->nclist.pattern);
+ calcsize(n->nclist.next);
+ break;
+ case NDEFUN:
+ case NARG:
+ sizenodelist(n->narg.backquote);
+ funcstringsize += strlen(n->narg.text) + 1;
+ calcsize(n->narg.next);
+ break;
+ case NTO:
+ case NCLOBBER:
+ case NFROM:
+ case NFROMTO:
+ case NAPPEND:
+ calcsize(n->nfile.fname);
+ calcsize(n->nfile.next);
+ break;
+ case NTOFD:
+ case NFROMFD:
+ calcsize(n->ndup.vname);
+ calcsize(n->ndup.next);
+ break;
+ case NHERE:
+ case NXHERE:
+ calcsize(n->nhere.doc);
+ calcsize(n->nhere.next);
+ break;
+ case NNOT:
+ calcsize(n->nnot.com);
+ break;
+ };
+}
- what = 'f';
- while ((optc = nextopt("HSatfdsmcnpl")) != '\0')
- switch (optc) {
- case 'H':
- how = HARD;
- break;
- case 'S':
- how = SOFT;
- break;
- case 'a':
- all = 1;
- break;
- default:
- what = optc;
- }
- for (l = limits; l->name && l->option != what; l++)
- ;
- if (!l->name)
- error("internal error (%c)", what);
+static void
+sizenodelist(struct nodelist *lp)
+{
+ while (lp) {
+ funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
+ calcsize(lp->n);
+ lp = lp->next;
+ }
+}
- set = *argptr ? 1 : 0;
- if (set) {
- char *p = *argptr;
- if (all || argptr[1])
- error("too many arguments");
- if (strcmp(p, "unlimited") == 0)
- val = RLIM_INFINITY;
- else {
- val = (rlim_t) 0;
-
- while ((c = *p++) >= '0' && c <= '9')
- {
- val = (val * 10) + (long)(c - '0');
- if (val < (rlim_t) 0)
- break;
- }
- if (c)
- error("bad number");
- val *= l->factor;
- }
- }
- if (all) {
- for (l = limits; l->name; l++) {
- getrlimit(l->cmd, &limit);
- if (how & SOFT)
- val = limit.rlim_cur;
- else if (how & HARD)
- val = limit.rlim_max;
-
- printf("%-20s ", l->name);
- if (val == RLIM_INFINITY)
- printf("unlimited\n");
- else
- {
- val /= l->factor;
- printf("%lld\n", (long long) val);
- }
- }
- return 0;
- }
-
- getrlimit(l->cmd, &limit);
- if (set) {
- if (how & HARD)
- limit.rlim_max = val;
- if (how & SOFT)
- limit.rlim_cur = val;
- if (setrlimit(l->cmd, &limit) < 0)
- error("error setting limit (%m)");
- } else {
- if (how & SOFT)
- val = limit.rlim_cur;
- else if (how & HARD)
- val = limit.rlim_max;
-
- if (val == RLIM_INFINITY)
- printf("unlimited\n");
- else
- {
- val /= l->factor;
- printf("%lld\n", (long long) val);
- }
- }
- return 0;
-}
-/*
- * prefix -- see if pfx is a prefix of string.
- */
-
-static int
-prefix(char const *pfx, char const *string)
-{
- while (*pfx) {
- if (*pfx++ != *string++)
- return 0;
- }
- return 1;
-}
-
-/*
- * Return true if s is a string of digits, and save munber in intptr
- * nagative is bad
- */
-
-static int
-is_number(const char *p, int *intptr)
-{
- int ret = 0;
-
- do {
- if (! is_digit(*p))
- return 0;
- ret *= 10;
- ret += digit_val(*p);
- p++;
- } while (*p != '\0');
-
- *intptr = ret;
- return 1;
-}
-
-/*
- * Convert a string of digits to an integer, printing an error message on
- * failure.
- */
-
-static int
-number(const char *s)
-{
- int i;
- if (! is_number(s, &i))
- error("Illegal number: %s", s);
- return i;
-}
-
-/*
- * Produce a possibly single quoted string suitable as input to the shell.
- * The return string is allocated on the stack.
- */
-
-static char *
-single_quote(const char *s) {
- char *p;
-
- STARTSTACKSTR(p);
-
- do {
- char *q = p;
- size_t len1, len1p, len2, len2p;
-
- len1 = strcspn(s, "'");
- len2 = strspn(s + len1, "'");
-
- len1p = len1 ? len1 + 2 : len1;
- switch (len2) {
- case 0:
- len2p = 0;
- break;
- case 1:
- len2p = 2;
- break;
- default:
- len2p = len2 + 2;
- }
-
- CHECKSTRSPACE(len1p + len2p + 1, p);
-
- if (len1) {
- *p = '\'';
- q = p + 1 + len1;
- memcpy(p + 1, s, len1);
- *q++ = '\'';
- s += len1;
- }
-
- switch (len2) {
- case 0:
- break;
- case 1:
- *q++ = '\\';
- *q = '\'';
- s++;
- break;
- default:
- *q = '"';
- q += 1 + len2;
- memcpy(q + 1, s, len2);
- *q = '"';
- s += len2;
- }
-
- STADJUST(len1p + len2p, p);
- } while (*s);
-
- USTPUTC(0, p);
-
- return grabstackstr(p);
-}
-
-/*
- * Like strdup but works with the ash stack.
- */
-
-static char *
-sstrdup(const char *p)
-{
- size_t len = strlen(p) + 1;
- return memcpy(stalloc(len), p, len);
-}
-
-
-/*
- * Routine for dealing with parsed shell commands.
- */
-
-
-static void sizenodelist (const struct nodelist *);
-static struct nodelist *copynodelist (const struct nodelist *);
-static char *nodesavestr (const char *);
-
-static void
-calcsize(const union node *n)
-{
- if (n == NULL)
- return;
- funcblocksize += nodesize[n->type];
- switch (n->type) {
- case NSEMI:
- case NAND:
- case NOR:
- case NWHILE:
- case NUNTIL:
- calcsize(n->nbinary.ch2);
- calcsize(n->nbinary.ch1);
- break;
- case NCMD:
- calcsize(n->ncmd.redirect);
- calcsize(n->ncmd.args);
- calcsize(n->ncmd.assign);
- break;
- case NPIPE:
- sizenodelist(n->npipe.cmdlist);
- break;
- case NREDIR:
- case NBACKGND:
- case NSUBSHELL:
- calcsize(n->nredir.redirect);
- calcsize(n->nredir.n);
- break;
- case NIF:
- calcsize(n->nif.elsepart);
- calcsize(n->nif.ifpart);
- calcsize(n->nif.test);
- break;
- case NFOR:
- funcstringsize += strlen(n->nfor.var) + 1;
- calcsize(n->nfor.body);
- calcsize(n->nfor.args);
- break;
- case NCASE:
- calcsize(n->ncase.cases);
- calcsize(n->ncase.expr);
- break;
- case NCLIST:
- calcsize(n->nclist.body);
- calcsize(n->nclist.pattern);
- calcsize(n->nclist.next);
- break;
- case NDEFUN:
- case NARG:
- sizenodelist(n->narg.backquote);
- funcstringsize += strlen(n->narg.text) + 1;
- calcsize(n->narg.next);
- break;
- case NTO:
- case NFROM:
- case NFROMTO:
- case NAPPEND:
- case NTOOV:
- calcsize(n->nfile.fname);
- calcsize(n->nfile.next);
- break;
- case NTOFD:
- case NFROMFD:
- calcsize(n->ndup.vname);
- calcsize(n->ndup.next);
- break;
- case NHERE:
- case NXHERE:
- calcsize(n->nhere.doc);
- calcsize(n->nhere.next);
- break;
- case NNOT:
- calcsize(n->nnot.com);
- break;
- };
-}
-
-static void
-sizenodelist(const struct nodelist *lp)
-{
- while (lp) {
- funcblocksize += ALIGN(sizeof(struct nodelist));
- calcsize(lp->n);
- lp = lp->next;
- }
-}
-
-
-static union node *
-copynode(const union node *n)
-{
- union node *new;
+static union node *
+copynode(union node *n)
+{
+ union node *new;
if (n == NULL)
return NULL;
new = funcblock;
funcblock = (char *) funcblock + nodesize[n->type];
switch (n->type) {
- case NSEMI:
- case NAND:
- case NOR:
- case NWHILE:
- case NUNTIL:
- new->nbinary.ch2 = copynode(n->nbinary.ch2);
- new->nbinary.ch1 = copynode(n->nbinary.ch1);
- break;
case NCMD:
new->ncmd.redirect = copynode(n->ncmd.redirect);
new->ncmd.args = copynode(n->ncmd.args);
new->ncmd.assign = copynode(n->ncmd.assign);
- new->ncmd.backgnd = n->ncmd.backgnd;
break;
case NPIPE:
new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
new->nredir.redirect = copynode(n->nredir.redirect);
new->nredir.n = copynode(n->nredir.n);
break;
+ case NAND:
+ case NOR:
+ case NSEMI:
+ case NWHILE:
+ case NUNTIL:
+ new->nbinary.ch2 = copynode(n->nbinary.ch2);
+ new->nbinary.ch1 = copynode(n->nbinary.ch1);
+ break;
case NIF:
new->nif.elsepart = copynode(n->nif.elsepart);
new->nif.ifpart = copynode(n->nif.ifpart);
new->narg.next = copynode(n->narg.next);
break;
case NTO:
+ case NCLOBBER:
case NFROM:
case NFROMTO:
case NAPPEND:
- case NTOOV:
new->nfile.fname = copynode(n->nfile.fname);
new->nfile.fd = n->nfile.fd;
new->nfile.next = copynode(n->nfile.next);
break;
};
new->type = n->type;
- return new;
+ return new;
}
static struct nodelist *
-copynodelist(const struct nodelist *lp)
+copynodelist(struct nodelist *lp)
{
struct nodelist *start;
struct nodelist **lpp;
lpp = &start;
while (lp) {
*lpp = funcblock;
- funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist));
+ funcblock = (char *) funcblock +
+ SHELL_ALIGN(sizeof(struct nodelist));
(*lpp)->n = copynode(lp->n);
lp = lp->next;
lpp = &(*lpp)->next;
static char *
-nodesavestr(const char *s)
+nodesavestr(char *s)
{
-#ifdef _GNU_SOURCE
char *rtn = funcstring;
funcstring = stpcpy(funcstring, s) + 1;
return rtn;
-#else
- const char *p = s;
- char *q = funcstring;
- char *rtn = funcstring;
+}
- while ((*q++ = *p++) != '\0')
- continue;
- funcstring = q;
- return rtn;
-#endif
+
+/*
+ * Free a parse tree.
+ */
+
+static void
+freefunc(struct funcnode *f)
+{
+ if (f && --f->count < 0)
+ ckfree(f);
}
-#ifdef ASH_GETOPTS
-static int getopts (char *, char *, char **, int *, int *);
-#endif
+
+static void options(int);
+static void setoption(int, int);
/*
* Process the shell command line arguments.
*/
-static void
-procargs(argc, argv)
- int argc;
- char **argv;
+void
+procargs(int argc, char **argv)
{
int i;
+ const char *xminusc;
+ char **xargv;
- argptr = argv;
+ xargv = argv;
+ arg0 = xargv[0];
if (argc > 0)
- argptr++;
+ xargv++;
for (i = 0; i < NOPTS; i++)
- optent_val(i) = 2;
+ optlist[i] = 2;
+ argptr = xargv;
options(1);
- if (*argptr == NULL && minusc == NULL)
+ xargv = argptr;
+ xminusc = minusc;
+ if (*xargv == NULL) {
+ if (xminusc)
+ error("-c requires an argument");
sflag = 1;
+ }
if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
iflag = 1;
if (mflag == 2)
mflag = iflag;
for (i = 0; i < NOPTS; i++)
- if (optent_val(i) == 2)
- optent_val(i) = 0;
- arg0 = argv[0];
- if (sflag == 0 && minusc == NULL) {
- commandname = argv[0];
- arg0 = *argptr++;
- setinputfile(arg0, 0);
+ if (optlist[i] == 2)
+ optlist[i] = 0;
+#if DEBUG == 2
+ debug = 1;
+#endif
+ /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
+ if (xminusc) {
+ minusc = *xargv++;
+ if (*xargv)
+ goto setarg0;
+ } else if (!sflag) {
+ setinputfile(*xargv, 0);
+setarg0:
+ arg0 = *xargv++;
commandname = arg0;
}
- /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
- if (argptr && minusc && *argptr)
- arg0 = *argptr++;
- shellparam.p = argptr;
+ shellparam.p = xargv;
+#ifdef CONFIG_ASH_GETOPTS
shellparam.optind = 1;
shellparam.optoff = -1;
+#endif
/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
- while (*argptr) {
+ while (*xargv) {
shellparam.nparam++;
- argptr++;
+ xargv++;
}
optschanged();
}
-
-/*
- * Process shell options. The global variable argptr contains a pointer
- * to the argument list; we advance it past the options.
- */
-
-static inline void
-minus_o(const char *name, int val)
+void
+optschanged(void)
{
- int i;
-
- if (name == NULL) {
+#ifdef DEBUG
+ opentrace();
+#endif
+ setinteractive(iflag);
+ setjobctl(mflag);
+}
+
+static inline void
+minus_o(char *name, int val)
+{
+ int i;
+
+ if (name == NULL) {
out1str("Current option settings\n");
for (i = 0; i < NOPTS; i++)
- printf("%-16s%s\n", optent_name(optlist[i]),
- optent_val(i) ? "on" : "off");
+ out1fmt("%-16s%s\n", optnames(i),
+ optlist[i] ? "on" : "off");
} else {
for (i = 0; i < NOPTS; i++)
- if (equal(name, optent_name(optlist[i]))) {
- setoption(optent_letter(optlist[i]), val);
+ if (equal(name, optnames(i))) {
+ optlist[i] = val;
return;
}
error("Illegal option -o %s", name);
}
}
+/*
+ * Process shell options. The global variable argptr contains a pointer
+ * to the argument list; we advance it past the options.
+ */
static void
options(int cmdline)
}
while ((c = *p++) != '\0') {
if (c == 'c' && cmdline) {
- char *q;
-#ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */
- if (*p == '\0')
-#endif
- q = *argptr++;
- if (q == NULL || minusc != NULL)
- error("Bad -c option");
- minusc = q;
-#ifdef NOHACK
- break;
-#endif
+ minusc = p; /* command is after shell args*/
} else if (c == 'o') {
minus_o(*argptr, val);
if (*argptr)
argptr++;
+ } else if (cmdline && (c == '-')) { // long options
+ if (strcmp(p, "login") == 0)
+ isloginsh = 1;
+ break;
} else {
setoption(c, val);
}
int i;
for (i = 0; i < NOPTS; i++)
- if (optent_letter(optlist[i]) == flag) {
- optent_val(i) = val;
- if (val) {
- /* #%$ hack for ksh semantics */
- if (flag == 'V')
- Eflag = 0;
- else if (flag == 'E')
- Vflag = 0;
- }
+ if (optletters(i) == flag) {
+ optlist[i] = val;
return;
}
error("Illegal option -%c", flag);
* Set the shell parameters.
*/
-static void
+void
setparam(char **argv)
{
char **newparam;
shellparam.malloc = 1;
shellparam.nparam = nparam;
shellparam.p = newparam;
+#ifdef CONFIG_ASH_GETOPTS
shellparam.optind = 1;
shellparam.optoff = -1;
+#endif
}
* Free the list of positional parameters.
*/
-static void
+void
freeparam(volatile struct shparam *param)
{
char **ap;
* The shift builtin command.
*/
-static int
-shiftcmd(argc, argv)
- int argc;
- char **argv;
+int
+shiftcmd(int argc, char **argv)
{
int n;
char **ap1, **ap2;
}
ap2 = shellparam.p;
while ((*ap2++ = *ap1++) != NULL);
+#ifdef CONFIG_ASH_GETOPTS
shellparam.optind = 1;
shellparam.optoff = -1;
+#endif
INTON;
return 0;
}
* The set command builtin.
*/
-static int
-setcmd(argc, argv)
- int argc;
- char **argv;
+int
+setcmd(int argc, char **argv)
{
if (argc == 1)
- return showvarscmd(argc, argv);
+ return showvars(nullstr, 0, VUNSET);
INTOFF;
options(0);
optschanged();
}
+#ifdef CONFIG_ASH_GETOPTS
static void
-getoptsreset(const char *value)
+getoptsreset(value)
+ const char *value;
{
shellparam.optind = number(value);
shellparam.optoff = -1;
}
+#endif
-#ifdef BB_LOCALE_SUPPORT
+#ifdef CONFIG_LOCALE_SUPPORT
static void change_lc_all(const char *value)
{
- if(value != 0 && *value != 0)
+ if (value != 0 && *value != 0)
setlocale(LC_ALL, value);
}
static void change_lc_ctype(const char *value)
{
- if(value != 0 && *value != 0)
+ if (value != 0 && *value != 0)
setlocale(LC_CTYPE, value);
}
#endif
-#ifdef ASH_GETOPTS
-/*
- * The getopts builtin. Shellparam.optnext points to the next argument
- * to be processed. Shellparam.optptr points to the next character to
- * be processed in the current argument. If shellparam.optnext is NULL,
- * then it's the first time getopts has been called.
- */
-
-static int
-getoptscmd(argc, argv)
- int argc;
- char **argv;
+#ifdef CONFIG_ASH_RANDOM_SUPPORT
+/* Roughly copied from bash.. */
+static void change_random(const char *value)
{
- char **optbase;
+ if(value == NULL) {
+ /* "get", generate */
+ char buf[16];
- if (argc < 3)
- error("Usage: getopts optstring var [arg]");
- else if (argc == 3) {
- optbase = shellparam.p;
- if (shellparam.optind > shellparam.nparam + 1) {
- shellparam.optind = 1;
- shellparam.optoff = -1;
- }
- }
- else {
- optbase = &argv[3];
- if (shellparam.optind > argc - 2) {
- shellparam.optind = 1;
- shellparam.optoff = -1;
- }
+ rseed = rseed * 1103515245 + 12345;
+ sprintf(buf, "%d", (unsigned int)((rseed & 32767)));
+ /* set without recursion */
+ setvar(vrandom.text, buf, VNOFUNC);
+ vrandom.flags &= ~VNOFUNC;
+ } else {
+ /* set/reset */
+ rseed = strtoul(value, (char **)NULL, 10);
}
-
- return getopts(argv[1], argv[2], optbase, &shellparam.optind,
- &shellparam.optoff);
}
-
-/*
- * Safe version of setvar, returns 1 on success 0 on failure.
- */
-
-static int
-setvarsafe(name, val, flags)
- const char *name, *val;
- int flags;
-{
- struct jmploc jmploc;
- struct jmploc *volatile savehandler = handler;
- int err = 0;
-#ifdef __GNUC__
- (void) &err;
#endif
- if (setjmp(jmploc.loc))
- err = 1;
- else {
- handler = &jmploc;
- setvar(name, val, flags);
- }
- handler = savehandler;
- return err;
-}
+#ifdef CONFIG_ASH_GETOPTS
static int
-getopts(optstr, optvar, optfirst, myoptind, optoff)
- char *optstr;
- char *optvar;
- char **optfirst;
- int *myoptind;
- int *optoff;
+getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff)
{
char *p, *q;
char c = '?';
int done = 0;
int err = 0;
- char s[10];
- char **optnext = optfirst + *myoptind - 1;
+ char s[12];
+ char **optnext;
+
+ if(*param_optind < 1)
+ return 1;
+ optnext = optfirst + *param_optind - 1;
- if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
- strlen(*(optnext - 1)) < *optoff)
+ if (*param_optind <= 1 || *optoff < 0 || strlen(optnext[-1]) < *optoff)
p = NULL;
else
- p = *(optnext - 1) + *optoff;
+ p = optnext[-1] + *optoff;
if (p == NULL || *p == '\0') {
/* Current word is done, advance */
- if (optnext == NULL)
- return 1;
p = *optnext;
if (p == NULL || *p != '-' || *++p == '\0') {
atend:
- *myoptind = optnext - optfirst + 1;
p = NULL;
done = 1;
goto out;
s[0] = c;
s[1] = '\0';
err |= setvarsafe("OPTARG", s, 0);
- }
- else {
- out2fmt("Illegal option -%c\n", c);
+ } else {
+ fprintf(stderr, "Illegal option -%c\n", c);
(void) unsetvar("OPTARG");
}
c = '?';
- goto bad;
+ goto out;
}
if (*++q == ':')
q++;
s[1] = '\0';
err |= setvarsafe("OPTARG", s, 0);
c = ':';
- }
- else {
- out2fmt("No arg for -%c option\n", c);
+ } else {
+ fprintf(stderr, "No arg for -%c option\n", c);
(void) unsetvar("OPTARG");
c = '?';
}
- goto bad;
+ goto out;
}
if (p == *optnext)
optnext++;
- setvarsafe("OPTARG", p, 0);
+ err |= setvarsafe("OPTARG", p, 0);
p = NULL;
- }
- else
- setvarsafe("OPTARG", "", 0);
- *myoptind = optnext - optfirst + 1;
- goto out;
+ } else
+ err |= setvarsafe("OPTARG", nullstr, 0);
-bad:
- *myoptind = 1;
- p = NULL;
out:
*optoff = p ? p - *(optnext - 1) : -1;
- snprintf(s, sizeof(s), "%d", *myoptind);
+ *param_optind = optnext - optfirst + 1;
+ fmtstr(s, sizeof(s), "%d", *param_optind);
err |= setvarsafe("OPTIND", s, VNOFUNC);
s[0] = c;
s[1] = '\0';
err |= setvarsafe(optvar, s, 0);
if (err) {
- *myoptind = 1;
+ *param_optind = 1;
*optoff = -1;
+ flushall();
exraise(EXERROR);
}
return done;
}
-#endif
+
+/*
+ * The getopts builtin. Shellparam.optnext points to the next argument
+ * to be processed. Shellparam.optptr points to the next character to
+ * be processed in the current argument. If shellparam.optnext is NULL,
+ * then it's the first time getopts has been called.
+ */
+
+int
+getoptscmd(int argc, char **argv)
+{
+ char **optbase;
+
+ if (argc < 3)
+ error("Usage: getopts optstring var [arg]");
+ else if (argc == 3) {
+ optbase = shellparam.p;
+ if (shellparam.optind > shellparam.nparam + 1) {
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
+ }
+ }
+ else {
+ optbase = &argv[3];
+ if (shellparam.optind > argc - 2) {
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
+ }
+ }
+
+ return getopts(argv[1], argv[2], optbase, &shellparam.optind,
+ &shellparam.optoff);
+}
+#endif /* CONFIG_ASH_GETOPTS */
/*
* XXX - should get rid of. have all builtins use getopt(3). the
return c;
}
-static void
-flushall() {
+
+/* $NetBSD: output.c,v 1.27 2002/11/24 22:35:42 christos Exp $ */
+
+void
+outstr(const char *p, FILE *file)
+{
+ INTOFF;
+ fputs(p, file);
+ INTON;
+}
+
+void
+flushall(void)
+{
INTOFF;
fflush(stdout);
+ fflush(stderr);
INTON;
}
+void
+flusherr(void)
+{
+ INTOFF;
+ fflush(stderr);
+ INTON;
+}
static void
-out2fmt(const char *fmt, ...)
+outcslow(int c, FILE *dest)
+{
+ INTOFF;
+ putc(c, dest);
+ fflush(dest);
+ INTON;
+}
+
+
+static int
+out1fmt(const char *fmt, ...)
{
va_list ap;
+ int r;
+
+ INTOFF;
va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
+ r = vprintf(fmt, ap);
va_end(ap);
+ INTON;
+ return r;
}
-/*
- * Version of write which resumes after a signal is caught.
- */
-static int
-xwrite(int fd, const char *buf, int nbytes)
+int
+fmtstr(char *outbuf, size_t length, const char *fmt, ...)
{
- int ntry;
- int i;
- int n;
+ va_list ap;
+ int ret;
- n = nbytes;
- ntry = 0;
- for (;;) {
- i = write(fd, buf, n);
- if (i > 0) {
- if ((n -= i) <= 0)
- return nbytes;
- buf += i;
- ntry = 0;
- } else if (i == 0) {
- if (++ntry > 10)
- return nbytes - n;
- } else if (errno != EINTR) {
- return -1;
- }
- }
+ va_start(ap, fmt);
+ INTOFF;
+ ret = vsnprintf(outbuf, length, fmt, ap);
+ va_end(ap);
+ INTON;
+ return ret;
}
+
+/* $NetBSD: parser.c,v 1.54 2002/11/24 22:35:42 christos Exp $ */
+
+
/*
* Shell command parser.
*/
#define EOFMARKLEN 79
-
struct heredoc {
struct heredoc *next; /* next here document in list */
union node *here; /* redirection node */
int striptabs; /* if set, strip leading tabs */
};
-static struct heredoc *heredoclist; /* list of here documents to read */
-static int parsebackquote; /* nonzero if we are inside backquotes */
-static int doprompt; /* if set, prompt the user */
-static int needprompt; /* true if interactive and at start of line */
-static int lasttoken; /* last token read */
-static char *wordtext; /* text of last word returned by readtoken */
-static struct nodelist *backquotelist;
-static union node *redirnode;
-static struct heredoc *heredoc;
-static int quoteflag; /* set if (part of) last token was quoted */
-static int startlinno; /* line # where last token started */
+static struct heredoc *heredoclist; /* list of here documents to read */
-static union node *list (int);
-static union node *andor (void);
-static union node *pipeline (void);
-static union node *command (void);
-static union node *simplecmd (void);
-static void parsefname (void);
-static void parseheredoc (void);
-static int peektoken (void);
-static int readtoken (void);
-static int xxreadtoken (void);
-static int readtoken1 (int, char const *, char *, int);
-static int noexpand (char *);
-static void synexpect (int) __attribute__((noreturn));
-static void synerror (const char *) __attribute__((noreturn));
-static void setprompt (int);
+static union node *list(int);
+static union node *andor(void);
+static union node *pipeline(void);
+static union node *command(void);
+static union node *simplecmd(void);
+static union node *makename(void);
+static void parsefname(void);
+static void parseheredoc(void);
+static char peektoken(void);
+static int readtoken(void);
+static int xxreadtoken(void);
+static int readtoken1(int firstc, int syntax, char *eofmark, int striptabs);
+static int noexpand(char *);
+static void synexpect(int) __attribute__((__noreturn__));
+static void synerror(const char *) __attribute__((__noreturn__));
+static void setprompt(int);
+
+
+
+static inline int
+isassignment(const char *p)
+{
+ const char *q = endofname(p);
+ if (p == q)
+ return 0;
+ return *q == '=';
+}
/*
* valid parse tree indicating a blank line.)
*/
-static union node *
+union node *
parsecmd(int interact)
{
int t;
tokpushback = 0;
doprompt = interact;
if (doprompt)
- setprompt(1);
- else
- setprompt(0);
+ setprompt(doprompt);
needprompt = 0;
t = readtoken();
if (t == TEOF)
static union node *
-list(nlflag)
- int nlflag;
+list(int nlflag)
{
union node *n1, *n2, *n3;
int tok;
- checkkwd = 2;
- if (nlflag == 0 && tokendlist[peektoken()])
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (nlflag == 2 && peektoken())
return NULL;
n1 = NULL;
for (;;) {
n2 = andor();
tok = readtoken();
if (tok == TBACKGND) {
- if (n2->type == NCMD || n2->type == NPIPE) {
- n2->ncmd.backgnd = 1;
- } else if (n2->type == NREDIR) {
- n2->type = NBACKGND;
+ if (n2->type == NPIPE) {
+ n2->npipe.backgnd = 1;
} else {
- n3 = (union node *)stalloc(sizeof (struct nredir));
- n3->type = NBACKGND;
- n3->nredir.n = n2;
- n3->nredir.redirect = NULL;
- n2 = n3;
+ if (n2->type != NREDIR) {
+ n3 = stalloc(sizeof(struct nredir));
+ n3->nredir.n = n2;
+ n3->nredir.redirect = NULL;
+ n2 = n3;
+ }
+ n2->type = NBACKGND;
}
}
if (n1 == NULL) {
case TNL:
if (tok == TNL) {
parseheredoc();
- if (nlflag)
+ if (nlflag == 1)
return n1;
} else {
tokpushback++;
}
- checkkwd = 2;
- if (tokendlist[peektoken()])
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (peektoken())
return n1;
break;
case TEOF:
pungetc(); /* push back EOF on input */
return n1;
default:
- if (nlflag)
+ if (nlflag == 1)
synexpect(-1);
tokpushback++;
return n1;
static union node *
-andor() {
+andor(void)
+{
union node *n1, *n2, *n3;
int t;
- checkkwd = 1;
n1 = pipeline();
for (;;) {
if ((t = readtoken()) == TAND) {
tokpushback++;
return n1;
}
- checkkwd = 2;
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
n2 = pipeline();
n3 = (union node *)stalloc(sizeof (struct nbinary));
n3->type = t;
static union node *
-pipeline() {
+pipeline(void)
+{
union node *n1, *n2, *pipenode;
struct nodelist *lp, *prev;
int negate;
TRACE(("pipeline: entered\n"));
if (readtoken() == TNOT) {
negate = !negate;
- checkkwd = 1;
+ checkkwd = CHKKWD | CHKALIAS;
} else
tokpushback++;
n1 = command();
do {
prev = lp;
lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
- checkkwd = 2;
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
lp->n = command();
prev->next = lp;
} while (readtoken() == TPIPE);
static union node *
-command() {
+command(void)
+{
union node *n1, *n2;
union node *ap, **app;
union node *cp, **cpp;
union node *redir, **rpp;
+ union node **rpp2;
int t;
redir = NULL;
- n1 = NULL;
- rpp = &redir;
+ rpp2 = &redir;
switch (readtoken()) {
+ default:
+ synexpect(-1);
+ /* NOTREACHED */
case TIF:
n1 = (union node *)stalloc(sizeof (struct nif));
n1->type = NIF;
n2->nif.elsepart = NULL;
tokpushback++;
}
- if (readtoken() != TFI)
- synexpect(TFI);
- checkkwd = 1;
+ t = TFI;
break;
case TWHILE:
case TUNTIL: {
n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
n1->nbinary.ch1 = list(0);
if ((got=readtoken()) != TDO) {
-TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
+TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
synexpect(TDO);
}
n1->nbinary.ch2 = list(0);
- if (readtoken() != TDONE)
- synexpect(TDONE);
- checkkwd = 1;
+ t = TDONE;
break;
}
case TFOR:
n1 = (union node *)stalloc(sizeof (struct nfor));
n1->type = NFOR;
n1->nfor.var = wordtext;
- checkkwd = 1;
+ checkkwd = CHKKWD | CHKALIAS;
if (readtoken() == TIN) {
app = ≈
while (readtoken() == TWORD) {
if (lasttoken != TNL && lasttoken != TSEMI)
synexpect(-1);
} else {
- static char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
- '@', '=', '\0'};
n2 = (union node *)stalloc(sizeof (struct narg));
n2->type = NARG;
- n2->narg.text = argvars;
+ n2->narg.text = (char *)dolatstr;
n2->narg.backquote = NULL;
n2->narg.next = NULL;
n1->nfor.args = n2;
if (lasttoken != TNL && lasttoken != TSEMI)
tokpushback++;
}
- checkkwd = 2;
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
if (readtoken() != TDO)
synexpect(TDO);
n1->nfor.body = list(0);
- if (readtoken() != TDONE)
- synexpect(TDONE);
- checkkwd = 1;
+ t = TDONE;
break;
case TCASE:
n1 = (union node *)stalloc(sizeof (struct ncase));
n2->narg.backquote = backquotelist;
n2->narg.next = NULL;
do {
- checkkwd = 1;
+ checkkwd = CHKKWD | CHKALIAS;
} while (readtoken() == TNL);
if (lasttoken != TIN)
- synerror("expecting \"in\"");
+ synexpect(TIN);
cpp = &n1->ncase.cases;
- checkkwd = 2, readtoken();
- do {
+next_case:
+ checkkwd = CHKNL | CHKKWD;
+ t = readtoken();
+ while(t != TESAC) {
if (lasttoken == TLP)
readtoken();
*cpp = cp = (union node *)stalloc(sizeof (struct nclist));
ap->type = NARG;
ap->narg.text = wordtext;
ap->narg.backquote = backquotelist;
- if (checkkwd = 2, readtoken() != TPIPE)
+ if (readtoken() != TPIPE)
break;
app = &ap->narg.next;
readtoken();
ap->narg.next = NULL;
if (lasttoken != TRP)
synexpect(TRP);
- cp->nclist.body = list(0);
+ cp->nclist.body = list(2);
+
+ cpp = &cp->nclist.next;
- checkkwd = 2;
+ checkkwd = CHKNL | CHKKWD;
if ((t = readtoken()) != TESAC) {
if (t != TENDCASE)
synexpect(TENDCASE);
else
- checkkwd = 2, readtoken();
+ goto next_case;
}
- cpp = &cp->nclist.next;
- } while(lasttoken != TESAC);
+ }
*cpp = NULL;
- checkkwd = 1;
- break;
+ goto redir;
case TLP:
n1 = (union node *)stalloc(sizeof (struct nredir));
n1->type = NSUBSHELL;
n1->nredir.n = list(0);
n1->nredir.redirect = NULL;
- if (readtoken() != TRP)
- synexpect(TRP);
- checkkwd = 1;
+ t = TRP;
break;
case TBEGIN:
n1 = list(0);
- if (readtoken() != TEND)
- synexpect(TEND);
- checkkwd = 1;
+ t = TEND;
break;
- /* Handle an empty command like other simple commands. */
- case TSEMI:
- case TAND:
- case TOR:
- case TNL:
- case TEOF:
- case TRP:
- case TBACKGND:
- /*
- * An empty command before a ; doesn't make much sense, and
- * should certainly be disallowed in the case of `if ;'.
- */
- if (!redir)
- synexpect(-1);
case TWORD:
case TREDIR:
tokpushback++;
- n1 = simplecmd();
- return n1;
- default:
- synexpect(-1);
- /* NOTREACHED */
+ return simplecmd();
}
+ if (readtoken() != t)
+ synexpect(t);
+
+redir:
/* Now check for redirection which may follow command */
+ checkkwd = CHKKWD | CHKALIAS;
+ rpp = rpp2;
while (readtoken() == TREDIR) {
*rpp = n2 = redirnode;
rpp = &n2->nfile.next;
static union node *
-simplecmd() {
+simplecmd(void) {
union node *args, **app;
union node *n = NULL;
union node *vars, **vpp;
union node **rpp, *redir;
+ int savecheckkwd;
args = NULL;
app = &args;
redir = NULL;
rpp = &redir;
- checkalias = 2;
+ savecheckkwd = CHKALIAS;
for (;;) {
+ checkkwd = savecheckkwd;
switch (readtoken()) {
case TWORD:
- case TASSIGN:
n = (union node *)stalloc(sizeof (struct narg));
n->type = NARG;
n->narg.text = wordtext;
n->narg.backquote = backquotelist;
- if (lasttoken == TWORD) {
- *app = n;
- app = &n->narg.next;
- } else {
+ if (savecheckkwd && isassignment(wordtext)) {
*vpp = n;
vpp = &n->narg.next;
+ } else {
+ *app = n;
+ app = &n->narg.next;
+ savecheckkwd = 0;
}
break;
case TREDIR:
args && app == &args->narg.next &&
!vars && !redir
) {
+ struct builtincmd *bcmd;
+ const char *name;
+
/* We have a function */
if (readtoken() != TRP)
synexpect(TRP);
+ name = n->narg.text;
+ if (
+ !goodname(name) || (
+ (bcmd = find_builtin(name)) &&
+ IS_BUILTIN_SPECIAL(bcmd)
+ )
+ )
+ synerror("Bad function name");
n->type = NDEFUN;
- checkkwd = 2;
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
n->narg.next = command();
return n;
}
*rpp = NULL;
n = (union node *)stalloc(sizeof (struct ncmd));
n->type = NCMD;
- n->ncmd.backgnd = 0;
n->ncmd.args = args;
n->ncmd.assign = vars;
n->ncmd.redirect = redir;
}
static union node *
-makename(void) {
+makename(void)
+{
union node *n;
n = (union node *)stalloc(sizeof (struct narg));
return n;
}
-static void fixredir(union node *n, const char *text, int err)
+void fixredir(union node *n, const char *text, int err)
{
TRACE(("Fix redir %s %d\n", text, err));
if (!err)
static void
-parsefname(void) {
+parsefname(void)
+{
union node *n = redirnode;
if (readtoken() != TWORD)
if (quoteflag == 0)
n->type = NXHERE;
TRACE(("Here document %d\n", n->type));
- if (here->striptabs) {
- while (*wordtext == '\t')
- wordtext++;
- }
if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
synerror("Illegal eof marker for << redirection");
rmescapes(wordtext);
*/
static void
-parseheredoc() {
+parseheredoc(void)
+{
struct heredoc *here;
union node *n;
- while (heredoclist) {
- here = heredoclist;
- heredoclist = here->next;
+ here = heredoclist;
+ heredoclist = 0;
+
+ while (here) {
if (needprompt) {
setprompt(2);
needprompt = 0;
n->narg.text = wordtext;
n->narg.backquote = backquotelist;
here->here->nhere.doc = n;
+ here = here->next;
}
}
-static int
-peektoken() {
+static char peektoken(void)
+{
int t;
t = readtoken();
tokpushback++;
- return (t);
+ return tokname_array[t][0];
}
static int
-readtoken() {
+readtoken(void)
+{
int t;
-
-#ifdef ASH_ALIAS
- int savecheckalias = checkalias;
- int savecheckkwd = checkkwd;
- struct alias *ap;
-#endif
-
#ifdef DEBUG
int alreadyseen = tokpushback;
#endif
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
top:
#endif
t = xxreadtoken();
-#ifdef ASH_ALIAS
- checkalias = savecheckalias;
-#endif
-
- if (checkkwd) {
- /*
- * eat newlines
- */
- if (checkkwd == 2) {
- checkkwd = 0;
- while (t == TNL) {
- parseheredoc();
- t = xxreadtoken();
- }
+ /*
+ * eat newlines
+ */
+ if (checkkwd & CHKNL) {
+ while (t == TNL) {
+ parseheredoc();
+ t = xxreadtoken();
}
- checkkwd = 0;
- /*
- * check for keywords
- */
- if (t == TWORD && !quoteflag)
- {
- const char *const *pp;
+ }
- if ((pp = findkwd(wordtext))) {
- lasttoken = t = pp - parsekwd + KWDOFFSET;
- TRACE(("keyword %s recognized\n", tokname[t]));
- goto out;
- }
- }
+ if (t != TWORD || quoteflag) {
+ goto out;
}
+ /*
+ * check for keywords
+ */
+ if (checkkwd & CHKKWD) {
+ const char *const *pp;
- if (t != TWORD) {
- if (t != TREDIR) {
- checkalias = 0;
+ if ((pp = findkwd(wordtext))) {
+ lasttoken = t = pp - tokname_array;
+ TRACE(("keyword %s recognized\n", tokname(t)));
+ goto out;
}
- } else if (checkalias == 2 && isassignment(wordtext)) {
- lasttoken = t = TASSIGN;
-#ifdef ASH_ALIAS
- } else if (checkalias) {
- if (!quoteflag && (ap = lookupalias(wordtext, 1)) != NULL) {
- if (*ap->val) {
- pushstring(ap->val, strlen(ap->val), ap);
+ }
+
+ if (checkkwd & CHKALIAS) {
+#ifdef CONFIG_ASH_ALIAS
+ struct alias *ap;
+ if ((ap = lookupalias(wordtext, 1)) != NULL) {
+ if (*ap->val) {
+ pushstring(ap->val, ap);
}
- checkkwd = savecheckkwd;
goto top;
}
- checkalias = 0;
#endif
}
out:
+ checkkwd = 0;
#ifdef DEBUG
if (!alreadyseen)
- TRACE(("token %s %s\n", tokname[t], t == TWORD || t == TASSIGN ? wordtext : ""));
+ TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
else
- TRACE(("reread token %s %s\n", tokname[t], t == TWORD || t == TASSIGN ? wordtext : ""));
+ TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
#endif
return (t);
}
* have parseword (readtoken1?) handle both words and redirection.]
*/
+#define NEW_xxreadtoken
+#ifdef NEW_xxreadtoken
+
+/* singles must be first! */
+static const char xxreadtoken_chars[7] = { '\n', '(', ')', '&', '|', ';', 0 };
+
+static const char xxreadtoken_tokens[] = {
+ TNL, TLP, TRP, /* only single occurrence allowed */
+ TBACKGND, TPIPE, TSEMI, /* if single occurrence */
+ TEOF, /* corresponds to trailing nul */
+ TAND, TOR, TENDCASE, /* if double occurrence */
+};
+
+#define xxreadtoken_doubles \
+ (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
+#define xxreadtoken_singles \
+ (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
+
+static int xxreadtoken()
+{
+ int c;
+
+ if (tokpushback) {
+ tokpushback = 0;
+ return lasttoken;
+ }
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+ startlinno = plinno;
+ for (;;) { /* until token or start of word found */
+ c = pgetc_macro();
+
+ if ((c != ' ') && (c != '\t')
+#ifdef CONFIG_ASH_ALIAS
+ && (c != PEOA)
+#endif
+ ) {
+ if (c == '#') {
+ while ((c = pgetc()) != '\n' && c != PEOF);
+ pungetc();
+ } else if (c == '\\') {
+ if (pgetc() != '\n') {
+ pungetc();
+ goto READTOKEN1;
+ }
+ startlinno = ++plinno;
+ if (doprompt)
+ setprompt(2);
+ } else {
+ const char *p
+ = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
+
+ if (c != PEOF) {
+ if (c == '\n') {
+ plinno++;
+ needprompt = doprompt;
+ }
+
+ p = strchr(xxreadtoken_chars, c);
+ if (p == NULL) {
+ READTOKEN1:
+ return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
+ }
+
+ if (p - xxreadtoken_chars >= xxreadtoken_singles) {
+ if (pgetc() == *p) { /* double occurrence? */
+ p += xxreadtoken_doubles + 1;
+ } else {
+ pungetc();
+ }
+ }
+ }
+
+ return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
+ }
+ }
+ }
+}
+
+
+#else
#define RETURN(token) return lasttoken = token
static int
-xxreadtoken() {
+xxreadtoken(void)
+{
int c;
if (tokpushback) {
c = pgetc_macro();
switch (c) {
case ' ': case '\t':
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
case PEOA:
#endif
continue;
startlinno = ++plinno;
if (doprompt)
setprompt(2);
- else
- setprompt(0);
continue;
}
pungetc();
return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
#undef RETURN
}
-
+#endif /* NEW_xxreadtoken */
/*
#define PARSEARITH() {goto parsearith; parsearith_return:;}
static int
-readtoken1(firstc, syntax, eofmark, striptabs)
- int firstc;
- char const *syntax;
- char *eofmark;
- int striptabs;
- {
+readtoken1(int firstc, int syntax, char *eofmark, int striptabs)
+{
int c = firstc;
char *out;
int len;
int parenlevel; /* levels of parens in arithmetic */
int dqvarnest; /* levels of variables expansion within double quotes */
int oldstyle;
- char const *prevsyntax; /* syntax before arithmetic */
+ int prevsyntax; /* syntax before arithmetic */
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &out;
loop: { /* for each line, until end of word */
CHECKEND(); /* set c to PEOF if at end of here document */
for (;;) { /* until end of line or end of word */
- CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
- switch(syntax[c]) {
+ CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
+ switch(SIT(c, syntax)) {
case CNL: /* '\n' */
if (syntax == BASESYNTAX)
goto endword; /* exit outer loop */
plinno++;
if (doprompt)
setprompt(2);
- else
- setprompt(0);
c = pgetc();
goto loop; /* continue outer loop */
case CWORD:
USTPUTC(c, out);
break;
case CCTL:
- if ((eofmark == NULL || dblquote) &&
- dqvarnest == 0)
+ if (eofmark == NULL || dblquote)
USTPUTC(CTLESC, out);
USTPUTC(c, out);
break;
case CBACK: /* backslash */
c = pgetc2();
if (c == PEOF) {
+ USTPUTC(CTLESC, out);
USTPUTC('\\', out);
pungetc();
} else if (c == '\n') {
if (doprompt)
setprompt(2);
- else
- setprompt(0);
} else {
- if (dblquote && c != '\\' && c != '`' && c != '$'
- && (c != '"' || eofmark != NULL))
+ if (
+ dblquote &&
+ c != '\\' && c != '`' &&
+ c != '$' && (
+ c != '"' ||
+ eofmark != NULL
+ )
+ ) {
+ USTPUTC(CTLESC, out);
USTPUTC('\\', out);
- if (SQSYNTAX[c] == CCTL)
+ }
+ if (SIT(c, SQSYNTAX) == CCTL)
USTPUTC(CTLESC, out);
- else if (eofmark == NULL)
- USTPUTC(CTLQUOTEMARK, out);
USTPUTC(c, out);
quotef++;
}
break;
case CSQUOTE:
- if (eofmark == NULL)
- USTPUTC(CTLQUOTEMARK, out);
syntax = SQSYNTAX;
+quotemark:
+ if (eofmark == NULL) {
+ USTPUTC(CTLQUOTEMARK, out);
+ }
break;
case CDQUOTE:
- if (eofmark == NULL)
- USTPUTC(CTLQUOTEMARK, out);
syntax = DQSYNTAX;
dblquote = 1;
- break;
+ goto quotemark;
case CENDQUOTE:
if (eofmark != NULL && arinest == 0 &&
varnest == 0) {
USTPUTC(c, out);
} else {
- if (arinest) {
- syntax = ARISYNTAX;
- dblquote = 0;
- } else if (eofmark == NULL &&
- dqvarnest == 0) {
+ if (dqvarnest == 0) {
syntax = BASESYNTAX;
dblquote = 0;
}
quotef++;
+ goto quotemark;
}
break;
case CVAR: /* '$' */
USTPUTC(c, out);
}
break;
-#ifdef ASH_MATH_SUPPORT
+#ifdef CONFIG_ASH_MATH_SUPPORT
case CLP: /* '(' in arithmetic */
parenlevel++;
USTPUTC(c, out);
default:
if (varnest == 0)
goto endword; /* exit outer loop */
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
if (c != PEOA)
#endif
USTPUTC(c, out);
}
}
endword:
+#ifdef CONFIG_ASH_MATH_SUPPORT
if (syntax == ARISYNTAX)
synerror("Missing '))'");
+#endif
if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
synerror("Unterminated quoted string");
if (varnest != 0) {
startlinno = plinno;
+ /* { */
synerror("Missing '}'");
}
USTPUTC('\0', out);
- len = out - stackblock();
+ len = out - (char *)stackblock();
out = stackblock();
if (eofmark == NULL) {
if ((c == '>' || c == '<')
checkend: {
if (eofmark) {
-#ifdef ASH_ALIAS
+#ifdef CONFIG_ASH_ALIAS
if (c == PEOA) {
c = pgetc2();
}
plinno++;
needprompt = doprompt;
} else {
- pushstring(line, strlen(line), NULL);
+ pushstring(line, NULL);
+ }
+ }
+ }
+ }
+ goto checkend_return;
+}
+
+
+/*
+ * Parse a redirection operator. The variable "out" points to a string
+ * specifying the fd to be redirected. The variable "c" contains the
+ * first character of the redirection operator.
+ */
+
+parseredir: {
+ char fd = *out;
+ union node *np;
+
+ np = (union node *)stalloc(sizeof (struct nfile));
+ if (c == '>') {
+ np->nfile.fd = 1;
+ c = pgetc();
+ if (c == '>')
+ np->type = NAPPEND;
+ else if (c == '|')
+ np->type = NCLOBBER;
+ else if (c == '&')
+ np->type = NTOFD;
+ else {
+ np->type = NTO;
+ pungetc();
+ }
+ } else { /* c == '<' */
+ np->nfile.fd = 0;
+ switch (c = pgetc()) {
+ case '<':
+ if (sizeof (struct nfile) != sizeof (struct nhere)) {
+ np = (union node *)stalloc(sizeof (struct nhere));
+ np->nfile.fd = 0;
+ }
+ np->type = NHERE;
+ heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
+ heredoc->here = np;
+ if ((c = pgetc()) == '-') {
+ heredoc->striptabs = 1;
+ } else {
+ heredoc->striptabs = 0;
+ pungetc();
+ }
+ break;
+
+ case '&':
+ np->type = NFROMFD;
+ break;
+
+ case '>':
+ np->type = NFROMTO;
+ break;
+
+ default:
+ np->type = NFROM;
+ pungetc();
+ break;
+ }
+ }
+ if (fd != '\0')
+ np->nfile.fd = digit_val(fd);
+ redirnode = np;
+ goto parseredir_return;
+}
+
+
+/*
+ * Parse a substitution. At this point, we have read the dollar sign
+ * and nothing else.
+ */
+
+parsesub: {
+ int subtype;
+ int typeloc;
+ int flags;
+ char *p;
+ static const char types[] = "}-+?=";
+
+ c = pgetc();
+ if (
+ c <= PEOA_OR_PEOF ||
+ (c != '(' && c != '{' && !is_name(c) && !is_special(c))
+ ) {
+ USTPUTC('$', out);
+ pungetc();
+ } else if (c == '(') { /* $(command) or $((arith)) */
+ if (pgetc() == '(') {
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ PARSEARITH();
+#else
+ synerror("We unsupport $((arith))");
+#endif
+ } else {
+ pungetc();
+ PARSEBACKQNEW();
+ }
+ } else {
+ USTPUTC(CTLVAR, out);
+ typeloc = out - (char *)stackblock();
+ USTPUTC(VSNORMAL, out);
+ subtype = VSNORMAL;
+ if (c == '{') {
+ c = pgetc();
+ if (c == '#') {
+ if ((c = pgetc()) == '}')
+ c = '#';
+ else
+ subtype = VSLENGTH;
+ }
+ else
+ subtype = 0;
+ }
+ if (c > PEOA_OR_PEOF && is_name(c)) {
+ do {
+ STPUTC(c, out);
+ c = pgetc();
+ } while (c > PEOA_OR_PEOF && is_in_name(c));
+ } else if (is_digit(c)) {
+ do {
+ STPUTC(c, out);
+ c = pgetc();
+ } while (is_digit(c));
+ }
+ else if (is_special(c)) {
+ USTPUTC(c, out);
+ c = pgetc();
+ }
+ else
+badsub: synerror("Bad substitution");
+
+ STPUTC('=', out);
+ flags = 0;
+ if (subtype == 0) {
+ switch (c) {
+ case ':':
+ flags = VSNUL;
+ c = pgetc();
+ /*FALLTHROUGH*/
+ default:
+ p = strchr(types, c);
+ if (p == NULL)
+ goto badsub;
+ subtype = p - types + VSNORMAL;
+ break;
+ case '%':
+ case '#':
+ {
+ int cc = c;
+ subtype = c == '#' ? VSTRIMLEFT :
+ VSTRIMRIGHT;
+ c = pgetc();
+ if (c == cc)
+ subtype++;
+ else
+ pungetc();
+ break;
}
}
+ } else {
+ pungetc();
+ }
+ if (dblquote || arinest)
+ flags |= VSQUOTE;
+ *((char *)stackblock() + typeloc) = subtype | flags;
+ if (subtype != VSNORMAL) {
+ varnest++;
+ if (dblquote || arinest) {
+ dqvarnest++;
+ }
+ }
+ }
+ goto parsesub_return;
+}
+
+
+/*
+ * Called to parse command substitutions. Newstyle is set if the command
+ * is enclosed inside $(...); nlpp is a pointer to the head of the linked
+ * list of commands (passed by reference), and savelen is the number of
+ * characters on the top of the stack which must be preserved.
+ */
+
+parsebackq: {
+ struct nodelist **nlpp;
+ int savepbq;
+ union node *n;
+ char *volatile str;
+ struct jmploc jmploc;
+ struct jmploc *volatile savehandler;
+ size_t savelen;
+ int saveprompt;
+#ifdef __GNUC__
+ (void) &saveprompt;
+#endif
+
+ savepbq = parsebackquote;
+ if (setjmp(jmploc.loc)) {
+ if (str)
+ ckfree(str);
+ parsebackquote = 0;
+ handler = savehandler;
+ longjmp(handler->loc, 1);
+ }
+ INTOFF;
+ str = NULL;
+ savelen = out - (char *)stackblock();
+ if (savelen > 0) {
+ str = ckmalloc(savelen);
+ memcpy(str, stackblock(), savelen);
+ }
+ savehandler = handler;
+ handler = &jmploc;
+ INTON;
+ if (oldstyle) {
+ /* We must read until the closing backquote, giving special
+ treatment to some slashes, and then push the string and
+ reread it as input, interpreting it normally. */
+ char *pout;
+ int pc;
+ size_t psavelen;
+ char *pstr;
+
+
+ STARTSTACKSTR(pout);
+ for (;;) {
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+ switch (pc = pgetc()) {
+ case '`':
+ goto done;
+
+ case '\\':
+ if ((pc = pgetc()) == '\n') {
+ plinno++;
+ if (doprompt)
+ setprompt(2);
+ /*
+ * If eating a newline, avoid putting
+ * the newline into the new character
+ * stream (via the STPUTC after the
+ * switch).
+ */
+ continue;
+ }
+ if (pc != '\\' && pc != '`' && pc != '$'
+ && (!dblquote || pc != '"'))
+ STPUTC('\\', pout);
+ if (pc > PEOA_OR_PEOF) {
+ break;
+ }
+ /* fall through */
+
+ case PEOF:
+#ifdef CONFIG_ASH_ALIAS
+ case PEOA:
+#endif
+ startlinno = plinno;
+ synerror("EOF in backquote substitution");
+
+ case '\n':
+ plinno++;
+ needprompt = doprompt;
+ break;
+
+ default:
+ break;
+ }
+ STPUTC(pc, pout);
+ }
+done:
+ STPUTC('\0', pout);
+ psavelen = pout - (char *)stackblock();
+ if (psavelen > 0) {
+ pstr = grabstackstr(pout);
+ setinputstring(pstr);
+ }
+ }
+ nlpp = &bqlist;
+ while (*nlpp)
+ nlpp = &(*nlpp)->next;
+ *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+ (*nlpp)->next = NULL;
+ parsebackquote = oldstyle;
+
+ if (oldstyle) {
+ saveprompt = doprompt;
+ doprompt = 0;
+ }
+
+ n = list(2);
+
+ if (oldstyle)
+ doprompt = saveprompt;
+ else {
+ if (readtoken() != TRP)
+ synexpect(TRP);
+ }
+
+ (*nlpp)->n = n;
+ if (oldstyle) {
+ /*
+ * Start reading from old file again, ignoring any pushed back
+ * tokens left from the backquote parsing
+ */
+ popfile();
+ tokpushback = 0;
+ }
+ while (stackblocksize() <= savelen)
+ growstackblock();
+ STARTSTACKSTR(out);
+ if (str) {
+ memcpy(out, str, savelen);
+ STADJUST(savelen, out);
+ INTOFF;
+ ckfree(str);
+ str = NULL;
+ INTON;
+ }
+ parsebackquote = savepbq;
+ handler = savehandler;
+ if (arinest || dblquote)
+ USTPUTC(CTLBACKQ | CTLQUOTE, out);
+ else
+ USTPUTC(CTLBACKQ, out);
+ if (oldstyle)
+ goto parsebackq_oldreturn;
+ else
+ goto parsebackq_newreturn;
+}
+
+#ifdef CONFIG_ASH_MATH_SUPPORT
+/*
+ * Parse an arithmetic expansion (indicate start of one and set state)
+ */
+parsearith: {
+
+ if (++arinest == 1) {
+ prevsyntax = syntax;
+ syntax = ARISYNTAX;
+ USTPUTC(CTLARI, out);
+ if (dblquote)
+ USTPUTC('"',out);
+ else
+ USTPUTC(' ',out);
+ } else {
+ /*
+ * we collapse embedded arithmetic expansion to
+ * parenthesis, which should be equivalent
+ */
+ USTPUTC('(', out);
+ }
+ goto parsearith_return;
+}
+#endif
+
+} /* end of readtoken */
+
+
+
+/*
+ * Returns true if the text contains nothing to expand (no dollar signs
+ * or backquotes).
+ */
+
+static int
+noexpand(char *text)
+{
+ char *p;
+ char c;
+
+ p = text;
+ while ((c = *p++) != '\0') {
+ if (c == CTLQUOTEMARK)
+ continue;
+ if (c == CTLESC)
+ p++;
+ else if (SIT(c, BASESYNTAX) == CCTL)
+ return 0;
+ }
+ return 1;
+}
+
+
+/*
+ * Return of a legal variable name (a letter or underscore followed by zero or
+ * more letters, underscores, and digits).
+ */
+
+static char *
+endofname(const char *name)
+{
+ char *p;
+
+ p = (char *) name;
+ if (! is_name(*p))
+ return p;
+ while (*++p) {
+ if (! is_in_name(*p))
+ break;
+ }
+ return p;
+}
+
+
+/*
+ * Called when an unexpected token is read during the parse. The argument
+ * is the token that is expected, or -1 if more than one type of token can
+ * occur at this point.
+ */
+
+static void synexpect(int token)
+{
+ char msg[64];
+ int l;
+
+ l = sprintf(msg, "%s unexpected", tokname(lasttoken));
+ if (token >= 0)
+ sprintf(msg + l, " (expecting %s)", tokname(token));
+ synerror(msg);
+ /* NOTREACHED */
+}
+
+static void
+synerror(const char *msg)
+{
+ error("Syntax error: %s", msg);
+ /* NOTREACHED */
+}
+
+
+/*
+ * called by editline -- any expansions to the prompt
+ * should be added here.
+ */
+
+static void setprompt(int whichprompt)
+{
+ const char *prompt;
+
+ switch (whichprompt) {
+ case 1:
+ prompt = ps1val();
+ break;
+ case 2:
+ prompt = ps2val();
+ break;
+ default: /* 0 */
+ prompt = nullstr;
+ }
+ putprompt(prompt);
+}
+
+
+static const char *const *findkwd(const char *s)
+{
+ return bsearch(s, tokname_array + KWDOFFSET,
+ (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
+ sizeof(const char *), pstrcmp);
+}
+
+/* $NetBSD: redir.c,v 1.27 2002/11/24 22:35:42 christos Exp $ */
+
+/*
+ * Code for dealing with input/output redirection.
+ */
+
+#define EMPTY -2 /* marks an unused slot in redirtab */
+#ifndef PIPE_BUF
+# define PIPESIZE 4096 /* amount of buffering in a pipe */
+#else
+# define PIPESIZE PIPE_BUF
+#endif
+
+/*
+ * Open a file in noclobber mode.
+ * The code was copied from bash.
+ */
+static inline int
+noclobberopen(const char *fname)
+{
+ int r, fd;
+ struct stat finfo, finfo2;
+
+ /*
+ * If the file exists and is a regular file, return an error
+ * immediately.
+ */
+ r = stat(fname, &finfo);
+ if (r == 0 && S_ISREG(finfo.st_mode)) {
+ errno = EEXIST;
+ return -1;
+ }
+
+ /*
+ * If the file was not present (r != 0), make sure we open it
+ * exclusively so that if it is created before we open it, our open
+ * will fail. Make sure that we do not truncate an existing file.
+ * Note that we don't turn on O_EXCL unless the stat failed -- if the
+ * file was not a regular file, we leave O_EXCL off.
+ */
+ if (r != 0)
+ return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
+ fd = open(fname, O_WRONLY|O_CREAT, 0666);
+
+ /* If the open failed, return the file descriptor right away. */
+ if (fd < 0)
+ return fd;
+
+ /*
+ * OK, the open succeeded, but the file may have been changed from a
+ * non-regular file to a regular file between the stat and the open.
+ * We are assuming that the O_EXCL open handles the case where FILENAME
+ * did not exist and is symlinked to an existing file between the stat
+ * and open.
+ */
+
+ /*
+ * If we can open it and fstat the file descriptor, and neither check
+ * revealed that it was a regular file, and the file has not been
+ * replaced, return the file descriptor.
+ */
+ if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
+ finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
+ return fd;
+
+ /* The file has been replaced. badness. */
+ close(fd);
+ errno = EEXIST;
+ return -1;
+}
+
+/*
+ * Handle here documents. Normally we fork off a process to write the
+ * data to a pipe. If the document is short, we can stuff the data in
+ * the pipe without forking.
+ */
+
+static inline int
+openhere(union node *redir)
+{
+ int pip[2];
+ size_t len = 0;
+
+ if (pipe(pip) < 0)
+ error("Pipe call failed");
+ if (redir->type == NHERE) {
+ len = strlen(redir->nhere.doc->narg.text);
+ if (len <= PIPESIZE) {
+ bb_full_write(pip[1], redir->nhere.doc->narg.text, len);
+ goto out;
+ }
+ }
+ if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
+ close(pip[0]);
+ signal(SIGINT, SIG_IGN);
+ signal(SIGQUIT, SIG_IGN);
+ signal(SIGHUP, SIG_IGN);
+#ifdef SIGTSTP
+ signal(SIGTSTP, SIG_IGN);
+#endif
+ signal(SIGPIPE, SIG_DFL);
+ if (redir->type == NHERE)
+ bb_full_write(pip[1], redir->nhere.doc->narg.text, len);
+ else
+ expandhere(redir->nhere.doc, pip[1]);
+ _exit(0);
+ }
+out:
+ close(pip[1]);
+ return pip[0];
+}
+
+static int
+openredirect(union node *redir)
+{
+ char *fname;
+ int f;
+
+ switch (redir->nfile.type) {
+ case NFROM:
+ fname = redir->nfile.expfname;
+ if ((f = open(fname, O_RDONLY)) < 0)
+ goto eopen;
+ break;
+ case NFROMTO:
+ fname = redir->nfile.expfname;
+ if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
+ goto ecreate;
+ break;
+ case NTO:
+ /* Take care of noclobber mode. */
+ if (Cflag) {
+ fname = redir->nfile.expfname;
+ if ((f = noclobberopen(fname)) < 0)
+ goto ecreate;
+ break;
+ }
+ /* FALLTHROUGH */
+ case NCLOBBER:
+ fname = redir->nfile.expfname;
+ if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
+ goto ecreate;
+ break;
+ case NAPPEND:
+ fname = redir->nfile.expfname;
+ if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
+ goto ecreate;
+ break;
+ default:
+#ifdef DEBUG
+ abort();
+#endif
+ /* Fall through to eliminate warning. */
+ case NTOFD:
+ case NFROMFD:
+ f = -1;
+ break;
+ case NHERE:
+ case NXHERE:
+ f = openhere(redir);
+ break;
+ }
+
+ return f;
+ecreate:
+ error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
+eopen:
+ error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
+}
+
+static inline void
+dupredirect(union node *redir, int f)
+{
+ int fd = redir->nfile.fd;
+
+ if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
+ if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
+ copyfd(redir->ndup.dupfd, fd);
+ }
+ return;
+ }
+
+ if (f != fd) {
+ copyfd(f, fd);
+ close(f);
+ }
+ return;
+}
+
+/*
+ * Process a list of redirection commands. If the REDIR_PUSH flag is set,
+ * old file descriptors are stashed away so that the redirection can be
+ * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
+ * standard output, and the standard error if it becomes a duplicate of
+ * stdout, is saved in memory.
+ */
+
+static void
+redirect(union node *redir, int flags)
+{
+ union node *n;
+ struct redirtab *sv;
+ int i;
+ int fd;
+ int newfd;
+ int *p;
+ nullredirs++;
+ if (!redir) {
+ return;
+ }
+ sv = NULL;
+ INTOFF;
+ if (flags & REDIR_PUSH) {
+ struct redirtab *q;
+ q = ckmalloc(sizeof (struct redirtab));
+ q->next = redirlist;
+ redirlist = q;
+ q->nullredirs = nullredirs - 1;
+ for (i = 0 ; i < 10 ; i++)
+ q->renamed[i] = EMPTY;
+ nullredirs = 0;
+ sv = q;
+ }
+ n = redir;
+ do {
+ fd = n->nfile.fd;
+ if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
+ n->ndup.dupfd == fd)
+ continue; /* redirect from/to same file descriptor */
+
+ newfd = openredirect(n);
+ if (fd == newfd)
+ continue;
+ if (sv && *(p = &sv->renamed[fd]) == EMPTY) {
+ i = fcntl(fd, F_DUPFD, 10);
+
+ if (i == -1) {
+ i = errno;
+ if (i != EBADF) {
+ close(newfd);
+ errno = i;
+ error("%d: %m", fd);
+ /* NOTREACHED */
+ }
+ } else {
+ *p = i;
+ close(fd);
+ }
+ } else {
+ close(fd);
+ }
+ dupredirect(n, newfd);
+ } while ((n = n->nfile.next));
+ INTON;
+ if (flags & REDIR_SAVEFD2 && sv && sv->renamed[2] >= 0)
+ preverrout_fd = sv->renamed[2];
+}
+
+
+/*
+ * Undo the effects of the last redirection.
+ */
+
+void
+popredir(int drop)
+{
+ struct redirtab *rp;
+ int i;
+
+ if (--nullredirs >= 0)
+ return;
+ INTOFF;
+ rp = redirlist;
+ for (i = 0 ; i < 10 ; i++) {
+ if (rp->renamed[i] != EMPTY) {
+ if (!drop) {
+ close(i);
+ copyfd(rp->renamed[i], i);
+ }
+ close(rp->renamed[i]);
+ }
+ }
+ redirlist = rp->next;
+ nullredirs = rp->nullredirs;
+ ckfree(rp);
+ INTON;
+}
+
+/*
+ * Undo all redirections. Called on error or interrupt.
+ */
+
+/*
+ * Discard all saved file descriptors.
+ */
+
+void
+clearredir(int drop)
+{
+ for (;;) {
+ nullredirs = 0;
+ if (!redirlist)
+ break;
+ popredir(drop);
+ }
+}
+
+
+/*
+ * Copy a file descriptor to be >= to. Returns -1
+ * if the source file descriptor is closed, EMPTY if there are no unused
+ * file descriptors left.
+ */
+
+int
+copyfd(int from, int to)
+{
+ int newfd;
+
+ newfd = fcntl(from, F_DUPFD, to);
+ if (newfd < 0) {
+ if (errno == EMFILE)
+ return EMPTY;
+ else
+ error("%d: %m", from);
+ }
+ return newfd;
+}
+
+
+int
+redirectsafe(union node *redir, int flags)
+{
+ int err;
+ volatile int saveint;
+ struct jmploc *volatile savehandler = handler;
+ struct jmploc jmploc;
+
+ SAVEINT(saveint);
+ if (!(err = setjmp(jmploc.loc) * 2)) {
+ handler = &jmploc;
+ redirect(redir, flags);
+ }
+ handler = savehandler;
+ if (err && exception != EXERROR)
+ longjmp(handler->loc, 1);
+ RESTOREINT(saveint);
+ return err;
+}
+
+/* $NetBSD: show.c,v 1.24 2003/01/22 20:36:04 dsl Exp $ */
+
+#ifdef DEBUG
+static void shtree(union node *, int, char *, FILE*);
+static void shcmd(union node *, FILE *);
+static void sharg(union node *, FILE *);
+static void indent(int, char *, FILE *);
+static void trstring(char *);
+
+
+void
+showtree(union node *n)
+{
+ trputs("showtree called\n");
+ shtree(n, 1, NULL, stdout);
+}
+
+
+static void
+shtree(union node *n, int ind, char *pfx, FILE *fp)
+{
+ struct nodelist *lp;
+ const char *s;
+
+ if (n == NULL)
+ return;
+
+ indent(ind, pfx, fp);
+ switch(n->type) {
+ case NSEMI:
+ s = "; ";
+ goto binop;
+ case NAND:
+ s = " && ";
+ goto binop;
+ case NOR:
+ s = " || ";
+binop:
+ shtree(n->nbinary.ch1, ind, NULL, fp);
+ /* if (ind < 0) */
+ fputs(s, fp);
+ shtree(n->nbinary.ch2, ind, NULL, fp);
+ break;
+ case NCMD:
+ shcmd(n, fp);
+ if (ind >= 0)
+ putc('\n', fp);
+ break;
+ case NPIPE:
+ for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+ shcmd(lp->n, fp);
+ if (lp->next)
+ fputs(" | ", fp);
}
+ if (n->npipe.backgnd)
+ fputs(" &", fp);
+ if (ind >= 0)
+ putc('\n', fp);
+ break;
+ default:
+ fprintf(fp, "<node type %d>", n->type);
+ if (ind >= 0)
+ putc('\n', fp);
+ break;
}
- goto checkend_return;
}
-/*
- * Parse a redirection operator. The variable "out" points to a string
- * specifying the fd to be redirected. The variable "c" contains the
- * first character of the redirection operator.
- */
-
-parseredir: {
- char fd = *out;
+static void
+shcmd(union node *cmd, FILE *fp)
+{
union node *np;
+ int first;
+ const char *s;
+ int dftfd;
- np = (union node *)stalloc(sizeof (struct nfile));
- if (c == '>') {
- np->nfile.fd = 1;
- c = pgetc();
- if (c == '>')
- np->type = NAPPEND;
- else if (c == '&')
- np->type = NTOFD;
- else if (c == '|')
- np->type = NTOOV;
- else {
- np->type = NTO;
- pungetc();
+ first = 1;
+ for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
+ if (! first)
+ putchar(' ');
+ sharg(np, fp);
+ first = 0;
+ }
+ for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
+ if (! first)
+ putchar(' ');
+ switch (np->nfile.type) {
+ case NTO: s = ">"; dftfd = 1; break;
+ case NCLOBBER: s = ">|"; dftfd = 1; break;
+ case NAPPEND: s = ">>"; dftfd = 1; break;
+ case NTOFD: s = ">&"; dftfd = 1; break;
+ case NFROM: s = "<"; dftfd = 0; break;
+ case NFROMFD: s = "<&"; dftfd = 0; break;
+ case NFROMTO: s = "<>"; dftfd = 0; break;
+ default: s = "*error*"; dftfd = 0; break;
}
- } else { /* c == '<' */
- np->nfile.fd = 0;
- switch (c = pgetc()) {
- case '<':
- if (sizeof (struct nfile) != sizeof (struct nhere)) {
- np = (union node *)stalloc(sizeof (struct nhere));
- np->nfile.fd = 0;
- }
- np->type = NHERE;
- heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
- heredoc->here = np;
- if ((c = pgetc()) == '-') {
- heredoc->striptabs = 1;
- } else {
- heredoc->striptabs = 0;
- pungetc();
- }
- break;
-
- case '&':
- np->type = NFROMFD;
- break;
-
- case '>':
- np->type = NFROMTO;
- break;
-
- default:
- np->type = NFROM;
- pungetc();
- break;
+ if (np->nfile.fd != dftfd)
+ fprintf(fp, "%d", np->nfile.fd);
+ fputs(s, fp);
+ if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
+ fprintf(fp, "%d", np->ndup.dupfd);
+ } else {
+ sharg(np->nfile.fname, fp);
}
+ first = 0;
}
- if (fd != '\0')
- np->nfile.fd = digit_val(fd);
- redirnode = np;
- goto parseredir_return;
}
-/*
- * Parse a substitution. At this point, we have read the dollar sign
- * and nothing else.
- */
-parsesub: {
- int subtype;
- int typeloc;
- int flags;
+static void
+sharg(union node *arg, FILE *fp)
+{
char *p;
- static const char types[] = "}-+?=";
+ struct nodelist *bqlist;
+ int subtype;
- c = pgetc();
- if (
- c <= PEOA ||
- (c != '(' && c != '{' && !is_name(c) && !is_special(c))
- ) {
- USTPUTC('$', out);
- pungetc();
- } else if (c == '(') { /* $(command) or $((arith)) */
- if (pgetc() == '(') {
- PARSEARITH();
- } else {
- pungetc();
- PARSEBACKQNEW();
- }
- } else {
- USTPUTC(CTLVAR, out);
- typeloc = out - stackblock();
- USTPUTC(VSNORMAL, out);
- subtype = VSNORMAL;
- if (c == '{') {
- c = pgetc();
- if (c == '#') {
- if ((c = pgetc()) == '}')
- c = '#';
- else
- subtype = VSLENGTH;
- }
- else
- subtype = 0;
- }
- if (c > PEOA && is_name(c)) {
- do {
- STPUTC(c, out);
- c = pgetc();
- } while (c > PEOA && is_in_name(c));
- } else if (is_digit(c)) {
- do {
- USTPUTC(c, out);
- c = pgetc();
- } while (is_digit(c));
- }
- else if (is_special(c)) {
- USTPUTC(c, out);
- c = pgetc();
- }
- else
-badsub: synerror("Bad substitution");
+ if (arg->type != NARG) {
+ out1fmt("<node type %d>\n", arg->type);
+ abort();
+ }
+ bqlist = arg->narg.backquote;
+ for (p = arg->narg.text ; *p ; p++) {
+ switch (*p) {
+ case CTLESC:
+ putc(*++p, fp);
+ break;
+ case CTLVAR:
+ putc('$', fp);
+ putc('{', fp);
+ subtype = *++p;
+ if (subtype == VSLENGTH)
+ putc('#', fp);
- STPUTC('=', out);
- flags = 0;
- if (subtype == 0) {
- switch (c) {
- case ':':
- flags = VSNUL;
- c = pgetc();
- /*FALLTHROUGH*/
- default:
- p = strchr(types, c);
- if (p == NULL)
- goto badsub;
- subtype = p - types + VSNORMAL;
+ while (*p != '=')
+ putc(*p++, fp);
+
+ if (subtype & VSNUL)
+ putc(':', fp);
+
+ switch (subtype & VSTYPE) {
+ case VSNORMAL:
+ putc('}', fp);
break;
- case '%':
- case '#':
- {
- int cc = c;
- subtype = c == '#' ? VSTRIMLEFT :
- VSTRIMRIGHT;
- c = pgetc();
- if (c == cc)
- subtype++;
- else
- pungetc();
- break;
- }
- }
- } else {
- pungetc();
- }
- if (dblquote || arinest)
- flags |= VSQUOTE;
- *(stackblock() + typeloc) = subtype | flags;
- if (subtype != VSNORMAL) {
- varnest++;
- if (dblquote) {
- dqvarnest++;
+ case VSMINUS:
+ putc('-', fp);
+ break;
+ case VSPLUS:
+ putc('+', fp);
+ break;
+ case VSQUESTION:
+ putc('?', fp);
+ break;
+ case VSASSIGN:
+ putc('=', fp);
+ break;
+ case VSTRIMLEFT:
+ putc('#', fp);
+ break;
+ case VSTRIMLEFTMAX:
+ putc('#', fp);
+ putc('#', fp);
+ break;
+ case VSTRIMRIGHT:
+ putc('%', fp);
+ break;
+ case VSTRIMRIGHTMAX:
+ putc('%', fp);
+ putc('%', fp);
+ break;
+ case VSLENGTH:
+ break;
+ default:
+ out1fmt("<subtype %d>", subtype);
}
+ break;
+ case CTLENDVAR:
+ putc('}', fp);
+ break;
+ case CTLBACKQ:
+ case CTLBACKQ|CTLQUOTE:
+ putc('$', fp);
+ putc('(', fp);
+ shtree(bqlist->n, -1, NULL, fp);
+ putc(')', fp);
+ break;
+ default:
+ putc(*p, fp);
+ break;
}
}
- goto parsesub_return;
}
-/*
- * Called to parse command substitutions. Newstyle is set if the command
- * is enclosed inside $(...); nlpp is a pointer to the head of the linked
- * list of commands (passed by reference), and savelen is the number of
- * characters on the top of the stack which must be preserved.
- */
-
-parsebackq: {
- struct nodelist **nlpp;
- int savepbq;
- union node *n;
- char *volatile str;
- struct jmploc jmploc;
- struct jmploc *volatile savehandler;
- int savelen;
- int saveprompt;
-#ifdef __GNUC__
- (void) &saveprompt;
-#endif
+static void
+indent(int amount, char *pfx, FILE *fp)
+{
+ int i;
- savepbq = parsebackquote;
- if (setjmp(jmploc.loc)) {
- if (str)
- ckfree(str);
- parsebackquote = 0;
- handler = savehandler;
- longjmp(handler->loc, 1);
- }
- INTOFF;
- str = NULL;
- savelen = out - stackblock();
- if (savelen > 0) {
- str = ckmalloc(savelen);
- memcpy(str, stackblock(), savelen);
+ for (i = 0 ; i < amount ; i++) {
+ if (pfx && i == amount - 1)
+ fputs(pfx, fp);
+ putc('\t', fp);
}
- savehandler = handler;
- handler = &jmploc;
- INTON;
- if (oldstyle) {
- /* We must read until the closing backquote, giving special
- treatment to some slashes, and then push the string and
- reread it as input, interpreting it normally. */
- char *pout;
- int pc;
- int psavelen;
- char *pstr;
-
+}
- STARTSTACKSTR(pout);
- for (;;) {
- if (needprompt) {
- setprompt(2);
- needprompt = 0;
- }
- switch (pc = pgetc()) {
- case '`':
- goto done;
- case '\\':
- if ((pc = pgetc()) == '\n') {
- plinno++;
- if (doprompt)
- setprompt(2);
- else
- setprompt(0);
- /*
- * If eating a newline, avoid putting
- * the newline into the new character
- * stream (via the STPUTC after the
- * switch).
- */
- continue;
- }
- if (pc != '\\' && pc != '`' && pc != '$'
- && (!dblquote || pc != '"'))
- STPUTC('\\', pout);
- if (pc > PEOA) {
- break;
- }
- /* fall through */
- case PEOF:
-#ifdef ASH_ALIAS
- case PEOA:
-#endif
- startlinno = plinno;
- synerror("EOF in backquote substitution");
+/*
+ * Debugging stuff.
+ */
- case '\n':
- plinno++;
- needprompt = doprompt;
- break;
- default:
- break;
- }
- STPUTC(pc, pout);
- }
-done:
- STPUTC('\0', pout);
- psavelen = pout - stackblock();
- if (psavelen > 0) {
- pstr = grabstackstr(pout);
- setinputstring(pstr);
- }
- }
- nlpp = &bqlist;
- while (*nlpp)
- nlpp = &(*nlpp)->next;
- *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
- (*nlpp)->next = NULL;
- parsebackquote = oldstyle;
+FILE *tracefile;
- if (oldstyle) {
- saveprompt = doprompt;
- doprompt = 0;
- }
- n = list(0);
+void
+trputc(int c)
+{
+ if (debug != 1)
+ return;
+ putc(c, tracefile);
+}
- if (oldstyle)
- doprompt = saveprompt;
- else {
- if (readtoken() != TRP)
- synexpect(TRP);
- }
+void
+trace(const char *fmt, ...)
+{
+ va_list va;
- (*nlpp)->n = n;
- if (oldstyle) {
- /*
- * Start reading from old file again, ignoring any pushed back
- * tokens left from the backquote parsing
- */
- popfile();
- tokpushback = 0;
- }
- while (stackblocksize() <= savelen)
- growstackblock();
- STARTSTACKSTR(out);
- if (str) {
- memcpy(out, str, savelen);
- STADJUST(savelen, out);
- INTOFF;
- ckfree(str);
- str = NULL;
- INTON;
- }
- parsebackquote = savepbq;
- handler = savehandler;
- if (arinest || dblquote)
- USTPUTC(CTLBACKQ | CTLQUOTE, out);
- else
- USTPUTC(CTLBACKQ, out);
- if (oldstyle)
- goto parsebackq_oldreturn;
- else
- goto parsebackq_newreturn;
+ if (debug != 1)
+ return;
+ va_start(va, fmt);
+ (void) vfprintf(tracefile, fmt, va);
+ va_end(va);
}
-/*
- * Parse an arithmetic expansion (indicate start of one and set state)
- */
-parsearith: {
-
- if (++arinest == 1) {
- prevsyntax = syntax;
- syntax = ARISYNTAX;
- USTPUTC(CTLARI, out);
- if (dblquote)
- USTPUTC('"',out);
- else
- USTPUTC(' ',out);
- } else {
- /*
- * we collapse embedded arithmetic expansion to
- * parenthesis, which should be equivalent
- */
- USTPUTC('(', out);
- }
- goto parsearith_return;
+void
+tracev(const char *fmt, va_list va)
+{
+ if (debug != 1)
+ return;
+ (void) vfprintf(tracefile, fmt, va);
}
-} /* end of readtoken */
+void
+trputs(const char *s)
+{
+ if (debug != 1)
+ return;
+ fputs(s, tracefile);
+}
-/*
- * Returns true if the text contains nothing to expand (no dollar signs
- * or backquotes).
- */
-static int
-noexpand(text)
- char *text;
- {
+static void
+trstring(char *s)
+{
char *p;
char c;
- p = text;
- while ((c = *p++) != '\0') {
- if (c == CTLQUOTEMARK)
- continue;
- if (c == CTLESC)
- p++;
- else if (BASESYNTAX[(int)c] == CCTL)
- return 0;
+ if (debug != 1)
+ return;
+ putc('"', tracefile);
+ for (p = s ; *p ; p++) {
+ switch (*p) {
+ case '\n': c = 'n'; goto backslash;
+ case '\t': c = 't'; goto backslash;
+ case '\r': c = 'r'; goto backslash;
+ case '"': c = '"'; goto backslash;
+ case '\\': c = '\\'; goto backslash;
+ case CTLESC: c = 'e'; goto backslash;
+ case CTLVAR: c = 'v'; goto backslash;
+ case CTLVAR+CTLQUOTE: c = 'V'; goto backslash;
+ case CTLBACKQ: c = 'q'; goto backslash;
+ case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash;
+backslash: putc('\\', tracefile);
+ putc(c, tracefile);
+ break;
+ default:
+ if (*p >= ' ' && *p <= '~')
+ putc(*p, tracefile);
+ else {
+ putc('\\', tracefile);
+ putc(*p >> 6 & 03, tracefile);
+ putc(*p >> 3 & 07, tracefile);
+ putc(*p & 07, tracefile);
+ }
+ break;
+ }
}
- return 1;
+ putc('"', tracefile);
}
-/*
- * Return true if the argument is a legal variable name (a letter or
- * underscore followed by zero or more letters, underscores, and digits).
- */
-
-static int
-goodname(const char *name)
+void
+trargs(char **ap)
{
- const char *p;
-
- p = name;
- if (! is_name(*p))
- return 0;
- while (*++p) {
- if (! is_in_name(*p))
- return 0;
+ if (debug != 1)
+ return;
+ while (*ap) {
+ trstring(*ap++);
+ if (*ap)
+ putc(' ', tracefile);
+ else
+ putc('\n', tracefile);
}
- return 1;
}
-/*
- * Called when an unexpected token is read during the parse. The argument
- * is the token that is expected, or -1 if more than one type of token can
- * occur at this point.
- */
-
-static void
-synexpect(token)
- int token;
+void
+opentrace(void)
{
- char msg[64];
+ char s[100];
+#ifdef O_APPEND
+ int flags;
+#endif
- if (token >= 0) {
- snprintf(msg, 64, "%s unexpected (expecting %s)",
- tokname[lasttoken], tokname[token]);
+ if (debug != 1) {
+ if (tracefile)
+ fflush(tracefile);
+ /* leave open because libedit might be using it */
+ return;
+ }
+ scopy("./trace", s);
+ if (tracefile) {
+ if (!freopen(s, "a", tracefile)) {
+ fprintf(stderr, "Can't re-open %s\n", s);
+ debug = 0;
+ return;
+ }
} else {
- snprintf(msg, 64, "%s unexpected", tokname[lasttoken]);
+ if ((tracefile = fopen(s, "a")) == NULL) {
+ fprintf(stderr, "Can't open %s\n", s);
+ debug = 0;
+ return;
+ }
}
- synerror(msg);
- /* NOTREACHED */
+#ifdef O_APPEND
+ if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
+ fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
+#endif
+ setlinebuf(tracefile);
+ fputs("\nTracing started.\n", tracefile);
}
+#endif /* DEBUG */
-static void
-synerror(const char *msg)
-{
- if (commandname)
- out2fmt("%s: %d: ", commandname, startlinno);
- out2fmt("Syntax error: %s\n", msg);
- error((char *)NULL);
- /* NOTREACHED */
-}
-
+/* $NetBSD: trap.c,v 1.28 2002/11/24 22:35:43 christos Exp $ */
/*
- * called by editline -- any expansions to the prompt
- * should be added here.
+ * Sigmode records the current value of the signal handlers for the various
+ * modes. A value of zero means that the current handler is not known.
+ * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
*/
-static void
-setprompt(int whichprompt)
-{
- char *prompt;
- switch (whichprompt) {
- case 1:
- prompt = ps1val();
- break;
- case 2:
- prompt = ps2val();
- break;
- default: /* 0 */
- prompt = "";
- }
- putprompt(prompt);
-}
-
-/*
- * Code for dealing with input/output redirection.
- */
+#define S_DFL 1 /* default signal handling (SIG_DFL) */
+#define S_CATCH 2 /* signal is caught */
+#define S_IGN 3 /* signal is ignored (SIG_IGN) */
+#define S_HARD_IGN 4 /* signal is ignored permenantly */
+#define S_RESET 5 /* temporary - to reset a hard ignored sig */
-#define EMPTY -2 /* marks an unused slot in redirtab */
-#ifndef PIPE_BUF
-# define PIPESIZE 4096 /* amount of buffering in a pipe */
-#else
-# define PIPESIZE PIPE_BUF
-#endif
/*
- * Open a file in noclobber mode.
- * The code was copied from bash.
+ * The trap builtin.
*/
-static inline int
-noclobberopen(const char *fname)
-{
- int r, fd;
- struct stat finfo, finfo2;
-
- /*
- * If the file exists and is a regular file, return an error
- * immediately.
- */
- r = stat(fname, &finfo);
- if (r == 0 && S_ISREG(finfo.st_mode)) {
- errno = EEXIST;
- return -1;
- }
-
- /*
- * If the file was not present (r != 0), make sure we open it
- * exclusively so that if it is created before we open it, our open
- * will fail. Make sure that we do not truncate an existing file.
- * Note that we don't turn on O_EXCL unless the stat failed -- if the
- * file was not a regular file, we leave O_EXCL off.
- */
- if (r != 0)
- return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
- fd = open(fname, O_WRONLY|O_CREAT, 0666);
-
- /* If the open failed, return the file descriptor right away. */
- if (fd < 0)
- return fd;
- /*
- * OK, the open succeeded, but the file may have been changed from a
- * non-regular file to a regular file between the stat and the open.
- * We are assuming that the O_EXCL open handles the case where FILENAME
- * did not exist and is symlinked to an existing file between the stat
- * and open.
- */
+int
+trapcmd(int argc, char **argv)
+{
+ char *action;
+ char **ap;
+ int signo;
- /*
- * If we can open it and fstat the file descriptor, and neither check
- * revealed that it was a regular file, and the file has not been
- * replaced, return the file descriptor.
- */
- if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
- finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
- return fd;
+ nextopt(nullstr);
+ ap = argptr;
+ if (!*ap) {
+ for (signo = 0 ; signo < NSIG ; signo++) {
+ if (trap[signo] != NULL) {
+ const char *sn;
- /* The file has been replaced. badness. */
- close(fd);
- errno = EEXIST;
- return -1;
+ sn = u_signal_names(0, &signo, 0);
+ if (sn == NULL)
+ sn = "???";
+ out1fmt("trap -- %s %s\n",
+ single_quote(trap[signo]), sn);
+ }
+ }
+ return 0;
+ }
+ if (!ap[1])
+ action = NULL;
+ else
+ action = *ap++;
+ while (*ap) {
+ if ((signo = decode_signal(*ap, 0)) < 0)
+ error("%s: bad trap", *ap);
+ INTOFF;
+ if (action) {
+ if (action[0] == '-' && action[1] == '\0')
+ action = NULL;
+ else
+ action = savestr(action);
+ }
+ if (trap[signo])
+ ckfree(trap[signo]);
+ trap[signo] = action;
+ if (signo != 0)
+ setsignal(signo);
+ INTON;
+ ap++;
+ }
+ return 0;
}
+
/*
- * Handle here documents. Normally we fork off a process to write the
- * data to a pipe. If the document is short, we can stuff the data in
- * the pipe without forking.
+ * Clear traps on a fork.
*/
-static inline int
-openhere(const union node *redir)
+void
+clear_traps(void)
{
- int pip[2];
- int len = 0;
+ char **tp;
- if (pipe(pip) < 0)
- error("Pipe call failed");
- if (redir->type == NHERE) {
- len = strlen(redir->nhere.doc->narg.text);
- if (len <= PIPESIZE) {
- xwrite(pip[1], redir->nhere.doc->narg.text, len);
- goto out;
+ for (tp = trap ; tp < &trap[NSIG] ; tp++) {
+ if (*tp && **tp) { /* trap not NULL or SIG_IGN */
+ INTOFF;
+ ckfree(*tp);
+ *tp = NULL;
+ if (tp != &trap[0])
+ setsignal(tp - trap);
+ INTON;
}
}
- if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
- close(pip[0]);
- signal(SIGINT, SIG_IGN);
- signal(SIGQUIT, SIG_IGN);
- signal(SIGHUP, SIG_IGN);
-#ifdef SIGTSTP
- signal(SIGTSTP, SIG_IGN);
-#endif
- signal(SIGPIPE, SIG_DFL);
- if (redir->type == NHERE)
- xwrite(pip[1], redir->nhere.doc->narg.text, len);
- else
- expandhere(redir->nhere.doc, pip[1]);
- _exit(0);
- }
-out:
- close(pip[1]);
- return pip[0];
}
-static inline int
-openredirect(const union node *redir)
+/*
+ * Set the signal handler for the specified signal. The routine figures
+ * out what it should be set to.
+ */
+
+void
+setsignal(int signo)
{
- char *fname;
- int f;
+ int action;
+ char *t, tsig;
+ struct sigaction act;
- switch (redir->nfile.type) {
- case NFROM:
- fname = redir->nfile.expfname;
- if ((f = open(fname, O_RDONLY)) < 0)
- goto eopen;
- break;
- case NFROMTO:
- fname = redir->nfile.expfname;
- if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
- goto ecreate;
- break;
- case NTO:
- /* Take care of noclobber mode. */
- if (Cflag) {
- fname = redir->nfile.expfname;
- if ((f = noclobberopen(fname)) < 0)
- goto ecreate;
+ if ((t = trap[signo]) == NULL)
+ action = S_DFL;
+ else if (*t != '\0')
+ action = S_CATCH;
+ else
+ action = S_IGN;
+ if (rootshell && action == S_DFL) {
+ switch (signo) {
+ case SIGINT:
+ if (iflag || minusc || sflag == 0)
+ action = S_CATCH;
break;
+ case SIGQUIT:
+#ifdef DEBUG
+ if (debug)
+ break;
+#endif
+ /* FALLTHROUGH */
+ case SIGTERM:
+ if (iflag)
+ action = S_IGN;
+ break;
+#if JOBS
+ case SIGTSTP:
+ case SIGTTOU:
+ if (mflag)
+ action = S_IGN;
+ break;
+#endif
+ }
+ }
+
+ t = &sigmode[signo - 1];
+ tsig = *t;
+ if (tsig == 0) {
+ /*
+ * current setting unknown
+ */
+ if (sigaction(signo, 0, &act) == -1) {
+ /*
+ * Pretend it worked; maybe we should give a warning
+ * here, but other shells don't. We don't alter
+ * sigmode, so that we retry every time.
+ */
+ return;
+ }
+ if (act.sa_handler == SIG_IGN) {
+ if (mflag && (signo == SIGTSTP ||
+ signo == SIGTTIN || signo == SIGTTOU)) {
+ tsig = S_IGN; /* don't hard ignore these */
+ } else
+ tsig = S_HARD_IGN;
+ } else {
+ tsig = S_RESET; /* force to be set */
}
- case NTOOV:
- fname = redir->nfile.expfname;
-#ifdef O_CREAT
- if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
- goto ecreate;
-#else
- if ((f = creat(fname, 0666)) < 0)
- goto ecreate;
-#endif
+ }
+ if (tsig == S_HARD_IGN || tsig == action)
+ return;
+ switch (action) {
+ case S_CATCH:
+ act.sa_handler = onsig;
break;
- case NAPPEND:
- fname = redir->nfile.expfname;
-#ifdef O_APPEND
- if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
- goto ecreate;
-#else
- if ((f = open(fname, O_WRONLY)) < 0
- && (f = creat(fname, 0666)) < 0)
- goto ecreate;
- lseek(f, (off_t)0, 2);
-#endif
+ case S_IGN:
+ act.sa_handler = SIG_IGN;
break;
default:
-#ifdef DEBUG
- abort();
-#endif
- /* Fall through to eliminate warning. */
- case NTOFD:
- case NFROMFD:
- f = -1;
- break;
- case NHERE:
- case NXHERE:
- f = openhere(redir);
- break;
+ act.sa_handler = SIG_DFL;
}
+ *t = action;
+ act.sa_flags = 0;
+ sigfillset(&act.sa_mask);
+ sigaction(signo, &act, 0);
+}
- return f;
-ecreate:
- error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
-eopen:
- error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
+/*
+ * Ignore a signal.
+ */
+
+void
+ignoresig(int signo)
+{
+ if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
+ signal(signo, SIG_IGN);
+ }
+ sigmode[signo - 1] = S_HARD_IGN;
}
/*
- * Process a list of redirection commands. If the REDIR_PUSH flag is set,
- * old file descriptors are stashed away so that the redirection can be
- * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
- * standard output, and the standard error if it becomes a duplicate of
- * stdout.
+ * Signal handler.
*/
-static void
-redirect(union node *redir, int flags)
+void
+onsig(int signo)
{
- union node *n;
- struct redirtab *sv = NULL;
- int i;
- int fd;
- int newfd;
- int try;
- int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
-
- if (flags & REDIR_PUSH) {
- sv = ckmalloc(sizeof (struct redirtab));
- for (i = 0 ; i < 10 ; i++)
- sv->renamed[i] = EMPTY;
- sv->next = redirlist;
- redirlist = sv;
- }
- for (n = redir ; n ; n = n->nfile.next) {
- fd = n->nfile.fd;
- try = 0;
- if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
- n->ndup.dupfd == fd)
- continue; /* redirect from/to same file descriptor */
+ gotsig[signo - 1] = 1;
+ pendingsigs = signo;
- INTOFF;
- newfd = openredirect(n);
- if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
- if (newfd == fd) {
- try++;
- } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
- switch (errno) {
- case EBADF:
- if (!try) {
- dupredirect(n, newfd, fd1dup);
- try++;
- break;
- }
- /* FALLTHROUGH*/
- default:
- if (newfd >= 0) {
- close(newfd);
- }
- INTON;
- error("%d: %m", fd);
- /* NOTREACHED */
- }
- }
- if (!try) {
- close(fd);
- if (flags & REDIR_PUSH) {
- sv->renamed[fd] = i;
- }
- }
- } else if (fd != newfd) {
- close(fd);
- }
- if (fd == 0)
- fd0_redirected++;
- if (!try)
- dupredirect(n, newfd, fd1dup);
- INTON;
+ if (exsig || (signo == SIGINT && !trap[SIGINT])) {
+ if (!suppressint)
+ onint();
+ intpending = 1;
}
}
-static void
-dupredirect(const union node *redir, int f, int fd1dup)
-{
- int fd = redir->nfile.fd;
+/*
+ * Called to execute a trap. Perhaps we should avoid entering new trap
+ * handlers while we are executing a trap handler.
+ */
- if(fd==1)
- fd1dup = 0;
- if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
- if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
- if (redir->ndup.dupfd!=1 || fd1dup!=1)
- dup_as_newfd(redir->ndup.dupfd, fd);
- }
- return;
- }
+void
+dotrap(void)
+{
+ char *p;
+ char *q;
+ int savestatus;
- if (f != fd) {
- dup_as_newfd(f, fd);
- close(f);
+ savestatus = exitstatus;
+ q = gotsig;
+ while (pendingsigs = 0, xbarrier(), (p = memchr(q, 1, NSIG - 1))) {
+ *p = 0;
+ p = trap[p - q + 1];
+ if (!p)
+ continue;
+ evalstring(p);
+ exitstatus = savestatus;
}
- return;
}
-
/*
- * Undo the effects of the last redirection.
+ * Controls whether the shell is interactive or not.
*/
-static void
-popredir(void)
+void
+setinteractive(int on)
{
- struct redirtab *rp = redirlist;
- int i;
+ static int is_interactive;
- INTOFF;
- for (i = 0 ; i < 10 ; i++) {
- if (rp->renamed[i] != EMPTY) {
- if (i == 0)
- fd0_redirected--;
- close(i);
- if (rp->renamed[i] >= 0) {
- dup_as_newfd(rp->renamed[i], i);
- close(rp->renamed[i]);
+ if (++on == is_interactive)
+ return;
+ is_interactive = on;
+ setsignal(SIGINT);
+ setsignal(SIGQUIT);
+ setsignal(SIGTERM);
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+ if(is_interactive > 1) {
+ /* Looks like they want an interactive shell */
+ static int do_banner;
+
+ if(!do_banner) {
+ out1fmt(
+ "\n\n" BB_BANNER " Built-in shell (ash)\n"
+ "Enter 'help' for a list of built-in commands.\n\n");
+ do_banner++;
+ }
+ }
+#endif
+}
+
+
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+/*** List the available builtins ***/
+
+static int helpcmd(int argc, char **argv)
+{
+ int col, i;
+
+ out1fmt("\nBuilt-in commands:\n-------------------\n");
+ for (col = 0, i = 0; i < NUMBUILTINS; i++) {
+ col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
+ builtincmd[i].name + 1);
+ if (col > 60) {
+ out1fmt("\n");
+ col = 0;
+ }
+ }
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ {
+ extern const struct BB_applet applets[];
+ extern const size_t NUM_APPLETS;
+
+ for (i = 0; i < NUM_APPLETS; i++) {
+
+ col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
+ if (col > 60) {
+ out1fmt("\n");
+ col = 0;
}
}
}
- redirlist = rp->next;
- ckfree(rp);
- INTON;
+#endif
+ out1fmt("\n\n");
+ return EXIT_SUCCESS;
}
+#endif /* CONFIG_FEATURE_SH_EXTRA_QUIET */
/*
- * Discard all saved file descriptors.
+ * Called to exit the shell.
*/
-static void
-clearredir(void) {
- struct redirtab *rp;
- int i;
+void
+exitshell(void)
+{
+ struct jmploc loc;
+ char *p;
+ int status;
+ int jmp;
- for (rp = redirlist ; rp ; rp = rp->next) {
- for (i = 0 ; i < 10 ; i++) {
- if (rp->renamed[i] >= 0) {
- close(rp->renamed[i]);
- }
- rp->renamed[i] = EMPTY;
- }
+ jmp = setjmp(loc.loc);
+ status = exitstatus;
+ TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
+ if (jmp)
+ goto out;
+ handler = &loc;
+ if ((p = trap[0]) != NULL && *p != '\0') {
+ trap[0] = NULL;
+ evalstring(p);
+ }
+ flushall();
+ setjobctl(0);
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+ if (iflag && rootshell) {
+ const char *hp = lookupvar("HISTFILE");
+
+ if(hp != NULL )
+ save_history ( hp );
}
+#endif
+out:
+ _exit(status);
+ /* NOTREACHED */
}
+static int decode_signal(const char *string, int minsig)
+{
+ int signo;
+ const char *name = u_signal_names(string, &signo, minsig);
+
+ return name ? signo : -1;
+}
+
+/* $NetBSD: var.c,v 1.32 2003/01/22 20:36:04 dsl Exp $ */
+
+static struct var *vartab[VTABSIZE];
+
+static int vpcmp(const void *, const void *);
+static struct var **findvar(struct var **, const char *);
/*
- * Copy a file descriptor to be >= to. Returns -1
- * if the source file descriptor is closed, EMPTY if there are no unused
- * file descriptors left.
+ * Initialize the variable symbol tables and import the environment
*/
-static int
-dup_as_newfd(from, to)
- int from;
- int to;
+
+#ifdef CONFIG_ASH_GETOPTS
+/*
+ * Safe version of setvar, returns 1 on success 0 on failure.
+ */
+
+int
+setvarsafe(const char *name, const char *val, int flags)
{
- int newfd;
+ int err;
+ volatile int saveint;
+ struct jmploc *volatile savehandler = handler;
+ struct jmploc jmploc;
- newfd = fcntl(from, F_DUPFD, to);
- if (newfd < 0) {
- if (errno == EMFILE)
- return EMPTY;
- else
- error("%d: %m", from);
+ SAVEINT(saveint);
+ if (setjmp(jmploc.loc))
+ err = 1;
+ else {
+ handler = &jmploc;
+ setvar(name, val, flags);
+ err = 0;
}
- return newfd;
+ handler = savehandler;
+ RESTOREINT(saveint);
+ return err;
}
-
-/*#ifdef __weak_alias
-__weak_alias(getmode,_getmode)
-__weak_alias(setmode,_setmode)
-#endif*/
-
-#ifndef S_ISTXT
-#if defined(__GLIBC__) && __GLIBC__ >= 2
-#define S_ISTXT __S_ISVTX
-#else
-#define S_ISTXT S_ISVTX
-#endif
#endif
-#define SET_LEN 6 /* initial # of bitcmd struct to malloc */
-#define SET_LEN_INCR 4 /* # of bitcmd structs to add as needed */
+/*
+ * Set the value of a variable. The flags argument is ored with the
+ * flags of the variable. If val is NULL, the variable is unset.
+ */
-typedef struct bitcmd {
- char cmd;
- char cmd2;
- mode_t bits;
-} BITCMD;
+static void
+setvar(const char *name, const char *val, int flags)
+{
+ char *p, *q;
+ size_t namelen;
+ char *nameeq;
+ size_t vallen;
-#define CMD2_CLR 0x01
-#define CMD2_SET 0x02
-#define CMD2_GBITS 0x04
-#define CMD2_OBITS 0x08
-#define CMD2_UBITS 0x10
+ q = endofname(name);
+ p = strchrnul(q, '=');
+ namelen = p - name;
+ if (!namelen || p != q)
+ error("%.*s: bad variable name", namelen, name);
+ vallen = 0;
+ if (val == NULL) {
+ flags |= VUNSET;
+ } else {
+ vallen = strlen(val);
+ }
+ INTOFF;
+ p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen);
+ *p++ = '\0';
+ if (vallen) {
+ p[-1] = '=';
+ p = mempcpy(p, val, vallen);
+ }
+ *p = '\0';
+ setvareq(nameeq, flags | VNOSAVE);
+ INTON;
+}
-static BITCMD *addcmd (BITCMD *, int, int, int, u_int);
-static void compress_mode (BITCMD *);
-#ifdef SETMODE_DEBUG
-static void dumpmode (BITCMD *);
-#endif
/*
- * Given the old mode and an array of bitcmd structures, apply the operations
- * described in the bitcmd structures to the old mode, and return the new mode.
- * Note that there is no '=' command; a strict assignment is just a '-' (clear
- * bits) followed by a '+' (set bits).
+ * Same as setvar except that the variable and value are passed in
+ * the first argument as name=value. Since the first argument will
+ * be actually stored in the table, it should not be a string that
+ * will go away.
+ * Called with interrupts off.
*/
-static mode_t
-getmode(bbox, omode)
- const void *bbox;
- mode_t omode;
+
+void
+setvareq(char *s, int flags)
{
- const BITCMD *set;
- mode_t clrval, newmode, value;
+ struct var *vp, **vpp;
- _DIAGASSERT(bbox != NULL);
+ vpp = hashvar(s);
+ flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
+ vp = *findvar(vpp, s);
+ if (vp) {
+ if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) {
+ const char *n;
- set = (const BITCMD *)bbox;
- newmode = omode;
- for (value = 0;; set++)
- switch(set->cmd) {
- /*
- * When copying the user, group or other bits around, we "know"
- * where the bits are in the mode so that we can do shifts to
- * copy them around. If we don't use shifts, it gets real
- * grundgy with lots of single bit checks and bit sets.
- */
- case 'u':
- value = (newmode & S_IRWXU) >> 6;
- goto common;
-
- case 'g':
- value = (newmode & S_IRWXG) >> 3;
- goto common;
-
- case 'o':
- value = newmode & S_IRWXO;
-common: if (set->cmd2 & CMD2_CLR) {
- clrval =
- (set->cmd2 & CMD2_SET) ? S_IRWXO : value;
- if (set->cmd2 & CMD2_UBITS)
- newmode &= ~((clrval<<6) & set->bits);
- if (set->cmd2 & CMD2_GBITS)
- newmode &= ~((clrval<<3) & set->bits);
- if (set->cmd2 & CMD2_OBITS)
- newmode &= ~(clrval & set->bits);
- }
- if (set->cmd2 & CMD2_SET) {
- if (set->cmd2 & CMD2_UBITS)
- newmode |= (value<<6) & set->bits;
- if (set->cmd2 & CMD2_GBITS)
- newmode |= (value<<3) & set->bits;
- if (set->cmd2 & CMD2_OBITS)
- newmode |= value & set->bits;
- }
- break;
+ if (flags & VNOSAVE)
+ free(s);
+ n = vp->text;
+ error("%.*s: is read only", strchrnul(n, '=') - n, n);
+ }
- case '+':
- newmode |= set->bits;
- break;
+ if (flags & VNOSET)
+ return;
- case '-':
- newmode &= ~set->bits;
- break;
+ if (vp->func && (flags & VNOFUNC) == 0)
+ (*vp->func)(strchrnul(s, '=') + 1);
- case 'X':
- if (omode & (S_IFDIR|S_IXUSR|S_IXGRP|S_IXOTH))
- newmode |= set->bits;
- break;
+ if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
+ ckfree(vp->text);
- case '\0':
- default:
-#ifdef SETMODE_DEBUG
- (void)printf("getmode:%04o -> %04o\n", omode, newmode);
-#endif
- return (newmode);
- }
+ flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
+ } else {
+ if (flags & VNOSET)
+ return;
+ /* not found */
+ vp = ckmalloc(sizeof (*vp));
+ vp->next = *vpp;
+ vp->func = NULL;
+ *vpp = vp;
+ }
+ if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
+ s = savestr(s);
+ vp->text = s;
+ vp->flags = flags;
}
-#define ADDCMD(a, b, c, d) do { \
- if (set >= endset) { \
- BITCMD *newset; \
- setlen += SET_LEN_INCR; \
- newset = realloc(saveset, sizeof(BITCMD) * setlen); \
- if (newset == NULL) { \
- free(saveset); \
- return (NULL); \
- } \
- set = newset + (set - saveset); \
- saveset = newset; \
- endset = newset + (setlen - 2); \
- } \
- set = addcmd(set, (a), (b), (c), (d)); \
-} while (/*CONSTCOND*/0)
-#define STANDARD_BITS (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
+/*
+ * Process a linked list of variable assignments.
+ */
-static void *
-setmode(p)
- const char *p;
+static void
+listsetvar(struct strlist *list_set_var, int flags)
{
- int perm, who;
- char op, *ep;
- BITCMD *set, *saveset, *endset;
- sigset_t mysigset, sigoset;
- mode_t mask;
- int equalopdone = 0; /* pacify gcc */
- int permXbits, setlen;
+ struct strlist *lp = list_set_var;
- if (!*p)
- return (NULL);
+ if (!lp)
+ return;
+ INTOFF;
+ do {
+ setvareq(lp->text, flags);
+ } while ((lp = lp->next));
+ INTON;
+}
- /*
- * Get a copy of the mask for the permissions that are mask relative.
- * Flip the bits, we want what's not set. Since it's possible that
- * the caller is opening files inside a signal handler, protect them
- * as best we can.
- */
- sigfillset(&mysigset);
- (void)sigprocmask(SIG_BLOCK, &mysigset, &sigoset);
- (void)umask(mask = umask(0));
- mask = ~mask;
- (void)sigprocmask(SIG_SETMASK, &sigoset, NULL);
- setlen = SET_LEN + 2;
+/*
+ * Find the value of a variable. Returns NULL if not set.
+ */
- if ((set = malloc((u_int)(sizeof(BITCMD) * setlen))) == NULL)
- return (NULL);
- saveset = set;
- endset = set + (setlen - 2);
+static char *
+lookupvar(const char *name)
+{
+ struct var *v;
+ if ((v = *findvar(hashvar(name), name))) {
+#ifdef DYNAMIC_VAR
/*
- * If an absolute number, get it and return; disallow non-octal digits
- * or illegal bits.
+ * Dynamic variables are implemented roughly the same way they are
+ * in bash. Namely, they're "special" so long as they aren't unset.
+ * As soon as they're unset, they're no longer dynamic, and dynamic
+ * lookup will no longer happen at that point. -- PFM.
*/
- if (is_digit((unsigned char)*p)) {
- perm = (mode_t)strtol(p, &ep, 8);
- if (*ep || perm & ~(STANDARD_BITS|S_ISTXT)) {
- free(saveset);
- return (NULL);
- }
- ADDCMD('=', (STANDARD_BITS|S_ISTXT), perm, mask);
- set->cmd = 0;
- return (saveset);
+ if((v->flags & VDYNAMIC))
+ (*v->func)(NULL);
+#endif
+ if(!(v->flags & VUNSET))
+ return strchrnul(v->text, '=') + 1;
}
- /*
- * Build list of structures to set/clear/copy bits as described by
- * each clause of the symbolic mode.
- */
- for (;;) {
- /* First, find out which bits might be modified. */
- for (who = 0;; ++p) {
- switch (*p) {
- case 'a':
- who |= STANDARD_BITS;
- break;
- case 'u':
- who |= S_ISUID|S_IRWXU;
- break;
- case 'g':
- who |= S_ISGID|S_IRWXG;
- break;
- case 'o':
- who |= S_IRWXO;
- break;
- default:
- goto getop;
- }
- }
+ return NULL;
+}
-getop: if ((op = *p++) != '+' && op != '-' && op != '=') {
- free(saveset);
- return (NULL);
- }
- if (op == '=')
- equalopdone = 0;
- who &= ~S_ISTXT;
- for (perm = 0, permXbits = 0;; ++p) {
- switch (*p) {
- case 'r':
- perm |= S_IRUSR|S_IRGRP|S_IROTH;
- break;
- case 's':
- /*
- * If specific bits where requested and
- * only "other" bits ignore set-id.
- */
- if (who == 0 || (who & ~S_IRWXO))
- perm |= S_ISUID|S_ISGID;
- break;
- case 't':
- /*
- * If specific bits where requested and
- * only "other" bits ignore set-id.
- */
- if (who == 0 || (who & ~S_IRWXO)) {
- who |= S_ISTXT;
- perm |= S_ISTXT;
- }
- break;
- case 'w':
- perm |= S_IWUSR|S_IWGRP|S_IWOTH;
- break;
- case 'X':
- permXbits = S_IXUSR|S_IXGRP|S_IXOTH;
- break;
- case 'x':
- perm |= S_IXUSR|S_IXGRP|S_IXOTH;
- break;
- case 'u':
- case 'g':
- case 'o':
- /*
- * When ever we hit 'u', 'g', or 'o', we have
- * to flush out any partial mode that we have,
- * and then do the copying of the mode bits.
- */
- if (perm) {
- ADDCMD(op, who, perm, mask);
- perm = 0;
- }
- if (op == '=')
- equalopdone = 1;
- if (op == '+' && permXbits) {
- ADDCMD('X', who, permXbits, mask);
- permXbits = 0;
- }
- ADDCMD(*p, who, op, mask);
- break;
+/*
+ * Search the environment of a builtin command.
+ */
- default:
- /*
- * Add any permissions that we haven't already
- * done.
- */
- if (perm || (op == '=' && !equalopdone)) {
- if (op == '=')
- equalopdone = 1;
- ADDCMD(op, who, perm, mask);
- perm = 0;
- }
- if (permXbits) {
- ADDCMD('X', who, permXbits, mask);
- permXbits = 0;
- }
- goto apply;
- }
- }
+static char *
+bltinlookup(const char *name)
+{
+ struct strlist *sp;
-apply: if (!*p)
- break;
- if (*p != ',')
- goto getop;
- ++p;
+ for (sp = cmdenviron ; sp ; sp = sp->next) {
+ if (varequal(sp->text, name))
+ return strchrnul(sp->text, '=') + 1;
}
- set->cmd = 0;
-#ifdef SETMODE_DEBUG
- (void)printf("Before compress_mode()\n");
- dumpmode(saveset);
-#endif
- compress_mode(saveset);
-#ifdef SETMODE_DEBUG
- (void)printf("After compress_mode()\n");
- dumpmode(saveset);
-#endif
- return (saveset);
+ return lookupvar(name);
}
-static BITCMD *
-addcmd(set, op, who, oparg, mask)
- BITCMD *set;
- int oparg, who;
- int op;
- u_int mask;
-{
-
- _DIAGASSERT(set != NULL);
-
- switch (op) {
- case '=':
- set->cmd = '-';
- set->bits = who ? who : STANDARD_BITS;
- set++;
-
- op = '+';
- /* FALLTHROUGH */
- case '+':
- case '-':
- case 'X':
- set->cmd = op;
- set->bits = (who ? who : mask) & oparg;
- break;
-
- case 'u':
- case 'g':
- case 'o':
- set->cmd = op;
- if (who) {
- set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) |
- ((who & S_IRGRP) ? CMD2_GBITS : 0) |
- ((who & S_IROTH) ? CMD2_OBITS : 0);
- set->bits = (mode_t)~0;
- } else {
- set->cmd2 = CMD2_UBITS | CMD2_GBITS | CMD2_OBITS;
- set->bits = mask;
- }
- if (oparg == '+')
- set->cmd2 |= CMD2_SET;
- else if (oparg == '-')
- set->cmd2 |= CMD2_CLR;
- else if (oparg == '=')
- set->cmd2 |= CMD2_SET|CMD2_CLR;
- break;
- }
- return (set + 1);
-}
+/*
+ * Generate a list of variables satisfying the given conditions.
+ */
-#ifdef SETMODE_DEBUG
-static void
-dumpmode(set)
- BITCMD *set;
+static char **
+listvars(int on, int off, char ***end)
{
+ struct var **vpp;
+ struct var *vp;
+ char **ep;
+ int mask;
- _DIAGASSERT(set != NULL);
-
- for (; set->cmd; ++set)
- (void)printf("cmd: '%c' bits %04o%s%s%s%s%s%s\n",
- set->cmd, set->bits, set->cmd2 ? " cmd2:" : "",
- set->cmd2 & CMD2_CLR ? " CLR" : "",
- set->cmd2 & CMD2_SET ? " SET" : "",
- set->cmd2 & CMD2_UBITS ? " UBITS" : "",
- set->cmd2 & CMD2_GBITS ? " GBITS" : "",
- set->cmd2 & CMD2_OBITS ? " OBITS" : "");
+ STARTSTACKSTR(ep);
+ vpp = vartab;
+ mask = on | off;
+ do {
+ for (vp = *vpp ; vp ; vp = vp->next)
+ if ((vp->flags & mask) == on) {
+ if (ep == stackstrend())
+ ep = growstackstr();
+ *ep++ = (char *) vp->text;
+ }
+ } while (++vpp < vartab + VTABSIZE);
+ if (ep == stackstrend())
+ ep = growstackstr();
+ if (end)
+ *end = ep;
+ *ep++ = NULL;
+ return grabstackstr(ep);
}
-#endif
+
/*
- * Given an array of bitcmd structures, compress by compacting consecutive
- * '+', '-' and 'X' commands into at most 3 commands, one of each. The 'u',
- * 'g' and 'o' commands continue to be separate. They could probably be
- * compacted, but it's not worth the effort.
+ * POSIX requires that 'set' (but not export or readonly) output the
+ * variables in lexicographic order - by the locale's collating order (sigh).
+ * Maybe we could keep them in an ordered balanced binary tree
+ * instead of hashed lists.
+ * For now just roll 'em through qsort for printing...
*/
-static void
-compress_mode(set)
- BITCMD *set;
+
+static int
+showvars(const char *sep_prefix, int on, int off)
{
- BITCMD *nset;
- int setbits, clrbits, Xbits, op;
+ const char *sep;
+ char **ep, **epend;
- _DIAGASSERT(set != NULL);
+ ep = listvars(on, off, &epend);
+ qsort(ep, epend - ep, sizeof(char *), vpcmp);
- for (nset = set;;) {
- /* Copy over any 'u', 'g' and 'o' commands. */
- while ((op = nset->cmd) != '+' && op != '-' && op != 'X') {
- *set++ = *nset++;
- if (!op)
- return;
- }
+ sep = *sep_prefix ? spcstr : sep_prefix;
- for (setbits = clrbits = Xbits = 0;; nset++) {
- if ((op = nset->cmd) == '-') {
- clrbits |= nset->bits;
- setbits &= ~nset->bits;
- Xbits &= ~nset->bits;
- } else if (op == '+') {
- setbits |= nset->bits;
- clrbits &= ~nset->bits;
- Xbits &= ~nset->bits;
- } else if (op == 'X')
- Xbits |= nset->bits & ~setbits;
- else
- break;
- }
- if (clrbits) {
- set->cmd = '-';
- set->cmd2 = 0;
- set->bits = clrbits;
- set++;
- }
- if (setbits) {
- set->cmd = '+';
- set->cmd2 = 0;
- set->bits = setbits;
- set++;
- }
- if (Xbits) {
- set->cmd = 'X';
- set->cmd2 = 0;
- set->bits = Xbits;
- set++;
- }
+ for (; ep < epend; ep++) {
+ const char *p;
+ const char *q;
+
+ p = strchrnul(*ep, '=');
+ q = nullstr;
+ if (*p)
+ q = single_quote(++p);
+
+ out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q);
}
+
+ return 0;
}
-#ifdef DEBUG
-static void shtree (union node *, int, char *, FILE*);
-static void shcmd (union node *, FILE *);
-static void sharg (union node *, FILE *);
-static void indent (int, char *, FILE *);
-static void trstring (char *);
-static void
-showtree(n)
- union node *n;
-{
- trputs("showtree called\n");
- shtree(n, 1, NULL, stdout);
-}
+/*
+ * The export and readonly commands.
+ */
-static void
-shtree(n, ind, pfx, fp)
- union node *n;
- int ind;
- char *pfx;
- FILE *fp;
+static int
+exportcmd(int argc, char **argv)
{
- struct nodelist *lp;
- const char *s;
-
- if (n == NULL)
- return;
+ struct var *vp;
+ char *name;
+ const char *p;
+ char **aptr;
+ int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
+ int notp;
- indent(ind, pfx, fp);
- switch(n->type) {
- case NSEMI:
- s = "; ";
- goto binop;
- case NAND:
- s = " && ";
- goto binop;
- case NOR:
- s = " || ";
-binop:
- shtree(n->nbinary.ch1, ind, NULL, fp);
- /* if (ind < 0) */
- fputs(s, fp);
- shtree(n->nbinary.ch2, ind, NULL, fp);
- break;
- case NCMD:
- shcmd(n, fp);
- if (ind >= 0)
- putc('\n', fp);
- break;
- case NPIPE:
- for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
- shcmd(lp->n, fp);
- if (lp->next)
- fputs(" | ", fp);
- }
- if (n->npipe.backgnd)
- fputs(" &", fp);
- if (ind >= 0)
- putc('\n', fp);
- break;
- default:
- fprintf(fp, "<node type %d>", n->type);
- if (ind >= 0)
- putc('\n', fp);
- break;
+ notp = nextopt("p") - 'p';
+ if (notp && ((name = *(aptr = argptr)))) {
+ do {
+ if ((p = strchr(name, '=')) != NULL) {
+ p++;
+ } else {
+ if ((vp = *findvar(hashvar(name), name))) {
+ vp->flags |= flag;
+ continue;
+ }
+ }
+ setvar(name, p, flag);
+ } while ((name = *++aptr) != NULL);
+ } else {
+ showvars(argv[0], flag, 0);
}
+ return 0;
}
+/*
+ * Make a variable a local variable. When a variable is made local, it's
+ * value and flags are saved in a localvar structure. The saved values
+ * will be restored when the shell function returns. We handle the name
+ * "-" as a special case.
+ */
-static void
-shcmd(cmd, fp)
- union node *cmd;
- FILE *fp;
+static inline void
+mklocal(char *name)
{
- union node *np;
- int first;
- const char *s;
- int dftfd;
+ struct localvar *lvp;
+ struct var **vpp;
+ struct var *vp;
- first = 1;
- for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
- if (! first)
- putchar(' ');
- sharg(np, fp);
- first = 0;
- }
- for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
- if (! first)
- putchar(' ');
- switch (np->nfile.type) {
- case NTO: s = ">"; dftfd = 1; break;
- case NAPPEND: s = ">>"; dftfd = 1; break;
- case NTOFD: s = ">&"; dftfd = 1; break;
- case NTOOV: s = ">|"; dftfd = 1; break;
- case NFROM: s = "<"; dftfd = 0; break;
- case NFROMFD: s = "<&"; dftfd = 0; break;
- case NFROMTO: s = "<>"; dftfd = 0; break;
- default: s = "*error*"; dftfd = 0; break;
- }
- if (np->nfile.fd != dftfd)
- fprintf(fp, "%d", np->nfile.fd);
- fputs(s, fp);
- if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
- fprintf(fp, "%d", np->ndup.dupfd);
+ INTOFF;
+ lvp = ckmalloc(sizeof (struct localvar));
+ if (name[0] == '-' && name[1] == '\0') {
+ char *p;
+ p = ckmalloc(sizeof(optlist));
+ lvp->text = memcpy(p, optlist, sizeof(optlist));
+ vp = NULL;
+ } else {
+ char *eq;
+
+ vpp = hashvar(name);
+ vp = *findvar(vpp, name);
+ eq = strchr(name, '=');
+ if (vp == NULL) {
+ if (eq)
+ setvareq(name, VSTRFIXED);
+ else
+ setvar(name, NULL, VSTRFIXED);
+ vp = *vpp; /* the new variable */
+ lvp->flags = VUNSET;
} else {
- sharg(np->nfile.fname, fp);
+ lvp->text = vp->text;
+ lvp->flags = vp->flags;
+ vp->flags |= VSTRFIXED|VTEXTFIXED;
+ if (eq)
+ setvareq(name, 0);
}
- first = 0;
}
+ lvp->vp = vp;
+ lvp->next = localvars;
+ localvars = lvp;
+ INTON;
}
+/*
+ * The "local" command.
+ */
+static int
+localcmd(int argc, char **argv)
+{
+ char *name;
-static void
-sharg(arg, fp)
- union node *arg;
- FILE *fp;
- {
- char *p;
- struct nodelist *bqlist;
- int subtype;
-
- if (arg->type != NARG) {
- printf("<node type %d>\n", arg->type);
- fflush(stdout);
- abort();
+ argv = argptr;
+ while ((name = *argv++) != NULL) {
+ mklocal(name);
}
- bqlist = arg->narg.backquote;
- for (p = arg->narg.text ; *p ; p++) {
- switch (*p) {
- case CTLESC:
- putc(*++p, fp);
- break;
- case CTLVAR:
- putc('$', fp);
- putc('{', fp);
- subtype = *++p;
- if (subtype == VSLENGTH)
- putc('#', fp);
+ return 0;
+}
- while (*p != '=')
- putc(*p++, fp);
- if (subtype & VSNUL)
- putc(':', fp);
+/*
+ * Called after a function returns.
+ * Interrupts must be off.
+ */
- switch (subtype & VSTYPE) {
- case VSNORMAL:
- putc('}', fp);
- break;
- case VSMINUS:
- putc('-', fp);
- break;
- case VSPLUS:
- putc('+', fp);
- break;
- case VSQUESTION:
- putc('?', fp);
- break;
- case VSASSIGN:
- putc('=', fp);
- break;
- case VSTRIMLEFT:
- putc('#', fp);
- break;
- case VSTRIMLEFTMAX:
- putc('#', fp);
- putc('#', fp);
- break;
- case VSTRIMRIGHT:
- putc('%', fp);
- break;
- case VSTRIMRIGHTMAX:
- putc('%', fp);
- putc('%', fp);
- break;
- case VSLENGTH:
- break;
- default:
- printf("<subtype %d>", subtype);
- }
- break;
- case CTLENDVAR:
- putc('}', fp);
- break;
- case CTLBACKQ:
- case CTLBACKQ|CTLQUOTE:
- putc('$', fp);
- putc('(', fp);
- shtree(bqlist->n, -1, NULL, fp);
- putc(')', fp);
- break;
- default:
- putc(*p, fp);
- break;
+static void
+poplocalvars(void)
+{
+ struct localvar *lvp;
+ struct var *vp;
+
+ while ((lvp = localvars) != NULL) {
+ localvars = lvp->next;
+ vp = lvp->vp;
+ TRACE(("poplocalvar %s", vp ? vp->text : "-"));
+ if (vp == NULL) { /* $- saved */
+ memcpy(optlist, lvp->text, sizeof(optlist));
+ ckfree(lvp->text);
+ optschanged();
+ } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
+ unsetvar(vp->text);
+ } else {
+ if (vp->func)
+ (*vp->func)(strchrnul(lvp->text, '=') + 1);
+ if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
+ ckfree(vp->text);
+ vp->flags = lvp->flags;
+ vp->text = lvp->text;
}
+ ckfree(lvp);
}
}
-static void
-indent(amount, pfx, fp)
- int amount;
- char *pfx;
- FILE *fp;
+/*
+ * The unset builtin command. We unset the function before we unset the
+ * variable to allow a function to be unset when there is a readonly variable
+ * with the same name.
+ */
+
+int
+unsetcmd(int argc, char **argv)
{
+ char **ap;
int i;
+ int flag = 0;
+ int ret = 0;
- for (i = 0 ; i < amount ; i++) {
- if (pfx && i == amount - 1)
- fputs(pfx, fp);
- putc('\t', fp);
+ while ((i = nextopt("vf")) != '\0') {
+ flag = i;
}
-}
-#endif
+ for (ap = argptr; *ap ; ap++) {
+ if (flag != 'f') {
+ i = unsetvar(*ap);
+ ret |= i;
+ if (!(i & 2))
+ continue;
+ }
+ if (flag != 'v')
+ unsetfunc(*ap);
+ }
+ return ret & 1;
+}
/*
- * Debugging stuff.
+ * Unset the specified variable.
*/
+int
+unsetvar(const char *s)
+{
+ struct var **vpp;
+ struct var *vp;
+ int retval;
-#ifdef DEBUG
-FILE *tracefile;
+ vpp = findvar(hashvar(s), s);
+ vp = *vpp;
+ retval = 2;
+ if (vp) {
+ int flags = vp->flags;
-#if DEBUG == 2
-static int debug = 1;
-#else
-static int debug = 0;
+ retval = 1;
+ if (flags & VREADONLY)
+ goto out;
+#ifdef DYNAMIC_VAR
+ vp->flags &= ~VDYNAMIC;
#endif
+ if (flags & VUNSET)
+ goto ok;
+ if ((flags & VSTRFIXED) == 0) {
+ INTOFF;
+ if ((flags & (VTEXTFIXED|VSTACK)) == 0)
+ ckfree(vp->text);
+ *vpp = vp->next;
+ ckfree(vp);
+ INTON;
+ } else {
+ setvar(s, 0, 0);
+ vp->flags &= ~VEXPORT;
+ }
+ok:
+ retval = 0;
+ }
+out:
+ return retval;
+}
-static void
-trputc(c)
- int c;
+
+
+/*
+ * Find the appropriate entry in the hash table from the name.
+ */
+
+static struct var **
+hashvar(const char *p)
{
- if (tracefile == NULL)
- return;
- putc(c, tracefile);
- if (c == '\n')
- fflush(tracefile);
+ unsigned int hashval;
+
+ hashval = ((unsigned char) *p) << 4;
+ while (*p && *p != '=')
+ hashval += (unsigned char) *p++;
+ return &vartab[hashval % VTABSIZE];
}
-static void
-trace(const char *fmt, ...)
+
+
+/*
+ * Compares two strings up to the first = or '\0'. The first
+ * string must be terminated by '='; the second may be terminated by
+ * either '=' or '\0'.
+ */
+
+int
+varcmp(const char *p, const char *q)
{
- va_list va;
-#ifdef __STDC__
- va_start(va, fmt);
-#else
- char *fmt;
- va_start(va);
- fmt = va_arg(va, char *);
-#endif
- if (tracefile != NULL) {
- (void) vfprintf(tracefile, fmt, va);
- if (strchr(fmt, '\n'))
- (void) fflush(tracefile);
+ int c, d;
+
+ while ((c = *p) == (d = *q)) {
+ if (!c || c == '=')
+ goto out;
+ p++;
+ q++;
}
- va_end(va);
+ if (c == '=')
+ c = 0;
+ if (d == '=')
+ d = 0;
+out:
+ return c - d;
}
-
-static void
-trputs(s)
- const char *s;
+static int
+vpcmp(const void *a, const void *b)
{
- if (tracefile == NULL)
- return;
- fputs(s, tracefile);
- if (strchr(s, '\n'))
- fflush(tracefile);
+ return varcmp(*(const char **)a, *(const char **)b);
}
-
-static void
-trstring(s)
- char *s;
+static struct var **
+findvar(struct var **vpp, const char *name)
{
- char *p;
- char c;
-
- if (tracefile == NULL)
- return;
- putc('"', tracefile);
- for (p = s ; *p ; p++) {
- switch (*p) {
- case '\n': c = 'n'; goto backslash;
- case '\t': c = 't'; goto backslash;
- case '\r': c = 'r'; goto backslash;
- case '"': c = '"'; goto backslash;
- case '\\': c = '\\'; goto backslash;
- case CTLESC: c = 'e'; goto backslash;
- case CTLVAR: c = 'v'; goto backslash;
- case CTLVAR+CTLQUOTE: c = 'V'; goto backslash;
- case CTLBACKQ: c = 'q'; goto backslash;
- case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash;
-backslash: putc('\\', tracefile);
- putc(c, tracefile);
- break;
- default:
- if (*p >= ' ' && *p <= '~')
- putc(*p, tracefile);
- else {
- putc('\\', tracefile);
- putc(*p >> 6 & 03, tracefile);
- putc(*p >> 3 & 07, tracefile);
- putc(*p & 07, tracefile);
- }
+ for (; *vpp; vpp = &(*vpp)->next) {
+ if (varequal((*vpp)->text, name)) {
break;
}
}
- putc('"', tracefile);
+ return vpp;
}
+/* $NetBSD: setmode.c,v 1.29 2003/01/15 23:58:03 kleink Exp $ */
+#include <sys/times.h>
-static void
-trargs(ap)
- char **ap;
+static const unsigned char timescmd_str[] = {
+ ' ', offsetof(struct tms, tms_utime),
+ '\n', offsetof(struct tms, tms_stime),
+ ' ', offsetof(struct tms, tms_cutime),
+ '\n', offsetof(struct tms, tms_cstime),
+ 0
+};
+
+static int timescmd(int ac, char **av)
{
- if (tracefile == NULL)
- return;
- while (*ap) {
- trstring(*ap++);
- if (*ap)
- putc(' ', tracefile);
- else
- putc('\n', tracefile);
- }
- fflush(tracefile);
-}
+ long int clk_tck, s, t;
+ const unsigned char *p;
+ struct tms buf;
+ clk_tck = sysconf(_SC_CLK_TCK);
+ times(&buf);
-static void
-opentrace() {
- char s[100];
-#ifdef O_APPEND
- int flags;
-#endif
+ p = timescmd_str;
+ do {
+ t = *(clock_t *)(((char *) &buf) + p[1]);
+ s = t / clk_tck;
+ out1fmt("%ldm%ld.%.3lds%c",
+ s/60, s%60,
+ ((t - s * clk_tck) * 1000) / clk_tck,
+ p[0]);
+ } while (*(p += 2));
+
+ return 0;
+}
- if (!debug)
- return;
-#ifdef not_this_way
- {
- char *p;
- if ((p = getenv("HOME")) == NULL) {
- if (geteuid() == 0)
- p = "/";
- else
- p = "/tmp";
- }
- strcpy(s, p);
- strcat(s, "/trace");
- }
-#else
- strcpy(s, "./trace");
-#endif /* not_this_way */
- if ((tracefile = fopen(s, "a")) == NULL) {
- fprintf(stderr, "Can't open %s\n", s);
- return;
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static arith_t
+dash_arith(const char *s)
+{
+ arith_t result;
+ int errcode = 0;
+
+ INTOFF;
+ result = arith(s, &errcode);
+ if (errcode < 0) {
+ if (errcode == -3)
+ error("exponent less than 0");
+ else if (errcode == -2)
+ error("divide by zero");
+ else if (errcode == -5)
+ error("expression recursion loop detected");
+ else
+ synerror(s);
}
-#ifdef O_APPEND
- if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
- fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
-#endif
- fputs("\nTracing started.\n", tracefile);
- fflush(tracefile);
+ INTON;
+
+ return (result);
}
-#endif /* DEBUG */
/*
- * The trap builtin.
+ * The let builtin. partial stolen from GNU Bash, the Bourne Again SHell.
+ * Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
+ *
+ * Copyright (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
*/
static int
-trapcmd(argc, argv)
- int argc;
- char **argv;
+letcmd(int argc, char **argv)
{
- char *action;
char **ap;
- int signo;
-
- if (argc <= 1) {
- for (signo = 0 ; signo < NSIG ; signo++) {
- if (trap[signo] != NULL) {
- char *p;
+ arith_t i;
- p = single_quote(trap[signo]);
- printf("trap -- %s %s\n", p,
- signal_names[signo] + (signo ? 3 : 0)
- );
- stunalloc(p);
- }
- }
- return 0;
- }
ap = argv + 1;
- if (argc == 2)
- action = NULL;
- else
- action = *ap++;
- while (*ap) {
- if ((signo = decode_signal(*ap, 0)) < 0)
- error("%s: bad trap", *ap);
- INTOFF;
- if (action) {
- if (action[0] == '-' && action[1] == '\0')
- action = NULL;
- else
- action = savestr(action);
- }
- if (trap[signo])
- ckfree(trap[signo]);
- trap[signo] = action;
- if (signo != 0)
- setsignal(signo);
- INTON;
- ap++;
+ if(!*ap)
+ error("expression expected");
+ for (ap = argv + 1; *ap; ap++) {
+ i = dash_arith(*ap);
}
- return 0;
+
+ return (!i);
}
+#endif /* CONFIG_ASH_MATH_SUPPORT */
+/* $NetBSD: miscbltin.c,v 1.31 2002/11/24 22:35:41 christos Exp $ */
+/*
+ * Miscellaneous builtins.
+ */
+#undef rflag
+#ifdef __GLIBC__
+#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
+typedef enum __rlimit_resource rlim_t;
+#endif
+#endif
/*
- * Set the signal handler for the specified signal. The routine figures
- * out what it should be set to.
+ * The read builtin. The -e option causes backslashes to escape the
+ * following character.
+ *
+ * This uses unbuffered input, which may be avoidable in some cases.
*/
-static void
-setsignal(int signo)
+static int
+readcmd(int argc, char **argv)
{
- int action;
- char *t;
- struct sigaction act;
-
- if ((t = trap[signo]) == NULL)
- action = S_DFL;
- else if (*t != '\0')
- action = S_CATCH;
- else
- action = S_IGN;
- if (rootshell && action == S_DFL) {
- switch (signo) {
- case SIGINT:
- if (iflag || minusc || sflag == 0)
- action = S_CATCH;
- break;
- case SIGQUIT:
-#ifdef DEBUG
- {
+ char **ap;
+ int backslash;
+ char c;
+ int rflag;
+ char *prompt;
+ const char *ifs;
+ char *p;
+ int startword;
+ int status;
+ int i;
- if (debug)
- break;
- }
-#endif
- /* FALLTHROUGH */
- case SIGTERM:
- if (iflag)
- action = S_IGN;
- break;
-#ifdef JOBS
- case SIGTSTP:
- case SIGTTOU:
- if (mflag)
- action = S_IGN;
+ rflag = 0;
+ prompt = NULL;
+ while ((i = nextopt("p:r")) != '\0') {
+ if (i == 'p')
+ prompt = optionarg;
+ else
+ rflag = 1;
+ }
+ if (prompt && isatty(0)) {
+ out2str(prompt);
+ }
+ if (*(ap = argptr) == NULL)
+ error("arg count");
+ if ((ifs = bltinlookup("IFS")) == NULL)
+ ifs = defifs;
+ status = 0;
+ startword = 1;
+ backslash = 0;
+ STARTSTACKSTR(p);
+ for (;;) {
+ if (read(0, &c, 1) != 1) {
+ status = 1;
break;
-#endif
}
- }
-
- t = &sigmode[signo - 1];
- if (*t == 0) {
- /*
- * current setting unknown
- */
- if (sigaction(signo, 0, &act) == -1) {
- /*
- * Pretend it worked; maybe we should give a warning
- * here, but other shells don't. We don't alter
- * sigmode, so that we retry every time.
- */
- return;
+ if (c == '\0')
+ continue;
+ if (backslash) {
+ backslash = 0;
+ if (c != '\n')
+ goto put;
+ continue;
}
- if (act.sa_handler == SIG_IGN) {
- if (mflag && (signo == SIGTSTP ||
- signo == SIGTTIN || signo == SIGTTOU)) {
- *t = S_IGN; /* don't hard ignore these */
- } else
- *t = S_HARD_IGN;
+ if (!rflag && c == '\\') {
+ backslash++;
+ continue;
+ }
+ if (c == '\n')
+ break;
+ if (startword && *ifs == ' ' && strchr(ifs, c)) {
+ continue;
+ }
+ startword = 0;
+ if (ap[1] != NULL && strchr(ifs, c) != NULL) {
+ STACKSTRNUL(p);
+ setvar(*ap, stackblock(), 0);
+ ap++;
+ startword = 1;
+ STARTSTACKSTR(p);
} else {
- *t = S_RESET; /* force to be set */
+put:
+ STPUTC(c, p);
}
}
- if (*t == S_HARD_IGN || *t == action)
- return;
- switch (action) {
- case S_CATCH:
- act.sa_handler = onsig;
- break;
- case S_IGN:
- act.sa_handler = SIG_IGN;
- break;
- default:
- act.sa_handler = SIG_DFL;
- }
- *t = action;
- act.sa_flags = 0;
- sigemptyset(&act.sa_mask);
- sigaction(signo, &act, 0);
+ STACKSTRNUL(p);
+ /* Remove trailing blanks */
+ while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL)
+ *p = '\0';
+ setvar(*ap, stackblock(), 0);
+ while (*++ap != NULL)
+ setvar(*ap, nullstr, 0);
+ return status;
}
-/*
- * Ignore a signal.
- */
-static void
-ignoresig(signo)
- int signo;
+static int umaskcmd(int argc, char **argv)
{
- if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
- signal(signo, SIG_IGN);
- }
- sigmode[signo - 1] = S_HARD_IGN;
-}
-
+ static const char permuser[3] = "ugo";
+ static const char permmode[3] = "rwx";
+ static const short int permmask[] = {
+ S_IRUSR, S_IWUSR, S_IXUSR,
+ S_IRGRP, S_IWGRP, S_IXGRP,
+ S_IROTH, S_IWOTH, S_IXOTH
+ };
-/*
- * Signal handler.
- */
+ char *ap;
+ mode_t mask;
+ int i;
+ int symbolic_mode = 0;
-static void
-onsig(int signo)
-{
- if (signo == SIGINT && trap[SIGINT] == NULL) {
- onint();
- return;
+ while (nextopt("S") != '\0') {
+ symbolic_mode = 1;
}
- gotsig[signo - 1] = 1;
- pendingsigs++;
-}
+ INTOFF;
+ mask = umask(0);
+ umask(mask);
+ INTON;
-/*
- * Called to execute a trap. Perhaps we should avoid entering new trap
- * handlers while we are executing a trap handler.
- */
+ if ((ap = *argptr) == NULL) {
+ if (symbolic_mode) {
+ char buf[18];
+ char *p = buf;
-static void
-dotrap(void)
-{
- int i;
- int savestatus;
+ for (i = 0; i < 3; i++) {
+ int j;
- for (;;) {
- for (i = 1 ; ; i++) {
- if (gotsig[i - 1])
- break;
- if (i >= NSIG - 1)
- goto done;
+ *p++ = permuser[i];
+ *p++ = '=';
+ for (j = 0; j < 3; j++) {
+ if ((mask & permmask[3 * i + j]) == 0) {
+ *p++ = permmode[j];
+ }
+ }
+ *p++ = ',';
+ }
+ *--p = 0;
+ puts(buf);
+ } else {
+ out1fmt("%.4o\n", mask);
+ }
+ } else {
+ if (is_digit((unsigned char) *ap)) {
+ mask = 0;
+ do {
+ if (*ap >= '8' || *ap < '0')
+ error(illnum, argv[1]);
+ mask = (mask << 3) + (*ap - '0');
+ } while (*++ap != '\0');
+ umask(mask);
+ } else {
+ mask = ~mask & 0777;
+ if (!bb_parse_mode(ap, &mask)) {
+ error("Illegal mode: %s", ap);
+ }
+ umask(~mask & 0777);
}
- gotsig[i - 1] = 0;
- savestatus=exitstatus;
- evalstring(trap[i], 0);
- exitstatus=savestatus;
}
-done:
- pendingsigs = 0;
+ return 0;
}
/*
- * Called to exit the shell.
+ * ulimit builtin
+ *
+ * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
+ * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
+ * ash by J.T. Conklin.
+ *
+ * Public domain.
*/
-static void
-exitshell(int status)
-{
- struct jmploc loc1, loc2;
- char *p;
+struct limits {
+ const char *name;
+ int cmd;
+ int factor; /* multiply by to get rlim_{cur,max} values */
+ char option;
+};
- TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
- if (setjmp(loc1.loc)) {
- goto l1;
- }
- if (setjmp(loc2.loc)) {
- goto l2;
- }
- handler = &loc1;
- if ((p = trap[0]) != NULL && *p != '\0') {
- trap[0] = NULL;
- evalstring(p, 0);
- }
-l1: handler = &loc2; /* probably unnecessary */
- flushall();
-#ifdef JOBS
- setjobctl(0);
+static const struct limits limits[] = {
+#ifdef RLIMIT_CPU
+ { "time(seconds)", RLIMIT_CPU, 1, 't' },
#endif
-l2: _exit(status);
- /* NOTREACHED */
-}
+#ifdef RLIMIT_FSIZE
+ { "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
+#endif
+#ifdef RLIMIT_DATA
+ { "data(kbytes)", RLIMIT_DATA, 1024, 'd' },
+#endif
+#ifdef RLIMIT_STACK
+ { "stack(kbytes)", RLIMIT_STACK, 1024, 's' },
+#endif
+#ifdef RLIMIT_CORE
+ { "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
+#endif
+#ifdef RLIMIT_RSS
+ { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' },
+#endif
+#ifdef RLIMIT_MEMLOCK
+ { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' },
+#endif
+#ifdef RLIMIT_NPROC
+ { "process", RLIMIT_NPROC, 1, 'p' },
+#endif
+#ifdef RLIMIT_NOFILE
+ { "nofiles", RLIMIT_NOFILE, 1, 'n' },
+#endif
+#ifdef RLIMIT_AS
+ { "vmemory(kbytes)", RLIMIT_AS, 1024, 'v' },
+#endif
+#ifdef RLIMIT_LOCKS
+ { "locks", RLIMIT_LOCKS, 1, 'w' },
+#endif
+ { (char *) 0, 0, 0, '\0' }
+};
-static int decode_signal(const char *string, int minsig)
+enum limtype { SOFT = 0x1, HARD = 0x2 };
+
+static void printlim(enum limtype how, const struct rlimit *limit,
+ const struct limits *l)
{
- int signo;
+ rlim_t val;
- if (is_number(string, &signo)) {
- if (signo >= NSIG) {
- return -1;
- }
- return signo;
- }
+ val = limit->rlim_max;
+ if (how & SOFT)
+ val = limit->rlim_cur;
- signo = minsig;
- if (!signo) {
- goto zero;
- }
- for (; signo < NSIG; signo++) {
- if (!strcasecmp(string, &(signal_names[signo])[3])) {
- return signo;
- }
-zero:
- if (!strcasecmp(string, signal_names[signo])) {
- return signo;
- }
+ if (val == RLIM_INFINITY)
+ out1fmt("unlimited\n");
+ else {
+ val /= l->factor;
+ out1fmt("%lld\n", (long long) val);
}
-
- return -1;
}
-static struct var **hashvar (const char *);
-static void showvars (const char *, int, int);
-static struct var **findvar (struct var **, const char *);
-/*
- * Initialize the varable symbol tables and import the environment
- */
-
-/*
- * This routine initializes the builtin variables. It is called when the
- * shell is initialized and again when a shell procedure is spawned.
- */
-
-static void
-initvar() {
- const struct varinit *ip;
- struct var *vp;
- struct var **vpp;
+int
+ulimitcmd(int argc, char **argv)
+{
+ int c;
+ rlim_t val = 0;
+ enum limtype how = SOFT | HARD;
+ const struct limits *l;
+ int set, all = 0;
+ int optc, what;
+ struct rlimit limit;
- for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
- if ((vp->flags & VEXPORT) == 0) {
- vpp = hashvar(ip->text);
- vp->next = *vpp;
- *vpp = vp;
- vp->text = strdup(ip->text);
- vp->flags = ip->flags;
- vp->func = ip->func;
+ what = 'f';
+ while ((optc = nextopt("HSa"
+#ifdef RLIMIT_CPU
+ "t"
+#endif
+#ifdef RLIMIT_FSIZE
+ "f"
+#endif
+#ifdef RLIMIT_DATA
+ "d"
+#endif
+#ifdef RLIMIT_STACK
+ "s"
+#endif
+#ifdef RLIMIT_CORE
+ "c"
+#endif
+#ifdef RLIMIT_RSS
+ "m"
+#endif
+#ifdef RLIMIT_MEMLOCK
+ "l"
+#endif
+#ifdef RLIMIT_NPROC
+ "p"
+#endif
+#ifdef RLIMIT_NOFILE
+ "n"
+#endif
+#ifdef RLIMIT_AS
+ "v"
+#endif
+#ifdef RLIMIT_LOCKS
+ "w"
+#endif
+ )) != '\0')
+ switch (optc) {
+ case 'H':
+ how = HARD;
+ break;
+ case 'S':
+ how = SOFT;
+ break;
+ case 'a':
+ all = 1;
+ break;
+ default:
+ what = optc;
}
- }
- /*
- * PS1 depends on uid
- */
- if ((vps1.flags & VEXPORT) == 0) {
- vpp = hashvar("PS1=");
- vps1.next = *vpp;
- *vpp = &vps1;
- vps1.text = strdup(geteuid() ? "PS1=$ " : "PS1=# ");
- vps1.flags = VSTRFIXED|VTEXTFIXED;
- }
-}
-/*
- * Set the value of a variable. The flags argument is ored with the
- * flags of the variable. If val is NULL, the variable is unset.
- */
+ for (l = limits; l->option != what; l++)
+ ;
-static void
-setvar(name, val, flags)
- const char *name, *val;
- int flags;
-{
- const char *p;
- int len;
- int namelen;
- char *nameeq;
- int isbad;
- int vallen = 0;
+ set = *argptr ? 1 : 0;
+ if (set) {
+ char *p = *argptr;
- isbad = 0;
- p = name;
- if (! is_name(*p))
- isbad = 1;
- p++;
- for (;;) {
- if (! is_in_name(*p)) {
- if (*p == '\0' || *p == '=')
- break;
- isbad = 1;
+ if (all || argptr[1])
+ error("too many arguments");
+ if (strncmp(p, "unlimited\n", 9) == 0)
+ val = RLIM_INFINITY;
+ else {
+ val = (rlim_t) 0;
+
+ while ((c = *p++) >= '0' && c <= '9')
+ {
+ val = (val * 10) + (long)(c - '0');
+ if (val < (rlim_t) 0)
+ break;
+ }
+ if (c)
+ error("bad number");
+ val *= l->factor;
}
- p++;
}
- namelen = p - name;
- if (isbad)
- error("%.*s: bad variable name", namelen, name);
- len = namelen + 2; /* 2 is space for '=' and '\0' */
- if (val == NULL) {
- flags |= VUNSET;
- } else {
- len += vallen = strlen(val);
+ if (all) {
+ for (l = limits; l->name; l++) {
+ getrlimit(l->cmd, &limit);
+ out1fmt("%-20s ", l->name);
+ printlim(how, &limit, l);
+ }
+ return 0;
}
- INTOFF;
- nameeq = ckmalloc(len);
- memcpy(nameeq, name, namelen);
- nameeq[namelen] = '=';
- if (val) {
- memcpy(nameeq + namelen + 1, val, vallen + 1);
+
+ getrlimit(l->cmd, &limit);
+ if (set) {
+ if (how & HARD)
+ limit.rlim_max = val;
+ if (how & SOFT)
+ limit.rlim_cur = val;
+ if (setrlimit(l->cmd, &limit) < 0)
+ error("error setting limit (%m)");
} else {
- nameeq[namelen + 1] = '\0';
+ printlim(how, &limit, l);
}
- setvareq(nameeq, flags);
- INTON;
+ return 0;
}
+#ifdef CONFIG_ASH_MATH_SUPPORT
-/*
- * Same as setvar except that the variable and value are passed in
- * the first argument as name=value. Since the first argument will
- * be actually stored in the table, it should not be a string that
- * will go away.
- */
-
-static void
-setvareq(s, flags)
- char *s;
- int flags;
-{
- struct var *vp, **vpp;
-
- vpp = hashvar(s);
- flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
- if ((vp = *findvar(vpp, s))) {
- if (vp->flags & VREADONLY) {
- size_t len = strchr(s, '=') - s;
- error("%.*s: is read only", len, s);
- }
- INTOFF;
+/* Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
- if (vp->func && (flags & VNOFUNC) == 0)
- (*vp->func)(strchr(s, '=') + 1);
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
- if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
- ckfree(vp->text);
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
- vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
- vp->flags |= flags;
- vp->text = s;
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
- /*
- * We could roll this to a function, to handle it as
- * a regular variable function callback, but why bother?
- */
- if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset())))
- chkmail(1);
- INTON;
- return;
- }
- /* not found */
- vp = ckmalloc(sizeof (*vp));
- vp->flags = flags;
- vp->text = s;
- vp->next = *vpp;
- vp->func = NULL;
- *vpp = vp;
-}
+/* This is my infix parser/evaluator. It is optimized for size, intended
+ * as a replacement for yacc-based parsers. However, it may well be faster
+ * than a comparable parser written in yacc. The supported operators are
+ * listed in #defines below. Parens, order of operations, and error handling
+ * are supported. This code is thread safe. The exact expression format should
+ * be that which POSIX specifies for shells. */
+/* The code uses a simple two-stack algorithm. See
+ * http://www.onthenet.com.au/~grahamis/int2008/week02/lect02.html
+ * for a detailed explanation of the infix-to-postfix algorithm on which
+ * this is based (this code differs in that it applies operators immediately
+ * to the stack instead of adding them to a queue to end up with an
+ * expression). */
+/* To use the routine, call it with an expression string and error return
+ * pointer */
/*
- * Process a linked list of variable assignments.
+ * Aug 24, 2001 Manuel Novoa III
+ *
+ * Reduced the generated code size by about 30% (i386) and fixed several bugs.
+ *
+ * 1) In arith_apply():
+ * a) Cached values of *numptr and &(numptr[-1]).
+ * b) Removed redundant test for zero denominator.
+ *
+ * 2) In arith():
+ * a) Eliminated redundant code for processing operator tokens by moving
+ * to a table-based implementation. Also folded handling of parens
+ * into the table.
+ * b) Combined all 3 loops which called arith_apply to reduce generated
+ * code size at the cost of speed.
+ *
+ * 3) The following expressions were treated as valid by the original code:
+ * 1() , 0! , 1 ( *3 ) .
+ * These bugs have been fixed by internally enclosing the expression in
+ * parens and then checking that all binary ops and right parens are
+ * preceded by a valid expression (NUM_TOKEN).
+ *
+ * Note: It may be desirable to replace Aaron's test for whitespace with
+ * ctype's isspace() if it is used by another busybox applet or if additional
+ * whitespace chars should be considered. Look below the "#include"s for a
+ * precompiler test.
*/
-static void
-listsetvar(mylist)
- struct strlist *mylist;
- {
- struct strlist *lp;
-
- INTOFF;
- for (lp = mylist ; lp ; lp = lp->next) {
- setvareq(savestr(lp->text), 0);
- }
- INTON;
-}
-
-
-
/*
- * Find the value of a variable. Returns NULL if not set.
+ * Aug 26, 2001 Manuel Novoa III
+ *
+ * Return 0 for null expressions. Pointed out by Vladimir Oleynik.
+ *
+ * Merge in Aaron's comments previously posted to the busybox list,
+ * modified slightly to take account of my changes to the code.
+ *
*/
-static const char *
-lookupvar(name)
- const char *name;
- {
- struct var *v;
-
- if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
- return strchr(v->text, '=') + 1;
- }
- return NULL;
-}
-
-
-
/*
- * Search the environment of a builtin command.
- */
-
-static const char *
-bltinlookup(const char *name)
-{
- const struct strlist *sp;
-
- for (sp = cmdenviron ; sp ; sp = sp->next) {
- if (varequal(sp->text, name))
- return strchr(sp->text, '=') + 1;
- }
- return lookupvar(name);
-}
+ * (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
+ *
+ * - allow access to variable,
+ * used recursive find value indirection (c=2*2; a="c"; $((a+=2)) produce 6)
+ * - realize assign syntax (VAR=expr, +=, *= etc)
+ * - realize exponentiation (** operator)
+ * - realize comma separated - expr, expr
+ * - realise ++expr --expr expr++ expr--
+ * - realise expr ? expr : expr (but, second expr calculate always)
+ * - allow hexadecimal and octal numbers
+ * - was restored loses XOR operator
+ * - remove one goto label, added three ;-)
+ * - protect $((num num)) as true zero expr (Manuel`s error)
+ * - always use special isspace(), see comment from bash ;-)
+ */
+#define arith_isspace(arithval) \
+ (arithval == ' ' || arithval == '\n' || arithval == '\t')
-/*
- * Generate a list of exported variables. This routine is used to construct
- * the third argument to execve when executing a program.
- */
-static char **
-environment() {
- int nenv;
- struct var **vpp;
- struct var *vp;
- char **env;
- char **ep;
+typedef unsigned char operator;
- nenv = 0;
- for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
- for (vp = *vpp ; vp ; vp = vp->next)
- if (vp->flags & VEXPORT)
- nenv++;
- }
- ep = env = stalloc((nenv + 1) * sizeof *env);
- for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
- for (vp = *vpp ; vp ; vp = vp->next)
- if (vp->flags & VEXPORT)
- *ep++ = vp->text;
- }
- *ep = NULL;
- return env;
-}
+/* An operator's token id is a bit of a bitfield. The lower 5 bits are the
+ * precedence, and 3 high bits are an ID unique across operators of that
+ * precedence. The ID portion is so that multiple operators can have the
+ * same precedence, ensuring that the leftmost one is evaluated first.
+ * Consider * and /. */
+#define tok_decl(prec,id) (((id)<<5)|(prec))
+#define PREC(op) ((op) & 0x1F)
-/*
- * Called when a shell procedure is invoked to clear out nonexported
- * variables. It is also necessary to reallocate variables of with
- * VSTACK set since these are currently allocated on the stack.
- */
+#define TOK_LPAREN tok_decl(0,0)
-static void
-shprocvar(void) {
- struct var **vpp;
- struct var *vp, **prev;
-
- for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
- for (prev = vpp ; (vp = *prev) != NULL ; ) {
- if ((vp->flags & VEXPORT) == 0) {
- *prev = vp->next;
- if ((vp->flags & VTEXTFIXED) == 0)
- ckfree(vp->text);
- if ((vp->flags & VSTRFIXED) == 0)
- ckfree(vp);
- } else {
- if (vp->flags & VSTACK) {
- vp->text = savestr(vp->text);
- vp->flags &=~ VSTACK;
- }
- prev = &vp->next;
- }
- }
- }
- initvar();
-}
+#define TOK_COMMA tok_decl(1,0)
+#define TOK_ASSIGN tok_decl(2,0)
+#define TOK_AND_ASSIGN tok_decl(2,1)
+#define TOK_OR_ASSIGN tok_decl(2,2)
+#define TOK_XOR_ASSIGN tok_decl(2,3)
+#define TOK_PLUS_ASSIGN tok_decl(2,4)
+#define TOK_MINUS_ASSIGN tok_decl(2,5)
+#define TOK_LSHIFT_ASSIGN tok_decl(2,6)
+#define TOK_RSHIFT_ASSIGN tok_decl(2,7)
+#define TOK_MUL_ASSIGN tok_decl(3,0)
+#define TOK_DIV_ASSIGN tok_decl(3,1)
+#define TOK_REM_ASSIGN tok_decl(3,2)
-/*
- * Command to list all variables which are set. Currently this command
- * is invoked from the set command when the set command is called without
- * any variables.
- */
+/* all assign is right associativity and precedence eq, but (7+3)<<5 > 256 */
+#define convert_prec_is_assing(prec) do { if(prec == 3) prec = 2; } while(0)
-static int
-showvarscmd(argc, argv)
- int argc;
- char **argv;
-{
- showvars(nullstr, VUNSET, VUNSET);
- return 0;
-}
+/* conditional is right associativity too */
+#define TOK_CONDITIONAL tok_decl(4,0)
+#define TOK_CONDITIONAL_SEP tok_decl(4,1)
+#define TOK_OR tok_decl(5,0)
+#define TOK_AND tok_decl(6,0)
-/*
- * The export and readonly commands.
- */
+#define TOK_BOR tok_decl(7,0)
-static int
-exportcmd(argc, argv)
- int argc;
- char **argv;
-{
- struct var *vp;
- char *name;
- const char *p;
- int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
- int pflag;
+#define TOK_BXOR tok_decl(8,0)
- listsetvar(cmdenviron);
- pflag = (nextopt("p") == 'p');
- if (argc > 1 && !pflag) {
- while ((name = *argptr++) != NULL) {
- if ((p = strchr(name, '=')) != NULL) {
- p++;
- } else {
- if ((vp = *findvar(hashvar(name), name))) {
- vp->flags |= flag;
- goto found;
- }
- }
- setvar(name, p, flag);
-found:;
- }
- } else {
- showvars(argv[0], flag, 0);
- }
- return 0;
-}
+#define TOK_BAND tok_decl(9,0)
+#define TOK_EQ tok_decl(10,0)
+#define TOK_NE tok_decl(10,1)
-/*
- * The "local" command.
- */
+#define TOK_LT tok_decl(11,0)
+#define TOK_GT tok_decl(11,1)
+#define TOK_GE tok_decl(11,2)
+#define TOK_LE tok_decl(11,3)
-/* funcnest nonzero if we are currently evaluating a function */
+#define TOK_LSHIFT tok_decl(12,0)
+#define TOK_RSHIFT tok_decl(12,1)
-static int
-localcmd(argc, argv)
- int argc;
- char **argv;
-{
- char *name;
+#define TOK_ADD tok_decl(13,0)
+#define TOK_SUB tok_decl(13,1)
- if (! funcnest)
- error("Not in a function");
- while ((name = *argptr++) != NULL) {
- mklocal(name);
- }
- return 0;
-}
+#define TOK_MUL tok_decl(14,0)
+#define TOK_DIV tok_decl(14,1)
+#define TOK_REM tok_decl(14,2)
+/* exponent is right associativity */
+#define TOK_EXPONENT tok_decl(15,1)
-/*
- * Make a variable a local variable. When a variable is made local, it's
- * value and flags are saved in a localvar structure. The saved values
- * will be restored when the shell function returns. We handle the name
- * "-" as a special case.
- */
+/* For now unary operators. */
+#define UNARYPREC 16
+#define TOK_BNOT tok_decl(UNARYPREC,0)
+#define TOK_NOT tok_decl(UNARYPREC,1)
-static void
-mklocal(name)
- char *name;
- {
- struct localvar *lvp;
- struct var **vpp;
- struct var *vp;
+#define TOK_UMINUS tok_decl(UNARYPREC+1,0)
+#define TOK_UPLUS tok_decl(UNARYPREC+1,1)
- INTOFF;
- lvp = ckmalloc(sizeof (struct localvar));
- if (name[0] == '-' && name[1] == '\0') {
- char *p;
- p = ckmalloc(sizeof optet_vals);
- lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
- vp = NULL;
- } else {
- vpp = hashvar(name);
- vp = *findvar(vpp, name);
- if (vp == NULL) {
- if (strchr(name, '='))
- setvareq(savestr(name), VSTRFIXED);
- else
- setvar(name, NULL, VSTRFIXED);
- vp = *vpp; /* the new variable */
- lvp->text = NULL;
- lvp->flags = VUNSET;
- } else {
- lvp->text = vp->text;
- lvp->flags = vp->flags;
- vp->flags |= VSTRFIXED|VTEXTFIXED;
- if (strchr(name, '='))
- setvareq(savestr(name), 0);
- }
- }
- lvp->vp = vp;
- lvp->next = localvars;
- localvars = lvp;
- INTON;
-}
+#define PREC_PRE (UNARYPREC+2)
+#define TOK_PRE_INC tok_decl(PREC_PRE, 0)
+#define TOK_PRE_DEC tok_decl(PREC_PRE, 1)
-/*
- * Called after a function returns.
- */
+#define PREC_POST (UNARYPREC+3)
-static void
-poplocalvars() {
- struct localvar *lvp;
- struct var *vp;
+#define TOK_POST_INC tok_decl(PREC_POST, 0)
+#define TOK_POST_DEC tok_decl(PREC_POST, 1)
- while ((lvp = localvars) != NULL) {
- localvars = lvp->next;
- vp = lvp->vp;
- if (vp == NULL) { /* $- saved */
- memcpy(optet_vals, lvp->text, sizeof optet_vals);
- ckfree(lvp->text);
- } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
- (void)unsetvar(vp->text);
- } else {
- if ((vp->flags & VTEXTFIXED) == 0)
- ckfree(vp->text);
- vp->flags = lvp->flags;
- vp->text = lvp->text;
- }
- ckfree(lvp);
- }
-}
+#define SPEC_PREC (UNARYPREC+4)
+#define TOK_NUM tok_decl(SPEC_PREC, 0)
+#define TOK_RPAREN tok_decl(SPEC_PREC, 1)
-static int
-setvarcmd(argc, argv)
- int argc;
- char **argv;
+#define NUMPTR (*numstackptr)
+
+static inline int tok_have_assign(operator op)
{
- if (argc <= 2)
- return unsetcmd(argc, argv);
- else if (argc == 3)
- setvar(argv[1], argv[2], 0);
- else
- error("List assignment not implemented");
- return 0;
+ operator prec = PREC(op);
+
+ convert_prec_is_assing(prec);
+ return (prec == PREC(TOK_ASSIGN) ||
+ prec == PREC_PRE || prec == PREC_POST);
}
+static inline int is_right_associativity(operator prec)
+{
+ return (prec == PREC(TOK_ASSIGN) || prec == PREC(TOK_EXPONENT) ||
+ prec == PREC(TOK_CONDITIONAL));
+}
-/*
- * The unset builtin command. We unset the function before we unset the
- * variable to allow a function to be unset when there is a readonly variable
- * with the same name.
- */
-static int
-unsetcmd(argc, argv)
- int argc;
- char **argv;
-{
- char **ap;
- int i;
- int flg_func = 0;
- int flg_var = 0;
- int ret = 0;
+typedef struct ARITCH_VAR_NUM {
+ arith_t val;
+ arith_t contidional_second_val;
+ char contidional_second_val_initialized;
+ char *var; /* if NULL then is regular number,
+ else is variable name */
+} v_n_t;
- while ((i = nextopt("vf")) != '\0') {
- if (i == 'f')
- flg_func = 1;
- else
- flg_var = 1;
- }
- if (flg_func == 0 && flg_var == 0)
- flg_var = 1;
- for (ap = argptr; *ap ; ap++) {
- if (flg_func)
- unsetfunc(*ap);
- if (flg_var)
- ret |= unsetvar(*ap);
- }
- return ret;
-}
+typedef struct CHK_VAR_RECURSIVE_LOOPED {
+ const char *var;
+ struct CHK_VAR_RECURSIVE_LOOPED *next;
+} chk_var_recursive_looped_t;
+static chk_var_recursive_looped_t *prev_chk_var_recursive;
-/*
- * Unset the specified variable.
- */
-static int
-unsetvar(const char *s)
+static int arith_lookup_val(v_n_t *t)
{
- struct var **vpp;
- struct var *vp;
+ if(t->var) {
+ const char * p = lookupvar(t->var);
- vpp = findvar(hashvar(s), s);
- vp = *vpp;
- if (vp) {
- if (vp->flags & VREADONLY)
- return (1);
- INTOFF;
- if (*(strchr(vp->text, '=') + 1) != '\0')
- setvar(s, nullstr, 0);
- vp->flags &= ~VEXPORT;
- vp->flags |= VUNSET;
- if ((vp->flags & VSTRFIXED) == 0) {
- if ((vp->flags & VTEXTFIXED) == 0)
- ckfree(vp->text);
- *vpp = vp->next;
- ckfree(vp);
+ if(p) {
+ int errcode;
+
+ /* recursive try as expression */
+ chk_var_recursive_looped_t *cur;
+ chk_var_recursive_looped_t cur_save;
+
+ for(cur = prev_chk_var_recursive; cur; cur = cur->next) {
+ if(strcmp(cur->var, t->var) == 0) {
+ /* expression recursion loop detected */
+ return -5;
}
- INTON;
- return (0);
+ }
+ /* save current lookuped var name */
+ cur = prev_chk_var_recursive;
+ cur_save.var = t->var;
+ cur_save.next = cur;
+ prev_chk_var_recursive = &cur_save;
+
+ t->val = arith (p, &errcode);
+ /* restore previous ptr after recursiving */
+ prev_chk_var_recursive = cur;
+ return errcode;
+ } else {
+ /* allow undefined var as 0 */
+ t->val = 0;
}
-
- return (0);
+ }
+ return 0;
}
+/* "applying" a token means performing it on the top elements on the integer
+ * stack. For a unary operator it will only change the top element, but a
+ * binary operator will pop two arguments and push a result */
+static inline int
+arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
+{
+ v_n_t *numptr_m1;
+ arith_t numptr_val, rez;
+ int ret_arith_lookup_val;
+
+ if (NUMPTR == numstack) goto err; /* There is no operator that can work
+ without arguments */
+ numptr_m1 = NUMPTR - 1;
+
+ /* check operand is var with noninteger value */
+ ret_arith_lookup_val = arith_lookup_val(numptr_m1);
+ if(ret_arith_lookup_val)
+ return ret_arith_lookup_val;
+
+ rez = numptr_m1->val;
+ if (op == TOK_UMINUS)
+ rez *= -1;
+ else if (op == TOK_NOT)
+ rez = !rez;
+ else if (op == TOK_BNOT)
+ rez = ~rez;
+ else if (op == TOK_POST_INC || op == TOK_PRE_INC)
+ rez++;
+ else if (op == TOK_POST_DEC || op == TOK_PRE_DEC)
+ rez--;
+ else if (op != TOK_UPLUS) {
+ /* Binary operators */
+
+ /* check and binary operators need two arguments */
+ if (numptr_m1 == numstack) goto err;
+
+ /* ... and they pop one */
+ --NUMPTR;
+ numptr_val = rez;
+ if (op == TOK_CONDITIONAL) {
+ if(! numptr_m1->contidional_second_val_initialized) {
+ /* protect $((expr1 ? expr2)) without ": expr" */
+ goto err;
+ }
+ rez = numptr_m1->contidional_second_val;
+ } else if(numptr_m1->contidional_second_val_initialized) {
+ /* protect $((expr1 : expr2)) without "expr ? " */
+ goto err;
+ }
+ numptr_m1 = NUMPTR - 1;
+ if(op != TOK_ASSIGN) {
+ /* check operand is var with noninteger value for not '=' */
+ ret_arith_lookup_val = arith_lookup_val(numptr_m1);
+ if(ret_arith_lookup_val)
+ return ret_arith_lookup_val;
+ }
+ if (op == TOK_CONDITIONAL) {
+ numptr_m1->contidional_second_val = rez;
+ }
+ rez = numptr_m1->val;
+ if (op == TOK_BOR || op == TOK_OR_ASSIGN)
+ rez |= numptr_val;
+ else if (op == TOK_OR)
+ rez = numptr_val || rez;
+ else if (op == TOK_BAND || op == TOK_AND_ASSIGN)
+ rez &= numptr_val;
+ else if (op == TOK_BXOR || op == TOK_XOR_ASSIGN)
+ rez ^= numptr_val;
+ else if (op == TOK_AND)
+ rez = rez && numptr_val;
+ else if (op == TOK_EQ)
+ rez = (rez == numptr_val);
+ else if (op == TOK_NE)
+ rez = (rez != numptr_val);
+ else if (op == TOK_GE)
+ rez = (rez >= numptr_val);
+ else if (op == TOK_RSHIFT || op == TOK_RSHIFT_ASSIGN)
+ rez >>= numptr_val;
+ else if (op == TOK_LSHIFT || op == TOK_LSHIFT_ASSIGN)
+ rez <<= numptr_val;
+ else if (op == TOK_GT)
+ rez = (rez > numptr_val);
+ else if (op == TOK_LT)
+ rez = (rez < numptr_val);
+ else if (op == TOK_LE)
+ rez = (rez <= numptr_val);
+ else if (op == TOK_MUL || op == TOK_MUL_ASSIGN)
+ rez *= numptr_val;
+ else if (op == TOK_ADD || op == TOK_PLUS_ASSIGN)
+ rez += numptr_val;
+ else if (op == TOK_SUB || op == TOK_MINUS_ASSIGN)
+ rez -= numptr_val;
+ else if (op == TOK_ASSIGN || op == TOK_COMMA)
+ rez = numptr_val;
+ else if (op == TOK_CONDITIONAL_SEP) {
+ if (numptr_m1 == numstack) {
+ /* protect $((expr : expr)) without "expr ? " */
+ goto err;
+ }
+ numptr_m1->contidional_second_val_initialized = op;
+ numptr_m1->contidional_second_val = numptr_val;
+ }
+ else if (op == TOK_CONDITIONAL) {
+ rez = rez ?
+ numptr_val : numptr_m1->contidional_second_val;
+ }
+ else if(op == TOK_EXPONENT) {
+ if(numptr_val < 0)
+ return -3; /* exponent less than 0 */
+ else {
+ arith_t c = 1;
+ if(numptr_val)
+ while(numptr_val--)
+ c *= rez;
+ rez = c;
+ }
+ }
+ else if(numptr_val==0) /* zero divisor check */
+ return -2;
+ else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
+ rez /= numptr_val;
+ else if (op == TOK_REM || op == TOK_REM_ASSIGN)
+ rez %= numptr_val;
+ }
+ if(tok_have_assign(op)) {
+ char buf[32];
+
+ if(numptr_m1->var == NULL) {
+ /* Hmm, 1=2 ? */
+ goto err;
+ }
+ /* save to shell variable */
+ snprintf(buf, sizeof(buf), "%lld", (long long) rez);
+ setvar(numptr_m1->var, buf, 0);
+ /* after saving, make previous value for v++ or v-- */
+ if(op == TOK_POST_INC)
+ rez--;
+ else if(op == TOK_POST_DEC)
+ rez++;
+ }
+ numptr_m1->val = rez;
+ /* protect geting var value, is number now */
+ numptr_m1->var = NULL;
+ return 0;
+err: return(-1);
+}
+
+/* longest must first */
+static const char op_tokens[] = {
+ '<','<','=',0, TOK_LSHIFT_ASSIGN,
+ '>','>','=',0, TOK_RSHIFT_ASSIGN,
+ '<','<', 0, TOK_LSHIFT,
+ '>','>', 0, TOK_RSHIFT,
+ '|','|', 0, TOK_OR,
+ '&','&', 0, TOK_AND,
+ '!','=', 0, TOK_NE,
+ '<','=', 0, TOK_LE,
+ '>','=', 0, TOK_GE,
+ '=','=', 0, TOK_EQ,
+ '|','=', 0, TOK_OR_ASSIGN,
+ '&','=', 0, TOK_AND_ASSIGN,
+ '*','=', 0, TOK_MUL_ASSIGN,
+ '/','=', 0, TOK_DIV_ASSIGN,
+ '%','=', 0, TOK_REM_ASSIGN,
+ '+','=', 0, TOK_PLUS_ASSIGN,
+ '-','=', 0, TOK_MINUS_ASSIGN,
+ '-','-', 0, TOK_POST_DEC,
+ '^','=', 0, TOK_XOR_ASSIGN,
+ '+','+', 0, TOK_POST_INC,
+ '*','*', 0, TOK_EXPONENT,
+ '!', 0, TOK_NOT,
+ '<', 0, TOK_LT,
+ '>', 0, TOK_GT,
+ '=', 0, TOK_ASSIGN,
+ '|', 0, TOK_BOR,
+ '&', 0, TOK_BAND,
+ '*', 0, TOK_MUL,
+ '/', 0, TOK_DIV,
+ '%', 0, TOK_REM,
+ '+', 0, TOK_ADD,
+ '-', 0, TOK_SUB,
+ '^', 0, TOK_BXOR,
+ /* uniq */
+ '~', 0, TOK_BNOT,
+ ',', 0, TOK_COMMA,
+ '?', 0, TOK_CONDITIONAL,
+ ':', 0, TOK_CONDITIONAL_SEP,
+ ')', 0, TOK_RPAREN,
+ '(', 0, TOK_LPAREN,
+ 0
+};
+/* ptr to ")" */
+#define endexpression &op_tokens[sizeof(op_tokens)-7]
-/*
- * Find the appropriate entry in the hash table from the name.
- */
-static struct var **
-hashvar(const char *p)
+static arith_t arith (const char *expr, int *perrcode)
{
- unsigned int hashval;
-
- hashval = ((unsigned char) *p) << 4;
- while (*p && *p != '=')
- hashval += (unsigned char) *p++;
- return &vartab[hashval % VTABSIZE];
-}
+ register char arithval; /* Current character under analysis */
+ operator lasttok, op;
+ operator prec;
+ const char *p = endexpression;
+ int errcode;
+ size_t datasizes = strlen(expr) + 2;
-/*
- * Returns true if the two strings specify the same varable. The first
- * variable name is terminated by '='; the second may be terminated by
- * either '=' or '\0'.
- */
+ /* Stack of integers */
+ /* The proof that there can be no more than strlen(startbuf)/2+1 integers
+ * in any given correct or incorrect expression is left as an exercise to
+ * the reader. */
+ v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
+ *numstackptr = numstack;
+ /* Stack of operator tokens */
+ operator *stack = alloca((datasizes) * sizeof(operator)),
+ *stackptr = stack;
-static int
-varequal(const char *p, const char *q)
-{
- while (*p == *q++) {
- if (*p++ == '=')
- return 1;
- }
- if (*p == '=' && *(q - 1) == '\0')
- return 1;
- return 0;
-}
+ *stackptr++ = lasttok = TOK_LPAREN; /* start off with a left paren */
+ *perrcode = errcode = 0;
-static void
-showvars(const char *myprefix, int mask, int xor)
-{
- struct var **vpp;
- struct var *vp;
- const char *sep = myprefix == nullstr ? myprefix : spcstr;
+ while(1) {
+ if ((arithval = *expr) == 0) {
+ if (p == endexpression) {
+ /* Null expression. */
+ return 0;
+ }
- for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
- for (vp = *vpp ; vp ; vp = vp->next) {
- if ((vp->flags & mask) ^ xor) {
- char *p;
- int len;
+ /* This is only reached after all tokens have been extracted from the
+ * input stream. If there are still tokens on the operator stack, they
+ * are to be applied in order. At the end, there should be a final
+ * result on the integer stack */
- p = strchr(vp->text, '=') + 1;
- len = p - vp->text;
- p = single_quote(p);
+ if (expr != endexpression + 1) {
+ /* If we haven't done so already, */
+ /* append a closing right paren */
+ expr = endexpression;
+ /* and let the loop process it. */
+ continue;
+ }
+ /* At this point, we're done with the expression. */
+ if (numstackptr != numstack+1) {
+ /* ... but if there isn't, it's bad */
+ err:
+ return (*perrcode = -1);
+ }
+ if(numstack->var) {
+ /* expression is $((var)) only, lookup now */
+ errcode = arith_lookup_val(numstack);
+ }
+ ret:
+ *perrcode = errcode;
+ return numstack->val;
+ } else {
+ /* Continue processing the expression. */
+ if (arith_isspace(arithval)) {
+ /* Skip whitespace */
+ goto prologue;
+ }
+ if((p = endofname(expr)) != expr) {
+ size_t var_name_size = (p-expr) + 1; /* trailing zero */
+
+ numstackptr->var = alloca(var_name_size);
+ safe_strncpy(numstackptr->var, expr, var_name_size);
+ expr = p;
+ num:
+ numstackptr->contidional_second_val_initialized = 0;
+ numstackptr++;
+ lasttok = TOK_NUM;
+ continue;
+ } else if (is_digit(arithval)) {
+ numstackptr->var = NULL;
+ numstackptr->val = strtoll(expr, (char **) &expr, 0);
+ goto num;
+ }
+ for(p = op_tokens; ; p++) {
+ const char *o;
- printf("%s%s%.*s%s\n", myprefix, sep, len,
- vp->text, p);
- stunalloc(p);
+ if(*p == 0) {
+ /* strange operator not found */
+ goto err;
+ }
+ for(o = expr; *p && *o == *p; p++)
+ o++;
+ if(! *p) {
+ /* found */
+ expr = o - 1;
+ break;
+ }
+ /* skip tail uncompared token */
+ while(*p)
+ p++;
+ /* skip zero delim */
+ p++;
+ }
+ op = p[1];
+
+ /* post grammar: a++ reduce to num */
+ if(lasttok == TOK_POST_INC || lasttok == TOK_POST_DEC)
+ lasttok = TOK_NUM;
+
+ /* Plus and minus are binary (not unary) _only_ if the last
+ * token was as number, or a right paren (which pretends to be
+ * a number, since it evaluates to one). Think about it.
+ * It makes sense. */
+ if (lasttok != TOK_NUM) {
+ switch(op) {
+ case TOK_ADD:
+ op = TOK_UPLUS;
+ break;
+ case TOK_SUB:
+ op = TOK_UMINUS;
+ break;
+ case TOK_POST_INC:
+ op = TOK_PRE_INC;
+ break;
+ case TOK_POST_DEC:
+ op = TOK_PRE_DEC;
+ break;
}
}
- }
-}
+ /* We don't want a unary operator to cause recursive descent on the
+ * stack, because there can be many in a row and it could cause an
+ * operator to be evaluated before its argument is pushed onto the
+ * integer stack. */
+ /* But for binary operators, "apply" everything on the operator
+ * stack until we find an operator with a lesser priority than the
+ * one we have just extracted. */
+ /* Left paren is given the lowest priority so it will never be
+ * "applied" in this way.
+ * if associativity is right and priority eq, applied also skip
+ */
+ prec = PREC(op);
+ if ((prec > 0 && prec < UNARYPREC) || prec == SPEC_PREC) {
+ /* not left paren or unary */
+ if (lasttok != TOK_NUM) {
+ /* binary op must be preceded by a num */
+ goto err;
+ }
+ while (stackptr != stack) {
+ if (op == TOK_RPAREN) {
+ /* The algorithm employed here is simple: while we don't
+ * hit an open paren nor the bottom of the stack, pop
+ * tokens and apply them */
+ if (stackptr[-1] == TOK_LPAREN) {
+ --stackptr;
+ /* Any operator directly after a */
+ lasttok = TOK_NUM;
+ /* close paren should consider itself binary */
+ goto prologue;
+ }
+ } else {
+ operator prev_prec = PREC(stackptr[-1]);
-static struct var **
-findvar(struct var **vpp, const char *name)
-{
- for (; *vpp; vpp = &(*vpp)->next) {
- if (varequal((*vpp)->text, name)) {
- break;
+ convert_prec_is_assing(prec);
+ convert_prec_is_assing(prev_prec);
+ if (prev_prec < prec)
+ break;
+ /* check right assoc */
+ if(prev_prec == prec && is_right_associativity(prec))
+ break;
+ }
+ errcode = arith_apply(*--stackptr, numstack, &numstackptr);
+ if(errcode) goto ret;
+ }
+ if (op == TOK_RPAREN) {
+ goto err;
+ }
}
+
+ /* Push this operator to the stack and remember it. */
+ *stackptr++ = lasttok = op;
+
+ prologue:
+ ++expr;
}
- return vpp;
+ }
}
+#endif /* CONFIG_ASH_MATH_SUPPORT */
-/*
- * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
- * This file contains code for the times builtin.
- * $Id: ash.c,v 1.11 2001/07/17 01:12:35 andersen Exp $
- */
-static int timescmd (int argc, char **argv)
-{
- struct tms buf;
- long int clk_tck = sysconf(_SC_CLK_TCK);
- times(&buf);
- printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
- (int) (buf.tms_utime / clk_tck / 60),
- ((double) buf.tms_utime) / clk_tck,
- (int) (buf.tms_stime / clk_tck / 60),
- ((double) buf.tms_stime) / clk_tck,
- (int) (buf.tms_cutime / clk_tck / 60),
- ((double) buf.tms_cutime) / clk_tck,
- (int) (buf.tms_cstime / clk_tck / 60),
- ((double) buf.tms_cstime) / clk_tck);
- return 0;
+#ifdef DEBUG
+const char *bb_applet_name = "debug stuff usage";
+int main(int argc, char **argv)
+{
+ return ash_main(argc, argv);
}
-
+#endif
/*-
* Copyright (c) 1989, 1991, 1993, 1994