First commit (NetBSD 9.1)

1 files changed, 907 insertions, 0 deletions

diff --git a/c_sh.c b/c_sh.c
new file mode 100644
index 0000000..adfe3f2
--- /dev/null
+++ b/c_sh.c
@@ -0,0 +1,907 @@
+/*	$NetBSD: c_sh.c,v 1.24 2018/05/08 16:37:59 kamil Exp $	*/
+
+/*
+ * built-in Bourne commands
+ */
+#include <sys/cdefs.h>
+
+#ifndef lint
+__RCSID("$NetBSD: c_sh.c,v 1.24 2018/05/08 16:37:59 kamil Exp $");
+#endif
+
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <time.h>
+
+#include "sh.h"
+
+static	char *clocktos ARGS((clock_t t));
+
+
+/* :, false and true */
+int
+c_label(wp)
+	char **wp;
+{
+	return wp[0][0] == 'f' ? 1 : 0;
+}
+
+int
+c_shift(wp)
+	char **wp;
+{
+	struct block *l = e->loc;
+	int n;
+	long val;
+	char *arg;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	arg = wp[builtin_opt.optind];
+
+	if (arg) {
+		evaluate(arg, &val, KSH_UNWIND_ERROR);
+		n = val;
+	} else
+		n = 1;
+	if (n < 0) {
+		bi_errorf("%s: bad number", arg);
+		return (1);
+	}
+	if (l->argc < n) {
+		bi_errorf("nothing to shift");
+		return (1);
+	}
+	l->argv[n] = l->argv[0];
+	l->argv += n;
+	l->argc -= n;
+	return 0;
+}
+
+int
+c_umask(wp)
+	char **wp;
+{
+	int i;
+	char *cp;
+	int symbolic = 0;
+	int old_umask;
+	int optc;
+
+	while ((optc = ksh_getopt(wp, &builtin_opt, "S")) != EOF)
+		switch (optc) {
+		  case 'S':
+			symbolic = 1;
+			break;
+		  case '?':
+			return 1;
+		}
+	cp = wp[builtin_opt.optind];
+	if (cp == NULL) {
+		old_umask = umask(0);
+		umask(old_umask);
+		if (symbolic) {
+			char buf[18];
+			int j;
+
+			old_umask = ~old_umask;
+			cp = buf;
+			for (i = 0; i < 3; i++) {
+				*cp++ = "ugo"[i];
+				*cp++ = '=';
+				for (j = 0; j < 3; j++)
+					if (old_umask & (1 << (8 - (3*i + j))))
+						*cp++ = "rwx"[j];
+				*cp++ = ',';
+			}
+			cp[-1] = '\0';
+			shprintf("%s\n", buf);
+		} else
+			shprintf("%#3.3o\n", old_umask);
+	} else {
+		int new_umask;
+
+		if (digit(*cp)) {
+			for (new_umask = 0; *cp >= '0' && *cp <= '7'; cp++)
+				new_umask = new_umask * 8 + (*cp - '0');
+			if (*cp) {
+				bi_errorf("bad number");
+				return 1;
+			}
+		} else {
+			/* symbolic format */
+			int positions, new_val;
+			char op;
+
+			old_umask = umask(0);
+			umask(old_umask); /* in case of error */
+			old_umask = ~old_umask;
+			new_umask = old_umask;
+			positions = 0;
+			while (*cp) {
+				while (*cp && strchr("augo", *cp))
+					switch (*cp++) {
+					case 'a': positions |= 0111; break;
+					case 'u': positions |= 0100; break;
+					case 'g': positions |= 0010; break;
+					case 'o': positions |= 0001; break;
+					}
+				if (!positions)
+					positions = 0111; /* default is a */
+				if (!strchr("=+-", op = *cp))
+					break;
+				cp++;
+				new_val = 0;
+				while (*cp && strchr("rwxugoXs", *cp))
+					switch (*cp++) {
+					case 'r': new_val |= 04; break;
+					case 'w': new_val |= 02; break;
+					case 'x': new_val |= 01; break;
+					case 'u': new_val |= old_umask >> 6;
+						  break;
+					case 'g': new_val |= old_umask >> 3;
+						  break;
+					case 'o': new_val |= old_umask >> 0;
+						  break;
+					case 'X': if (old_umask & 0111)
+							new_val |= 01;
+						  break;
+					case 's': /* ignored */
+						  break;
+					}
+				new_val = (new_val & 07) * positions;
+				switch (op) {
+				case '-':
+					new_umask &= ~new_val;
+					break;
+				case '=':
+					new_umask = new_val
+					    | (new_umask & ~(positions * 07));
+					break;
+				case '+':
+					new_umask |= new_val;
+				}
+				if (*cp == ',') {
+					positions = 0;
+					cp++;
+				} else if (!strchr("=+-", *cp))
+					break;
+			}
+			if (*cp) {
+				bi_errorf("bad mask");
+				return 1;
+			}
+			new_umask = ~new_umask;
+		}
+		umask(new_umask);
+	}
+	return 0;
+}
+
+int
+c_dot(wp)
+	char **wp;
+{
+	char *file, *cp;
+	char **argv;
+	int argc;
+	int i;
+	int err;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+
+	if ((cp = wp[builtin_opt.optind]) == NULL)
+		return 0;
+	file = search(cp, path, R_OK, &err);
+	if (file == NULL) {
+		bi_errorf("%s: %s", cp, err ? strerror(err) : "not found");
+		return 1;
+	}
+
+	/* Set positional parameters? */
+	if (wp[builtin_opt.optind + 1]) {
+		argv = wp + builtin_opt.optind;
+		argv[0] = e->loc->argv[0]; /* preserve $0 */
+		for (argc = 0; argv[argc + 1]; argc++)
+			;
+	} else {
+		argc = 0;
+		argv = (char **) 0;
+	}
+	i = include(file, argc, argv, 0);
+	if (i < 0) { /* should not happen */
+		bi_errorf("%s: %s", cp, strerror(errno));
+		return 1;
+	}
+	return i;
+}
+
+int
+c_wait(wp)
+	char **wp;
+{
+	int UNINITIALIZED(rv);
+	int sig;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	wp += builtin_opt.optind;
+	if (*wp == (char *) 0) {
+		while (waitfor((char *) 0, &sig) >= 0)
+			;
+		rv = sig;
+	} else {
+		for (; *wp; wp++)
+			rv = waitfor(*wp, &sig);
+		if (rv < 0)
+			rv = sig ? sig : 127; /* magic exit code: bad job-id */
+	}
+	return rv;
+}
+
+int
+c_read(wp)
+	char **wp;
+{
+	int c = 0;
+	int expandv = 1, history = 0;
+	int expanding;
+	int ecode = 0;
+	char *cp;
+	int fd = 0;
+	struct shf *shf;
+	int optc;
+	const char *emsg;
+	XString cs, xs;
+	struct tbl *vp;
+	char UNINITIALIZED(*xp);
+	static char REPLY[] = "REPLY";
+
+	while ((optc = ksh_getopt(wp, &builtin_opt, "prsu,")) != EOF)
+		switch (optc) {
+#ifdef KSH
+		  case 'p':
+			if ((fd = coproc_getfd(R_OK, &emsg)) < 0) {
+				bi_errorf("-p: %s", emsg);
+				return 1;
+			}
+			break;
+#endif /* KSH */
+		  case 'r':
+			expandv = 0;
+			break;
+		  case 's':
+			history = 1;
+			break;
+		  case 'u':
+			if (!*(cp = builtin_opt.optarg))
+				fd = 0;
+			else if ((fd = check_fd(cp, R_OK, &emsg)) < 0) {
+				bi_errorf("-u: %s: %s", cp, emsg);
+				return 1;
+			}
+			break;
+		  case '?':
+			return 1;
+		}
+	wp += builtin_opt.optind;
+
+	if (*wp == NULL)
+		*--wp = REPLY;
+
+	/* Since we can't necessarily seek backwards on non-regular files,
+	 * don't buffer them so we can't read too much.
+	 */
+	shf = shf_reopen(fd, SHF_RD | SHF_INTERRUPT | can_seek(fd), shl_spare);
+
+	if ((cp = strchr(*wp, '?')) != NULL) {
+		*cp = 0;
+		if (isatty(fd)) {
+			/* at&t ksh says it prints prompt on fd if it's open
+			 * for writing and is a tty, but it doesn't do it
+			 * (it also doesn't check the interactive flag,
+			 * as is indicated in the Kornshell book).
+			 */
+			shellf("%s", cp+1);
+		}
+	}
+
+#ifdef KSH
+	/* If we are reading from the co-process for the first time,
+	 * make sure the other side of the pipe is closed first.  This allows
+	 * the detection of eof.
+	 *
+	 * This is not compatible with at&t ksh... the fd is kept so another
+	 * coproc can be started with same output, however, this means eof
+	 * can't be detected...  This is why it is closed here.
+	 * If this call is removed, remove the eof check below, too.
+	 * coproc_readw_close(fd);
+	 */
+#endif /* KSH */
+
+	if (history)
+		Xinit(xs, xp, 128, ATEMP);
+	expanding = 0;
+	Xinit(cs, cp, 128, ATEMP);
+	for (; *wp != NULL; wp++) {
+		for (cp = Xstring(cs, cp); ; ) {
+			if (c == '\n' || c == EOF)
+				break;
+			while (1) {
+				c = shf_getc(shf);
+				if (c == '\0'
+				    )
+					continue;
+				if (c == EOF && shf_error(shf)
+				    && shf_errno(shf) == EINTR)
+				{
+					/* Was the offending signal one that
+					 * would normally kill a process?
+					 * If so, pretend the read was killed.
+					 */
+					ecode = fatal_trap_check();
+
+					/* non fatal (eg, CHLD), carry on */
+					if (!ecode) {
+						shf_clearerr(shf);
+						continue;
+					}
+				}
+				break;
+			}
+			if (history) {
+				Xcheck(xs, xp);
+				Xput(xs, xp, c);
+			}
+			Xcheck(cs, cp);
+			if (expanding) {
+				expanding = 0;
+				if (c == '\n') {
+					c = 0;
+					if (Flag(FTALKING_I) && isatty(fd)) {
+						/* set prompt in case this is
+						 * called from .profile or $ENV
+						 */
+						set_prompt(PS2, (Source *) 0);
+						pprompt(prompt, 0);
+					}
+				} else if (c != EOF)
+					Xput(cs, cp, c);
+				continue;
+			}
+			if (expandv && c == '\\') {
+				expanding = 1;
+				continue;
+			}
+			if (c == '\n' || c == EOF)
+				break;
+			if (ctype(c, C_IFS)) {
+				if (Xlength(cs, cp) == 0 && ctype(c, C_IFSWS))
+					continue;
+				if (wp[1])
+					break;
+			}
+			Xput(cs, cp, c);
+		}
+		/* strip trailing IFS white space from last variable */
+		if (!wp[1])
+			while (Xlength(cs, cp) && ctype(cp[-1], C_IFS)
+			       && ctype(cp[-1], C_IFSWS))
+				cp--;
+		Xput(cs, cp, '\0');
+		vp = global(*wp);
+		/* Must be done before setting export. */
+		if (vp->flag & RDONLY) {
+			shf_flush(shf);
+			bi_errorf("%s is read only", *wp);
+			return 1;
+		}
+		if (Flag(FEXPORT))
+			typeset(*wp, EXPORT, 0, 0, 0);
+		if (!setstr(vp, Xstring(cs, cp), KSH_RETURN_ERROR)) {
+		    shf_flush(shf);
+		    return 1;
+		}
+	}
+
+	shf_flush(shf);
+	if (history) {
+		Xput(xs, xp, '\0');
+		source->line++;
+		histsave(source->line, Xstring(xs, xp), 1);
+		Xfree(xs, xp);
+	}
+#ifdef KSH
+	/* if this is the co-process fd, close the file descriptor
+	 * (can get eof if and only if all processes are have died, ie,
+	 * coproc.njobs is 0 and the pipe is closed).
+	 */
+	if (c == EOF && !ecode)
+		coproc_read_close(fd);
+#endif /* KSH */
+
+	return ecode ? ecode : c == EOF;
+}
+
+int
+c_eval(wp)
+	char **wp;
+{
+	struct source *s;
+	int rv;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	s = pushs(SWORDS, ATEMP);
+	s->u.strv = wp + builtin_opt.optind;
+	if (!Flag(FPOSIX)) {
+		/*
+		 * Handle case where the command is empty due to failed
+		 * command substitution, eg, eval "$(false)".
+		 * In this case, shell() will not set/change exstat (because
+		 * compiled tree is empty), so will use this value.
+		 * subst_exstat is cleared in execute(), so should be 0 if
+		 * there were no substitutions.
+		 *
+		 * A strict reading of POSIX says we don't do this (though
+		 * it is traditionally done). [from 1003.2-1992]
+		 *    3.9.1: Simple Commands
+		 *	... If there is a command name, execution shall
+		 *	continue as described in 3.9.1.1.  If there
+		 *	is no command name, but the command contained a command
+		 *	substitution, the command shall complete with the exit
+		 *	status of the last command substitution
+		 *    3.9.1.1: Command Search and Execution
+		 *	...(1)...(a) If the command name matches the name of
+		 *	a special built-in utility, that special built-in
+		 *	utility shall be invoked.
+		 * 3.14.5: Eval
+		 *	... If there are no arguments, or only null arguments,
+		 *	eval shall return an exit status of zero.
+		 */
+		exstat = subst_exstat;
+	}
+
+	rv = shell(s, false);
+	afree(s, ATEMP);
+	return rv;
+}
+
+int
+c_trap(wp)
+	char **wp;
+{
+	int i;
+	char *s;
+	Trap *p;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	wp += builtin_opt.optind;
+
+	if (*wp == NULL) {
+		int anydfl = 0;
+
+		for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++) {
+			if (p->trap == NULL)
+				anydfl = 1;
+			else {
+				shprintf("trap -- ");
+				print_value_quoted(p->trap);
+				shprintf(" %s\n", p->name);
+			}
+		}
+#if 0 /* this is ugly and not clear POSIX needs it */
+		/* POSIX may need this so output of trap can be saved and
+		 * used to restore trap conditions
+		 */
+		if (anydfl) {
+			shprintf("trap -- -");
+			for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
+				if (p->trap == NULL && p->name)
+					shprintf(" %s", p->name);
+			shprintf(newline);
+		}
+#else
+		__USE(anydfl);
+#endif
+		return 0;
+	}
+
+	/*
+	 * Use case sensitive lookup for first arg so the
+	 * command 'exit' isn't confused with the pseudo-signal
+	 * 'EXIT'.
+	 */
+	s = (gettrap(*wp, false) == NULL) ? *wp++ : NULL; /* get command */
+	if (s != NULL && s[0] == '-' && s[1] == '\0')
+		s = NULL;
+
+	/* set/clear traps */
+	while (*wp != NULL) {
+		p = gettrap(*wp++, true);
+		if (p == NULL) {
+			bi_errorf("bad signal %s", wp[-1]);
+			return 1;
+		}
+		settrap(p, s);
+	}
+	return 0;
+}
+
+int
+c_exitreturn(wp)
+	char **wp;
+{
+	int how = LEXIT;
+	int n;
+	char *arg;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	arg = wp[builtin_opt.optind];
+
+	if (arg) {
+	    if (!getn(arg, &n)) {
+		    exstat = 1;
+		    warningf(true, "%s: bad number", arg);
+	    } else
+		    exstat = n;
+	}
+	if (wp[0][0] == 'r') { /* return */
+		struct env *ep;
+
+		/* need to tell if this is exit or return so trap exit will
+		 * work right (POSIX)
+		 */
+		for (ep = e; ep; ep = ep->oenv)
+			if (STOP_RETURN(ep->type)) {
+				how = LRETURN;
+				break;
+			}
+	}
+
+	if (how == LEXIT && !really_exit && j_stopped_running()) {
+		really_exit = 1;
+		how = LSHELL;
+	}
+
+	quitenv();	/* get rid of any i/o redirections */
+	unwind(how);
+	/*NOTREACHED*/
+	return 0;
+}
+
+int
+c_brkcont(wp)
+	char **wp;
+{
+	int n, quit;
+	struct env *ep, *last_ep = (struct env *) 0;
+	char *arg;
+
+	if (ksh_getopt(wp, &builtin_opt, null) == '?')
+		return 1;
+	arg = wp[builtin_opt.optind];
+
+	if (!arg)
+		n = 1;
+	else if (!bi_getn(arg, &n))
+		return 1;
+	quit = n;
+	if (quit <= 0) {
+		/* at&t ksh does this for non-interactive shells only - weird */
+		bi_errorf("%s: bad value", arg);
+		return 1;
+	}
+
+	/* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */
+	for (ep = e; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv)
+		if (ep->type == E_LOOP) {
+			if (--quit == 0)
+				break;
+			ep->flags |= EF_BRKCONT_PASS;
+			last_ep = ep;
+		}
+
+	if (quit) {
+		/* at&t ksh doesn't print a message - just does what it
+		 * can.  We print a message 'cause it helps in debugging
+		 * scripts, but don't generate an error (ie, keep going).
+		 */
+		if (n == quit) {
+			warningf(true, "%s: cannot %s", wp[0], wp[0]);
+			return 0;
+		}
+		/* POSIX says if n is too big, the last enclosing loop
+		 * shall be used.  Doesn't say to print an error but we
+		 * do anyway 'cause the user messed up.
+		 */
+		if (last_ep)
+			last_ep->flags &= ~EF_BRKCONT_PASS;
+		warningf(true, "%s: can only %s %d level(s)",
+			wp[0], wp[0], n - quit);
+	}
+
+	unwind(*wp[0] == 'b' ? LBREAK : LCONTIN);
+	/*NOTREACHED*/
+}
+
+int
+c_set(wp)
+	char **wp;
+{
+	int argi, setargs;
+	struct block *l = e->loc;
+	char **owp = wp;
+
+	if (wp[1] == NULL) {
+		static const char *const args [] = { "set", "-", NULL };
+		return c_typeset((char **)__UNCONST(args));
+	}
+
+	argi = parse_args(wp, OF_SET, &setargs);
+	if (argi < 0)
+		return 1;
+	/* set $# and $* */
+	if (setargs) {
+		owp = wp += argi - 1;
+		wp[0] = l->argv[0]; /* save $0 */
+		while (*++wp != NULL)
+			*wp = str_save(*wp, &l->area);
+		l->argc = wp - owp - 1;
+		l->argv = (char **) alloc(sizeofN(char *, l->argc+2), &l->area);
+		for (wp = l->argv; (*wp++ = *owp++) != NULL; )
+			;
+	}
+	/* POSIX says set exit status is 0, but old scripts that use
+	 * getopt(1), use the construct: set -- `getopt ab:c "$@"`
+	 * which assumes the exit value set will be that of the ``
+	 * (subst_exstat is cleared in execute() so that it will be 0
+	 * if there are no command substitutions).
+	 */
+	return Flag(FPOSIX) ? 0 : subst_exstat;
+}
+
+int
+c_unset(wp)
+	char **wp;
+{
+	char *id;
+	int optc, unset_var = 1;
+	int ret = 0;
+
+	while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != EOF)
+		switch (optc) {
+		  case 'f':
+			unset_var = 0;
+			break;
+		  case 'v':
+			unset_var = 1;
+			break;
+		  case '?':
+			return 1;
+		}
+	wp += builtin_opt.optind;
+	for (; (id = *wp) != NULL; wp++)
+		if (unset_var) {	/* unset variable */
+			struct tbl *vp = global(id);
+
+			if ((vp->flag&RDONLY)) {
+				bi_errorf("%s is read only", vp->name);
+				return 1;
+			}
+			unset(vp, strchr(id, '[') ? 1 : 0);
+		} else {		/* unset function */
+			if (define(id, NULL))
+				ret = 1;
+		}
+	return ret;
+}
+
+int
+c_times(wp)
+	char **wp;
+{
+	struct tms all;
+
+	times(&all);
+	shprintf("Shell: %8ss user ", clocktos(all.tms_utime));
+	shprintf("%8ss system\n", clocktos(all.tms_stime));
+	shprintf("Kids:  %8ss user ", clocktos(all.tms_cutime));
+	shprintf("%8ss system\n", clocktos(all.tms_cstime));
+
+	return 0;
+}
+
+/*
+ * time pipeline (really a statement, not a built-in command)
+ */
+int
+timex(t, f)
+	struct op *t;
+	int f;
+{
+#define TF_NOARGS	BIT(0)
+#define TF_NOREAL	BIT(1)		/* don't report real time */
+#define TF_POSIX	BIT(2)		/* report in posix format */
+	int rv = 0;
+	struct tms t0, t1, tms;
+	clock_t t0t, t1t = 0;
+	int tf = 0;
+	extern clock_t j_usrtime, j_systime; /* computed by j_wait */
+	char opts[1];
+
+	t0t = times(&t0);
+	if (t->left) {
+		/*
+		 * Two ways of getting cpu usage of a command: just use t0
+		 * and t1 (which will get cpu usage from other jobs that
+		 * finish while we are executing t->left), or get the
+		 * cpu usage of t->left. at&t ksh does the former, while
+		 * pdksh tries to do the later (the j_usrtime hack doesn't
+		 * really work as it only counts the last job).
+		 */
+		j_usrtime = j_systime = 0;
+		if (t->left->type == TCOM)
+			t->left->str = opts;
+		opts[0] = 0;
+		rv = execute(t->left, f | XTIME);
+		tf |= opts[0];
+		t1t = times(&t1);
+	} else
+		tf = TF_NOARGS;
+
+	if (tf & TF_NOARGS) { /* ksh93 - report shell times (shell+kids) */
+		tf |= TF_NOREAL;
+		tms.tms_utime = t0.tms_utime + t0.tms_cutime;
+		tms.tms_stime = t0.tms_stime + t0.tms_cstime;
+	} else {
+		tms.tms_utime = t1.tms_utime - t0.tms_utime + j_usrtime;
+		tms.tms_stime = t1.tms_stime - t0.tms_stime + j_systime;
+	}
+
+	if (!(tf & TF_NOREAL))
+		shf_fprintf(shl_out,
+			tf & TF_POSIX ? "real %8s\n" : "%8ss real ",
+			clocktos(t1t - t0t));
+	shf_fprintf(shl_out, tf & TF_POSIX ? "user %8s\n" : "%8ss user ",
+		clocktos(tms.tms_utime));
+	shf_fprintf(shl_out, tf & TF_POSIX ? "sys  %8s\n" : "%8ss system\n",
+		clocktos(tms.tms_stime));
+	shf_flush(shl_out);
+
+	return rv;
+}
+
+void
+timex_hook(t, app)
+	struct op *t;
+	char ** volatile *app;
+{
+	char **wp = *app;
+	int optc;
+	int i, j;
+	Getopt opt;
+
+	ksh_getopt_reset(&opt, 0);
+	opt.optind = 0;	/* start at the start */
+	while ((optc = ksh_getopt(wp, &opt, ":p")) != EOF)
+		switch (optc) {
+		  case 'p':
+			t->str[0] |= TF_POSIX;
+			break;
+		  case '?':
+			errorf("time: -%s unknown option", opt.optarg);
+		  case ':':
+			errorf("time: -%s requires an argument",
+				opt.optarg);
+		}
+	/* Copy command words down over options. */
+	if (opt.optind != 0) {
+		for (i = 0; i < opt.optind; i++)
+			afree(wp[i], ATEMP);
+		for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++)
+			;
+	}
+	if (!wp[0])
+		t->str[0] |= TF_NOARGS;
+	*app = wp;
+}
+
+static char *
+clocktos(t)
+	clock_t t;
+{
+	static char temp[22]; /* enough for 64 bit clock_t */
+	int i;
+	char *cp = temp + sizeof(temp);
+
+	/* note: posix says must use max precision, ie, if clk_tck is
+	 * 1000, must print 3 places after decimal (if non-zero, else 1).
+	 */
+	if (CLK_TCK != 100)	/* convert to 1/100'ths */
+	    t = (t < (clock_t)(1000000000/CLK_TCK)) ?
+		    (t * 100) / CLK_TCK : (t / CLK_TCK) * 100;
+
+	*--cp = '\0';
+	for (i = -2; i <= 0 || t > 0; i++) {
+		if (i == 0)
+			*--cp = '.';
+		*--cp = '0' + (char)(t%10);
+		t /= 10;
+	}
+	return cp;
+}
+
+/* exec with no args - args case is taken care of in comexec() */
+int
+c_exec(wp)
+	char ** wp;
+{
+	int i;
+
+	/* make sure redirects stay in place */
+	if (e->savefd != NULL) {
+		for (i = 0; i < NUFILE; i++) {
+			if (e->savefd[i] > 0)
+				close(e->savefd[i]);
+			/*
+			 * For ksh keep anything > 2 private,
+			 * for sh, let them be (POSIX says what
+			 * happens is unspecified and the bourne shell
+			 * keeps them open).
+			 */
+#ifdef KSH
+			if (i > 2 && e->savefd[i])
+				fd_clexec(i);
+#endif /* KSH */
+		}
+		e->savefd = NULL;
+	}
+	return 0;
+}
+
+/* dummy function, special case in comexec() */
+int
+c_builtin(wp)
+	char ** wp;
+{
+	return 0;
+}
+
+extern	int c_test ARGS((char **wp));		/* in c_test.c */
+extern	int c_ulimit ARGS((char **wp));		/* in c_ulimit.c */
+
+/* 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 shbuiltins [] = {
+	{"*=.", c_dot},
+	{"*=:", c_label},
+	{"[", c_test},
+	{"*=break", c_brkcont},
+	{"=builtin", c_builtin},
+	{"*=continue", c_brkcont},
+	{"*=eval", c_eval},
+	{"*=exec", c_exec},
+	{"*=exit", c_exitreturn},
+	{"+false", c_label},
+	{"*=return", c_exitreturn},
+	{"*=set", c_set},
+	{"*=shift", c_shift},
+	{"=times", c_times},
+	{"*=trap", c_trap},
+	{"+=wait", c_wait},
+	{"+read", c_read},
+	{"test", c_test},
+	{"+true", c_label},
+	{"ulimit", c_ulimit},
+	{"+umask", c_umask},
+	{"*=unset", c_unset},
+	{NULL, NULL}
+};