diff options
Diffstat (limited to 'Src/builtin.c')
| -rw-r--r-- | Src/builtin.c | 3599 |
1 files changed, 3599 insertions, 0 deletions
diff --git a/Src/builtin.c b/Src/builtin.c new file mode 100644 index 000000000..31f396d93 --- /dev/null +++ b/Src/builtin.c @@ -0,0 +1,3599 @@ +/* + * builtin.c - builtin commands + * + * This file is part of zsh, the Z shell. + * + * Copyright (c) 1992-1997 Paul Falstad + * All rights reserved. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and to distribute modified versions of this software for any + * purpose, provided that the above copyright notice and the following + * two paragraphs appear in all copies of this software. + * + * In no event shall Paul Falstad or the Zsh Development Group be liable + * to any party for direct, indirect, special, incidental, or consequential + * damages arising out of the use of this software and its documentation, + * even if Paul Falstad and the Zsh Development Group have been advised of + * the possibility of such damage. + * + * Paul Falstad and the Zsh Development Group specifically disclaim any + * warranties, including, but not limited to, the implied warranties of + * merchantability and fitness for a particular purpose. The software + * provided hereunder is on an "as is" basis, and Paul Falstad and the + * Zsh Development Group have no obligation to provide maintenance, + * support, updates, enhancements, or modifications. + * + */ + +#include "zsh.mdh" +#include "builtin.pro" + +/* Builtins in the main executable */ + +static struct builtin builtins[] = +{ + BIN_PREFIX("-", BINF_DASH), + BIN_PREFIX("builtin", BINF_BUILTIN), + BIN_PREFIX("command", BINF_COMMAND), + BIN_PREFIX("exec", BINF_EXEC), + BIN_PREFIX("noglob", BINF_NOGLOB), + BUILTIN("[", 0, bin_test, 0, -1, BIN_BRACKET, NULL, NULL), + BUILTIN(".", BINF_PSPECIAL, bin_dot, 1, -1, 0, NULL, NULL), + BUILTIN(":", BINF_PSPECIAL, bin_true, 0, -1, 0, NULL, NULL), + BUILTIN("alias", BINF_MAGICEQUALS, bin_alias, 0, -1, 0, "Lgmr", NULL), + BUILTIN("autoload", BINF_TYPEOPTS, bin_functions, 0, -1, 0, "t", "u"), + BUILTIN("bg", 0, bin_fg, 0, -1, BIN_BG, NULL, NULL), + BUILTIN("break", BINF_PSPECIAL, bin_break, 0, 1, BIN_BREAK, NULL, NULL), + BUILTIN("bye", 0, bin_break, 0, 1, BIN_EXIT, NULL, NULL), + BUILTIN("cd", 0, bin_cd, 0, 2, BIN_CD, NULL, NULL), + BUILTIN("chdir", 0, bin_cd, 0, 2, BIN_CD, NULL, NULL), + BUILTIN("continue", BINF_PSPECIAL, bin_break, 0, 1, BIN_CONTINUE, NULL, NULL), + BUILTIN("declare", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "LRUZfilrtux", NULL), + BUILTIN("dirs", 0, bin_dirs, 0, -1, 0, "v", NULL), + BUILTIN("disable", 0, bin_enable, 0, -1, BIN_DISABLE, "afmr", NULL), + BUILTIN("disown", 0, bin_fg, 0, -1, BIN_DISOWN, NULL, NULL), + BUILTIN("echo", BINF_PRINTOPTS | BINF_ECHOPTS, bin_print, 0, -1, BIN_ECHO, "neE", "-"), + BUILTIN("echotc", 0, bin_echotc, 1, -1, 0, NULL, NULL), + BUILTIN("emulate", 0, bin_emulate, 1, 1, 0, "R", NULL), + BUILTIN("enable", 0, bin_enable, 0, -1, BIN_ENABLE, "afmr", NULL), + BUILTIN("eval", BINF_PSPECIAL, bin_eval, 0, -1, BIN_EVAL, NULL, NULL), + BUILTIN("exit", BINF_PSPECIAL, bin_break, 0, 1, BIN_EXIT, NULL, NULL), + BUILTIN("export", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, BIN_EXPORT, "LRUZfilrtu", "x"), + BUILTIN("false", 0, bin_false, 0, -1, 0, NULL, NULL), + BUILTIN("fc", BINF_FCOPTS, bin_fc, 0, -1, BIN_FC, "nlreIRWAdDfEim", NULL), + BUILTIN("fg", 0, bin_fg, 0, -1, BIN_FG, NULL, NULL), + BUILTIN("functions", BINF_TYPEOPTS, bin_functions, 0, -1, 0, "mtu", NULL), + BUILTIN("getln", 0, bin_read, 0, -1, 0, "ecnAlE", "zr"), + BUILTIN("getopts", 0, bin_getopts, 2, -1, 0, NULL, NULL), + BUILTIN("hash", BINF_MAGICEQUALS, bin_hash, 0, -1, 0, "dfmrv", NULL), + +#ifdef ZSH_HASH_DEBUG + BUILTIN("hashinfo", 0, bin_hashinfo, 0, 0, 0, NULL, NULL), +#endif + + BUILTIN("history", 0, bin_fc, 0, -1, BIN_FC, "nrdDfEim", "l"), + BUILTIN("integer", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "lrtux", "i"), + BUILTIN("jobs", 0, bin_fg, 0, -1, BIN_JOBS, "dlpZrs", NULL), + BUILTIN("kill", 0, bin_kill, 0, -1, 0, NULL, NULL), + BUILTIN("let", 0, bin_let, 1, -1, 0, NULL, NULL), + BUILTIN("local", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "LRUZilrtu", NULL), + BUILTIN("log", 0, bin_log, 0, 0, 0, NULL, NULL), + BUILTIN("logout", 0, bin_break, 0, 1, BIN_LOGOUT, NULL, NULL), + +#if defined(ZSH_MEM) & defined(ZSH_MEM_DEBUG) + BUILTIN("mem", 0, bin_mem, 0, 0, 0, "v", NULL), +#endif + + BUILTIN("popd", 0, bin_cd, 0, 2, BIN_POPD, NULL, NULL), + BUILTIN("print", BINF_PRINTOPTS, bin_print, 0, -1, BIN_PRINT, "RDPnrslzNu0123456789pioOcm-", NULL), + BUILTIN("pushd", 0, bin_cd, 0, 2, BIN_PUSHD, NULL, NULL), + BUILTIN("pushln", BINF_PRINTOPTS, bin_print, 0, -1, BIN_PRINT, NULL, "-nz"), + BUILTIN("pwd", 0, bin_pwd, 0, 0, 0, "rLP", NULL), + BUILTIN("r", BINF_R, bin_fc, 0, -1, BIN_FC, "nrl", NULL), + BUILTIN("read", 0, bin_read, 0, -1, 0, "rzu0123456789pkqecnAlE", NULL), + BUILTIN("readonly", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "LRUZfiltux", "r"), + BUILTIN("rehash", 0, bin_hash, 0, 0, 0, "dfv", "r"), + BUILTIN("return", BINF_PSPECIAL, bin_break, 0, 1, BIN_RETURN, NULL, NULL), + BUILTIN("set", BINF_PSPECIAL, bin_set, 0, -1, 0, NULL, NULL), + BUILTIN("setopt", 0, bin_setopt, 0, -1, BIN_SETOPT, NULL, NULL), + BUILTIN("shift", BINF_PSPECIAL, bin_shift, 0, -1, 0, NULL, NULL), + BUILTIN("source", BINF_PSPECIAL, bin_dot, 1, -1, 0, NULL, NULL), + BUILTIN("suspend", 0, bin_suspend, 0, 0, 0, "f", NULL), + BUILTIN("test", 0, bin_test, 0, -1, BIN_TEST, NULL, NULL), + BUILTIN("ttyctl", 0, bin_ttyctl, 0, 0, 0, "fu", NULL), + BUILTIN("times", BINF_PSPECIAL, bin_times, 0, 0, 0, NULL, NULL), + BUILTIN("trap", BINF_PSPECIAL, bin_trap, 0, -1, 0, NULL, NULL), + BUILTIN("true", 0, bin_true, 0, -1, 0, NULL, NULL), + BUILTIN("type", 0, bin_whence, 0, -1, 0, "ampfsw", "v"), + BUILTIN("typeset", BINF_TYPEOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "LRUZfilrtuxm", NULL), + BUILTIN("umask", 0, bin_umask, 0, 1, 0, "S", NULL), + BUILTIN("unalias", 0, bin_unhash, 1, -1, 0, "m", "a"), + BUILTIN("unfunction", 0, bin_unhash, 1, -1, 0, "m", "f"), + BUILTIN("unhash", 0, bin_unhash, 1, -1, 0, "adfm", NULL), + BUILTIN("unset", BINF_PSPECIAL, bin_unset, 1, -1, 0, "fm", NULL), + BUILTIN("unsetopt", 0, bin_setopt, 0, -1, BIN_UNSETOPT, NULL, NULL), + BUILTIN("wait", 0, bin_fg, 0, -1, BIN_WAIT, NULL, NULL), + BUILTIN("whence", 0, bin_whence, 0, -1, 0, "acmpvfsw", NULL), + BUILTIN("where", 0, bin_whence, 0, -1, 0, "pmsw", "ca"), + BUILTIN("which", 0, bin_whence, 0, -1, 0, "ampsw", "c"), + +#ifdef DYNAMIC + BUILTIN("zmodload", 0, bin_zmodload, 0, -1, 0, "Laudi", NULL), +#endif +}; + +/****************************************/ +/* Builtin Command Hash Table Functions */ +/****************************************/ + +/* hash table containing builtin commands */ + +/**/ +HashTable builtintab; + +/**/ +void +createbuiltintable(void) +{ + builtintab = newhashtable(85, "builtintab", NULL); + + builtintab->hash = hasher; + builtintab->emptytable = NULL; + builtintab->filltable = NULL; + builtintab->addnode = addhashnode; + builtintab->getnode = gethashnode; + builtintab->getnode2 = gethashnode2; + builtintab->removenode = removehashnode; + builtintab->disablenode = disablehashnode; + builtintab->enablenode = enablehashnode; + builtintab->freenode = freebuiltinnode; + builtintab->printnode = printbuiltinnode; + + addbuiltins("zsh", builtins, sizeof(builtins)/sizeof(*builtins)); +} + +/* Print a builtin */ + +/**/ +static void +printbuiltinnode(HashNode hn, int printflags) +{ + Builtin bn = (Builtin) hn; + + if (printflags & PRINT_WHENCE_WORD) { + printf("%s: builtin\n", bn->nam); + return; + } + + if (printflags & PRINT_WHENCE_CSH) { + printf("%s: shell built-in command\n", bn->nam); + return; + } + + if (printflags & PRINT_WHENCE_VERBOSE) { + printf("%s is a shell builtin\n", bn->nam); + return; + } + + /* default is name only */ + printf("%s\n", bn->nam); +} + +/**/ +static void +freebuiltinnode(HashNode hn) +{ + Builtin bn = (Builtin) hn; + + if(!(bn->flags & BINF_ADDED)) { + zsfree(bn->nam); + zsfree(bn->optstr); + zfree(bn, sizeof(struct builtin)); + } +} + +static char *auxdata; +static int auxlen; + +/* execute a builtin handler function after parsing the arguments */ + +#define MAX_OPS 128 + +/**/ +int +execbuiltin(LinkList args, Builtin bn) +{ + LinkNode n; + char ops[MAX_OPS], *arg, *pp, *name, **argv, **oargv, *optstr; + char *oxarg, *xarg = NULL; + int flags, sense, argc = 0, execop; + + /* initialise some static variables */ + auxdata = NULL; + auxlen = 0; + + /* initialize some local variables */ + memset(ops, 0, MAX_OPS); + name = (char *) ugetnode(args); + + arg = (char *) ugetnode(args); + +#ifdef DYNAMIC + if (!bn->handlerfunc) { + zwarnnam(name, "autoload failed", NULL, 0); + deletebuiltin(bn->nam); + return 1; + } +#endif + + /* get some information about the command */ + flags = bn->flags; + optstr = bn->optstr; + + /* Sort out the options. */ + if ((flags & BINF_ECHOPTS) && isset(BSDECHO)) + ops['E'] = 1; + if (optstr) + /* while arguments look like options ... */ + while (arg && + ((sense = (*arg == '-')) || + ((flags & BINF_PLUSOPTS) && *arg == '+')) && + ((flags & BINF_PLUSOPTS) || !atoi(arg))) { + /* unrecognised options to echo etc. are not really options */ + if (flags & BINF_ECHOPTS) { + char *p = arg; + while (*++p && strchr(optstr, (int) *p)); + if (*p) + break; + } + /* save the options in xarg, for execution tracing */ + if (xarg) { + oxarg = tricat(xarg, " ", arg); + zsfree(xarg); + xarg = oxarg; + } else + xarg = ztrdup(arg); + /* handle -- or - (ops['-']), and + (ops['-'] and ops['+']) */ + if (arg[1] == '-') + arg++; + if (!arg[1]) { + ops['-'] = 1; + if (!sense) + ops['+'] = 1; + } + /* save options in ops, as long as they are in bn->optstr */ + execop = -1; + while (*++arg) + if (strchr(optstr, execop = (int)*arg)) + ops[(int)*arg] = (sense) ? 1 : 2; + else + break; + /* "typeset" may take a numeric argument * + * at the tail of the options */ + if (idigit(*arg) && (flags & BINF_TYPEOPT) && + (arg[-1] == 'L' || arg[-1] == 'R' || + arg[-1] == 'Z' || arg[-1] == 'i')) + auxlen = (int)zstrtol(arg, &arg, 10); + /* The above loop may have exited on an invalid option. (We * + * assume that any option requiring metafication is invalid.) */ + if (*arg) { + if(*arg == Meta) + *++arg ^= 32; + zerr("bad option: -%c", NULL, *arg); + zsfree(xarg); + return 1; + } + arg = (char *) ugetnode(args); + /* for the "print" builtin, the options after -R are treated as + options to "echo" */ + if ((flags & BINF_PRINTOPTS) && ops['R']) { + optstr = "ne"; + flags |= BINF_ECHOPTS; + } + /* the option -- indicates the end of the options */ + if (ops['-']) + break; + /* for "fc", -e takes an extra argument */ + if ((flags & BINF_FCOPTS) && execop == 'e') { + auxdata = arg; + arg = (char *) ugetnode(args); + } + /* for "typeset", -L, -R, -Z and -i take a numeric extra argument */ + if ((flags & BINF_TYPEOPT) && (execop == 'L' || execop == 'R' || + execop == 'Z' || execop == 'i') && arg && idigit(*arg)) { + auxlen = atoi(arg); + arg = (char *) ugetnode(args); + } + } + if (flags & BINF_R) + auxdata = "-"; + /* handle built-in options, for overloaded handler functions */ + if ((pp = bn->defopts)) + while (*pp) + ops[(int)*pp++] = 1; + + /* Set up the argument list. */ + if (arg) { + /* count the arguments */ + argc = 1; + n = firstnode(args); + while (n) + argc++, incnode(n); + } + /* Get the actual arguments, into argv. Oargv saves the * + * beginning of the array for later reference. */ + oargv = argv = (char **)ncalloc(sizeof(char **) * (argc + 1)); + if ((*argv++ = arg)) + while ((*argv++ = (char *)ugetnode(args))); + argv = oargv; + if (errflag) { + zsfree(xarg); + errflag = 0; + return 1; + } + + /* check that the argument count lies within the specified bounds */ + if (argc < bn->minargs || (argc > bn->maxargs && bn->maxargs != -1)) { + zwarnnam(name, (argc < bn->minargs) + ? "not enough arguments" : "too many arguments", NULL, 0); + zsfree(xarg); + return 1; + } + + /* display execution trace information, if required */ + if (isset(XTRACE)) { + fprintf(stderr, "%s%s", (prompt4) ? prompt4 : "", name); + if (xarg) + fprintf(stderr, " %s", xarg); + while (*oargv) + fprintf(stderr, " %s", *oargv++); + fputc('\n', stderr); + fflush(stderr); + } + zsfree(xarg); + /* call the handler function, and return its return value */ + return (*(bn->handlerfunc)) (name, argv, ops, bn->funcid); +} + +/* Enable/disable an element in one of the internal hash tables. * + * With no arguments, it lists all the currently enabled/disabled * + * elements in that particular hash table. */ + +/**/ +int +bin_enable(char *name, char **argv, char *ops, int func) +{ + HashTable ht; + HashNode hn; + ScanFunc scanfunc; + Comp com; + int flags1 = 0, flags2 = 0; + int match = 0, returnval = 0; + + /* Find out which hash table we are working with. */ + if (ops['f']) + ht = shfunctab; + else if (ops['r']) + ht = reswdtab; + else if (ops['a']) + ht = aliastab; + else + ht = builtintab; + + /* Do we want to enable or disable? */ + if (func == BIN_ENABLE) { + flags2 = DISABLED; + scanfunc = ht->enablenode; + } else { + flags1 = DISABLED; + scanfunc = ht->disablenode; + } + + /* Given no arguments, print the names of the enabled/disabled elements * + * in this hash table. If func == BIN_ENABLE, then scanhashtable will * + * print nodes NOT containing the DISABLED flag, else scanhashtable will * + * print nodes containing the DISABLED flag. */ + if (!*argv) { + scanhashtable(ht, 1, flags1, flags2, ht->printnode, 0); + return 0; + } + + /* With -m option, treat arguments as glob patterns. */ + if (ops['m']) { + for (; *argv; argv++) { + /* parse pattern */ + tokenize(*argv); + if ((com = parsereg(*argv))) + match += scanmatchtable(ht, com, 0, 0, scanfunc, 0); + else { + untokenize(*argv); + zwarnnam(name, "bad pattern : %s", *argv, 0); + returnval = 1; + } + } + /* If we didn't match anything, we return 1. */ + if (!match) + returnval = 1; + return returnval; + } + + /* Take arguments literally -- do not glob */ + for (; *argv; argv++) { + if ((hn = ht->getnode2(ht, *argv))) { + scanfunc(hn, 0); + } else { + zwarnnam(name, "no such hash table element: %s", *argv, 0); + returnval = 1; + } + } + return returnval; +} + +/* set: either set the shell options, or set the shell arguments, * + * or declare an array, or show various things */ + +/**/ +int +bin_set(char *nam, char **args, char *ops, int func) +{ + int action, optno, array = 0, hadopt = 0, + hadplus = 0, hadend = 0, sort = 0; + char **x; + + /* Obsolecent sh compatibility: set - is the same as set +xv * + * and set - args is the same as set +xv -- args */ + if (*args && **args == '-' && !args[0][1]) { + dosetopt(VERBOSE, 0, 0); + dosetopt(XTRACE, 0, 0); + if (!args[1]) + return 0; + } + + /* loop through command line options (begins with "-" or "+") */ + while (*args && (**args == '-' || **args == '+')) { + action = (**args == '-'); + hadplus |= !action; + if(!args[0][1]) + *args = "--"; + while (*++*args) { + if(**args == Meta) + *++*args ^= 32; + if(**args != '-' || action) + hadopt = 1; + /* The pseudo-option `--' signifies the end of options. */ + if (**args == '-') { + hadend = 1; + args++; + goto doneoptions; + } else if (**args == 'o') { + if (!*++*args) + args++; + if (!*args) { + zwarnnam(nam, "string expected after -o", NULL, 0); + inittyptab(); + return 1; + } + if(!(optno = optlookup(*args))) + zwarnnam(nam, "no such option: %s", *args, 0); + else if(dosetopt(optno, action, 0)) + zwarnnam(nam, "can't change option: %s", *args, 0); + break; + } else if(**args == 'A') { + if(!*++*args) + args++; + array = action ? 1 : -1; + goto doneoptions; + } else if (**args == 's') + sort = action ? 1 : -1; + else { + if (!(optno = optlookupc(**args))) + zwarnnam(nam, "bad option: -%c", NULL, **args); + else if(dosetopt(optno, action, 0)) + zwarnnam(nam, "can't change option: -%c", NULL, **args); + } + } + args++; + } + doneoptions: + inittyptab(); + + /* Show the parameters, possibly with values */ + if (!hadopt && !*args) + scanhashtable(paramtab, 1, 0, 0, paramtab->printnode, + hadplus ? PRINT_NAMEONLY : 0); + + if (array && !*args) { + /* display arrays */ + scanhashtable(paramtab, 1, PM_ARRAY, 0, paramtab->printnode, + hadplus ? PRINT_NAMEONLY : 0); + } + if (!*args && !hadend) + return 0; + if (array) + args++; + if (sort) + qsort(args, arrlen(args), sizeof(char *), + sort > 0 ? strpcmp : invstrpcmp); + if (array) { + /* create an array with the specified elements */ + char **a = NULL, **y, *name = args[-1]; + int len = arrlen(args); + + if (array < 0 && (a = getaparam(name))) { + int al = arrlen(a); + + if (al > len) + len = al; + } + for (x = y = zalloc((len + 1) * sizeof(char *)); len--; a++) { + if (!*args) + args = a; + *y++ = ztrdup(*args++); + } + *y++ = NULL; + setaparam(name, x); + } else { + /* set shell arguments */ + freearray(pparams); + PERMALLOC { + pparams = arrdup(args); + } LASTALLOC; + } + return 0; +} + +/**** directory-handling builtins ****/ + +/**/ +int doprintdir = 0; /* set in exec.c (for autocd) */ + +/* pwd: display the name of the current directory */ + +/**/ +int +bin_pwd(char *name, char **argv, char *ops, int func) +{ + if (ops['r'] || ops['P'] || (isset(CHASELINKS) && !ops['L'])) + printf("%s\n", zgetcwd()); + else { + zputs(pwd, stdout); + putchar('\n'); + } + return 0; +} + +/* the directory stack */ + +/**/ +LinkList dirstack; + +/* dirs: list the directory stack, or replace it with a provided list */ + +/**/ +int +bin_dirs(char *name, char **argv, char *ops, int func) +{ + LinkList l; + + /* with the -v option, provide a numbered list of directories, starting at + zero */ + if (ops['v']) { + LinkNode node; + int pos = 1; + + printf("0\t"); + fprintdir(pwd, stdout); + for (node = firstnode(dirstack); node; incnode(node)) { + printf("\n%d\t", pos++); + fprintdir(getdata(node), stdout); + } + putchar('\n'); + return 0; + } + /* given no arguments, list the stack normally */ + if (!*argv) { + printdirstack(); + return 0; + } + /* replace the stack with the specified directories */ + PERMALLOC { + l = newlinklist(); + if (*argv) { + while (*argv) + addlinknode(l, ztrdup(*argv++)); + freelinklist(dirstack, freestr); + dirstack = l; + } + } LASTALLOC; + return 0; +} + +/* cd, chdir, pushd, popd */ + +/**/ +void +set_pwd_env(void) +{ + Param pm; + + pm = (Param) paramtab->getnode(paramtab, "PWD"); + if (pm && PM_TYPE(pm->flags) != PM_SCALAR) { + pm->flags &= ~PM_READONLY; + unsetparam_pm(pm, 0, 1); + } + + pm = (Param) paramtab->getnode(paramtab, "OLDPWD"); + if (pm && PM_TYPE(pm->flags) != PM_SCALAR) { + pm->flags &= ~PM_READONLY; + unsetparam_pm(pm, 0, 1); + } + + setsparam("PWD", ztrdup(pwd)); + setsparam("OLDPWD", ztrdup(oldpwd)); + + pm = (Param) paramtab->getnode(paramtab, "PWD"); + if (!(pm->flags & PM_EXPORTED)) { + pm->flags |= PM_EXPORTED; + pm->env = addenv("PWD", pwd); + } + pm = (Param) paramtab->getnode(paramtab, "OLDPWD"); + if (!(pm->flags & PM_EXPORTED)) { + pm->flags |= PM_EXPORTED; + pm->env = addenv("PWD", pwd); + } +} + +/* The main pwd changing function. The real work is done by other * + * functions. cd_get_dest() does the initial argument processing; * + * cd_do_chdir() actually changes directory, if possible; cd_new_pwd() * + * does the ancilliary processing associated with actually changing * + * directory. */ + +/**/ +int +bin_cd(char *nam, char **argv, char *ops, int func) +{ + LinkNode dir; + struct stat st1, st2; + int chaselinks; + + if (isset(RESTRICTED)) { + zwarnnam(nam, "restricted", NULL, 0); + return 1; + } + doprintdir = (doprintdir == -1); + + for (; *argv && **argv == '-'; argv++) { + char *s = *argv + 1; + + do { + switch (*s) { + case 's': + case 'P': + case 'L': + break; + default: + goto brk; + } + } while (*++s); + for (s = *argv; *++s; ops[*s] = 1); + } + brk: + chaselinks = ops['P'] || (isset(CHASELINKS) && !ops['L']); + PERMALLOC { + pushnode(dirstack, ztrdup(pwd)); + if (!(dir = cd_get_dest(nam, argv, ops, func))) { + zsfree(getlinknode(dirstack)); + LASTALLOC_RETURN 1; + } + } LASTALLOC; + cd_new_pwd(func, dir, chaselinks); + + if (stat(unmeta(pwd), &st1) < 0) { + zsfree(pwd); + pwd = metafy(zgetcwd(), -1, META_DUP); + } else if (stat(".", &st2) < 0) + chdir(unmeta(pwd)); + else if (st1.st_ino != st2.st_ino || st1.st_dev != st2.st_dev) { + if (chaselinks) { + zsfree(pwd); + pwd = metafy(zgetcwd(), -1, META_DUP); + } else { + chdir(unmeta(pwd)); + } + } + set_pwd_env(); + return 0; +} + +/* Get directory to chdir to */ + +/**/ +static LinkNode +cd_get_dest(char *nam, char **argv, char *ops, int func) +{ + LinkNode dir = NULL; + LinkNode target; + char *dest; + + if (!argv[0]) { + if (func == BIN_POPD && !nextnode(firstnode(dirstack))) { + zwarnnam(nam, "directory stack empty", NULL, 0); + return NULL; + } + if (func == BIN_PUSHD && unset(PUSHDTOHOME)) + dir = nextnode(firstnode(dirstack)); + if (dir) + insertlinknode(dirstack, dir, getlinknode(dirstack)); + else if (func != BIN_POPD) + pushnode(dirstack, ztrdup(home)); + } else if (!argv[1]) { + int dd; + char *end; + + doprintdir++; + if (argv[0][1] && (argv[0][0] == '+' || argv[0][0] == '-')) { + dd = zstrtol(argv[0] + 1, &end, 10); + if (*end == '\0') { + if ((argv[0][0] == '+') ^ isset(PUSHDMINUS)) + for (dir = firstnode(dirstack); dir && dd; dd--, incnode(dir)); + else + for (dir = lastnode(dirstack); dir != (LinkNode) dirstack && dd; + dd--, dir = prevnode(dir)); + if (!dir || dir == (LinkNode) dirstack) { + zwarnnam(nam, "no such entry in dir stack", NULL, 0); + return NULL; + } + } + } + if (!dir) + pushnode(dirstack, ztrdup(strcmp(argv[0], "-") + ? (doprintdir--, argv[0]) : oldpwd)); + } else { + char *u, *d; + int len1, len2, len3; + + if (!(u = strstr(pwd, argv[0]))) { + zwarnnam(nam, "string not in pwd: %s", argv[0], 0); + return NULL; + } + len1 = strlen(argv[0]); + len2 = strlen(argv[1]); + len3 = u - pwd; + d = (char *)zalloc(len3 + len2 + strlen(u + len1) + 1); + strncpy(d, pwd, len3); + strcpy(d + len3, argv[1]); + strcat(d, u + len1); + pushnode(dirstack, d); + doprintdir++; + } + + target = dir; + if (func == BIN_POPD) { + if (!dir) { + target = dir = firstnode(dirstack); + } else if (dir != firstnode(dirstack)) { + return dir; + } + dir = nextnode(dir); + } + if (!dir) { + dir = firstnode(dirstack); + } + if (!(dest = cd_do_chdir(nam, getdata(dir), ops['s']))) { + if (!target) + zsfree(getlinknode(dirstack)); + if (func == BIN_POPD) + zsfree(remnode(dirstack, dir)); + return NULL; + } + if (dest != getdata(dir)) { + zsfree(getdata(dir)); + setdata(dir, dest); + } + return target ? target : dir; +} + +/* Change to given directory, if possible. This function works out * + * exactly how the directory should be interpreted, including cdpath * + * and CDABLEVARS. For each possible interpretation of the given * + * path, this calls cd_try_chdir(), which attempts to chdir to that * + * particular path. */ + +/**/ +static char * +cd_do_chdir(char *cnam, char *dest, int hard) +{ + char **pp, *ret; + int hasdot = 0, eno = ENOENT; + /* nocdpath indicates that cdpath should not be used. This is the case iff + dest is a relative path whose first segment is . or .., but if the path is + absolute then cdpath won't be used anyway. */ + int nocdpath = dest[0] == '.' && + (dest[1] == '/' || !dest[1] || (dest[1] == '.' && + (dest[2] == '/' || !dest[2]))); + + /* if we have an absolute path, use it as-is only */ + if (*dest == '/') { + if ((ret = cd_try_chdir(NULL, dest, hard))) + return ret; + zwarnnam(cnam, "%e: %s", dest, errno); + return NULL; + } + + /* if cdpath is being used, check it for . */ + if (!nocdpath) + for (pp = cdpath; *pp; pp++) + if (!(*pp)[0] || ((*pp)[0] == '.' && (*pp)[1] == '\0')) + hasdot = 1; + /* if there is no . in cdpath (or it is not being used), try the directory + as-is (i.e. from .) */ + if (!hasdot) { + if ((ret = cd_try_chdir(NULL, dest, hard))) + return ret; + if (errno != ENOENT) + eno = errno; + } + /* if cdpath is being used, try given directory relative to each element in + cdpath in turn */ + if (!nocdpath) + for (pp = cdpath; *pp; pp++) { + if ((ret = cd_try_chdir(*pp, dest, hard))) { + if (strcmp(*pp, ".")) { + doprintdir++; + } + return ret; + } + if (errno != ENOENT) + eno = errno; + } + + /* handle the CDABLEVARS option */ + if ((ret = cd_able_vars(dest))) { + if ((ret = cd_try_chdir(NULL, ret,hard))) { + doprintdir++; + return ret; + } + if (errno != ENOENT) + eno = errno; + } + + /* If we got here, it means that we couldn't chdir to any of the + multitudinous possible paths allowed by zsh. We've run out of options! + Add more here! */ + zwarnnam(cnam, "%e: %s", dest, eno); + return NULL; +} + +/* If the CDABLEVARS option is set, return the new * + * interpretation of the given path. */ + +/**/ +char * +cd_able_vars(char *s) +{ + char *rest, save; + + if (isset(CDABLEVARS)) { + for (rest = s; *rest && *rest != '/'; rest++); + save = *rest; + *rest = 0; + s = getnameddir(s); + *rest = save; + + if (s && *rest) + s = dyncat(s, rest); + + return s; + } + return NULL; +} + +/* Attempt to change to a single given directory. The directory, * + * for the convenience of the calling function, may be provided in * + * two parts, which must be concatenated before attempting to chdir. * + * Returns NULL if the chdir fails. If the directory change is * + * possible, it is performed, and a pointer to the new full pathname * + * is returned. */ + +/**/ +static char * +cd_try_chdir(char *pfix, char *dest, int hard) +{ + char *buf; + + /* handle directory prefix */ + if (pfix && *pfix) { + if (*pfix == '/') + buf = tricat(pfix, "/", dest); + else { + int pwl = strlen(pwd); + int pfl = strlen(pfix); + + buf = zalloc(pwl + pfl + strlen(dest) + 3); + strcpy(buf, pwd); + buf[pwl] = '/'; + strcpy(buf + pwl + 1, pfix); + buf[pwl + 1 + pfl] = '/'; + strcpy(buf + pwl + pfl + 2, dest); + } + } else if (*dest == '/') + buf = ztrdup(dest); + else { + int pwl = strlen(pwd); + + buf = zalloc(pwl + strlen(dest) + 2); + strcpy(buf, pwd); + buf[pwl] = '/'; + strcpy(buf + pwl + 1, dest); + } + + /* Normalise path. See the definition of fixdir() for what this means. */ + fixdir(buf); + + if (lchdir(buf, NULL, hard)) { + zsfree(buf); + return NULL; + } + return metafy(buf, -1, META_NOALLOC); +} + +/* do the extra processing associated with changing directory */ + +/**/ +static void +cd_new_pwd(int func, LinkNode dir, int chaselinks) +{ + Param pm; + List l; + char *new_pwd, *s; + int dirstacksize; + + if (func == BIN_PUSHD) + rolllist(dirstack, dir); + new_pwd = remnode(dirstack, dir); + + if (func == BIN_POPD && firstnode(dirstack)) { + zsfree(new_pwd); + new_pwd = getlinknode(dirstack); + } else if (func == BIN_CD && unset(AUTOPUSHD)) + zsfree(getlinknode(dirstack)); + + if (chaselinks) { + s = new_pwd; + new_pwd = findpwd(s); + zsfree(s); + } + if (isset(PUSHDIGNOREDUPS)) { + LinkNode n; + for (n = firstnode(dirstack); n; incnode(n)) { + if (!strcmp(new_pwd, getdata(n))) { + zsfree(remnode(dirstack, n)); + break; + } + } + } + + /* shift around the pwd variables, to make oldpwd and pwd relate to the + current (i.e. new) pwd */ + zsfree(oldpwd); + oldpwd = pwd; + pwd = new_pwd; + /* update the PWD and OLDPWD shell parameters */ + if ((pm = (Param) paramtab->getnode(paramtab, "PWD")) && + (pm->flags & PM_EXPORTED) && pm->env) + pm->env = replenv(pm->env, pwd); + if ((pm = (Param) paramtab->getnode(paramtab, "OLDPWD")) && + (pm->flags & PM_EXPORTED) && pm->env) + pm->env = replenv(pm->env, oldpwd); + if (unset(PUSHDSILENT) && func != BIN_CD && isset(INTERACTIVE)) + printdirstack(); + else if (doprintdir) { + fprintdir(pwd, stdout); + putchar('\n'); + } + + /* execute the chpwd function */ + if ((l = getshfunc("chpwd")) != &dummy_list) { + fflush(stdout); + fflush(stderr); + doshfunc(l, NULL, 0, 1); + } + + dirstacksize = getiparam("DIRSTACKSIZE"); + /* handle directory stack sizes out of range */ + if (dirstacksize > 0) { + int remove = countlinknodes(dirstack) - + (dirstacksize < 2 ? 2 : dirstacksize); + while (remove-- >= 0) + zsfree(remnode(dirstack, lastnode(dirstack))); + } +} + +/* Print the directory stack */ + +/**/ +static void +printdirstack(void) +{ + LinkNode node; + + fprintdir(pwd, stdout); + for (node = firstnode(dirstack); node; incnode(node)) { + putchar(' '); + fprintdir(getdata(node), stdout); + } + putchar('\n'); +} + +/* Normalise a path. Segments consisting of ., and foo/.. * + * combinations, are removed and the path is unmetafied. */ + +/**/ +static void +fixdir(char *src) +{ + char *dest = src; + char *d0 = dest; + +/*** if have RFS superroot directory ***/ +#ifdef HAVE_SUPERROOT + /* allow /.. segments to remain */ + while (*src == '/' && src[1] == '.' && src[2] == '.' && + (!src[3] || src[3] == '/')) { + *dest++ = '/'; + *dest++ = '.'; + *dest++ = '.'; + src += 3; + } +#endif + + for (;;) { + /* compress multiple /es into single */ + if (*src == '/') { + *dest++ = *src++; + while (*src == '/') + src++; + } + /* if we are at the end of the input path, remove a trailing / (if it + exists), and return ct */ + if (!*src) { + while (dest > d0 + 1 && dest[-1] == '/') + dest--; + *dest = '\0'; + return; + } + if (dest > d0 + 1 && src[0] == '.' && src[1] == '.' && + (src[2] == '\0' || src[2] == '/')) { + /* remove a foo/.. combination */ + for (dest--; dest > d0 + 1 && dest[-1] != '/'; dest--); + if (dest[-1] != '/') + dest--; + src++; + while (*++src == '/'); + } else if (src[0] == '.' && (src[1] == '/' || src[1] == '\0')) { + /* skip a . section */ + while (*++src == '/'); + } else { + /* copy a normal segment into the output */ + while (*src != '/' && *src != '\0') + if ((*dest++ = *src++) == Meta) + dest[-1] = *src++ ^ 32; + } + } +} + +/**/ +void +printqt(char *str) +{ + /* Print str, but turn any single quote into '\'' or ''. */ + for (; *str; str++) + if (*str == '\'') + printf(isset(RCQUOTES) ? "''" : "'\\''"); + else + putchar(*str); +} + +/**/ +void +printif(char *str, int c) +{ + /* If flag c has an argument, print that */ + if (str) { + printf(" -%c ", c); + quotedzputs(str, stdout); + } +} + +/**** history list functions ****/ + +/* fc, history, r */ + +/**/ +int +bin_fc(char *nam, char **argv, char *ops, int func) +{ + int first = -1, last = -1, retval, minflag = 0; + char *s; + struct asgment *asgf = NULL, *asgl = NULL; + Comp com = NULL; + + /* fc is only permitted in interactive shells */ + if (!interact) { + zwarnnam(nam, "not interactive shell", NULL, 0); + return 1; + } + /* with the -m option, the first argument is taken * + * as a pattern that history lines have to match */ + if (*argv && ops['m']) { + tokenize(*argv); + if (!(com = parsereg(*argv++))) { + zwarnnam(nam, "invalid match pattern", NULL, 0); + return 1; + } + } + if (ops['R']) { + /* read history from a file */ + readhistfile(*argv ? *argv : getsparam("HISTFILE"), 1); + return 0; + } + if (ops['W']) { + /* write history to a file */ + savehistfile(*argv ? *argv : getsparam("HISTFILE"), 1, + (ops['I'] ? 2 : 0)); + return 0; + } + if (ops['A']) { + /* append history to a file */ + savehistfile(*argv ? *argv : getsparam("HISTFILE"), 1, + (ops['I'] ? 3 : 1)); + return 0; + } + if (!(ops['l'] && unset(HISTNOSTORE))) + remhist(); + /* put foo=bar type arguments into the substitution list */ + while (*argv && equalsplit(*argv, &s)) { + Asgment a = (Asgment) alloc(sizeof *a); + + if (!asgf) + asgf = asgl = a; + else { + asgl->next = a; + asgl = a; + } + a->name = *argv; + a->value = s; + argv++; + } + /* interpret and check first history line specifier */ + if (*argv) { + minflag = **argv == '-'; + first = fcgetcomm(*argv); + if (first == -1) + return 1; + argv++; + } + /* interpret and check second history line specifier */ + if (*argv) { + last = fcgetcomm(*argv); + if (last == -1) + return 1; + argv++; + } + /* There is a maximum of two history specifiers. At least, there * + * will be as long as the history list is one-dimensional. */ + if (*argv) { + zwarnnam("fc", "too many arguments", NULL, 0); + return 1; + } + /* default values of first and last, and range checking */ + if (first == -1) + first = (ops['l']) ? curhist - 16 : curhist - 1; + if (last == -1) + last = (ops['l']) ? curhist - 1 : first; + if (first < firsthist()) + first = firsthist(); + if (last == -1) + last = (minflag) ? curhist : first; + else if (last < first) + last = first; + if (ops['l']) + /* list the required part of the history */ + retval = fclist(stdout, !ops['n'], ops['r'], ops['D'], + ops['d'] + ops['f'] * 2 + ops['E'] * 4 + ops['i'] * 8, + first, last, asgf, com); + else { + /* edit history file, and (if successful) use the result as a new command */ + int tempfd; + FILE *out; + char *fil; + + retval = 1; + fil = gettempname(); + if (((tempfd = open(fil, O_WRONLY | O_CREAT | O_EXCL | O_NOCTTY, 0600)) + == -1) || + ((out = fdopen(tempfd, "w")) == NULL)) { + zwarnnam("fc", "can't open temp file: %e", NULL, errno); + } else { + if (!fclist(out, 0, ops['r'], 0, 0, first, last, asgf, com)) { + char *editor; + + editor = auxdata ? auxdata : getsparam("FCEDIT"); + if (!editor) + editor = DEFAULT_FCEDIT; + + if (fcedit(editor, fil)) + if (stuff(fil)) + zwarnnam("fc", "%e: %s", s, errno); + else { + loop(0,1); + retval = lastval; + } + } + } + unlink(fil); + } + return retval; +} + +/* History handling functions: these are called by ZLE, as well as * + * the actual builtins. fcgetcomm() gets a history line, specified * + * either by number or leading string. fcsubs() performs a given * + * set of simple old=new substitutions on a given command line. * + * fclist() outputs a given range of history lines to a text file. */ + +/* get the history event associated with s */ + +/**/ +static int +fcgetcomm(char *s) +{ + int cmd; + + /* First try to match a history number. Negative * + * numbers indicate reversed numbering. */ + if ((cmd = atoi(s))) { + if (cmd < 0) + cmd = curhist + cmd; + if (cmd >= curhist) { + zwarnnam("fc", "bad history number: %d", 0, cmd); + return -1; + } + return cmd; + } + /* not a number, so search by string */ + cmd = hcomsearch(s); + if (cmd == -1) + zwarnnam("fc", "event not found: %s", s, 0); + return cmd; +} + +/* Perform old=new substituions. Uses the asgment structure from zsh.h, * + * which is essentially a linked list of string,replacement pairs. */ + +/**/ +static int +fcsubs(char **sp, struct asgment *sub) +{ + char *oldstr, *newstr, *oldpos, *newpos, *newmem, *s = *sp; + int subbed = 0; + + /* loop through the linked list */ + while (sub) { + oldstr = sub->name; + newstr = sub->value; + sub = sub->next; + oldpos = s; + /* loop over occurences of oldstr in s, replacing them with newstr */ + while ((newpos = (char *)strstr(oldpos, oldstr))) { + newmem = (char *) alloc(1 + (newpos - s) + + strlen(newstr) + strlen(newpos + strlen(oldstr))); + ztrncpy(newmem, s, newpos - s); + strcat(newmem, newstr); + oldpos = newmem + strlen(newmem); + strcat(newmem, newpos + strlen(oldstr)); + s = newmem; + subbed = 1; + } + } + *sp = s; + return subbed; +} + +/* Print a series of history events to a file. The file pointer is * + * given by f, and the required range of events by first and last. * + * subs is an optional list of foo=bar substitutions to perform on the * + * history lines before output. com is an optional comp structure * + * that the history lines are required to match. n, r, D and d are * + * options: n indicates that each line should be numbered. r indicates * + * that the lines should be output in reverse order (newest first). * + * D indicates that the real time taken by each command should be * + * output. d indicates that the time of execution of each command * + * should be output; d>1 means that the date should be output too; d>3 * + * means that mm/dd/yyyy form should be used for the dates, as opposed * + * to dd.mm.yyyy form; d>7 means that yyyy-mm-dd form should be used. */ + +/**/ +static int +fclist(FILE *f, int n, int r, int D, int d, int first, int last, struct asgment *subs, Comp com) +{ + int fclistdone = 0; + char *s, *hs; + Histent ent; + + /* reverse range if required */ + if (r) { + r = last; + last = first; + first = r; + } + /* suppress "no substitution" warning if no substitution is requested */ + if (!subs) + fclistdone = 1; + + for (;;) { + hs = quietgetevent(first); + if (!hs) { + zwarnnam("fc", "no such event: %d", NULL, first); + return 1; + } + s = dupstring(hs); + /* this if does the pattern matching, if required */ + if (!com || domatch(s, com, 0)) { + /* perform substitution */ + fclistdone |= fcsubs(&s, subs); + + /* do numbering */ + if (n) + fprintf(f, "%5d ", first); + ent = NULL; + /* output actual time (and possibly date) of execution of the + command, if required */ + if (d) { + struct tm *ltm; + if (!ent) + ent = gethistent(first); + ltm = localtime(&ent->stim); + if (d >= 2) { + if (d >= 8) { + fprintf(f, "%d-%02d-%02d ", + ltm->tm_year + 1900, + ltm->tm_mon + 1, ltm->tm_mday); + } else if (d >= 4) { + fprintf(f, "%d.%d.%d ", + ltm->tm_mday, ltm->tm_mon + 1, + ltm->tm_year + 1900); + } else { + fprintf(f, "%d/%d/%d ", + ltm->tm_mon + 1, ltm->tm_mday, + ltm->tm_year + 1900); + } + } + fprintf(f, "%02d:%02d ", ltm->tm_hour, ltm->tm_min); + } + /* display the time taken by the command, if required */ + if (D) { + long diff; + if (!ent) + ent = gethistent(first); + diff = (ent->ftim) ? ent->ftim - ent->stim : 0; + fprintf(f, "%ld:%02ld ", diff / 60, diff % 60); + } + + /* output the command */ + if (f == stdout) { + nicezputs(s, f); + putc('\n', f); + } else + fprintf(f, "%s\n", s); + } + /* move on to the next history line, or quit the loop */ + if (first == last) + break; + else if (first > last) + first--; + else + first++; + } + + /* final processing */ + if (f != stdout) + fclose(f); + if (!fclistdone) { + zwarnnam("fc", "no substitutions performed", NULL, 0); + return 1; + } + return 0; +} + +/* edit a history file */ + +/**/ +static int +fcedit(char *ename, char *fn) +{ + char *s; + + if (!strcmp(ename, "-")) + return 1; + + s = tricat(ename, " ", fn); + execstring(s, 1, 0); + zsfree(s); + + return !lastval; +} + +/**** parameter builtins ****/ + +/* Separate an argument into name=value parts, returning them in an * + * asgment structure. Because the asgment structure used is global, * + * only one of these can be active at a time. The string s gets placed * + * in this global structure, so it needs to be in permanent memory. */ + +/**/ +static Asgment +getasg(char *s) +{ + static struct asgment asg; + + /* sanity check for valid argument */ + if (!s) + return NULL; + + /* check if name is empty */ + if (*s == '=') { + zerr("bad assignment", NULL, 0); + return NULL; + } + asg.name = s; + + /* search for `=' */ + for (; *s && *s != '='; s++); + + /* found `=', so return with a value */ + if (*s) { + *s = '\0'; + asg.value = s + 1; + } else { + /* didn't find `=', so we only have a name */ + asg.value = NULL; + } + return &asg; +} + +/* declare, export, integer, local, readonly, typeset */ + +/**/ +int +bin_typeset(char *name, char **argv, char *ops, int func) +{ + Param pm; + Asgment asg; + Comp com; + char *optstr = "iLRZlurtxU"; + int on = 0, off = 0, roff, bit = PM_INTEGER; + int initon, initoff, of, i; + int returnval = 0, printflags = 0; + + /* hash -f is really the builtin `functions' */ + if (ops['f']) + return bin_functions(name, argv, ops, func); + + /* Translate the options into PM_* flags. * + * Unfortunately, this depends on the order * + * these flags are defined in zsh.h */ + for (; *optstr; optstr++, bit <<= 1) + if (ops[*optstr] == 1) + on |= bit; + else if (ops[*optstr] == 2) + off |= bit; + roff = off; + + /* Sanity checks on the options. Remove conficting options. */ + if (on & PM_INTEGER) + off |= PM_RIGHT_B | PM_LEFT | PM_RIGHT_Z | PM_UPPER | PM_ARRAY; + if (on & PM_LEFT) + off |= PM_RIGHT_B | PM_INTEGER; + if (on & PM_RIGHT_B) + off |= PM_LEFT | PM_INTEGER; + if (on & PM_RIGHT_Z) + off |= PM_INTEGER; + if (on & PM_UPPER) + off |= PM_LOWER; + if (on & PM_LOWER) + off |= PM_UPPER; + on &= ~off; + + /* Given no arguments, list whatever the options specify. */ + if (!*argv) { + if (!(on|roff)) + printflags |= PRINT_TYPE; + if (roff || ops['+']) + printflags |= PRINT_NAMEONLY; + scanhashtable(paramtab, 1, on|roff, 0, paramtab->printnode, printflags); + return 0; + } + + /* With the -m option, treat arguments as glob patterns */ + if (ops['m']) { + while ((asg = getasg(*argv++))) { + tokenize(asg->name); /* expand argument */ + if (!(com = parsereg(asg->name))) { + untokenize(asg->name); + zwarnnam(name, "bad pattern : %s", argv[-1], 0); + returnval = 1; + continue; + } + /* If no options or values are given, display all * + * parameters matching the glob pattern. */ + if (!(on || roff || asg->value)) { + scanmatchtable(paramtab, com, 0, 0, paramtab->printnode, 0); + continue; + } + /* Since either options or values are given, we search * + * through the parameter table and change all parameters * + * matching the glob pattern to have these flags and/or * + * value. */ + for (i = 0; i < paramtab->hsize; i++) { + for (pm = (Param) paramtab->nodes[i]; pm; pm = (Param) pm->next) { + if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) + continue; + if (domatch(pm->nam, com, 0)) { + /* set up flags if we have any */ + if (on || roff) { + if (PM_TYPE(pm->flags) == PM_ARRAY && (on & PM_UNIQUE) && + !(pm->flags & PM_READONLY & ~off)) + uniqarray((*pm->gets.afn) (pm)); + pm->flags = (pm->flags | on) & ~off; + if (PM_TYPE(pm->flags) != PM_ARRAY) { + if ((on & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z | PM_INTEGER)) && auxlen) + pm->ct = auxlen; + /* did we just export this? */ + if ((pm->flags & PM_EXPORTED) && !pm->env) { + pm->env = addenv(pm->nam, (asg->value) ? asg->value : getsparam(pm->nam)); + } else if (!(pm->flags & PM_EXPORTED) && pm->env) { + /* did we just unexport this? */ + delenv(pm->env); + zsfree(pm->env); + pm->env = NULL; + } + } + } + /* set up a new value if given */ + if (asg->value) { + setsparam(pm->nam, ztrdup(asg->value)); + } + } + } + } + } + return returnval; + } + + /* Save the values of on, off, and func */ + initon = on; + initoff = off; + of = func; + + /* Take arguments literally. Don't glob */ + while ((asg = getasg(*argv++))) { + /* restore the original values of on, off, and func */ + on = initon; + off = initoff; + func = of; + on &= ~PM_ARRAY; + + /* check if argument is a valid identifier */ + if (!isident(asg->name)) { + zerr("not an identifier: %s", asg->name, 0); + returnval = 1; + continue; + } + bit = 0; /* flag for switching int<->not-int */ + if ((pm = (Param)paramtab->getnode(paramtab, asg->name)) && + (((pm->flags & PM_SPECIAL) && pm->level == locallevel) || + (!(pm->flags & PM_UNSET) && + ((locallevel == pm->level) || func == BIN_EXPORT) && + !(bit = ((off & pm->flags) | (on & ~pm->flags)) & PM_INTEGER)))) { + /* if no flags or values are given, just print this parameter */ + if (!on && !roff && !asg->value) { + paramtab->printnode((HashNode) pm, 0); + continue; + } + if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) { + zerrnam(name, "%s: restricted", pm->nam, 0); + returnval = 1; + continue; + } + if((pm->flags & PM_SPECIAL) && + PM_TYPE((pm->flags | on) & ~off) != PM_TYPE(pm->flags)) { + zerrnam(name, "%s: cannot change type of a special parameter", + pm->nam, 0); + returnval = 1; + continue; + } + if (PM_TYPE(pm->flags) == PM_ARRAY && (on & PM_UNIQUE) && + !(pm->flags & PM_READONLY & ~off)) + uniqarray((*pm->gets.afn) (pm)); + pm->flags = (pm->flags | on) & ~off; + if ((on & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z | PM_INTEGER)) && + auxlen) + pm->ct = auxlen; + if (PM_TYPE(pm->flags) != PM_ARRAY) { + if (pm->flags & PM_EXPORTED) { + if (!(pm->flags & PM_UNSET) && !pm->env && !asg->value) + pm->env = addenv(asg->name, getsparam(asg->name)); + } else if (pm->env) { + delenv(pm->env); + zsfree(pm->env); + pm->env = NULL; + } + if (asg->value) + setsparam(asg->name, ztrdup(asg->value)); + } + } else { + if (bit) { + if (pm->flags & PM_READONLY) { + on |= ~off & PM_READONLY; + pm->flags &= ~PM_READONLY; + } + if (!asg->value) + asg->value = dupstring(getsparam(asg->name)); + unsetparam(asg->name); + } + /* create a new node for a parameter with the * + * flags in `on' minus the readonly flag */ + pm = createparam(ztrdup(asg->name), on & ~PM_READONLY); + DPUTS(!pm, "BUG: parameter not created"); + pm->ct = auxlen; + if (func != BIN_EXPORT) + pm->level = locallevel; + if (asg->value) + setsparam(asg->name, ztrdup(asg->value)); + pm->flags |= (on & PM_READONLY); + } + } + return returnval; +} + +/* Display or change the attributes of shell functions. * + * If called as autoload, it will define a new autoloaded * + * (undefined) shell function. */ + +/**/ +int +bin_functions(char *name, char **argv, char *ops, int func) +{ + Comp com; + Shfunc shf; + int i, returnval = 0; + int on = 0, off = 0; + + /* Do we have any flags defined? */ + if (ops['u'] || ops['t']) { + if (ops['u'] == 1) + on |= PM_UNDEFINED; + else if (ops['u'] == 2) + off |= PM_UNDEFINED; + + if (ops['t'] == 1) + on |= PM_TAGGED; + else if (ops['t'] == 2) + off |= PM_TAGGED; + } + + if (off & PM_UNDEFINED) { + zwarnnam(name, "invalid option(s)", NULL, 0); + return 1; + } + + /* If no arguments given, we will print functions. If flags * + * are given, we will print only functions containing these * + * flags, else we'll print them all. */ + if (!*argv) { + scanhashtable(shfunctab, 1, on|off, DISABLED, shfunctab->printnode, 0); + return 0; + } + + /* With the -m option, treat arguments as glob patterns */ + if (ops['m']) { + on &= ~PM_UNDEFINED; + for (; *argv; argv++) { + /* expand argument */ + tokenize(*argv); + if ((com = parsereg(*argv))) { + /* with no options, just print all functions matching the glob pattern */ + if (!(on|off)) { + scanmatchtable(shfunctab, com, 0, DISABLED, shfunctab->printnode, 0); + } else { + /* apply the options to all functions matching the glob pattern */ + for (i = 0; i < shfunctab->hsize; i++) { + for (shf = (Shfunc) shfunctab->nodes[i]; shf; shf = (Shfunc) shf->next) + if (domatch(shf->nam, com, 0) && !(shf->flags & DISABLED)) + shf->flags = (shf->flags | on) & (~off); + } + } + } else { + untokenize(*argv); + zwarnnam(name, "bad pattern : %s", *argv, 0); + returnval = 1; + } + } + return returnval; + } + + /* Take the arguments literally -- do not glob */ + for (; *argv; argv++) { + if ((shf = (Shfunc) shfunctab->getnode(shfunctab, *argv))) { + /* if any flag was given */ + if (on|off) + /* turn on/off the given flags */ + shf->flags = (shf->flags | (on & ~PM_UNDEFINED)) & ~off; + else + /* no flags, so just print */ + shfunctab->printnode((HashNode) shf, 0); + } else if (on & PM_UNDEFINED) { + /* Add a new undefined (autoloaded) function to the * + * hash table with the corresponding flags set. */ + shf = (Shfunc) zcalloc(sizeof *shf); + shf->flags = on; + shf->funcdef = mkautofn(shf); + shfunctab->addnode(shfunctab, ztrdup(*argv), shf); + } else + returnval = 1; + } + return returnval; +} + +/**/ +static List +mkautofn(Shfunc shf) +{ + List l; + Sublist s; + Pline p; + Cmd c; + AutoFn a; + PERMALLOC { + a = (AutoFn)allocnode(N_AUTOFN); + a->shf = shf; + c = (Cmd)allocnode(N_CMD); + c->type = AUTOFN; + c->u.autofn = a; + p = (Pline)allocnode(N_PLINE); + p->left = c; + p->type = END; + s = (Sublist)allocnode(N_SUBLIST); + s->left = p; + l = (List)allocnode(N_LIST); + l->left = s; + l->type = Z_SYNC; + } LASTALLOC; + return l; +} + +/* unset: unset parameters */ + +/**/ +int +bin_unset(char *name, char **argv, char *ops, int func) +{ + Param pm, next; + Comp com; + char *s; + int match = 0, returnval = 0; + int i; + + /* unset -f is the same as unfunction */ + if (ops['f']) + return bin_unhash(name, argv, ops, func); + + /* with -m option, treat arguments as glob patterns */ + if (ops['m']) { + while ((s = *argv++)) { + /* expand */ + tokenize(s); + if ((com = parsereg(s))) { + /* Go through the parameter table, and unset any matches */ + for (i = 0; i < paramtab->hsize; i++) { + for (pm = (Param) paramtab->nodes[i]; pm; pm = next) { + /* record pointer to next, since we may free this one */ + next = (Param) pm->next; + if ((!(pm->flags & PM_RESTRICTED) || + unset(RESTRICTED)) && domatch(pm->nam, com, 0)) { + unsetparam(pm->nam); + match++; + } + } + } + } else { + untokenize(s); + zwarnnam(name, "bad pattern : %s", s, 0); + returnval = 1; + } + } + /* If we didn't match anything, we return 1. */ + if (!match) + returnval = 1; + return returnval; + } + + /* do not glob -- unset the given parameter */ + while ((s = *argv++)) { + pm = (Param) paramtab->getnode(paramtab, s); + if (!pm) + returnval = 1; + else if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) { + zerrnam(name, "%s: restricted", pm->nam, 0); + returnval = 1; + } else + unsetparam(s); + } + return returnval; +} + +/* type, whence, which */ + +/**/ +int +bin_whence(char *nam, char **argv, char *ops, int func) +{ + HashNode hn; + Comp com; + int returnval = 0; + int printflags = 0; + int csh, all, v, wd; + int informed; + char *cnam; + + /* Check some option information */ + csh = ops['c']; + v = ops['v']; + all = ops['a']; + wd = ops['w']; + + if (ops['w']) + printflags |= PRINT_WHENCE_WORD; + else if (ops['c']) + printflags |= PRINT_WHENCE_CSH; + else if (ops['v']) + printflags |= PRINT_WHENCE_VERBOSE; + else + printflags |= PRINT_WHENCE_SIMPLE; + if (ops['f']) + printflags |= PRINT_WHENCE_FUNCDEF; + + /* With -m option -- treat arguments as a glob patterns */ + if (ops['m']) { + for (; *argv; argv++) { + /* parse the pattern */ + tokenize(*argv); + if (!(com = parsereg(*argv))) { + untokenize(*argv); + zwarnnam(nam, "bad pattern : %s", *argv, 0); + returnval = 1; + continue; + } + if (!ops['p']) { + /* -p option is for path search only. * + * We're not using it, so search for ... */ + + /* aliases ... */ + scanmatchtable(aliastab, com, 0, DISABLED, aliastab->printnode, printflags); + + /* and reserved words ... */ + scanmatchtable(reswdtab, com, 0, DISABLED, reswdtab->printnode, printflags); + + /* and shell functions... */ + scanmatchtable(shfunctab, com, 0, DISABLED, shfunctab->printnode, printflags); + + /* and builtins. */ + scanmatchtable(builtintab, com, 0, DISABLED, builtintab->printnode, printflags); + } + /* Done search for `internal' commands, if the -p option * + * was not used. Now search the path. */ + cmdnamtab->filltable(cmdnamtab); + scanmatchtable(cmdnamtab, com, 0, 0, cmdnamtab->printnode, printflags); + + } + return returnval; + } + + /* Take arguments literally -- do not glob */ + for (; *argv; argv++) { + informed = 0; + + if (!ops['p']) { + /* Look for alias */ + if ((hn = aliastab->getnode(aliastab, *argv))) { + aliastab->printnode(hn, printflags); + if (!all) + continue; + informed = 1; + } + /* Look for reserved word */ + if ((hn = reswdtab->getnode(reswdtab, *argv))) { + reswdtab->printnode(hn, printflags); + if (!all) + continue; + informed = 1; + } + /* Look for shell function */ + if ((hn = shfunctab->getnode(shfunctab, *argv))) { + shfunctab->printnode(hn, printflags); + if (!all) + continue; + informed = 1; + } + /* Look for builtin command */ + if ((hn = builtintab->getnode(builtintab, *argv))) { + builtintab->printnode(hn, printflags); + if (!all) + continue; + informed = 1; + } + /* Look for commands that have been added to the * + * cmdnamtab with the builtin `hash foo=bar'. */ + if ((hn = cmdnamtab->getnode(cmdnamtab, *argv)) && (hn->flags & HASHED)) { + cmdnamtab->printnode(hn, printflags); + if (!all) + continue; + informed = 1; + } + } + + /* Option -a is to search the entire path, * + * rather than just looking for one match. */ + if (all) { + char **pp, buf[PATH_MAX], *z; + + for (pp = path; *pp; pp++) { + z = buf; + if (**pp) { + strucpy(&z, *pp); + *z++ = '/'; + } + if ((z - buf) + strlen(*argv) >= PATH_MAX) + continue; + strcpy(z, *argv); + if (iscom(buf)) { + if (wd) { + printf("%s: command\n", *argv); + } else { + if (v && !csh) + zputs(*argv, stdout), fputs(" is ", stdout); + zputs(buf, stdout); + if (ops['s']) + print_if_link(buf); + fputc('\n', stdout); + } + informed = 1; + } + } + if (!informed && (wd || v || csh)) { + zputs(*argv, stdout); + puts(wd ? ": none" : " not found"); + returnval = 1; + } + } else if ((cnam = findcmd(*argv))) { + /* Found external command. */ + if (wd) { + printf("%s: command\n", *argv); + } else { + if (v && !csh) + zputs(*argv, stdout), fputs(" is ", stdout); + zputs(cnam, stdout); + if (ops['s']) + print_if_link(cnam); + fputc('\n', stdout); + } + zsfree(cnam); + } else { + /* Not found at all. */ + if (v || csh || wd) + zputs(*argv, stdout), puts(wd ? ": none" : " not found"); + returnval = 1; + } + } + return returnval; +} + +/**** command & named directory hash table builtins ****/ + +/***************************************************************** + * hash -- explicitly hash a command. * + * 1) Given no arguments, list the hash table. * + * 2) The -m option prints out commands in the hash table that * + * match a given glob pattern. * + * 3) The -f option causes the entire path to be added to the * + * hash table (cannot be combined with any arguments). * + * 4) The -r option causes the entire hash table to be discarded * + * (cannot be combined with any arguments). * + * 5) Given argument of the form foo=bar, add element to command * + * hash table, so that when `foo' is entered, then `bar' is * + * executed. * + * 6) Given arguments not of the previous form, add it to the * + * command hash table as if it were being executed. * + * 7) The -d option causes analogous things to be done using * + * the named directory hash table. * + *****************************************************************/ + +/**/ +int +bin_hash(char *name, char **argv, char *ops, int func) +{ + HashTable ht; + Comp com; + Asgment asg; + int returnval = 0; + + if (ops['d']) + ht = nameddirtab; + else + ht = cmdnamtab; + + if (ops['r'] || ops['f']) { + /* -f and -r can't be used with any arguments */ + if (*argv) { + zwarnnam("hash", "too many arguments", NULL, 0); + return 1; + } + + /* empty the hash table */ + if (ops['r']) + ht->emptytable(ht); + + /* fill the hash table in a standard way */ + if (ops['f']) + ht->filltable(ht); + + return 0; + } + + /* Given no arguments, display current hash table. */ + if (!*argv) { + scanhashtable(ht, 1, 0, 0, ht->printnode, 0); + return 0; + } + + while (*argv) { + void *hn; + if (ops['m']) { + /* with the -m option, treat the argument as a glob pattern */ + tokenize(*argv); /* expand */ + if ((com = parsereg(*argv))) { + /* display matching hash table elements */ + scanmatchtable(ht, com, 0, 0, ht->printnode, 0); + } else { + untokenize(*argv); + zwarnnam(name, "bad pattern : %s", *argv, 0); + returnval = 1; + } + } else if((asg = getasg(*argv))->value) { + if(isset(RESTRICTED)) { + zwarnnam(name, "restricted: %s", asg->value, 0); + returnval = 1; + } else { + /* The argument is of the form foo=bar, * + * so define an entry for the table. */ + if(ops['d']) { + Nameddir nd = hn = zcalloc(sizeof *nd); + nd->flags = 0; + nd->dir = ztrdup(asg->value); + } else { + Cmdnam cn = hn = zcalloc(sizeof *cn); + cn->flags = HASHED; + cn->u.cmd = ztrdup(asg->value); + } + ht->addnode(ht, ztrdup(asg->name), hn); + if(ops['v']) + ht->printnode(hn, 0); + } + } else if (!(hn = ht->getnode2(ht, asg->name))) { + /* With no `=value' part to the argument, * + * work out what it ought to be. */ + if(ops['d']) { + if(!getnameddir(asg->name)) { + zwarnnam(name, "no such directory name: %s", asg->name, 0); + returnval = 1; + } + } else { + if (!hashcmd(asg->name, path)) { + zwarnnam(name, "no such command: %s", asg->name, 0); + returnval = 1; + } + } + if(ops['v'] && (hn = ht->getnode2(ht, asg->name))) + ht->printnode(hn, 0); + } else if(ops['v']) + ht->printnode(hn, 0); + argv++; + } + return returnval; +} + +/* unhash: remove specified elements from a hash table */ + +/**/ +int +bin_unhash(char *name, char **argv, char *ops, int func) +{ + HashTable ht; + HashNode hn, nhn; + Comp com; + int match = 0, returnval = 0; + int i; + + /* Check which hash table we are working with. */ + if (ops['d']) + ht = nameddirtab; /* named directories */ + else if (ops['f']) + ht = shfunctab; /* shell functions */ + else if (ops['a']) + ht = aliastab; /* aliases */ + else + ht = cmdnamtab; /* external commands */ + + /* With -m option, treat arguments as glob patterns. * + * "unhash -m '*'" is legal, but not recommended. */ + if (ops['m']) { + for (; *argv; argv++) { + /* expand argument */ + tokenize(*argv); + if ((com = parsereg(*argv))) { + /* remove all nodes matching glob pattern */ + for (i = 0; i < ht->hsize; i++) { + for (hn = ht->nodes[i]; hn; hn = nhn) { + /* record pointer to next, since we may free this one */ + nhn = hn->next; + if (domatch(hn->nam, com, 0)) { + ht->freenode(ht->removenode(ht, hn->nam)); + match++; + } + } + } + } else { + untokenize(*argv); + zwarnnam(name, "bad pattern : %s", *argv, 0); + returnval = 1; + } + } + /* If we didn't match anything, we return 1. */ + if (!match) + returnval = 1; + return returnval; + } + + /* Take arguments literally -- do not glob */ + for (; *argv; argv++) { + if ((hn = ht->removenode(ht, *argv))) { + ht->freenode(hn); + } else { + zwarnnam(name, "no such hash table element: %s", *argv, 0); + returnval = 1; + } + } + return returnval; +} + +/**** alias builtins ****/ + +/* alias: display or create aliases. */ + +/**/ +int +bin_alias(char *name, char **argv, char *ops, int func) +{ + Alias a; + Comp com; + Asgment asg; + int haveflags = 0, returnval = 0; + int flags1 = 0, flags2 = DISABLED; + int printflags = 0; + + /* Did we specify the type of alias? */ + if (ops['r'] || ops['g']) { + if (ops['r'] && ops['g']) { + zwarnnam(name, "illegal combination of options", NULL, 0); + return 1; + } + haveflags = 1; + if (ops['g']) + flags1 |= ALIAS_GLOBAL; + else + flags2 |= ALIAS_GLOBAL; + } + + if (ops['L']) + printflags |= PRINT_LIST; + + /* In the absence of arguments, list all aliases. If a command * + * line flag is specified, list only those of that type. */ + if (!*argv) { + scanhashtable(aliastab, 1, flags1, flags2, aliastab->printnode, printflags); + return 0; + } + + /* With the -m option, treat the arguments as * + * glob patterns of aliases to display. */ + if (ops['m']) { + for (; *argv; argv++) { + tokenize(*argv); /* expand argument */ + if ((com = parsereg(*argv))) { + /* display the matching aliases */ + scanmatchtable(aliastab, com, flags1, flags2, aliastab->printnode, printflags); + } else { + untokenize(*argv); + zwarnnam(name, "bad pattern : %s", *argv, 0); + returnval = 1; + } + } + return returnval; + } + + /* Take arguments literally. Don't glob */ + while ((asg = getasg(*argv++))) { + if (asg->value && !ops['L']) { + /* The argument is of the form foo=bar and we are not * + * forcing a listing with -L, so define an alias */ + aliastab->addnode(aliastab, ztrdup(asg->name), + createaliasnode(ztrdup(asg->value), flags1)); + } else if ((a = (Alias) aliastab->getnode(aliastab, asg->name))) { + /* display alias if appropriate */ + if (!haveflags || + (ops['r'] && !(a->flags & ALIAS_GLOBAL)) || + (ops['g'] && (a->flags & ALIAS_GLOBAL))) + aliastab->printnode((HashNode) a, printflags); + } else + returnval = 1; + } + return returnval; +} + + +/**** miscellaneous builtins ****/ + +/* true, : (colon) */ + +/**/ +int +bin_true(char *name, char **argv, char *ops, int func) +{ + return 0; +} + +/* false builtin */ + +/**/ +int +bin_false(char *name, char **argv, char *ops, int func) +{ + return 1; +} + +/* the zle buffer stack */ + +/**/ +LinkList bufstack; + +/* echo, print, pushln */ + +/**/ +int +bin_print(char *name, char **args, char *ops, int func) +{ + int nnl = 0, fd, argc, n; + int *len; + Histent ent; + FILE *fout = stdout; + + /* -m option -- treat the first argument as a pattern and remove + * arguments not matching */ + if (ops['m']) { + Comp com; + char **t, **p; + + tokenize(*args); + if (!(com = parsereg(*args))) { + untokenize(*args); + zwarnnam(name, "bad pattern : %s", *args, 0); + return 1; + } + for (p = ++args; *p; p++) + if (!domatch(*p, com, 0)) + for (t = p--; (*t = t[1]); t++); + } + /* compute lengths, and interpret according to -P, -D, -e, etc. */ + argc = arrlen(args); + len = (int *)ncalloc(argc * sizeof(int)); + for(n = 0; n < argc; n++) { + /* first \ sequences */ + if (!ops['e'] && (ops['R'] || ops['r'] || ops['E'])) + unmetafy(args[n], &len[n]); + else + args[n] = getkeystring(args[n], &len[n], + func != BIN_ECHO && !ops['e'], &nnl); + /* -P option -- interpret as a prompt sequence */ + if(ops['P']) + args[n] = unmetafy(promptexpand(metafy(args[n], len[n], + META_NOALLOC), 0, NULL, NULL), &len[n]); + /* -D option -- interpret as a directory, and use ~ */ + if(ops['D']) { + Nameddir d = finddir(args[n]); + if(d) { + char *arg = alloc(strlen(args[n]) + 1); + sprintf(arg, "~%s%s", d->nam, + args[n] + strlen(d->dir)); + args[n] = arg; + len[n] = strlen(args[n]); + } + } + } + + /* -z option -- push the arguments onto the editing buffer stack */ + if (ops['z']) { + PERMALLOC { + pushnode(bufstack, sepjoin(args, NULL)); + } LASTALLOC; + return 0; + } + /* -s option -- add the arguments to the history list */ + if (ops['s']) { + int nwords = 0, nlen, iwords; + char **pargs = args; + + PERMALLOC { + ent = gethistent(++curhist); + zsfree(ent->text); + if (ent->nwords) + zfree(ent->words, ent->nwords*2*sizeof(short)); + while (*pargs++) + nwords++; + if ((ent->nwords = nwords)) { + ent->words = (short *)zalloc(nwords*2*sizeof(short)); + nlen = iwords = 0; + for (pargs = args; *pargs; pargs++) { + ent->words[iwords++] = nlen; + nlen += strlen(*pargs); + ent->words[iwords++] = nlen; + nlen++; + } + } else + ent->words = (short *)NULL; + ent->text = zjoin(args, ' '); + ent->stim = ent->ftim = time(NULL); + ent->flags = 0; + } LASTALLOC; + return 0; + } + /* -u and -p -- output to other than standard output */ + if (ops['u'] || ops['p']) { + if (ops['u']) { + for (fd = 0; fd < 10; fd++) + if (ops[fd + '0']) + break; + if (fd == 10) + fd = 0; + } else + fd = coprocout; + if ((fd = dup(fd)) < 0) { + zwarnnam(name, "bad file number", NULL, 0); + return 1; + } + if ((fout = fdopen(fd, "w")) == 0) { + zwarnnam(name, "bad mode on fd", NULL, 0); + return 1; + } + } + + /* -o and -O -- sort the arguments */ + if (ops['o']) { + if (ops['i']) + qsort(args, arrlen(args), sizeof(char *), cstrpcmp); + + else + qsort(args, arrlen(args), sizeof(char *), strpcmp); + } else if (ops['O']) { + if (ops['i']) + qsort(args, arrlen(args), sizeof(char *), invcstrpcmp); + + else + qsort(args, arrlen(args), sizeof(char *), invstrpcmp); + } + /* after sorting arguments, recalculate lengths */ + if(ops['o'] || ops['O']) + for(n = 0; n < argc; n++) + len[n] = strlen(args[n]); + + /* -c -- output in columns */ + if (ops['c']) { + int l, nc, nr, sc, n, t, i; + char **ap; + + for (n = l = 0, ap = args; *ap; ap++, n++) + if (l < (t = strlen(*ap))) + l = t; + + sc = l + 2; + nc = (columns + 1) / sc; + if (!nc) + nc = 1; + nr = (n + nc - 1) / nc; + + for (i = 0; i < nr; i++) { + ap = args + i; + do { + l = strlen(*ap); + fprintf(fout, "%s", *ap); + for (t = nr; t && *ap; t--, ap++); + if(*ap) + for (; l < sc; l++) + fputc(' ', fout); + } while (*ap); + fputc(ops['N'] ? '\0' : '\n', fout); + } + if (fout != stdout) + fclose(fout); + return 0; + } + /* normal output */ + for (; *args; args++, len++) { + fwrite(*args, *len, 1, fout); + if (args[1]) + fputc(ops['l'] ? '\n' : ops['N'] ? '\0' : ' ', fout); + } + if (!(ops['n'] || nnl)) + fputc(ops['N'] ? '\0' : '\n', fout); + if (fout != stdout) + fclose(fout); + return 0; +} + +/* echotc: output a termcap */ + +/**/ +int +bin_echotc(char *name, char **argv, char *ops, int func) +{ + char *s, buf[2048], *t, *u; + int num, argct; + + s = *argv++; + if (termflags & TERM_BAD) + return 1; + if ((termflags & TERM_UNKNOWN) && (isset(INTERACTIVE) || !init_term())) + return 1; + /* if the specified termcap has a numeric value, display it */ + if ((num = tgetnum(s)) != -1) { + printf("%d\n", num); + return 0; + } + /* if the specified termcap is boolean, and set, say so * + * ncurses can tell if an existing boolean capability is * + * off so in this case we print "no". */ +#if !defined(NCURSES_VERSION) || !defined(COLOR_PAIR) + if (tgetflag(s) > 0) { + puts("yes"); + return (0); + } +#else /* NCURSES_VERSION && COLOR_PAIR */ + switch (tgetflag(s)) { + case -1: + break; + case 0: + puts("no"); + return 0; + default: + puts("yes"); + return 0; + } +#endif /* NCURSES_VERSION && COLOR_PAIR */ + /* get a string-type capability */ + u = buf; + t = tgetstr(s, &u); + if (!t || !*t) { + /* capability doesn't exist, or (if boolean) is off */ + zwarnnam(name, "no such capability: %s", s, 0); + return 1; + } + /* count the number of arguments required */ + for (argct = 0, u = t; *u; u++) + if (*u == '%') { + if (u++, (*u == 'd' || *u == '2' || *u == '3' || *u == '.' || + *u == '+')) + argct++; + } + /* check that the number of arguments provided is correct */ + if (arrlen(argv) != argct) { + zwarnnam(name, (arrlen(argv) < argct) ? "not enough arguments" : + "too many arguments", NULL, 0); + return 1; + } + /* output string, through the proper termcap functions */ + if (!argct) + tputs(t, 1, putraw); + else { + num = (argv[1]) ? atoi(argv[1]) : atoi(*argv); + tputs(tgoto(t, atoi(*argv), num), num, putraw); + } + return 0; +} + +/* shift builtin */ + +/**/ +int +bin_shift(char *name, char **argv, char *ops, int func) +{ + int num = 1, l, ret = 0; + char **s; + + /* optional argument can be either numeric or an array */ + if (*argv && !getaparam(*argv)) + num = matheval(*argv++); + + if (num < 0) { + zwarnnam(name, "argument to shift must be non-negative", NULL, 0); + return 1; + } + + if (*argv) { + for (; *argv; argv++) + if ((s = getaparam(*argv))) { + if (num > arrlen(s)) { + zwarnnam(name, "shift count must be <= $#", NULL, 0); + ret++; + continue; + } + PERMALLOC { + s = arrdup(s + num); + } LASTALLOC; + setaparam(*argv, s); + } + } else { + if (num > (l = arrlen(pparams))) { + zwarnnam(name, "shift count must be <= $#", NULL, 0); + ret = 1; + } else { + s = zalloc((l - num + 1) * sizeof(char *)); + memcpy(s, pparams + num, (l - num + 1) * sizeof(char *)); + while (num--) + zsfree(pparams[num]); + zfree(pparams, (l + 1) * sizeof(char *)); + pparams = s; + } + } + return ret; +} + +/* getopts: automagical option handling for shell scripts */ + +/**/ +int +bin_getopts(char *name, char **argv, char *ops, int func) +{ + int lenstr, lenoptstr, quiet, lenoptbuf; + char *optstr = unmetafy(*argv++, &lenoptstr), *var = *argv++; + char **args = (*argv) ? argv : pparams; + static int optcind = 0; + char *str, optbuf[2] = " ", *p, opch; + + /* zoptind keeps count of the current argument number. The * + * user can set it to zero to start a new option parse. */ + if (zoptind < 1) { + /* first call */ + zoptind = 1; + optcind = 0; + } + if(zoptind > arrlen(args)) + /* no more options */ + return 1; + + /* leading ':' in optstr means don't print an error message */ + quiet = *optstr == ':'; + optstr += quiet; + lenoptstr -= quiet; + + /* find place in relevant argument */ + str = unmetafy(dupstring(args[zoptind - 1]), &lenstr); + if(optcind >= lenstr) { + optcind = 0; + if(!args[zoptind++]) + return 1; + str = unmetafy(dupstring(args[zoptind - 1]), &lenstr); + } + if(!optcind) { + if(lenstr < 2 || (*str != '-' && *str != '+')) + return 1; + if(lenstr == 2 && str[0] == '-' && str[1] == '-') { + zoptind++; + return 1; + } + optcind++; + } + opch = str[optcind++]; + if(str[0] == '+') { + optbuf[0] = '+'; + lenoptbuf = 2; + } else + lenoptbuf = 1; + optbuf[lenoptbuf - 1] = opch; + + /* check for legality */ + if(opch == ':' || !(p = memchr(optstr, opch, lenoptstr))) { + p = "?"; +err: + zsfree(zoptarg); + if(quiet) { + setsparam(var, ztrdup(p)); + zoptarg = metafy(optbuf, lenoptbuf, META_DUP); + } else { + zerr(*p == '?' ? "bad option: -%c" : + "argument expected after -%c option", NULL, opch); + zoptarg=ztrdup(""); + errflag = 0; + } + return 0; + } + + /* check for required argument */ + if(p[1] == ':') { + if(optcind == lenstr) { + if(!args[zoptind]) { + p = ":"; + goto err; + } + p = ztrdup(args[zoptind++]); + } else + p = metafy(str+optcind, lenstr-optcind, META_DUP); + optcind = ztrlen(args[zoptind - 1]); + zsfree(zoptarg); + zoptarg = p; + } else { + zsfree(zoptarg); + zoptarg = ztrdup(""); + } + + setsparam(var, metafy(optbuf, lenoptbuf, META_DUP)); + return 0; +} + +/* break, bye, continue, exit, logout, return -- most of these take * + * one numeric argument, and the other (logout) is related to return. * + * (return is treated as a logout when in a login shell.) */ + +/**/ +int +bin_break(char *name, char **argv, char *ops, int func) +{ + int num = lastval, nump = 0; + + /* handle one optional numeric argument */ + if (*argv) { + num = matheval(*argv++); + nump = 1; + } + + switch (func) { + case BIN_CONTINUE: + if (!loops) { /* continue is only permitted in loops */ + zerrnam(name, "not in while, until, select, or repeat loop", NULL, 0); + return 1; + } + contflag = 1; /* ARE WE SUPPOSED TO FALL THROUGH HERE? */ + case BIN_BREAK: + if (!loops) { /* break is only permitted in loops */ + zerrnam(name, "not in while, until, select, or repeat loop", NULL, 0); + return 1; + } + breaks = nump ? minimum(num,loops) : 1; + break; + case BIN_RETURN: + if (isset(INTERACTIVE) || locallevel || sourcelevel) { + retflag = 1; + breaks = loops; + lastval = num; + if (trapreturn == -2) + trapreturn = lastval; + return lastval; + } + zexit(num, 0); /* else treat return as logout/exit */ + break; + case BIN_LOGOUT: + if (unset(LOGINSHELL)) { + zerrnam(name, "not login shell", NULL, 0); + return 1; + } + zexit(num, 0); + break; + case BIN_EXIT: + zexit(num, 0); + break; + } + return 0; +} + +/* we have printed a 'you have stopped (running) jobs.' message */ + +/**/ +int stopmsg; + +/* check to see if user has jobs running/stopped */ + +/**/ +static void +checkjobs(void) +{ + int i; + + for (i = 1; i < MAXJOB; i++) + if (i != thisjob && (jobtab[i].stat & STAT_LOCKED) && + !(jobtab[i].stat & STAT_NOPRINT)) + break; + if (i < MAXJOB) { + if (jobtab[i].stat & STAT_STOPPED) { + +#ifdef USE_SUSPENDED + zerr("you have suspended jobs.", NULL, 0); +#else + zerr("you have stopped jobs.", NULL, 0); +#endif + + } else + zerr("you have running jobs.", NULL, 0); + stopmsg = 1; + } +} + +/* exit the shell. val is the return value of the shell. * + * from_signal should be non-zero if zexit is being called * + * because of a signal. */ + +/**/ +void +zexit(int val, int from_signal) +{ + static int in_exit; + + HEAPALLOC { + if (isset(MONITOR) && !stopmsg && !from_signal) { + scanjobs(); /* check if jobs need printing */ + checkjobs(); /* check if any jobs are running/stopped */ + if (stopmsg) { + stopmsg = 2; + LASTALLOC_RETURN; + } + } + if (in_exit++ && from_signal) + LASTALLOC_RETURN; + if (isset(MONITOR)) + /* send SIGHUP to any jobs left running */ + killrunjobs(from_signal); + if (isset(RCS) && interact) { + if (!nohistsave) + savehistfile(getsparam("HISTFILE"), 1, isset(APPENDHISTORY) ? 3 : 0); + if (islogin && !subsh) { + sourcehome(".zlogout"); +#ifdef GLOBAL_ZLOGOUT + source(GLOBAL_ZLOGOUT); +#endif + } + } + if (sigtrapped[SIGEXIT]) + dotrap(SIGEXIT); + if (mypid != getpid()) + _exit(val); + else + exit(val); + } LASTALLOC; +} + +/* . (dot), source */ + +/**/ +int +bin_dot(char *name, char **argv, char *ops, int func) +{ + char **old, *old0 = NULL; + int ret, diddot = 0, dotdot = 0; + char buf[PATH_MAX]; + char *s, **t, *enam, *arg0; + struct stat st; + + if (!*argv || strlen(*argv) >= PATH_MAX) + return 0; + old = pparams; + /* get arguments for the script */ + if (argv[1]) { + PERMALLOC { + pparams = arrdup(argv + 1); + } LASTALLOC; + } + enam = arg0 = ztrdup(*argv); + if (isset(FUNCTIONARGZERO)) { + old0 = argzero; + argzero = arg0; + } + s = unmeta(enam); + errno = ENOENT; + ret = 1; + /* for source only, check in current directory first */ + if (*name != '.' && access(s, F_OK) == 0 + && stat(s, &st) >= 0 && !S_ISDIR(st.st_mode)) { + diddot = 1; + ret = source(enam); + } + if (ret) { + /* use a path with / in it */ + for (s = arg0; *s; s++) + if (*s == '/') { + if (*arg0 == '.') { + if (arg0 + 1 == s) + ++diddot; + else if (arg0[1] == '.' && arg0 + 2 == s) + ++dotdot; + } + ret = source(arg0); + break; + } + if (!*s || (ret && isset(PATHDIRS) && diddot < 2 && dotdot == 0)) { + /* search path for script */ + for (t = path; *t; t++) { + if (!(*t)[0] || ((*t)[0] == '.' && !(*t)[1])) { + if (diddot) + continue; + diddot = 1; + strcpy(buf, arg0); + } else { + if (strlen(*t) + strlen(arg0) + 1 >= PATH_MAX) + continue; + sprintf(buf, "%s/%s", *t, arg0); + } + s = unmeta(buf); + if (access(s, F_OK) == 0 && stat(s, &st) >= 0 + && !S_ISDIR(st.st_mode)) { + ret = source(enam = buf); + break; + } + } + } + } + /* clean up and return */ + if (argv[1]) { + freearray(pparams); + pparams = old; + } + if (ret) + zwarnnam(name, "%e: %s", enam, errno); + zsfree(arg0); + if (old0) + argzero = old0; + return ret ? ret : lastval; +} + +/**/ +int +bin_emulate(char *nam, char **argv, char *ops, int func) +{ + emulate(*argv, ops['R']); + return 0; +} + +/* eval: simple evaluation */ + +/**/ +int +bin_eval(char *nam, char **argv, char *ops, int func) +{ + List list; + + inpush(zjoin(argv, ' '), 0, NULL); + strinbeg(); + stophist = 2; + list = parse_list(); + strinend(); + inpop(); + if (!list) { + errflag = 0; + return 1; + } + execlist(list, 1, 0); + if (errflag) { + lastval = errflag; + errflag = 0; + } + return lastval; +} + +static char *zbuf; +static int readfd; + +/* Read a character from readfd, or from the buffer zbuf. Return EOF on end of +file/buffer. */ + +/* read: get a line of input, or (for compctl functions) return some * + * useful data about the state of the editing line. The -E and -e * + * options mean that the result should be sent to stdout. -e means, * + * in addition, that the result should not actually be assigned to * + * the specified parameters. */ + +/**/ +int +bin_read(char *name, char **args, char *ops, int func) +{ + char *reply, *readpmpt; + int bsiz, c = 0, gotnl = 0, al = 0, first, nchars = 1, bslash; + int haso = 0; /* true if /dev/tty has been opened specially */ + int isem = !strcmp(term, "emacs"); + char *buf, *bptr, *firstarg, *zbuforig; + LinkList readll = newlinklist(); + + if ((ops['k'] || ops['b']) && *args && idigit(**args)) { + if (!(nchars = atoi(*args))) + nchars = 1; + args++; + } + + firstarg = *args; + if (*args && **args == '?') + args++; + /* default result parameter */ + reply = *args ? *args++ : ops['A'] ? "reply" : "REPLY"; + if (ops['A'] && *args) { + zwarnnam(name, "only one array argument allowed", NULL, 0); + return 1; + } + + /* handle compctl case */ + if(ops['l'] || ops['c']) + return compctlread(name, args, ops, reply); + + if ((ops['k'] && !ops['u'] && !ops['p']) || ops['q']) { + if (SHTTY == -1) { + /* need to open /dev/tty specially */ + SHTTY = open("/dev/tty", O_RDWR|O_NOCTTY); + haso = 1; + } + /* We should have a SHTTY opened by now. */ + if (SHTTY == -1) { + /* Unfortunately, we didn't. */ + fprintf(stderr, "not interactive and can't open terminal\n"); + fflush(stderr); + return 1; + } + if (unset(INTERACTIVE)) + gettyinfo(&shttyinfo); + /* attach to the tty */ + attachtty(mypgrp); + if (!isem && ops['k']) + setcbreak(); + readfd = SHTTY; + } else if (ops['u'] && !ops['p']) { + /* -u means take input from the specified file descriptor. * + * -up means take input from the coprocess. */ + for (readfd = 9; readfd && !ops[readfd + '0']; --readfd); + } else if (ops['p']) + readfd = coprocin; + else + readfd = 0; + + /* handle prompt */ + if (firstarg) { + for (readpmpt = firstarg; + *readpmpt && *readpmpt != '?'; readpmpt++); + if (*readpmpt++) { + if (isatty(0)) { + zputs(readpmpt, stderr); + fflush(stderr); + } + readpmpt[-1] = '\0'; + } + } + + /* option -k means read only a given number of characters (default 1) */ + if (ops['k']) { + int val; + char d; + + /* allocate buffer space for result */ + bptr = buf = (char *)zalloc(nchars+1); + + do { + /* If read returns 0, is end of file */ + if ((val = read(readfd, bptr, nchars)) <= 0) + break; + + /* decrement number of characters read from number required */ + nchars -= val; + + /* increment pointer past read characters */ + bptr += val; + } while (nchars > 0); + + if (!ops['u'] && !ops['p']) { + /* dispose of result appropriately, etc. */ + if (isem) + while (val > 0 && read(SHTTY, &d, 1) == 1 && d != '\n'); + else + settyinfo(&shttyinfo); + if (haso) { + close(SHTTY); + SHTTY = -1; + } + } + + if (ops['e'] || ops['E']) + fwrite(buf, bptr - buf, 1, stdout); + if (!ops['e']) + setsparam(reply, metafy(buf, bptr - buf, META_REALLOC)); + else + zfree(buf, bptr - buf + 1); + return val <= 0; + } + + /* option -q means get one character, and interpret it as a Y or N */ + if (ops['q']) { + char readbuf[2]; + + /* set up the buffer */ + readbuf[1] = '\0'; + + /* get, and store, reply */ + readbuf[0] = ((char)getquery(NULL, 0)) == 'y' ? 'y' : 'n'; + + /* dispose of result appropriately, etc. */ + if (haso) { + close(SHTTY); + SHTTY = -1; + } + + if (ops['e'] || ops['E']) + printf("%s\n", readbuf); + if (!ops['e']) + setsparam(reply, ztrdup(readbuf)); + + return readbuf[0] == 'n'; + } + + /* All possible special types of input have been exhausted. Take one line, + and assign words to the parameters until they run out. Leftover words go + onto the last parameter. If an array is specified, all the words become + separate elements of the array. */ + + zbuforig = zbuf = (!ops['z']) ? NULL : + (nonempty(bufstack)) ? (char *) getlinknode(bufstack) : ztrdup(""); + first = 1; + bslash = 0; + while (*args || (ops['A'] && !gotnl)) { + buf = bptr = (char *)zalloc(bsiz = 64); + /* get input, a character at a time */ + while (!gotnl) { + c = zread(); + /* \ at the end of a line indicates a continuation * + * line, except in raw mode (-r option) */ + if (bslash && c == '\n') { + bslash = 0; + continue; + } + if (c == EOF || c == '\n') + break; + if (!bslash && isep(c)) { + if (bptr != buf || (!iwsep(c) && first)) { + first |= !iwsep(c); + break; + } + first |= !iwsep(c); + continue; + } + bslash = c == '\\' && !bslash && !ops['r']; + if (bslash) + continue; + first = 0; + if (imeta(c)) { + *bptr++ = Meta; + *bptr++ = c ^ 32; + } else + *bptr++ = c; + /* increase the buffer size, if necessary */ + if (bptr >= buf + bsiz - 1) { + int blen = bptr - buf; + + buf = realloc(buf, bsiz *= 2); + bptr = buf + blen; + } + } + if (c == '\n' || c == EOF) + gotnl = 1; + *bptr = '\0'; + /* dispose of word appropriately */ + if (ops['e'] || ops['E']) { + zputs(buf, stdout); + putchar('\n'); + } + if (!ops['e']) { + if (ops['A']) { + addlinknode(readll, buf); + al++; + } else + setsparam(reply, buf); + } else + free(buf); + if (!ops['A']) + reply = *args++; + } + /* handle EOF */ + if (c == EOF) { + if (readfd == coprocin) { + close(coprocin); + close(coprocout); + coprocin = coprocout = -1; + } + } + /* final assignment (and display) of array parameter */ + if (ops['A']) { + char **pp, **p = NULL; + LinkNode n; + + p = (ops['e'] ? (char **)NULL + : (char **)zalloc((al + 1) * sizeof(char *))); + + for (pp = p, n = firstnode(readll); n; incnode(n)) { + if (ops['e'] || ops['E']) { + zputs((char *) getdata(n), stdout); + putchar('\n'); + } + if (p) + *pp++ = (char *)getdata(n); + else + zsfree(getdata(n)); + } + if (p) { + *pp++ = NULL; + setaparam(reply, p); + } + return c == EOF; + } + buf = bptr = (char *)zalloc(bsiz = 64); + /* any remaining part of the line goes into one parameter */ + bslash = 0; + if (!gotnl) + for (;;) { + c = zread(); + /* \ at the end of a line introduces a continuation line, except in + raw mode (-r option) */ + if (bslash && c == '\n') { + bslash = 0; + continue; + } + if (c == EOF || (c == '\n' && !zbuf)) + break; + if (!bslash && isep(c) && bptr == buf) + if (iwsep(c)) + continue; + else if (!first) { + first = 1; + continue; + } + bslash = c == '\\' && !bslash && !ops['r']; + if (bslash) + continue; + if (imeta(c)) { + *bptr++ = Meta; + *bptr++ = c ^ 32; + } else + *bptr++ = c; + /* increase the buffer size, if necessary */ + if (bptr >= buf + bsiz - 1) { + int blen = bptr - buf; + + buf = realloc(buf, bsiz *= 2); + bptr = buf + blen; + } + } + while (bptr > buf && iwsep(bptr[-1])) + bptr--; + *bptr = '\0'; + /* final assignment of reply, etc. */ + if (ops['e'] || ops['E']) { + zputs(buf, stdout); + putchar('\n'); + } + if (!ops['e']) + setsparam(reply, buf); + else + zsfree(buf); + if (zbuforig) { + char first = *zbuforig; + + zsfree(zbuforig); + if (!first) + return 1; + } else if (c == EOF) { + if (readfd == coprocin) { + close(coprocin); + close(coprocout); + coprocin = coprocout = -1; + } + return 1; + } + return 0; +} + +/**/ +static int +zread(void) +{ + char cc, retry = 0; + + /* use zbuf if possible */ + if (zbuf) + /* If zbuf points to anything, it points to the next character in the + buffer. This may be a null byte to indicate EOF. If reading from the + buffer, move on the buffer pointer. */ + if (*zbuf == Meta) + return zbuf++, STOUC(*zbuf++ ^ 32); + else + return (*zbuf) ? STOUC(*zbuf++) : EOF; + for (;;) { + /* read a character from readfd */ + switch (read(readfd, &cc, 1)) { + case 1: + /* return the character read */ + return STOUC(cc); +#if defined(EAGAIN) || defined(EWOULDBLOCK) + case -1: + if (!retry && readfd == 0 && ( +# ifdef EAGAIN + errno == EAGAIN +# ifdef EWOULDBLOCK + || +# endif /* EWOULDBLOCK */ +# endif /* EAGAIN */ +# ifdef EWOULDBLOCK + errno == EWOULDBLOCK +# endif /* EWOULDBLOCK */ + ) && setblock_stdin()) { + retry = 1; + continue; + } + break; +#endif /* EAGAIN || EWOULDBLOCK */ + } + return EOF; + } +} + +/* holds arguments for testlex() */ +/**/ +char **testargs; + +/* test, [: the old-style general purpose logical expression builtin */ + +/**/ +void +testlex(void) +{ + if (tok == LEXERR) + return; + + tokstr = *testargs; + if (!*testargs) { + /* if tok is already zero, reading past the end: error */ + tok = tok ? NULLTOK : LEXERR; + return; + } else if (!strcmp(*testargs, "-o")) + tok = DBAR; + else if (!strcmp(*testargs, "-a")) + tok = DAMPER; + else if (!strcmp(*testargs, "!")) + tok = BANG; + else if (!strcmp(*testargs, "(")) + tok = INPAR; + else if (!strcmp(*testargs, ")")) + tok = OUTPAR; + else + tok = STRING; + testargs++; +} + +/**/ +int +bin_test(char *name, char **argv, char *ops, int func) +{ + char **s; + Cond c; + + /* if "test" was invoked as "[", it needs a matching "]" * + * which is subsequently ignored */ + if (func == BIN_BRACKET) { + for (s = argv; *s; s++); + if (s == argv || strcmp(s[-1], "]")) { + zwarnnam(name, "']' expected", NULL, 0); + return 1; + } + s[-1] = NULL; + } + /* an empty argument list evaluates to false (1) */ + if (!*argv) + return 1; + + testargs = argv; + tok = NULLTOK; + condlex = testlex; + testlex(); + c = par_cond(); + condlex = yylex; + + if (errflag) { + errflag = 0; + return 1; + } + + if (!c || tok == LEXERR) { + zwarnnam(name, tokstr ? "parse error" : "argument expected", NULL, 0); + return 1; + } + + /* syntax is OK, so evaluate */ + return !evalcond(c); +} + +/* display a time, provided in units of 1/60s, as minutes and seconds */ +#define pttime(X) printf("%ldm%ld.%02lds",((long) (X))/3600,\ + ((long) (X))/60%60,((long) (X))*100/60%100) + +/* times: display, in a two-line format, the times provided by times(3) */ + +/**/ +int +bin_times(char *name, char **argv, char *ops, int func) +{ + struct tms buf; + + /* get time accounting information */ + if (times(&buf) == -1) + return 1; + pttime(buf.tms_utime); /* user time */ + putchar(' '); + pttime(buf.tms_stime); /* system time */ + putchar('\n'); + pttime(buf.tms_cutime); /* user time, children */ + putchar(' '); + pttime(buf.tms_cstime); /* system time, children */ + putchar('\n'); + return 0; +} + +/* trap: set/unset signal traps */ + +/**/ +int +bin_trap(char *name, char **argv, char *ops, int func) +{ + List l; + char *arg, *s; + int sig; + + if (*argv && !strcmp(*argv, "--")) + argv++; + + /* If given no arguments, list all currently-set traps */ + if (!*argv) { + for (sig = 0; sig < VSIGCOUNT; sig++) { + if (sigtrapped[sig] & ZSIG_FUNC) { + char fname[20]; + HashNode hn; + + sprintf(fname, "TRAP%s", sigs[sig]); + if ((hn = shfunctab->getnode(shfunctab, fname))) + shfunctab->printnode(hn, 0); + DPUTS(!hn, "BUG: I did not find any trap functions!"); + } else if (sigtrapped[sig]) { + if (!sigfuncs[sig]) + printf("trap -- '' %s\n", sigs[sig]); + else { + s = getpermtext((void *) dupstruct((void *) sigfuncs[sig])); + printf("trap -- "); + quotedzputs(s, stdout); + printf(" %s\n", sigs[sig]); + zsfree(s); + } + } + } + return 0; + } + + /* If we have a signal number, unset the specified * + * signals. With only -, remove all traps. */ + if ((getsignum(*argv) != -1) || (!strcmp(*argv, "-") && argv++)) { + if (!*argv) + for (sig = 0; sig < VSIGCOUNT; sig++) + unsettrap(sig); + else + while (*argv) + unsettrap(getsignum(*argv++)); + return 0; + } + + /* Sort out the command to execute on trap */ + arg = *argv++; + if (!*arg) + l = NULL; + else if (!(l = parse_string(arg))) { + zwarnnam(name, "couldn't parse trap command", NULL, 0); + return 1; + } + + /* set traps */ + for (; *argv; argv++) { + List t; + + sig = getsignum(*argv); + if (sig == -1) { + zwarnnam(name, "undefined signal: %s", *argv, 0); + break; + } + PERMALLOC { + t = (List) dupstruct(l); + } LASTALLOC; + if (settrap(sig, t)) + freestruct(t); + } + return *argv != NULL; +} + +/**/ +int +bin_ttyctl(char *name, char **argv, char *ops, int func) +{ + if (ops['f']) + ttyfrozen = 1; + else if (ops['u']) + ttyfrozen = 0; + else + printf("tty is %sfrozen\n", ttyfrozen ? "" : "not "); + return 0; +} + +/* let -- mathematical evaluation */ + +/**/ +int +bin_let(char *name, char **argv, char *ops, int func) +{ + long val = 0; + + while (*argv) + val = matheval(*argv++); + /* Errors in math evaluation in let are non-fatal. */ + errflag = 0; + return !val; +} + +/* umask command. umask may be specified as octal digits, or in the * + * symbolic form that chmod(1) uses. Well, a subset of it. Remember * + * that only the bottom nine bits of umask are used, so there's no * + * point allowing the set{u,g}id and sticky bits to be specified. */ + +/**/ +int +bin_umask(char *nam, char **args, char *ops, int func) +{ + mode_t um; + char *s = *args; + + /* Get the current umask. */ + um = umask(0); + umask(um); + /* No arguments means to display the current setting. */ + if (!s) { + if (ops['S']) { + char *who = "ugo"; + + while (*who) { + char *what = "rwx"; + printf("%c=", *who++); + while (*what) { + if (!(um & 0400)) + putchar(*what); + um <<= 1; + what++; + } + putchar(*who ? ',' : '\n'); + } + } else { + if (um & 0700) + putchar('0'); + printf("%03o\n", (unsigned)um); + } + return 0; + } + + if (idigit(*s)) { + /* Simple digital umask. */ + um = zstrtol(s, &s, 8); + if (*s) { + zwarnnam(nam, "bad umask", NULL, 0); + return 1; + } + } else { + /* Symbolic notation -- slightly complicated. */ + int whomask, umaskop, mask; + + /* More than one symbolic argument may be used at once, each separated + by commas. */ + for (;;) { + /* First part of the argument -- who does this apply to? + u=owner, g=group, o=other. */ + whomask = 0; + while (*s == 'u' || *s == 'g' || *s == 'o' || *s == 'a') + if (*s == 'u') + s++, whomask |= 0700; + else if (*s == 'g') + s++, whomask |= 0070; + else if (*s == 'o') + s++, whomask |= 0007; + else if (*s == 'a') + s++, whomask |= 0777; + /* Default whomask is everyone. */ + if (!whomask) + whomask = 0777; + /* Operation may be +, - or =. */ + umaskop = (int)*s; + if (!(umaskop == '+' || umaskop == '-' || umaskop == '=')) { + if (umaskop) + zwarnnam(nam, "bad symbolic mode operator: %c", NULL, umaskop); + else + zwarnnam(nam, "bad umask", NULL, 0); + return 1; + } + /* Permissions mask -- r=read, w=write, x=execute. */ + mask = 0; + while (*++s && *s != ',') + if (*s == 'r') + mask |= 0444 & whomask; + else if (*s == 'w') + mask |= 0222 & whomask; + else if (*s == 'x') + mask |= 0111 & whomask; + else { + zwarnnam(nam, "bad symbolic mode permission: %c", + NULL, *s); + return 1; + } + /* Apply parsed argument to um. */ + if (umaskop == '+') + um &= ~mask; + else if (umaskop == '-') + um |= mask; + else /* umaskop == '=' */ + um = (um | (whomask)) & ~mask; + if (*s == ',') + s++; + else + break; + } + if (*s) { + zwarnnam(nam, "bad character in symbolic mode: %c", NULL, *s); + return 1; + } + } + + /* Finally, set the new umask. */ + umask(um); + return 0; +} + +/* Generic builtin for facilities not available on this OS */ + +/**/ +int +bin_notavail(char *nam, char **argv, char *ops, int func) +{ + zwarnnam(nam, "not available on this system", NULL, 0); + return 1; +} |