Slackware 13.0slackware-13.0

Wed Aug 26 10:00:38 CDT 2009
Slackware 13.0 x86_64 is released as stable!  Thanks to everyone who
helped make this release possible -- see the RELEASE_NOTES for the
credits.  The ISOs are off to the replicator.  This time it will be a
6 CD-ROM 32-bit set and a dual-sided 32-bit/64-bit x86/x86_64 DVD.
We're taking pre-orders now at store.slackware.com.  Please consider
picking up a copy to help support the project.  Once again, thanks to
the entire Slackware community for all the help testing and fixing
things and offering suggestions during this development cycle.
As always, have fun and enjoy!  -P.

1 files changed, 843 insertions, 0 deletions

diff --git a/source/ap/ash/patches/ash-builtin.patch b/source/ap/ash/patches/ash-builtin.patch
new file mode 100644
index 000000000..b812e6375
--- /dev/null
+++ b/source/ap/ash/patches/ash-builtin.patch
@@ -0,0 +1,843 @@
+diff -urN netbsd-sh/builtins.def ash-0.3.7.orig/builtins.def
+--- netbsd-sh/builtins.def	Mon Apr 10 13:02:58 2000
++++ ash-0.3.7.orig/builtins.def	Mon Apr 23 22:16:46 2001
+@@ -49,12 +49,13 @@
+ #
+ # NOTE: bltincmd must come first!
+ 
+-bltincmd	command
++bltincmd	builtin
+ #alloccmd	alloc
+ bgcmd -j	bg
+ breakcmd	break continue
+ #catfcmd	catf
+ cdcmd		cd chdir
++commandcmd	command
+ dotcmd		.
+ echocmd		echo
+ evalcmd		eval
+diff -urN netbsd-sh/eval.c ash-0.3.7.orig/eval.c
+--- netbsd-sh/eval.c	Tue May 23 12:03:18 2000
++++ ash-0.3.7.orig/eval.c	Mon Apr 23 22:16:46 2001
+@@ -45,7 +45,9 @@
+ #endif
+ #endif /* not lint */
+ 
++#include <sys/types.h>
+ #include <signal.h>
++#include <malloc.h>
+ #include <unistd.h>
+ 
+ /*
+@@ -101,6 +103,8 @@
+ STATIC void evalpipe __P((union node *));
+ STATIC void evalcommand __P((union node *, int, struct backcmd *));
+ STATIC void prehash __P((union node *));
++STATIC int is_assignment_builtin __P((const char *));
++STATIC const char *get_standard_path __P((void));
+ 
+ 
+ /*
+@@ -257,6 +261,11 @@
+ 		evalcase(n, flags);
+ 		break;
+ 	case NDEFUN:
++		if (is_special_builtin(n->narg.text)) {
++			outfmt(out2, "%s is a special built-in\n", n->narg.text);
++			exitstatus = 1;
++			break;
++		}
+ 		defun(n->narg.text, n->narg.next);
+ 		exitstatus = 0;
+ 		break;
+@@ -497,9 +507,14 @@
+ 				close(0);
+ 				copyfd(prevfd, 0);
+ 				close(prevfd);
++				if (pip[0] == 0) {
++					pip[0] = -1;
++				}
+ 			}
+ 			if (pip[1] >= 0) {
+-				close(pip[0]);
++				if (pip[0] >= 0) {
++					close(pip[0]);
++				}
+ 				if (pip[1] != 1) {
+ 					close(1);
+ 					copyfd(pip[1], 1);
+@@ -607,6 +622,7 @@
+ 	int argc;
+ 	char **envp;
+ 	int varflag;
++	int pseudovarflag;
+ 	struct strlist *sp;
+ 	int mode;
+ 	int pip[2];
+@@ -619,12 +635,17 @@
+ 	struct localvar *volatile savelocalvars;
+ 	volatile int e;
+ 	char *lastarg;
++	int not_special;
++	const char *path;
++	const char *standard_path;
+ #if __GNUC__
+ 	/* Avoid longjmp clobbering */
+ 	(void) &argv;
+ 	(void) &argc;
+ 	(void) &lastarg;
+ 	(void) &flags;
++	(void) &not_special;
++	(void) &standard_path;
+ #endif
+ 
+ 	/* First expand the arguments. */
+@@ -632,21 +653,31 @@
+ 	setstackmark(&smark);
+ 	arglist.lastp = &arglist.list;
+ 	varlist.lastp = &varlist.list;
++	arglist.list = 0;
+ 	varflag = 1;
++	pseudovarflag = 0;
+ 	oexitstatus = exitstatus;
+ 	exitstatus = 0;
++	not_special = 0;
++	path = pathval();
++	standard_path = NULL;
+ 	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
+ 		char *p = argp->narg.text;
+-		if (varflag && is_name(*p)) {
++		if ((varflag || pseudovarflag) && is_name(*p)) {
+ 			do {
+ 				p++;
+ 			} while (is_in_name(*p));
+ 			if (*p == '=') {
+-				expandarg(argp, &varlist, EXP_VARTILDE);
++				if (varflag)
++					expandarg(argp, &varlist, EXP_VARTILDE);
++				else
++					expandarg(argp, &arglist, EXP_VARTILDE);
+ 				continue;
+ 			}
+ 		}
+ 		expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
++		if (varflag && arglist.list && is_assignment_builtin(arglist.list->text))
++			pseudovarflag = 1;
+ 		varflag = 0;
+ 	}
+ 	*arglist.lastp = NULL;
+@@ -688,37 +719,75 @@
+ 		cmdentry.u.index = BLTINCMD;
+ 	} else {
+ 		static const char PATH[] = "PATH=";
+-		const char *path = pathval();
++		const char *oldpath = NULL;
++		int findflag = DO_ERR;
+ 
+ 		/*
+ 		 * Modify the command lookup path, if a PATH= assignment
+ 		 * is present
+ 		 */
+ 		for (sp = varlist.list ; sp ; sp = sp->next)
+-			if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)
++			if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0) {
+ 				path = sp->text + sizeof(PATH) - 1;
+-
+-		find_command(argv[0], &cmdentry, DO_ERR, path);
+-		if (cmdentry.cmdtype == CMDUNKNOWN) {	/* command not found */
+-			exitstatus = 127;
+-			flushout(&errout);
+-			return;
+-		}
+-		/* implement the bltin builtin here */
+-		if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) {
+-			for (;;) {
++				findflag |= DO_BRUTE;
++			}
++		for(;;) {
++			find_command(argv[0], &cmdentry, findflag, path);
++			if (oldpath) {
++				path = oldpath;
++				oldpath = NULL;
++			}
++			if (cmdentry.cmdtype == CMDUNKNOWN) {	/* command not found */
++				exitstatus = 127;
++				flushout(&errout);
++				goto out;
++			}
++			/* implement the bltin builtin here */
++			if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) {
++				not_special = 1;
++				for(;;) {
++					argv++;
++					if (--argc == 0)
++						break;
++					if ((cmdentry.u.index = find_builtin(*argv)) < 0) {
++						outfmt(&errout, "%s: not found\n", *argv);
++						exitstatus = 127;
++						flushout(&errout);
++						goto out;
++					}
++					if (cmdentry.u.index != BLTINCMD)
++						break;
++				}
++			}
++			if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == COMMANDCMD) {
++				not_special = 1;
+ 				argv++;
+-				if (--argc == 0)
+-					break;
+-				if ((cmdentry.u.index = find_builtin(*argv)) < 0) {
+-					outfmt(&errout, "%s: not found\n", *argv);
+-					exitstatus = 127;
+-					flushout(&errout);
+-					return;
++				if (--argc == 0) {
++					exitstatus = 0;
++					goto out;
+ 				}
+-				if (cmdentry.u.index != BLTINCMD)
+-					break;
++				if (*argv[0] == '-') {
++					if (!equal(argv[0], "-p")) {
++						argv--;
++						argc++;
++						break;
++					}
++					argv++;
++					if (--argc == 0) {
++						exitstatus = 0;
++						goto out;
++					}
++					if (!standard_path) {
++						standard_path = get_standard_path();
++					}
++					oldpath = path;
++					path = standard_path;
++					findflag |= DO_BRUTE;
++				}
++				findflag |= DO_NOFUN;
++				continue;
+ 			}
++			break;
+ 		}
+ 	}
+ 
+@@ -756,13 +825,12 @@
+ #ifdef DEBUG
+ 		trputs("Shell function:  ");  trargs(argv);
+ #endif
++		exitstatus = oexitstatus;
+ 		redirect(cmd->ncmd.redirect, REDIR_PUSH);
+ 		saveparam = shellparam;
+ 		shellparam.malloc = 0;
+-		shellparam.reset = 1;
+ 		shellparam.nparam = argc - 1;
+ 		shellparam.p = argv + 1;
+-		shellparam.optnext = NULL;
+ 		INTOFF;
+ 		savelocalvars = localvars;
+ 		localvars = NULL;
+@@ -772,6 +840,8 @@
+ 				freeparam((volatile struct shparam *)
+ 				    &saveparam);
+ 			} else {
++				saveparam.optind = shellparam.optind;
++				saveparam.optoff = shellparam.optoff;
+ 				freeparam(&shellparam);
+ 				shellparam = saveparam;
+ 			}
+@@ -790,6 +860,8 @@
+ 		INTOFF;
+ 		poplocalvars();
+ 		localvars = savelocalvars;
++		saveparam.optind = shellparam.optind;
++		saveparam.optoff = shellparam.optoff;
+ 		freeparam(&shellparam);
+ 		shellparam = saveparam;
+ 		handler = savehandler;
+@@ -832,6 +908,8 @@
+ 		out1 = &output;
+ 		out2 = &errout;
+ 		freestdout();
++		if (!not_special && is_special_builtin(commandname))
++			listsetvar(cmdenviron);
+ 		cmdenviron = NULL;
+ 		if (e != EXSHELLPROC) {
+ 			commandname = savecmdname;
+@@ -867,7 +953,7 @@
+ 		for (sp = varlist.list ; sp ; sp = sp->next)
+ 			setvareq(sp->text, VEXPORT|VSTACK);
+ 		envp = environment();
+-		shellexec(argv, envp, pathval(), cmdentry.u.index);
++		shellexec(argv, envp, path, cmdentry.u.index);
+ 	}
+ 	goto out;
+ 
+@@ -1025,4 +1111,49 @@
+ 		shellexec(argv + 1, environment(), pathval(), 0);
+ 	}
+ 	return 0;
++}
++
++STATIC int
++is_assignment_builtin (command)
++	const char *command;
++{
++	static const char *assignment_builtins[] = {
++		"alias", "declare", "export", "local", "readonly", "typeset",
++		(char *)NULL
++	};
++	int i;
++
++	for (i = 0; assignment_builtins[i]; i++)
++		if (strcmp(command, assignment_builtins[i]) == 0) return 1;
++	return 0;
++}
++
++int
++is_special_builtin(name)
++	const char *name;
++{
++	static const char *special_builtins[] = {
++		"break", ":", ".", "continue", "eval", "exec", "exit",
++		"export", "readonly", "return", "set", "shift", "times",
++		"trap", "unset", (char *)NULL
++	};
++	int i;
++
++	if (!name) return 0;
++	for (i = 0; special_builtins[i]; i++)
++		if (equal(name, special_builtins[i])) return 1;
++	return 0;
++}
++
++STATIC const char *
++get_standard_path()
++{
++	char *p;
++	size_t len;
++
++	len = confstr(_CS_PATH, NULL, 0);
++	p = stalloc(len + 2);
++	*p = '\0';
++	confstr(_CS_PATH, p, len);
++	return p;
+ }
+diff -urN netbsd-sh/eval.h ash-0.3.7.orig/eval.h
+--- netbsd-sh/eval.h	Fri Jan 28 13:03:00 2000
++++ ash-0.3.7.orig/eval.h	Mon Apr 23 22:16:46 2001
+@@ -61,6 +61,7 @@
+ int falsecmd __P((int, char **));
+ int truecmd __P((int, char **));
+ int execcmd __P((int, char **));
++int is_special_builtin __P((const char *));
+ 
+ /* in_function returns nonzero if we are currently evaluating a function */
+ #define in_function()	funcnest
+diff -urN netbsd-sh/exec.c ash-0.3.7.orig/exec.c
+--- netbsd-sh/exec.c	Fri Jan 12 17:50:35 2001
++++ ash-0.3.7.orig/exec.c	Mon Apr 23 22:16:46 2001
+@@ -51,6 +51,7 @@
+ #include <fcntl.h>
+ #include <errno.h>
+ #include <stdlib.h>
++#include <sysexits.h>
+ 
+ /*
+  * When commands are first encountered, they are entered in a hash table.
+@@ -108,6 +109,9 @@
+ STATIC void clearcmdentry __P((int));
+ STATIC struct tblentry *cmdlookup __P((char *, int));
+ STATIC void delete_cmd_entry __P((void));
++STATIC int describe_command __P((char *, int));
++STATIC int path_change __P((const char *, int *));
++STATIC int is_regular_builtin __P((const char *));
+ 
+ 
+ 
+@@ -164,7 +172,7 @@
+ 	char **envp;
+ 	{
+ 	int e;
+-#ifndef BSD
++#if !defined(BSD) && !defined(linux)
+ 	char *p;
+ #endif
+ 
+@@ -180,7 +188,7 @@
+ 		initshellproc();
+ 		setinputfile(cmd, 0);
+ 		commandname = arg0 = savestr(argv[0]);
+-#ifndef BSD
++#if !defined(BSD) && !defined(linux)
+ 		pgetc(); pungetc();		/* fill up input buffer */
+ 		p = parsenextc;
+ 		if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
+@@ -195,7 +203,7 @@
+ }
+ 
+ 
+-#ifndef BSD
++#if !defined(BSD) && !defined(linux)
+ /*
+  * Execute an interpreter introduced by "#!", for systems where this
+  * feature has not been built into the kernel.  If the interpreter is
+@@ -351,27 +359,29 @@
+ 	if (*argptr == NULL) {
+ 		for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
+ 			for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+-				printentry(cmdp, verbose);
++				if (cmdp->cmdtype != CMDBUILTIN) {
++					printentry(cmdp, verbose);
++				}
+ 			}
+ 		}
+ 		return 0;
+ 	}
++	c = 0;
+ 	while ((name = *argptr) != NULL) {
+ 		if ((cmdp = cmdlookup(name, 0)) != NULL
+ 		 && (cmdp->cmdtype == CMDNORMAL
+ 		     || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
+ 			delete_cmd_entry();
+ 		find_command(name, &entry, DO_ERR, pathval());
+-		if (verbose) {
+-			if (entry.cmdtype != CMDUNKNOWN) {	/* if no error msg */
+-				cmdp = cmdlookup(name, 0);
+-				printentry(cmdp, verbose);
+-			}
++		if (entry.cmdtype == CMDUNKNOWN) c = 1;
++		else if (verbose) {
++			cmdp = cmdlookup(name, 0);
++			if (cmdp) printentry(cmdp, verbose);
+ 			flushall();
+ 		}
+ 		argptr++;
+ 	}
+-	return 0;
++	return c;
+ }
+ 
+ 
+@@ -435,6 +445,10 @@
+ 	struct stat statb;
+ 	int e;
+ 	int i;
++	int bltin;
++	int firstchange;
++	int updatetbl;
++	int regular;
+ 
+ 	/* If name contains a slash, don't use the hash table */
+ 	if (strchr(name, '/') != NULL) {
+@@ -459,12 +473,54 @@
+ 		return;
+ 	}
+ 
++	updatetbl = 1;
++	if (act & DO_BRUTE) {
++		firstchange = path_change(path, &bltin);
++	} else {
++		bltin = builtinloc;
++		firstchange = 9999;
++	}
++
+ 	/* If name is in the table, and not invalidated by cd, we're done */
+-	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0)
+-		goto success;
++	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;
++		}
++	}
++
++	if ((regular = is_regular_builtin(name))) {
++		if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
++		    	goto success;
++		}
++	} else if (act & DO_BRUTE) {
++		if (firstchange == 0) {
++			updatetbl = 0;
++		}
++	}
+ 
+ 	/* If %builtin not in path, check for builtin next */
+-	if (builtinloc < 0 && (i = find_builtin(name)) >= 0) {
++	if ((bltin < 0 || regular) && (i = find_builtin(name)) >= 0) {
++		if (!updatetbl) {
++			entry->cmdtype = CMDBUILTIN;
++			entry->u.index = i;
++			return;
++		}
+ 		INTOFF;
+ 		cmdp = cmdlookup(name, 1);
+ 		cmdp->cmdtype = CMDBUILTIN;
+@@ -475,7 +531,7 @@
+ 
+ 	/* We have to search path. */
+ 	prev = -1;		/* where to start */
+-	if (cmdp) {		/* doing a rehash */
++	if (cmdp && cmdp->rehash) {	/* doing a rehash */
+ 		if (cmdp->cmdtype == CMDBUILTIN)
+ 			prev = builtinloc;
+ 		else
+@@ -488,26 +544,38 @@
+ 	while ((fullname = padvance(&path, name)) != NULL) {
+ 		stunalloc(fullname);
+ 		idx++;
++		if (idx >= firstchange) {
++			updatetbl = 0;
++		}
+ 		if (pathopt) {
+ 			if (prefix("builtin", pathopt)) {
+-				if ((i = find_builtin(name)) < 0)
+-					goto loop;
+-				INTOFF;
+-				cmdp = cmdlookup(name, 1);
+-				cmdp->cmdtype = CMDBUILTIN;
+-				cmdp->param.index = i;
+-				INTON;
+-				goto success;
+-			} else if (prefix("func", pathopt)) {
++				if ((i = find_builtin(name)) >= 0) {
++					if (!updatetbl) {
++						entry->cmdtype = CMDBUILTIN;
++						entry->u.index = i;
++						return;
++					}
++					INTOFF;
++					cmdp = cmdlookup(name, 1);
++					cmdp->cmdtype = CMDBUILTIN;
++					cmdp->param.index = i;
++					INTON;
++					goto success;
++				} else {
++					continue;
++				}
++			} else if (!(act & DO_NOFUN) &&
++				   prefix("func", pathopt)) {
+ 				/* handled below */
+ 			} else {
+-				goto loop;	/* ignore unimplemented options */
++				continue;	/* ignore unimplemented options */
+ 			}
+ 		}
+ 		/* if rehash, don't redo absolute path names */
+-		if (fullname[0] == '/' && idx <= prev) {
++		if (fullname[0] == '/' && idx <= prev &&
++		    idx < firstchange) {
+ 			if (idx < prev)
+-				goto loop;
++				continue;
+ 			TRACE(("searchexec \"%s\": no change\n", name));
+ 			goto success;
+ 		}
+@@ -522,7 +590,7 @@
+ 		}
+ 		e = EACCES;	/* if we fail, this will be the error */
+ 		if (!S_ISREG(statb.st_mode))
+-			goto loop;
++			continue;
+ 		if (pathopt) {		/* this is a %func directory */
+ 			stalloc(strlen(fullname) + 1);
+ 			readcmdfile(fullname);
+@@ -544,6 +612,13 @@
+ 		}
+ #endif
+ 		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;
++			return;
++		}
+ 		INTOFF;
+ 		cmdp = cmdlookup(name, 1);
+ 		cmdp->cmdtype = CMDNORMAL;
+@@ -553,7 +628,7 @@
+ 	}
+ 
+ 	/* We failed.  If there was an entry for this command, delete it */
+-	if (cmdp)
++	if (cmdp && updatetbl)
+ 		delete_cmd_entry();
+ 	if (act & DO_ERR)
+ 		outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));
+@@ -618,37 +693,12 @@
+ changepath(newval)
+ 	const char *newval;
+ {
+-	const char *old, *new;
+-	int idx;
+ 	int firstchange;
+ 	int bltin;
+ 
+-	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++;
+-	}
++	firstchange = path_change(newval, &bltin);
+ 	if (builtinloc < 0 && bltin >= 0)
+ 		builtinloc = bltin;		/* zap builtins */
+-	if (builtinloc >= 0 && bltin < 0)
+-		firstchange = 0;
+ 	clearcmdentry(firstchange);
+ 	builtinloc = bltin;
+ }
+@@ -838,11 +888,9 @@
+ 	{
+ 	struct cmdentry entry;
+ 
+-	INTOFF;
+ 	entry.cmdtype = CMDFUNCTION;
+ 	entry.u.func = copyfunc(func);
+ 	addcmdentry(name, &entry);
+-	INTON;
+ }
+ 
+ 
+@@ -944,4 +992,190 @@
+ 		}
+ 	}
+ 	return err;
++}
++
++STATIC int
++describe_command(command, verbose)
++	char *command;
++	int verbose;
++{
++	struct cmdentry entry;
++	struct tblentry *cmdp;
++	char **pp;
++	struct alias *ap;
++	extern char *const parsekwd[];
++
++	for (pp = (char **)parsekwd; *pp; pp++)
++		if (**pp == *command && equal(*pp, command))
++			break;
++
++	if (*pp) {
++		if (verbose) {
++			out1fmt("%s is a reserved word\n", command);
++		} else {
++			out1fmt("%s\n", command);
++		}
++		return 0;
++	}
++
++	/* Then look at the aliases */
++	if ((ap = lookupalias(command, 1)) != NULL) {
++		if (verbose) {
++			out1fmt("%s is aliased to `%s'\n", command, ap->val);
++		} else {
++			out1fmt("alias %s='%s'\n", command, ap->val);
++		}
++		return 0;
++	}
++
++	/* 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, pathval());
++	}
++
++	switch (entry.cmdtype) {
++	case CMDNORMAL: {
++		int j = entry.u.index;
++		const char *path = pathval();
++		char *name;
++		if (j == -1) 
++			name = command;
++		else {
++			do { 
++				name = padvance(&path, command);
++				stunalloc(name);
++			} while (--j >= 0);
++		}
++		if (verbose) {
++			out1fmt("%s is %s\n", command, name);
++		} else {
++			out1fmt("%s\n", name);
++		}
++		break;
++	}
++	case CMDFUNCTION:
++		if (verbose) {
++			out1fmt("%s is a function\n", command);
++		} else {
++			out1fmt("%s\n", command);
++		}
++		break;
++	case CMDBUILTIN:
++		if (verbose) {
++			if (is_special_builtin(command)) {
++				out1fmt("%s is a special built-in utility\n", command);
++			} else {
++				out1fmt("%s is a built-in utility\n", command);
++			}
++		} else {
++			out1fmt("%s\n", command);
++		}
++		break;
++	default:
++		outfmt(out2, "%s not found\n", command);
++		return 127;
++	}
++
++	return 0;
++}
++
++int
++commandcmd(argc, argv)
++	int argc;
++	char **argv;
++{
++	int c;
++	int default_path = 0;
++	int verify_only = 0;
++	int verbose_verify_only = 0;
++
++	while ((c = nextopt("pvV")) != '\0')
++		switch (c) {
++		case 'p':
++			default_path = 1;
++			break;
++		case 'v':
++			verify_only = 1;
++			break;
++		case 'V':
++			verbose_verify_only = 1;
++			break;
++		default:
++			outfmt(out2,
++"command: nextopt returned character code 0%o\n", c);
++			return EX_SOFTWARE;
++		}
++
++	if (default_path + verify_only + verbose_verify_only > 1 ||
++	    !*argptr) {
++			outfmt(out2,
++"command [-p] command [arg ...]\n");
++			outfmt(out2,
++"command {-v|-V} command\n");
++			return EX_USAGE;
++	}
++
++	if (verify_only || verbose_verify_only) {
++		return describe_command(*argptr, verbose_verify_only);
++	}
++
++	return 0;
++}
++
++STATIC int
++path_change(newval, bltin)
++	const char *newval;
++	int *bltin;
++{
++	const char *old, *new;
++	int idx;
++	int firstchange;
++
++	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;
++}
++
++STATIC int
++is_regular_builtin(name)
++        const char *name;
++{
++        static const char *regular_builtins[] = {
++        	"alias", "bg", "cd", "command", "false", "fc", "fg",
++        	"getopts", "jobs", "kill", "newgrp", "read", "true",
++        	"umask", "unalias", "wait", (char *)NULL
++        };
++        int i;
++
++        if (!name) return 0;
++        for (i = 0; regular_builtins[i]; i++)
++                if (equal(name, regular_builtins[i])) return 1;
++        return 0;
+ }
+diff -urN netbsd-sh/exec.h ash-0.3.7.orig/exec.h
+--- netbsd-sh/exec.h	Tue May 23 12:03:19 2000
++++ ash-0.3.7.orig/exec.h	Mon Apr 23 22:16:46 2001
+@@ -56,6 +56,8 @@
+ 
+ #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 */
+ 
+ extern const char *pathopt;	/* set by padvance */
+ extern int exerrno;		/* last exec error */
+@@ -74,3 +76,4 @@
+ void defun __P((char *, union node *));
+ int unsetfunc __P((char *));
+ int typecmd __P((int, char **));
++int commandcmd __P((int, char **));
+