aboutsummaryrefslogtreecommitdiff
path: root/bin/ksh/c_ksh.c
diff options
context:
space:
mode:
Diffstat (limited to 'bin/ksh/c_ksh.c')
-rw-r--r--bin/ksh/c_ksh.c1409
1 files changed, 1409 insertions, 0 deletions
diff --git a/bin/ksh/c_ksh.c b/bin/ksh/c_ksh.c
new file mode 100644
index 0000000..f29a3e1
--- /dev/null
+++ b/bin/ksh/c_ksh.c
@@ -0,0 +1,1409 @@
+/* $OpenBSD: c_ksh.c,v 1.50 2016/03/21 13:35:00 tb Exp $ */
+
+/*
+ * built-in Korn commands: c_*
+ */
+
+#include <sys/stat.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "sh.h"
+
+int
+c_cd(char **wp)
+{
+ int optc;
+ int physical = Flag(FPHYSICAL);
+ int cdnode; /* was a node from cdpath added in? */
+ int printpath = 0; /* print where we cd'd? */
+ int rval;
+ struct tbl *pwd_s, *oldpwd_s;
+ XString xs;
+ char *xp;
+ char *dir, *try, *pwd;
+ int phys_path;
+ char *cdpath;
+ char *fdir = NULL;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1)
+ switch (optc) {
+ case 'L':
+ physical = 0;
+ break;
+ case 'P':
+ physical = 1;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+
+ if (Flag(FRESTRICTED)) {
+ bi_errorf("restricted shell - can't cd");
+ return 1;
+ }
+
+ pwd_s = global("PWD");
+ oldpwd_s = global("OLDPWD");
+
+ if (!wp[0]) {
+ /* No arguments - go home */
+ if ((dir = str_val(global("HOME"))) == null) {
+ bi_errorf("no home directory (HOME not set)");
+ return 1;
+ }
+ } else if (!wp[1]) {
+ /* One argument: - or dir */
+ dir = wp[0];
+ if (strcmp(dir, "-") == 0) {
+ dir = str_val(oldpwd_s);
+ if (dir == null) {
+ bi_errorf("no OLDPWD");
+ return 1;
+ }
+ printpath++;
+ }
+ } else if (!wp[2]) {
+ /* Two arguments - substitute arg1 in PWD for arg2 */
+ int ilen, olen, nlen, elen;
+ char *cp;
+
+ if (!current_wd[0]) {
+ bi_errorf("don't know current directory");
+ return 1;
+ }
+ /* substitute arg1 for arg2 in current path.
+ * if the first substitution fails because the cd fails
+ * we could try to find another substitution. For now
+ * we don't
+ */
+ if ((cp = strstr(current_wd, wp[0])) == NULL) {
+ bi_errorf("bad substitution");
+ return 1;
+ }
+ ilen = cp - current_wd;
+ olen = strlen(wp[0]);
+ nlen = strlen(wp[1]);
+ elen = strlen(current_wd + ilen + olen) + 1;
+ fdir = dir = alloc(ilen + nlen + elen, ATEMP);
+ memcpy(dir, current_wd, ilen);
+ memcpy(dir + ilen, wp[1], nlen);
+ memcpy(dir + ilen + nlen, current_wd + ilen + olen, elen);
+ printpath++;
+ } else {
+ bi_errorf("too many arguments");
+ return 1;
+ }
+
+ Xinit(xs, xp, PATH, ATEMP);
+ /* xp will have a bogus value after make_path() - set it to 0
+ * so that if it's used, it will cause a dump
+ */
+ xp = NULL;
+
+ cdpath = str_val(global("CDPATH"));
+ do {
+ cdnode = make_path(current_wd, dir, &cdpath, &xs, &phys_path);
+ if (physical)
+ rval = chdir(try = Xstring(xs, xp) + phys_path);
+ else {
+ simplify_path(Xstring(xs, xp));
+ rval = chdir(try = Xstring(xs, xp));
+ }
+ } while (rval < 0 && cdpath != NULL);
+
+ if (rval < 0) {
+ if (cdnode)
+ bi_errorf("%s: bad directory", dir);
+ else
+ bi_errorf("%s - %s", try, strerror(errno));
+ afree(fdir, ATEMP);
+ return 1;
+ }
+
+ /* Clear out tracked aliases with relative paths */
+ flushcom(0);
+
+ /* Set OLDPWD (note: unsetting OLDPWD does not disable this
+ * setting in at&t ksh)
+ */
+ if (current_wd[0])
+ /* Ignore failure (happens if readonly or integer) */
+ setstr(oldpwd_s, current_wd, KSH_RETURN_ERROR);
+
+ if (Xstring(xs, xp)[0] != '/') {
+ pwd = NULL;
+ } else
+ if (!physical || !(pwd = get_phys_path(Xstring(xs, xp))))
+ pwd = Xstring(xs, xp);
+
+ /* Set PWD */
+ if (pwd) {
+ char *ptmp = pwd;
+ set_current_wd(ptmp);
+ /* Ignore failure (happens if readonly or integer) */
+ setstr(pwd_s, ptmp, KSH_RETURN_ERROR);
+ } else {
+ set_current_wd(null);
+ pwd = Xstring(xs, xp);
+ /* XXX unset $PWD? */
+ }
+ if (printpath || cdnode)
+ shprintf("%s\n", pwd);
+
+ afree(fdir, ATEMP);
+
+ return 0;
+}
+
+int
+c_pwd(char **wp)
+{
+ int optc;
+ int physical = Flag(FPHYSICAL);
+ char *p, *freep = NULL;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1)
+ switch (optc) {
+ case 'L':
+ physical = 0;
+ break;
+ case 'P':
+ physical = 1;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+
+ if (wp[0]) {
+ bi_errorf("too many arguments");
+ return 1;
+ }
+ p = current_wd[0] ? (physical ? get_phys_path(current_wd) : current_wd) :
+ NULL;
+ if (p && access(p, R_OK) < 0)
+ p = NULL;
+ if (!p) {
+ freep = p = ksh_get_wd(NULL, 0);
+ if (!p) {
+ bi_errorf("can't get current directory - %s",
+ strerror(errno));
+ return 1;
+ }
+ }
+ shprintf("%s\n", p);
+ afree(freep, ATEMP);
+ return 0;
+}
+
+int
+c_print(char **wp)
+{
+#define PO_NL BIT(0) /* print newline */
+#define PO_EXPAND BIT(1) /* expand backslash sequences */
+#define PO_PMINUSMINUS BIT(2) /* print a -- argument */
+#define PO_HIST BIT(3) /* print to history instead of stdout */
+#define PO_COPROC BIT(4) /* printing to coprocess: block SIGPIPE */
+ int fd = 1;
+ int flags = PO_EXPAND|PO_NL;
+ char *s;
+ const char *emsg;
+ XString xs;
+ char *xp;
+
+ if (wp[0][0] == 'e') { /* echo command */
+ int nflags = flags;
+
+ /* A compromise between sysV and BSD echo commands:
+ * escape sequences are enabled by default, and
+ * -n, -e and -E are recognized if they appear
+ * in arguments with no illegal options (ie, echo -nq
+ * will print -nq).
+ * Different from sysV echo since options are recognized,
+ * different from BSD echo since escape sequences are enabled
+ * by default.
+ */
+ wp += 1;
+ if (Flag(FPOSIX)) {
+ if (*wp && strcmp(*wp, "-n") == 0) {
+ flags &= ~PO_NL;
+ wp++;
+ }
+ } else {
+ while ((s = *wp) && *s == '-' && s[1]) {
+ while (*++s)
+ if (*s == 'n')
+ nflags &= ~PO_NL;
+ else if (*s == 'e')
+ nflags |= PO_EXPAND;
+ else if (*s == 'E')
+ nflags &= ~PO_EXPAND;
+ else
+ /* bad option: don't use
+ * nflags, print argument
+ */
+ break;
+ if (*s)
+ break;
+ wp++;
+ flags = nflags;
+ }
+ }
+ } else {
+ int optc;
+ const char *options = "Rnprsu,";
+ while ((optc = ksh_getopt(wp, &builtin_opt, options)) != -1)
+ switch (optc) {
+ case 'R': /* fake BSD echo command */
+ flags |= PO_PMINUSMINUS;
+ flags &= ~PO_EXPAND;
+ options = "ne";
+ break;
+ case 'e':
+ flags |= PO_EXPAND;
+ break;
+ case 'n':
+ flags &= ~PO_NL;
+ break;
+ case 'p':
+ if ((fd = coproc_getfd(W_OK, &emsg)) < 0) {
+ bi_errorf("-p: %s", emsg);
+ return 1;
+ }
+ break;
+ case 'r':
+ flags &= ~PO_EXPAND;
+ break;
+ case 's':
+ flags |= PO_HIST;
+ break;
+ case 'u':
+ if (!*(s = builtin_opt.optarg))
+ fd = 0;
+ else if ((fd = check_fd(s, W_OK, &emsg)) < 0) {
+ bi_errorf("-u: %s: %s", s, emsg);
+ return 1;
+ }
+ break;
+ case '?':
+ return 1;
+ }
+ if (!(builtin_opt.info & GI_MINUSMINUS)) {
+ /* treat a lone - like -- */
+ if (wp[builtin_opt.optind] &&
+ strcmp(wp[builtin_opt.optind], "-") == 0)
+ builtin_opt.optind++;
+ } else if (flags & PO_PMINUSMINUS)
+ builtin_opt.optind--;
+ wp += builtin_opt.optind;
+ }
+
+ Xinit(xs, xp, 128, ATEMP);
+
+ while (*wp != NULL) {
+ int c;
+ s = *wp;
+ while ((c = *s++) != '\0') {
+ Xcheck(xs, xp);
+ if ((flags & PO_EXPAND) && c == '\\') {
+ int i;
+
+ switch ((c = *s++)) {
+ /* Oddly enough, \007 seems more portable than
+ * \a (due to HP-UX cc, Ultrix cc, old pcc's,
+ * etc.).
+ */
+ case 'a': c = '\007'; break;
+ case 'b': c = '\b'; break;
+ case 'c': flags &= ~PO_NL;
+ continue; /* AT&T brain damage */
+ case 'f': c = '\f'; break;
+ case 'n': c = '\n'; break;
+ case 'r': c = '\r'; break;
+ case 't': c = '\t'; break;
+ case 'v': c = 0x0B; break;
+ case '0':
+ /* Look for an octal number: can have
+ * three digits (not counting the
+ * leading 0). Truly burnt.
+ */
+ c = 0;
+ for (i = 0; i < 3; i++) {
+ if (*s >= '0' && *s <= '7')
+ c = c*8 + *s++ - '0';
+ else
+ break;
+ }
+ break;
+ case '\0': s--; c = '\\'; break;
+ case '\\': break;
+ default:
+ Xput(xs, xp, '\\');
+ }
+ }
+ Xput(xs, xp, c);
+ }
+ if (*++wp != NULL)
+ Xput(xs, xp, ' ');
+ }
+ if (flags & PO_NL)
+ Xput(xs, xp, '\n');
+
+ if (flags & PO_HIST) {
+ Xput(xs, xp, '\0');
+ source->line++;
+ histsave(source->line, Xstring(xs, xp), 1);
+ Xfree(xs, xp);
+ } else {
+ int n, len = Xlength(xs, xp);
+ int opipe = 0;
+
+ /* Ensure we aren't killed by a SIGPIPE while writing to
+ * a coprocess. at&t ksh doesn't seem to do this (seems
+ * to just check that the co-process is alive, which is
+ * not enough).
+ */
+ if (coproc.write >= 0 && coproc.write == fd) {
+ flags |= PO_COPROC;
+ opipe = block_pipe();
+ }
+ for (s = Xstring(xs, xp); len > 0; ) {
+ n = write(fd, s, len);
+ if (n < 0) {
+ if (flags & PO_COPROC)
+ restore_pipe(opipe);
+ if (errno == EINTR) {
+ /* allow user to ^C out */
+ intrcheck();
+ if (flags & PO_COPROC)
+ opipe = block_pipe();
+ continue;
+ }
+ /* This doesn't really make sense - could
+ * break scripts (print -p generates
+ * error message).
+ *if (errno == EPIPE)
+ * coproc_write_close(fd);
+ */
+ return 1;
+ }
+ s += n;
+ len -= n;
+ }
+ if (flags & PO_COPROC)
+ restore_pipe(opipe);
+ }
+
+ return 0;
+}
+
+int
+c_whence(char **wp)
+{
+ struct tbl *tp;
+ char *id;
+ int pflag = 0, vflag = 0, Vflag = 0;
+ int ret = 0;
+ int optc;
+ int iam_whence = wp[0][0] == 'w';
+ int fcflags;
+ const char *options = iam_whence ? "pv" : "pvV";
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, options)) != -1)
+ switch (optc) {
+ case 'p':
+ pflag = 1;
+ break;
+ case 'v':
+ vflag = 1;
+ break;
+ case 'V':
+ Vflag = 1;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+
+
+ fcflags = FC_BI | FC_PATH | FC_FUNC;
+ if (!iam_whence) {
+ /* Note that -p on its own is dealt with in comexec() */
+ if (pflag)
+ fcflags |= FC_DEFPATH;
+ /* Convert command options to whence options. Note that
+ * command -pV and command -pv use a different path search
+ * than whence -v or whence -pv. This should be considered
+ * a feature.
+ */
+ vflag = Vflag;
+ } else if (pflag)
+ fcflags &= ~(FC_BI | FC_FUNC);
+
+ while ((vflag || ret == 0) && (id = *wp++) != NULL) {
+ tp = NULL;
+ if (!iam_whence || !pflag)
+ tp = ktsearch(&keywords, id, hash(id));
+ if (!tp && (!iam_whence || !pflag)) {
+ tp = ktsearch(&aliases, id, hash(id));
+ if (tp && !(tp->flag & ISSET))
+ tp = NULL;
+ }
+ if (!tp)
+ tp = findcom(id, fcflags);
+ if (vflag || (tp->type != CALIAS && tp->type != CEXEC &&
+ tp->type != CTALIAS))
+ shprintf("%s", id);
+ switch (tp->type) {
+ case CKEYWD:
+ if (vflag)
+ shprintf(" is a reserved word");
+ break;
+ case CALIAS:
+ if (vflag)
+ shprintf(" is an %salias for ",
+ (tp->flag & EXPORT) ? "exported " : "");
+ if (!iam_whence && !vflag)
+ shprintf("alias %s=", id);
+ print_value_quoted(tp->val.s);
+ break;
+ case CFUNC:
+ if (vflag) {
+ shprintf(" is a");
+ if (tp->flag & EXPORT)
+ shprintf("n exported");
+ if (tp->flag & TRACE)
+ shprintf(" traced");
+ if (!(tp->flag & ISSET)) {
+ shprintf(" undefined");
+ if (tp->u.fpath)
+ shprintf(" (autoload from %s)",
+ tp->u.fpath);
+ }
+ shprintf(" function");
+ }
+ break;
+ case CSHELL:
+ if (vflag)
+ shprintf(" is a%s shell builtin",
+ (tp->flag & SPEC_BI) ? " special" : "");
+ break;
+ case CTALIAS:
+ case CEXEC:
+ if (tp->flag & ISSET) {
+ if (vflag) {
+ shprintf(" is ");
+ if (tp->type == CTALIAS)
+ shprintf("a tracked %salias for ",
+ (tp->flag & EXPORT) ?
+ "exported " : "");
+ }
+ shprintf("%s", tp->val.s);
+ } else {
+ if (vflag)
+ shprintf(" not found");
+ ret = 1;
+ }
+ break;
+ default:
+ shprintf("%s is *GOK*", id);
+ break;
+ }
+ if (vflag || !ret)
+ shprintf("\n");
+ }
+ return ret;
+}
+
+/* Deal with command -vV - command -p dealt with in comexec() */
+int
+c_command(char **wp)
+{
+ /* Let c_whence do the work. Note that c_command() must be
+ * a distinct function from c_whence() (tested in comexec()).
+ */
+ return c_whence(wp);
+}
+
+/* typeset, export, and readonly */
+int
+c_typeset(char **wp)
+{
+ struct block *l;
+ struct tbl *vp, **p;
+ int fset = 0, fclr = 0, thing = 0, func = 0, local = 0, pflag = 0;
+ const char *options = "L#R#UZ#fi#lprtux"; /* see comment below */
+ char *fieldstr, *basestr;
+ int field, base, optc, flag;
+
+ switch (**wp) {
+ case 'e': /* export */
+ fset |= EXPORT;
+ options = "p";
+ break;
+ case 'r': /* readonly */
+ fset |= RDONLY;
+ options = "p";
+ break;
+ case 's': /* set */
+ /* called with 'typeset -' */
+ break;
+ case 't': /* typeset */
+ local = 1;
+ break;
+ }
+
+ fieldstr = basestr = NULL;
+ builtin_opt.flags |= GF_PLUSOPT;
+ /* at&t ksh seems to have 0-9 as options, which are multiplied
+ * to get a number that is used with -L, -R, -Z or -i (eg, -1R2
+ * sets right justify in a field of 12). This allows options
+ * to be grouped in an order (eg, -Lu12), but disallows -i8 -L3 and
+ * does not allow the number to be specified as a separate argument
+ * Here, the number must follow the RLZi option, but is optional
+ * (see the # kludge in ksh_getopt()).
+ */
+ while ((optc = ksh_getopt(wp, &builtin_opt, options)) != -1) {
+ flag = 0;
+ switch (optc) {
+ case 'L':
+ flag = LJUST;
+ fieldstr = builtin_opt.optarg;
+ break;
+ case 'R':
+ flag = RJUST;
+ fieldstr = builtin_opt.optarg;
+ break;
+ case 'U':
+ /* at&t ksh uses u, but this conflicts with
+ * upper/lower case. If this option is changed,
+ * need to change the -U below as well
+ */
+ flag = INT_U;
+ break;
+ case 'Z':
+ flag = ZEROFIL;
+ fieldstr = builtin_opt.optarg;
+ break;
+ case 'f':
+ func = 1;
+ break;
+ case 'i':
+ flag = INTEGER;
+ basestr = builtin_opt.optarg;
+ break;
+ case 'l':
+ flag = LCASEV;
+ break;
+ case 'p':
+ /* posix export/readonly -p flag.
+ * typeset -p is the same as typeset (in pdksh);
+ * here for compatibility with ksh93.
+ */
+ pflag = 1;
+ break;
+ case 'r':
+ flag = RDONLY;
+ break;
+ case 't':
+ flag = TRACE;
+ break;
+ case 'u':
+ flag = UCASEV_AL; /* upper case / autoload */
+ break;
+ case 'x':
+ flag = EXPORT;
+ break;
+ case '?':
+ return 1;
+ }
+ if (builtin_opt.info & GI_PLUS) {
+ fclr |= flag;
+ fset &= ~flag;
+ thing = '+';
+ } else {
+ fset |= flag;
+ fclr &= ~flag;
+ thing = '-';
+ }
+ }
+
+ field = 0;
+ if (fieldstr && !bi_getn(fieldstr, &field))
+ return 1;
+ base = 0;
+ if (basestr && !bi_getn(basestr, &base))
+ return 1;
+
+ if (!(builtin_opt.info & GI_MINUSMINUS) && wp[builtin_opt.optind] &&
+ (wp[builtin_opt.optind][0] == '-' ||
+ wp[builtin_opt.optind][0] == '+') &&
+ wp[builtin_opt.optind][1] == '\0') {
+ thing = wp[builtin_opt.optind][0];
+ builtin_opt.optind++;
+ }
+
+ if (func && ((fset|fclr) & ~(TRACE|UCASEV_AL|EXPORT))) {
+ bi_errorf("only -t, -u and -x options may be used with -f");
+ return 1;
+ }
+ if (wp[builtin_opt.optind]) {
+ /* Take care of exclusions.
+ * At this point, flags in fset are cleared in fclr and vise
+ * versa. This property should be preserved.
+ */
+ if (fset & LCASEV) /* LCASEV has priority over UCASEV_AL */
+ fset &= ~UCASEV_AL;
+ if (fset & LJUST) /* LJUST has priority over RJUST */
+ fset &= ~RJUST;
+ if ((fset & (ZEROFIL|LJUST)) == ZEROFIL) { /* -Z implies -ZR */
+ fset |= RJUST;
+ fclr &= ~RJUST;
+ }
+ /* Setting these attributes clears the others, unless they
+ * are also set in this command
+ */
+ if (fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | LCASEV |
+ INTEGER | INT_U | INT_L))
+ fclr |= ~fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL |
+ LCASEV | INTEGER | INT_U | INT_L);
+ }
+
+ /* set variables and attributes */
+ if (wp[builtin_opt.optind]) {
+ int i;
+ int rval = 0;
+ struct tbl *f;
+
+ if (local && !func)
+ fset |= LOCAL;
+ for (i = builtin_opt.optind; wp[i]; i++) {
+ if (func) {
+ f = findfunc(wp[i], hash(wp[i]),
+ (fset&UCASEV_AL) ? true : false);
+ if (!f) {
+ /* at&t ksh does ++rval: bogus */
+ rval = 1;
+ continue;
+ }
+ if (fset | fclr) {
+ f->flag |= fset;
+ f->flag &= ~fclr;
+ } else
+ fptreef(shl_stdout, 0,
+ f->flag & FKSH ?
+ "function %s %T\n" :
+ "%s() %T\n", wp[i], f->val.t);
+ } else if (!typeset(wp[i], fset, fclr, field, base)) {
+ bi_errorf("%s: not identifier", wp[i]);
+ return 1;
+ }
+ }
+ return rval;
+ }
+
+ /* list variables and attributes */
+ flag = fset | fclr; /* no difference at this point.. */
+ if (func) {
+ for (l = genv->loc; l; l = l->next) {
+ for (p = ktsort(&l->funs); (vp = *p++); ) {
+ if (flag && (vp->flag & flag) == 0)
+ continue;
+ if (thing == '-')
+ fptreef(shl_stdout, 0, vp->flag & FKSH ?
+ "function %s %T\n" : "%s() %T\n",
+ vp->name, vp->val.t);
+ else
+ shprintf("%s\n", vp->name);
+ }
+ }
+ } else {
+ for (l = genv->loc; l; l = l->next) {
+ for (p = ktsort(&l->vars); (vp = *p++); ) {
+ struct tbl *tvp;
+ int any_set = 0;
+ /*
+ * See if the parameter is set (for arrays, if any
+ * element is set).
+ */
+ for (tvp = vp; tvp; tvp = tvp->u.array)
+ if (tvp->flag & ISSET) {
+ any_set = 1;
+ break;
+ }
+
+ /*
+ * Check attributes - note that all array elements
+ * have (should have?) the same attributes, so checking
+ * the first is sufficient.
+ *
+ * Report an unset param only if the user has
+ * explicitly given it some attribute (like export);
+ * otherwise, after "echo $FOO", we would report FOO...
+ */
+ if (!any_set && !(vp->flag & USERATTRIB))
+ continue;
+ if (flag && (vp->flag & flag) == 0)
+ continue;
+ for (; vp; vp = vp->u.array) {
+ /* Ignore array elements that aren't
+ * set unless there are no set elements,
+ * in which case the first is reported on */
+ if ((vp->flag&ARRAY) && any_set &&
+ !(vp->flag & ISSET))
+ continue;
+ /* no arguments */
+ if (thing == 0 && flag == 0) {
+ /* at&t ksh prints things
+ * like export, integer,
+ * leftadj, zerofill, etc.,
+ * but POSIX says must
+ * be suitable for re-entry...
+ */
+ shprintf("typeset ");
+ if ((vp->flag&INTEGER))
+ shprintf("-i ");
+ if ((vp->flag&EXPORT))
+ shprintf("-x ");
+ if ((vp->flag&RDONLY))
+ shprintf("-r ");
+ if ((vp->flag&TRACE))
+ shprintf("-t ");
+ if ((vp->flag&LJUST))
+ shprintf("-L%d ", vp->u2.field);
+ if ((vp->flag&RJUST))
+ shprintf("-R%d ", vp->u2.field);
+ if ((vp->flag&ZEROFIL))
+ shprintf("-Z ");
+ if ((vp->flag&LCASEV))
+ shprintf("-l ");
+ if ((vp->flag&UCASEV_AL))
+ shprintf("-u ");
+ if ((vp->flag&INT_U))
+ shprintf("-U ");
+ shprintf("%s\n", vp->name);
+ if (vp->flag&ARRAY)
+ break;
+ } else {
+ if (pflag)
+ shprintf("%s ",
+ (flag & EXPORT) ?
+ "export" : "readonly");
+ if ((vp->flag&ARRAY) && any_set)
+ shprintf("%s[%d]",
+ vp->name, vp->index);
+ else
+ shprintf("%s", vp->name);
+ if (thing == '-' && (vp->flag&ISSET)) {
+ char *s = str_val(vp);
+
+ shprintf("=");
+ /* at&t ksh can't have
+ * justified integers.. */
+ if ((vp->flag &
+ (INTEGER|LJUST|RJUST)) ==
+ INTEGER)
+ shprintf("%s", s);
+ else
+ print_value_quoted(s);
+ }
+ shprintf("\n");
+ }
+ /* Only report first `element' of an array with
+ * no set elements.
+ */
+ if (!any_set)
+ break;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+int
+c_alias(char **wp)
+{
+ struct table *t = &aliases;
+ int rv = 0, rflag = 0, tflag, Uflag = 0, pflag = 0, prefix = 0;
+ int xflag = 0;
+ int optc;
+
+ builtin_opt.flags |= GF_PLUSOPT;
+ while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != -1) {
+ prefix = builtin_opt.info & GI_PLUS ? '+' : '-';
+ switch (optc) {
+ case 'd':
+ t = &homedirs;
+ break;
+ case 'p':
+ pflag = 1;
+ break;
+ case 'r':
+ rflag = 1;
+ break;
+ case 't':
+ t = &taliases;
+ break;
+ case 'U':
+ /*
+ * kludge for tracked alias initialization
+ * (don't do a path search, just make an entry)
+ */
+ Uflag = 1;
+ break;
+ case 'x':
+ xflag = EXPORT;
+ break;
+ case '?':
+ return 1;
+ }
+ }
+ wp += builtin_opt.optind;
+
+ if (!(builtin_opt.info & GI_MINUSMINUS) && *wp &&
+ (wp[0][0] == '-' || wp[0][0] == '+') && wp[0][1] == '\0') {
+ prefix = wp[0][0];
+ wp++;
+ }
+
+ tflag = t == &taliases;
+
+ /* "hash -r" means reset all the tracked aliases.. */
+ if (rflag) {
+ static const char *const args[] = {
+ "unalias", "-ta", NULL
+ };
+
+ if (!tflag || *wp) {
+ shprintf("alias: -r flag can only be used with -t"
+ " and without arguments\n");
+ return 1;
+ }
+ ksh_getopt_reset(&builtin_opt, GF_ERROR);
+ return c_unalias((char **) args);
+ }
+
+ if (*wp == NULL) {
+ struct tbl *ap, **p;
+
+ for (p = ktsort(t); (ap = *p++) != NULL; )
+ if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) {
+ if (pflag)
+ shf_puts("alias ", shl_stdout);
+ shf_puts(ap->name, shl_stdout);
+ if (prefix != '+') {
+ shf_putc('=', shl_stdout);
+ print_value_quoted(ap->val.s);
+ }
+ shprintf("\n");
+ }
+ }
+
+ for (; *wp != NULL; wp++) {
+ char *alias = *wp;
+ char *val = strchr(alias, '=');
+ char *newval;
+ struct tbl *ap;
+ int h;
+
+ if (val)
+ alias = str_nsave(alias, val++ - alias, ATEMP);
+ h = hash(alias);
+ if (val == NULL && !tflag && !xflag) {
+ ap = ktsearch(t, alias, h);
+ if (ap != NULL && (ap->flag&ISSET)) {
+ if (pflag)
+ shf_puts("alias ", shl_stdout);
+ shf_puts(ap->name, shl_stdout);
+ if (prefix != '+') {
+ shf_putc('=', shl_stdout);
+ print_value_quoted(ap->val.s);
+ }
+ shprintf("\n");
+ } else {
+ shprintf("%s alias not found\n", alias);
+ rv = 1;
+ }
+ continue;
+ }
+ ap = ktenter(t, alias, h);
+ ap->type = tflag ? CTALIAS : CALIAS;
+ /* Are we setting the value or just some flags? */
+ if ((val && !tflag) || (!val && tflag && !Uflag)) {
+ if (ap->flag&ALLOC) {
+ ap->flag &= ~(ALLOC|ISSET);
+ afree(ap->val.s, APERM);
+ }
+ /* ignore values for -t (at&t ksh does this) */
+ newval = tflag ? search(alias, path, X_OK, NULL) :
+ val;
+ if (newval) {
+ ap->val.s = str_save(newval, APERM);
+ ap->flag |= ALLOC|ISSET;
+ } else
+ ap->flag &= ~ISSET;
+ }
+ ap->flag |= DEFINED;
+ if (prefix == '+')
+ ap->flag &= ~xflag;
+ else
+ ap->flag |= xflag;
+ if (val)
+ afree(alias, ATEMP);
+ }
+
+ return rv;
+}
+
+int
+c_unalias(char **wp)
+{
+ struct table *t = &aliases;
+ struct tbl *ap;
+ int rv = 0, all = 0;
+ int optc;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "adt")) != -1)
+ switch (optc) {
+ case 'a':
+ all = 1;
+ break;
+ case 'd':
+ t = &homedirs;
+ break;
+ case 't':
+ t = &taliases;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+
+ for (; *wp != NULL; wp++) {
+ ap = ktsearch(t, *wp, hash(*wp));
+ if (ap == NULL) {
+ rv = 1; /* POSIX */
+ continue;
+ }
+ if (ap->flag&ALLOC) {
+ ap->flag &= ~(ALLOC|ISSET);
+ afree(ap->val.s, APERM);
+ }
+ ap->flag &= ~(DEFINED|ISSET|EXPORT);
+ }
+
+ if (all) {
+ struct tstate ts;
+
+ for (ktwalk(&ts, t); (ap = ktnext(&ts)); ) {
+ if (ap->flag&ALLOC) {
+ ap->flag &= ~(ALLOC|ISSET);
+ afree(ap->val.s, APERM);
+ }
+ ap->flag &= ~(DEFINED|ISSET|EXPORT);
+ }
+ }
+
+ return rv;
+}
+
+int
+c_let(char **wp)
+{
+ int rv = 1;
+ long val;
+
+ if (wp[1] == NULL) /* at&t ksh does this */
+ bi_errorf("no arguments");
+ else
+ for (wp++; *wp; wp++)
+ if (!evaluate(*wp, &val, KSH_RETURN_ERROR, true)) {
+ rv = 2; /* distinguish error from zero result */
+ break;
+ } else
+ rv = val == 0;
+ return rv;
+}
+
+int
+c_jobs(char **wp)
+{
+ int optc;
+ int flag = 0;
+ int nflag = 0;
+ int rv = 0;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "lpnz")) != -1)
+ switch (optc) {
+ case 'l':
+ flag = 1;
+ break;
+ case 'p':
+ flag = 2;
+ break;
+ case 'n':
+ nflag = 1;
+ break;
+ case 'z': /* debugging: print zombies */
+ nflag = -1;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+ if (!*wp) {
+ if (j_jobs(NULL, flag, nflag))
+ rv = 1;
+ } else {
+ for (; *wp; wp++)
+ if (j_jobs(*wp, flag, nflag))
+ rv = 1;
+ }
+ return rv;
+}
+
+#ifdef JOBS
+int
+c_fgbg(char **wp)
+{
+ int bg = strcmp(*wp, "bg") == 0;
+ int rv = 0;
+
+ if (!Flag(FMONITOR)) {
+ bi_errorf("job control not enabled");
+ return 1;
+ }
+ if (ksh_getopt(wp, &builtin_opt, null) == '?')
+ return 1;
+ wp += builtin_opt.optind;
+ if (*wp)
+ for (; *wp; wp++)
+ rv = j_resume(*wp, bg);
+ else
+ rv = j_resume("%%", bg);
+ /* POSIX says fg shall return 0 (unless an error occurs).
+ * at&t ksh returns the exit value of the job...
+ */
+ return (bg || Flag(FPOSIX)) ? 0 : rv;
+}
+#endif
+
+struct kill_info {
+ int num_width;
+ int name_width;
+};
+static char *kill_fmt_entry(void *arg, int i, char *buf, int buflen);
+
+/* format a single kill item */
+static char *
+kill_fmt_entry(void *arg, int i, char *buf, int buflen)
+{
+ struct kill_info *ki = (struct kill_info *) arg;
+
+ i++;
+ if (sigtraps[i].name)
+ shf_snprintf(buf, buflen, "%*d %*s %s",
+ ki->num_width, i,
+ ki->name_width, sigtraps[i].name,
+ sigtraps[i].mess);
+ else
+ shf_snprintf(buf, buflen, "%*d %*d %s",
+ ki->num_width, i,
+ ki->name_width, sigtraps[i].signal,
+ sigtraps[i].mess);
+ return buf;
+}
+
+
+int
+c_kill(char **wp)
+{
+ Trap *t = NULL;
+ char *p;
+ int lflag = 0;
+ int i, n, rv, sig;
+
+ /* assume old style options if -digits or -UPPERCASE */
+ if ((p = wp[1]) && *p == '-' &&
+ (digit(p[1]) || isupper((unsigned char)p[1]))) {
+ if (!(t = gettrap(p + 1, true))) {
+ bi_errorf("bad signal `%s'", p + 1);
+ return 1;
+ }
+ i = (wp[2] && strcmp(wp[2], "--") == 0) ? 3 : 2;
+ } else {
+ int optc;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "ls:")) != -1)
+ switch (optc) {
+ case 'l':
+ lflag = 1;
+ break;
+ case 's':
+ if (!(t = gettrap(builtin_opt.optarg, true))) {
+ bi_errorf("bad signal `%s'",
+ builtin_opt.optarg);
+ return 1;
+ }
+ break;
+ case '?':
+ return 1;
+ }
+ i = builtin_opt.optind;
+ }
+ if ((lflag && t) || (!wp[i] && !lflag)) {
+ shf_fprintf(shl_out,
+ "usage: kill [-s signame | -signum | -signame] { job | pid | pgrp } ...\n"
+ " kill -l [exit_status ...]\n");
+ bi_errorf(NULL);
+ return 1;
+ }
+
+ if (lflag) {
+ if (wp[i]) {
+ for (; wp[i]; i++) {
+ if (!bi_getn(wp[i], &n))
+ return 1;
+ if (n > 128 && n < 128 + NSIG)
+ n -= 128;
+ if (n > 0 && n < NSIG && sigtraps[n].name)
+ shprintf("%s\n", sigtraps[n].name);
+ else
+ shprintf("%d\n", n);
+ }
+ } else if (Flag(FPOSIX)) {
+ p = null;
+ for (i = 1; i < NSIG; i++, p = " ")
+ if (sigtraps[i].name)
+ shprintf("%s%s", p, sigtraps[i].name);
+ shprintf("\n");
+ } else {
+ int mess_width = 0, w, i;
+ struct kill_info ki = {
+ .num_width = 1,
+ .name_width = 0,
+ };
+
+ for (i = NSIG; i >= 10; i /= 10)
+ ki.num_width++;
+
+ for (i = 0; i < NSIG; i++) {
+ w = sigtraps[i].name ? strlen(sigtraps[i].name) :
+ ki.num_width;
+ if (w > ki.name_width)
+ ki.name_width = w;
+ w = strlen(sigtraps[i].mess);
+ if (w > mess_width)
+ mess_width = w;
+ }
+
+ print_columns(shl_stdout, NSIG - 1,
+ kill_fmt_entry, (void *) &ki,
+ ki.num_width + ki.name_width + mess_width + 3, 1);
+ }
+ return 0;
+ }
+ rv = 0;
+ sig = t ? t->signal : SIGTERM;
+ for (; (p = wp[i]); i++) {
+ if (*p == '%') {
+ if (j_kill(p, sig))
+ rv = 1;
+ } else if (!getn(p, &n)) {
+ bi_errorf("%s: arguments must be jobs or process IDs",
+ p);
+ rv = 1;
+ } else {
+ /* use killpg if < -1 since -1 does special things for
+ * some non-killpg-endowed kills
+ */
+ if ((n < -1 ? killpg(-n, sig) : kill(n, sig)) < 0) {
+ bi_errorf("%s: %s", p, strerror(errno));
+ rv = 1;
+ }
+ }
+ }
+ return rv;
+}
+
+void
+getopts_reset(int val)
+{
+ if (val >= 1) {
+ ksh_getopt_reset(&user_opt,
+ GF_NONAME | (Flag(FPOSIX) ? 0 : GF_PLUSOPT));
+ user_opt.optind = user_opt.uoptind = val;
+ }
+}
+
+int
+c_getopts(char **wp)
+{
+ int argc;
+ const char *options;
+ const char *var;
+ int optc;
+ int ret;
+ char buf[3];
+ struct tbl *vq, *voptarg;
+
+ if (ksh_getopt(wp, &builtin_opt, null) == '?')
+ return 1;
+ wp += builtin_opt.optind;
+
+ options = *wp++;
+ if (!options) {
+ bi_errorf("missing options argument");
+ return 1;
+ }
+
+ var = *wp++;
+ if (!var) {
+ bi_errorf("missing name argument");
+ return 1;
+ }
+ if (!*var || *skip_varname(var, true)) {
+ bi_errorf("%s: is not an identifier", var);
+ return 1;
+ }
+
+ if (genv->loc->next == NULL) {
+ internal_errorf(0, "c_getopts: no argv");
+ return 1;
+ }
+ /* Which arguments are we parsing... */
+ if (*wp == NULL)
+ wp = genv->loc->next->argv;
+ else
+ *--wp = genv->loc->next->argv[0];
+
+ /* Check that our saved state won't cause a core dump... */
+ for (argc = 0; wp[argc]; argc++)
+ ;
+ if (user_opt.optind > argc ||
+ (user_opt.p != 0 &&
+ user_opt.p > strlen(wp[user_opt.optind - 1]))) {
+ bi_errorf("arguments changed since last call");
+ return 1;
+ }
+
+ user_opt.optarg = NULL;
+ optc = ksh_getopt(wp, &user_opt, options);
+
+ if (optc >= 0 && optc != '?' && (user_opt.info & GI_PLUS)) {
+ buf[0] = '+';
+ buf[1] = optc;
+ buf[2] = '\0';
+ } else {
+ /* POSIX says var is set to ? at end-of-options, at&t ksh
+ * sets it to null - we go with POSIX...
+ */
+ buf[0] = optc < 0 ? '?' : optc;
+ buf[1] = '\0';
+ }
+
+ /* at&t ksh does not change OPTIND if it was an unknown option.
+ * Scripts counting on this are prone to break... (ie, don't count
+ * on this staying).
+ */
+ if (optc != '?') {
+ user_opt.uoptind = user_opt.optind;
+ }
+
+ voptarg = global("OPTARG");
+ voptarg->flag &= ~RDONLY; /* at&t ksh clears ro and int */
+ /* Paranoia: ensure no bizarre results. */
+ if (voptarg->flag & INTEGER)
+ typeset("OPTARG", 0, INTEGER, 0, 0);
+ if (user_opt.optarg == NULL)
+ unset(voptarg, 0);
+ else
+ /* This can't fail (have cleared readonly/integer) */
+ setstr(voptarg, user_opt.optarg, KSH_RETURN_ERROR);
+
+ ret = 0;
+
+ vq = global(var);
+ /* Error message already printed (integer, readonly) */
+ if (!setstr(vq, buf, KSH_RETURN_ERROR))
+ ret = 1;
+ if (Flag(FEXPORT))
+ typeset(var, EXPORT, 0, 0, 0);
+
+ return optc < 0 ? 1 : ret;
+}
+
+#ifdef EMACS
+int
+c_bind(char **wp)
+{
+ int optc, rv = 0, macro = 0, list = 0;
+ char *cp;
+
+ while ((optc = ksh_getopt(wp, &builtin_opt, "lm")) != -1)
+ switch (optc) {
+ case 'l':
+ list = 1;
+ break;
+ case 'm':
+ macro = 1;
+ break;
+ case '?':
+ return 1;
+ }
+ wp += builtin_opt.optind;
+
+ if (*wp == NULL) /* list all */
+ rv = x_bind(NULL, NULL, 0, list);
+
+ for (; *wp != NULL; wp++) {
+ cp = strchr(*wp, '=');
+ if (cp != NULL)
+ *cp++ = '\0';
+ if (x_bind(*wp, cp, macro, 0))
+ rv = 1;
+ }
+
+ return rv;
+}
+#endif
+
+/* A leading = means assignments before command are kept;
+ * a leading * means a POSIX special builtin;
+ * a leading + means a POSIX regular builtin
+ * (* and + should not be combined).
+ */
+const struct builtin kshbuiltins [] = {
+ {"+alias", c_alias}, /* no =: at&t manual wrong */
+ {"+cd", c_cd},
+ {"+command", c_command},
+ {"echo", c_print},
+ {"*=export", c_typeset},
+#ifdef HISTORY
+ {"+fc", c_fc},
+#endif /* HISTORY */
+ {"+getopts", c_getopts},
+ {"+jobs", c_jobs},
+ {"+kill", c_kill},
+ {"let", c_let},
+ {"print", c_print},
+ {"pwd", c_pwd},
+ {"*=readonly", c_typeset},
+ {"=typeset", c_typeset},
+ {"+unalias", c_unalias},
+ {"whence", c_whence},
+#ifdef JOBS
+ {"+bg", c_fgbg},
+ {"+fg", c_fgbg},
+#endif
+#ifdef EMACS
+ {"bind", c_bind},
+#endif
+ {NULL, NULL}
+};