diff options
Diffstat (limited to 'source/ap/ash/patches/ash-builtin.patch')
-rw-r--r-- | source/ap/ash/patches/ash-builtin.patch | 843 |
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 00000000..b812e637 --- /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) ¬_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 **)); + |