zsh-3.1.5 zsh-3.1.5

94 files changed, 54100 insertions, 0 deletions

diff --git a/Src/.cvsignore b/Src/.cvsignore
new file mode 100644
index 000000000..edec5401b
--- /dev/null
+++ b/Src/.cvsignore
@@ -0,0 +1,25 @@
+Makefile
+Makemod.in Makemod
+*.pro
+*.o
+*.o.c
+*.so
+*.mdh
+*.mdhi
+*.mdhs
+*.mdh.tmp
+modules.index
+modules.index.tmp
+modules.stamp
+modules-bltin
+stamp-modobjs
+stamp-modobjs.tmp
+ansi2knr
+zsh
+libzsh.so*
+sigcount.h
+signames.c
+zshpaths.h
+zshxmods.h
+bltinmods.list
+tags TAGS
diff --git a/Src/.distfiles b/Src/.distfiles
new file mode 100644
index 000000000..727c855cc
--- /dev/null
+++ b/Src/.distfiles
@@ -0,0 +1,11 @@
+DISTFILES_SRC='
+    .cvsignore .distfiles .exrc .indent.pro
+    Makefile.in Makemod.in.in
+    ansi2knr.c
+    builtin.c compat.c cond.c exec.c glob.c hashtable.c hashtable.h
+    hist.c init.c input.c jobs.c lex.c linklist.c loop.c main.c makepro.awk
+    math.c mem.c mkbltnmlst.sh mkmakemod.sh mkmodindex.sh
+    module.c options.c params.c parse.c prompt.c prototypes.h
+    signals.c signals.h signames.awk subst.c system.h text.c utils.c
+    watch.c xmods.conf zsh.h zsh.mdd ztype.h
+'
diff --git a/Src/.exrc b/Src/.exrc
new file mode 100644
index 000000000..91d0b39ef
--- /dev/null
+++ b/Src/.exrc
@@ -0,0 +1,2 @@
+set ai
+set sw=4
diff --git a/Src/Builtins/.cvsignore b/Src/Builtins/.cvsignore
new file mode 100644
index 000000000..ff73d86c4
--- /dev/null
+++ b/Src/Builtins/.cvsignore
@@ -0,0 +1,11 @@
+Makefile
+Makefile.in
+*.pro
+*.o
+*.o.c
+*.so
+*.mdh
+*.mdhi
+*.mdhs
+*.mdh.tmp
+rlimits.h
diff --git a/Src/Builtins/.distfiles b/Src/Builtins/.distfiles
new file mode 100644
index 000000000..cd36388ef
--- /dev/null
+++ b/Src/Builtins/.distfiles
@@ -0,0 +1,5 @@
+DISTFILES_SRC='
+    .cvsignore .distfiles .exrc
+    rlimits.mdd rlimits.c rlimits.awk
+    sched.mdd sched.c
+'
diff --git a/Src/Builtins/.exrc b/Src/Builtins/.exrc
new file mode 100644
index 000000000..91d0b39ef
--- /dev/null
+++ b/Src/Builtins/.exrc
@@ -0,0 +1,2 @@
+set ai
+set sw=4
diff --git a/Src/Builtins/rlimits.awk b/Src/Builtins/rlimits.awk
new file mode 100644
index 000000000..e2500582a
--- /dev/null
+++ b/Src/Builtins/rlimits.awk
@@ -0,0 +1,72 @@
+#
+# rlimits.awk: {g,n}awk script to generate rlimits.h
+#
+# NB: On SunOS 4.1.3 - user-functions don't work properly, also \" problems
+# Without 0 + hacks some nawks compare numbers as strings
+#
+BEGIN {limidx = 0}
+
+/^[\t ]*(#[\t ]*define[\t _]*RLIMIT_[A-Z]*[\t ]*[0-9][0-9]*|RLIMIT_[A-Z]*,[\t ]*)/ {
+    limindex = index($0, "RLIMIT_")
+    limtail = substr($0, limindex, 80)
+    split(limtail, tmp)
+    limnam = substr(tmp[1], 8, 20)
+    limnum = tmp[2]
+    # in this case I assume GNU libc resourcebits.h
+    if (limnum == "") {
+	limnum = limidx++
+	limindex = index($0, ",")
+	limnam = substr(limnam, 1, limindex-1)
+    }
+    limrev[limnam] = limnum
+    if (lim[limnum] == "") {
+	lim[limnum] = limnam
+	if (limnum ~ /^[0-9]*$/) {
+	    if (limnam == "MEMLOCK") { msg[limnum] = "memorylocked" }
+	    if (limnam == "RSS")     { msg[limnum] = "resident" }
+	    if (limnam == "VMEM")    { msg[limnum] = "vmemorysize" }
+	    if (limnam == "NOFILE")  { msg[limnum] = "descriptors" }
+	    if (limnam == "OFILE")   { msg[limnum] = "descriptors" }
+	    if (limnam == "CORE")    { msg[limnum] = "coredumpsize" }
+	    if (limnam == "STACK")   { msg[limnum] = "stacksize" }
+	    if (limnam == "DATA")    { msg[limnum] = "datasize" }
+	    if (limnam == "FSIZE")   { msg[limnum] = "filesize" }
+	    if (limnam == "CPU")     { msg[limnum] = "cputime" }
+	    if (limnam == "NPROC")   { msg[limnum] = "maxproc" }
+	    if (limnam == "AS")      { msg[limnum] = "addressspace" }
+	    if (limnam == "TCACHE")  { msg[limnum] = "cachedthreads" }
+        }
+    }
+}
+/^[\t ]*#[\t ]*define[\t _]*RLIM_NLIMITS[\t ]*[0-9][0-9]*/ {
+    limindex = index($0, "RLIM_")
+    limtail = substr($0, limindex, 80)
+    split(limtail, tmp)
+    nlimits = tmp[2]
+}
+# in case of GNU libc
+/^[\t ]*RLIM_NLIMITS[\t ]*=[\t ]*RLIMIT_NLIMITS/ {
+    nlimits = limidx
+}
+
+END {
+    if (limrev["MEMLOCK"] != "") {
+        irss = limrev["RSS"]
+        msg[irss] = "memoryuse"
+    }
+    ps = "%s"
+
+    printf("%s\n%s\n\n", "/** rlimits.h                              **/", "/** architecture-customized limits for zsh **/")
+    printf("#define ZSH_NLIMITS %d\n\nstatic char *recs[ZSH_NLIMITS+1] = {\n", 0 + nlimits)
+
+    for (i = 0; i < 0 + nlimits; i++)
+	if (msg[i] == "") {
+            badlimit++
+            printf("\t%c%s%c,\n", 34, lim[i], 34)
+	} else
+	    printf("\t%c%s%c,\n", 34, msg[i], 34)
+    print "\tNULL"
+    print "};"
+    print ""
+    exit(badlimit)
+}
diff --git a/Src/Builtins/rlimits.c b/Src/Builtins/rlimits.c
new file mode 100644
index 000000000..20b8d663d
--- /dev/null
+++ b/Src/Builtins/rlimits.c
@@ -0,0 +1,593 @@
+/*
+ * rlimits.c - resource limit builtins
+ *
+ * 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 "rlimits.mdh"
+#include "rlimits.pro"
+
+#if defined(HAVE_GETRLIMIT) && defined(RLIM_INFINITY)
+
+/* Generated rec array containing limits required for the limit builtin.     *
+ * They must appear in this array in numerical order of the RLIMIT_* macros. */
+
+# include "rlimits.h"
+
+# if defined(RLIM_T_IS_QUAD_T) || defined(RLIM_T_IS_UNSIGNED)
+static rlim_t
+zstrtorlimt(const char *s, char **t, int base)
+{
+    rlim_t ret = 0;
+ 
+    if (!base)
+	if (*s != '0')
+	    base = 10;
+	else if (*++s == 'x' || *s == 'X')
+	    base = 16, s++;
+	else
+	    base = 8;
+ 
+    if (base <= 10)
+	for (; *s >= '0' && *s < ('0' + base); s++)
+	    ret = ret * base + *s - '0';
+    else
+	for (; idigit(*s) || (*s >= 'a' && *s < ('a' + base - 10))
+	     || (*s >= 'A' && *s < ('A' + base - 10)); s++)
+	    ret = ret * base + (idigit(*s) ? (*s - '0') : (*s & 0x1f) + 9);
+    if (t)
+	*t = (char *)s;
+    return ret;
+}
+# else /* !RLIM_T_IS_QUAD_T && !RLIM_T_IS_UNSIGNED */
+#  define zstrtorlimt(a, b, c)	zstrtol((a), (b), (c))
+# endif /* !RLIM_T_IS_QUAD_T && !RLIM_T_IS_UNSIGNED */
+
+/* Display resource limits.  hard indicates whether `hard' or `soft'  *
+ * limits should be displayed.  lim specifies the limit, or may be -1 *
+ * to show all.                                                       */
+
+/**/
+static void
+showlimits(int hard, int lim)
+{
+    int rt;
+    rlim_t val;
+
+    /* main loop over resource types */
+    for (rt = 0; rt != ZSH_NLIMITS; rt++)
+	if (rt == lim || lim == -1) {
+	    /* display limit for resource number rt */
+	    printf("%-16s", recs[rt]);
+	    val = (hard) ? limits[rt].rlim_max : limits[rt].rlim_cur;
+	    if (val == RLIM_INFINITY)
+		printf("unlimited\n");
+	    else if (rt==RLIMIT_CPU)
+		/* time-type resource -- display as hours, minutes and
+		seconds. */
+		printf("%d:%02d:%02d\n", (int)(val / 3600),
+		       (int)(val / 60) % 60, (int)(val % 60));
+# ifdef RLIMIT_NPROC
+	    else if (rt == RLIMIT_NPROC)
+		/* pure numeric resource */
+		printf("%d\n", (int)val);
+# endif /* RLIMIT_NPROC */
+# ifdef RLIMIT_NOFILE
+	    else if (rt == RLIMIT_NOFILE)
+		/* pure numeric resource */
+		printf("%d\n", (int)val);
+# endif /* RLIMIT_NOFILE */
+	    else if (val >= 1024L * 1024L)
+		/* memory resource -- display with `K' or `M' modifier */
+# ifdef RLIM_T_IS_QUAD_T
+		printf("%qdMB\n", val / (1024L * 1024L));
+	    else
+		printf("%qdkB\n", val / 1024L);
+# else
+		printf("%ldMB\n", val / (1024L * 1024L));
+            else
+		printf("%ldkB\n", val / 1024L);
+# endif /* RLIM_T_IS_QUAD_T */
+	}
+}
+
+/* Display a resource limit, in ulimit style.  lim specifies which   *
+ * limit should be displayed, and hard indicates whether the hard or *
+ * soft limit should be displayed.                                   */
+
+/**/
+static void
+printulimit(int lim, int hard, int head)
+{
+    rlim_t limit;
+
+    /* get the limit in question */
+    limit = (hard) ? limits[lim].rlim_max : limits[lim].rlim_cur;
+    /* display the appropriate heading */
+    switch (lim) {
+    case RLIMIT_CPU:
+	if (head)
+	    printf("cpu time (seconds)         ");
+	break;
+    case RLIMIT_FSIZE:
+	if (head)
+	    printf("file size (blocks)         ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 512;
+	break;
+    case RLIMIT_DATA:
+	if (head)
+	    printf("data seg size (kbytes)     ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+    case RLIMIT_STACK:
+	if (head)
+	    printf("stack size (kbytes)        ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+    case RLIMIT_CORE:
+	if (head)
+	    printf("core file size (blocks)    ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 512;
+	break;
+# ifdef RLIMIT_RSS
+    case RLIMIT_RSS:
+	if (head)
+	    printf("resident set size (kbytes) ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+# endif /* RLIMIT_RSS */
+# ifdef RLIMIT_MEMLOCK
+    case RLIMIT_MEMLOCK:
+	if (head)
+	    printf("locked-in-memory size (kb) ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+# endif /* RLIMIT_MEMLOCK */
+# ifdef RLIMIT_NPROC
+    case RLIMIT_NPROC:
+	if (head)
+	    printf("processes                  ");
+	break;
+# endif /* RLIMIT_NPROC */
+# ifdef RLIMIT_NOFILE
+    case RLIMIT_NOFILE:
+	if (head)
+	    printf("file descriptors           ");
+	break;
+# endif /* RLIMIT_NOFILE */
+# ifdef RLIMIT_VMEM
+    case RLIMIT_VMEM:
+	if (head)
+	    printf("virtual memory size (kb)   ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+# endif /* RLIMIT_VMEM */
+# if defined RLIMIT_AS && RLIMIT_AS != RLIMIT_VMEM
+    case RLIMIT_AS:
+	if (head)
+	    printf("address space (kb)         ");
+	if (limit != RLIM_INFINITY)
+	    limit /= 1024;
+	break;
+# endif /* RLIMIT_AS */
+# ifdef RLIMIT_TCACHE
+    case RLIMIT_TCACHE:
+	if (head)
+	    printf("cached threads             ");
+	break;
+# endif /* RLIMIT_TCACHE */
+    }
+    /* display the limit */
+    if (limit == RLIM_INFINITY)
+	printf("unlimited\n");
+    else
+	printf("%ld\n", (long)limit);
+}
+
+/* limit: set or show resource limits.  The variable hard indicates *
+ * whether `hard' or `soft' resource limits are being set/shown.    */
+
+/**/
+static int
+bin_limit(char *nam, char **argv, char *ops, int func)
+{
+    char *s;
+    int hard, limnum, lim;
+    rlim_t val;
+    int ret = 0;
+
+    hard = ops['h'];
+    if (ops['s'] && !*argv)
+	return setlimits(NULL);
+    /* without arguments, display limits */
+    if (!*argv) {
+	showlimits(hard, -1);
+	return 0;
+    }
+    while ((s = *argv++)) {
+	/* Search for the appropriate resource name.  When a name matches (i.e. *
+	 * starts with) the argument, the lim variable changes from -1 to the   *
+	 * number of the resource.  If another match is found, lim goes to -2.  */
+	for (lim = -1, limnum = 0; limnum < ZSH_NLIMITS; limnum++)
+	    if (!strncmp(recs[limnum], s, strlen(s))) {
+		if (lim != -1)
+		    lim = -2;
+		else
+		    lim = limnum;
+	    }
+	/* lim==-1 indicates that no matches were found.       *
+	 * lim==-2 indicates that multiple matches were found. */
+	if (lim < 0) {
+	    zwarnnam("limit",
+		     (lim == -2) ? "ambiguous resource specification: %s"
+		     : "no such resource: %s", s, 0);
+	    return 1;
+	}
+	/* without value for limit, display the current limit */
+	if (!(s = *argv++)) {
+	    showlimits(hard, lim);
+	    return 0;
+	}
+	if (lim==RLIMIT_CPU) {
+	    /* time-type resource -- may be specified as seconds, or minutes or *
+	     * hours with the `m' and `h' modifiers, and `:' may be used to add *
+	     * together more than one of these.  It's easier to understand from *
+	     * the code:                                                        */
+	    val = zstrtorlimt(s, &s, 10);
+	    if (*s)
+		if ((*s == 'h' || *s == 'H') && !s[1])
+		    val *= 3600L;
+		else if ((*s == 'm' || *s == 'M') && !s[1])
+		    val *= 60L;
+		else if (*s == ':')
+		    val = val * 60 + zstrtorlimt(s + 1, &s, 10);
+		else {
+		    zwarnnam("limit", "unknown scaling factor: %s", s, 0);
+		    return 1;
+		}
+	}
+# ifdef RLIMIT_NPROC
+	else if (lim == RLIMIT_NPROC)
+	    /* pure numeric resource -- only a straight decimal number is
+	    permitted. */
+	    val = zstrtorlimt(s, &s, 10);
+# endif /* RLIMIT_NPROC */
+# ifdef RLIMIT_NOFILE
+	else if (lim == RLIMIT_NOFILE)
+	    /* pure numeric resource -- only a straight decimal number is
+	    permitted. */
+	    val = zstrtorlimt(s, &s, 10);
+# endif /* RLIMIT_NOFILE */
+	else {
+	    /* memory-type resource -- `k' and `M' modifiers are permitted,
+	    meaning (respectively) 2^10 and 2^20. */
+	    val = zstrtorlimt(s, &s, 10);
+	    if (!*s || ((*s == 'k' || *s == 'K') && !s[1]))
+		val *= 1024L;
+	    else if ((*s == 'M' || *s == 'm') && !s[1])
+		val *= 1024L * 1024;
+	    else {
+		zwarnnam("limit", "unknown scaling factor: %s", s, 0);
+		return 1;
+	    }
+	}
+	/* new limit is valid and has been interpreted; apply it to the
+	specified resource */
+	if (hard) {
+	    /* can only raise hard limits if running as root */
+	    if (val > current_limits[lim].rlim_max && geteuid()) {
+		zwarnnam("limit", "can't raise hard limits", NULL, 0);
+		return 1;
+	    } else {
+		limits[lim].rlim_max = val;
+		if (val < limits[lim].rlim_cur)
+		    limits[lim].rlim_cur = val;
+	    }
+	} else if (val > limits[lim].rlim_max) {
+	    zwarnnam("limit", "limit exceeds hard limit", NULL, 0);
+	    return 1;
+	} else
+	    limits[lim].rlim_cur = val;
+	if (ops['s'] && zsetlimit(lim, "limit"))
+	    ret++;
+    }
+    return ret;
+}
+
+/* unlimit: remove resource limits.  Much of this code is the same as *
+ * that in bin_limit().                                               */
+
+/**/
+static int
+bin_unlimit(char *nam, char **argv, char *ops, int func)
+{
+    int hard, limnum, lim;
+    int ret = 0;
+    uid_t euid = geteuid();
+
+    hard = ops['h'];
+    /* Without arguments, remove all limits. */
+    if (!*argv) {
+	for (limnum = 0; limnum != RLIM_NLIMITS; limnum++) {
+	    if (hard)
+		if (euid && current_limits[limnum].rlim_max != RLIM_INFINITY)
+		    ret++;
+		else
+		    limits[limnum].rlim_max = RLIM_INFINITY;
+	    else
+		limits[limnum].rlim_cur = limits[limnum].rlim_max;
+	}
+	if (ops['s'])
+	    ret += setlimits(nam);
+	if (ret)
+	    zwarnnam(nam, "can't remove hard limits", NULL, 0);
+    } else {
+	for (; *argv; argv++) {
+	    /* Search for the appropriate resource name.  When a name     *
+	     * matches (i.e. starts with) the argument, the lim variable  *
+	     * changes from -1 to the number of the resource.  If another *
+	     * match is found, lim goes to -2.                            */
+	    for (lim = -1, limnum = 0; limnum < ZSH_NLIMITS; limnum++)
+		if (!strncmp(recs[limnum], *argv, strlen(*argv))) {
+		    if (lim != -1)
+			lim = -2;
+		    else
+			lim = limnum;
+		}
+	    /* lim==-1 indicates that no matches were found.       *
+	     * lim==-2 indicates that multiple matches were found. */
+	    if (lim < 0) {
+		zwarnnam(nam,
+			 (lim == -2) ? "ambiguous resource specification: %s"
+			 : "no such resource: %s", *argv, 0);
+		return 1;
+	    }
+	    /* remove specified limit */
+	    if (hard)
+		if (euid && current_limits[lim].rlim_max != RLIM_INFINITY) {
+		    zwarnnam(nam, "can't remove hard limits", NULL, 0);
+		    ret++;
+		} else
+		    limits[lim].rlim_max = RLIM_INFINITY;
+	    else
+		limits[lim].rlim_cur = limits[lim].rlim_max;
+	    if (ops['s'] && zsetlimit(lim, nam))
+		ret++;
+	}
+    }
+    return ret;
+}
+
+/* ulimit: set or display resource limits */
+
+/**/
+static int
+bin_ulimit(char *name, char **argv, char *ops, int func)
+{
+    int res, resmask = 0, hard = 0, soft = 0, nres = 0;
+    char *options;
+
+    do {
+	options = *argv;
+	if (options && *options == '-' && !options[1]) {
+	    zwarnnam(name, "missing option letter", NULL, 0);
+	    return 1;
+	}
+	res = -1;
+	if (options && *options == '-') {
+	    argv++;
+	    while (*++options) {
+		if(*options == Meta)
+		    *++options ^= 32;
+		res = -1;
+		switch (*options) {
+		case 'H':
+		    hard = 1;
+		    continue;
+		case 'S':
+		    soft = 1;
+		    continue;
+		case 'a':
+		    if (*argv || options[1] || resmask) {
+			zwarnnam(name, "no arguments required after -a",
+				 NULL, 0);
+			return 1;
+		    }
+		    resmask = (1 << RLIM_NLIMITS) - 1;
+		    nres = RLIM_NLIMITS;
+		    continue;
+		case 't':
+		    res = RLIMIT_CPU;
+		    break;
+		case 'f':
+		    res = RLIMIT_FSIZE;
+		    break;
+		case 'd':
+		    res = RLIMIT_DATA;
+		    break;
+		case 's':
+		    res = RLIMIT_STACK;
+		    break;
+		case 'c':
+		    res = RLIMIT_CORE;
+		    break;
+# ifdef RLIMIT_RSS
+		case 'm':
+		    res = RLIMIT_RSS;
+		    break;
+# endif /* RLIMIT_RSS */
+# ifdef RLIMIT_MEMLOCK
+		case 'l':
+		    res = RLIMIT_MEMLOCK;
+		    break;
+# endif /* RLIMIT_MEMLOCK */
+# ifdef RLIMIT_NOFILE
+		case 'n':
+		    res = RLIMIT_NOFILE;
+		    break;
+# endif /* RLIMIT_NOFILE */
+# ifdef RLIMIT_NPROC
+		case 'u':
+		    res = RLIMIT_NPROC;
+		    break;
+# endif /* RLIMIT_NPROC */
+# ifdef RLIMIT_VMEM
+		case 'v':
+		    res = RLIMIT_VMEM;
+		    break;
+# endif /* RLIMIT_VMEM */
+		default:
+		    /* unrecognised limit */
+		    zwarnnam(name, "bad option: -%c", NULL, *options);
+		    return 1;
+		}
+		if (options[1]) {
+		    resmask |= 1 << res;
+		    nres++;
+		}
+	    }
+	}
+	if (!*argv || **argv == '-') {
+	    if (res < 0)
+		if (*argv || nres)
+		    continue;
+		else
+		    res = RLIMIT_FSIZE;
+	    resmask |= 1 << res;
+	    nres++;
+	    continue;
+	}
+	if (res < 0)
+	    res = RLIMIT_FSIZE;
+	if (strcmp(*argv, "unlimited")) {
+	    /* set limit to specified value */
+	    rlim_t limit;
+
+	    limit = zstrtorlimt(*argv, NULL, 10);
+	    /* scale appropriately */
+	    switch (res) {
+	    case RLIMIT_FSIZE:
+	    case RLIMIT_CORE:
+		limit *= 512;
+		break;
+	    case RLIMIT_DATA:
+	    case RLIMIT_STACK:
+# ifdef RLIMIT_RSS
+	    case RLIMIT_RSS:
+# endif /* RLIMIT_RSS */
+# ifdef RLIMIT_MEMLOCK
+	    case RLIMIT_MEMLOCK:
+# endif /* RLIMIT_MEMLOCK */
+# ifdef RLIMIT_VMEM
+	    case RLIMIT_VMEM:
+# endif /* RLIMIT_VMEM */
+		limit *= 1024;
+		break;
+	    }
+	    if (hard) {
+		/* can't raise hard limit unless running as root */
+		if (limit > current_limits[res].rlim_max && geteuid()) {
+		    zwarnnam(name, "can't raise hard limits", NULL, 0);
+		    return 1;
+		}
+		limits[res].rlim_max = limit;
+		if (limit < limits[res].rlim_cur)
+		    limits[res].rlim_cur = limit;
+	    }
+	    if (!hard || soft) {
+		/* can't raise soft limit above hard limit */
+		if (limit > limits[res].rlim_max) {
+		    if (limit > current_limits[res].rlim_max && geteuid()) {
+			zwarnnam(name, "value exceeds hard limit", NULL, 0);
+			return 1;
+		    }
+		    limits[res].rlim_max = limits[res].rlim_cur = limit;
+		} else
+		    limits[res].rlim_cur = limit;
+	    }
+	} else {
+	    /* remove specified limit */
+	    if (hard) {
+		/* can't remove hard limit unless running as root */
+		if (current_limits[res].rlim_max != RLIM_INFINITY && geteuid()) {
+		    zwarnnam(name, "can't remove hard limits", NULL, 0);
+		    return 1;
+		}
+		limits[res].rlim_max = RLIM_INFINITY;
+	    }
+	    if (!hard || soft)
+		/* `removal' of soft limit means setting it equal to the
+		   corresponding hard limit */
+		limits[res].rlim_cur = limits[res].rlim_max;
+	}
+	if (zsetlimit(res, name))
+	    return 1;
+	argv++;
+    } while (*argv);
+    for (res = 0; res < RLIM_NLIMITS; res++, resmask >>= 1)
+	if (resmask & 1)
+	    printulimit(res, hard, nres > 1);
+    return 0;
+}
+
+#else /* !HAVE_GETRLIMIT || !RLIM_INFINITY */
+
+# define bin_limit   bin_notavail
+# define bin_ulimit  bin_notavail
+# define bin_unlimit bin_notavail
+
+#endif /* !HAVE_GETRLIMIT || !RLIM_INFINITY */
+
+static struct builtin bintab[] = {
+    BUILTIN("limit",   0, bin_limit,   0, -1, 0, "sh", NULL),
+    BUILTIN("ulimit",  0, bin_ulimit,  0, -1, 0, NULL, NULL),
+    BUILTIN("unlimit", 0, bin_unlimit, 0, -1, 0, "hs", NULL),
+};
+
+/**/
+int
+boot_rlimits(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_rlimits(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Builtins/rlimits.mdd b/Src/Builtins/rlimits.mdd
new file mode 100644
index 000000000..f0e41b73e
--- /dev/null
+++ b/Src/Builtins/rlimits.mdd
@@ -0,0 +1,18 @@
+autobins="limit ulimit unlimit"
+
+objects="rlimits.o"
+
+:<<\Make
+rlimits.o rlimits..o: rlimits.h
+
+# this file will not be made if limits are unavailable:
+# silent so the warning doesn't appear unless necessary
+rlimits.h: rlimits.awk @RLIMITS_INC_H@
+	@echo '$(AWK) -f $(sdir)/rlimits.awk @RLIMITS_INC_H@ > rlimits.h'; \
+	$(AWK) -f $(sdir)/rlimits.awk @RLIMITS_INC_H@ > rlimits.h || \
+	    echo WARNING: unknown limits:  mail rlimits.h to developers
+
+clean-here: clean.rlimits
+clean.rlimits:
+	rm -f rlimits.h
+Make
diff --git a/Src/Builtins/sched.c b/Src/Builtins/sched.c
new file mode 100644
index 000000000..b4914899e
--- /dev/null
+++ b/Src/Builtins/sched.c
@@ -0,0 +1,214 @@
+/*
+ * sched.c - execute commands at scheduled times
+ *
+ * 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 "sched.mdh"
+#include "sched.pro"
+
+/* node in sched list */
+
+typedef struct schedcmd  *Schedcmd;
+
+struct schedcmd {
+    struct schedcmd *next;
+    char *cmd;			/* command to run */
+    time_t time;		/* when to run it */
+};
+
+/* the list of sched jobs pending */
+ 
+static struct schedcmd *schedcmds;
+
+/**/
+static int
+bin_sched(char *nam, char **argv, char *ops, int func)
+{
+    char *s = *argv++;
+    time_t t;
+    long h, m;
+    struct tm *tm;
+    struct schedcmd *sch, *sch2, *schl;
+    int sn;
+
+    /* If the argument begins with a -, remove the specified item from the
+    schedule. */
+    if (s && *s == '-') {
+	sn = atoi(s + 1);
+
+	if (!sn) {
+	    zwarnnam("sched", "usage for delete: sched -<item#>.", NULL, 0);
+	    return 1;
+	}
+	for (schl = (struct schedcmd *)&schedcmds, sch = schedcmds, sn--;
+	     sch && sn; sch = (schl = sch)->next, sn--);
+	if (!sch) {
+	    zwarnnam("sched", "not that many entries", NULL, 0);
+	    return 1;
+	}
+	schl->next = sch->next;
+	zsfree(sch->cmd);
+	zfree(sch, sizeof(struct schedcmd));
+
+	return 0;
+    }
+
+    /* given no arguments, display the schedule list */
+    if (!s) {
+	char tbuf[40];
+
+	for (sn = 1, sch = schedcmds; sch; sch = sch->next, sn++) {
+	    t = sch->time;
+	    tm = localtime(&t);
+	    ztrftime(tbuf, 20, "%a %b %e %k:%M:%S", tm);
+	    printf("%3d %s %s\n", sn, tbuf, sch->cmd);
+	}
+	return 0;
+    } else if (!*argv) {
+	/* other than the two cases above, sched *
+	 *requires at least two arguments        */
+	zwarnnam("sched", "not enough arguments", NULL, 0);
+	return 1;
+    }
+
+    /* The first argument specifies the time to schedule the command for.  The
+    remaining arguments form the command. */
+    if (*s == '+') {
+	/* + introduces a relative time.  The rest of the argument is an
+	hour:minute offset from the current time.  Once the hour and minute
+	numbers have been extracted, and the format verified, the resulting
+	offset is simply added to the current time. */
+	h = zstrtol(s + 1, &s, 10);
+	if (*s != ':') {
+	    zwarnnam("sched", "bad time specifier", NULL, 0);
+	    return 1;
+	}
+	m = zstrtol(s + 1, &s, 10);
+	if (*s) {
+	    zwarnnam("sched", "bad time specifier", NULL, 0);
+	    return 1;
+	}
+	t = time(NULL) + h * 3600 + m * 60;
+    } else {
+	/* If there is no +, an absolute time of day must have been given.
+	This is in hour:minute format, optionally followed by a string starting
+	with `a' or `p' (for a.m. or p.m.).  Characters after the `a' or `p'
+	are ignored. */
+	h = zstrtol(s, &s, 10);
+	if (*s != ':') {
+	    zwarnnam("sched", "bad time specifier", NULL, 0);
+	    return 1;
+	}
+	m = zstrtol(s + 1, &s, 10);
+	if (*s && *s != 'a' && *s != 'A' && *s != 'p' && *s != 'P') {
+	    zwarnnam("sched", "bad time specifier", NULL, 0);
+	    return 1;
+	}
+	t = time(NULL);
+	tm = localtime(&t);
+	t -= tm->tm_sec + tm->tm_min * 60 + tm->tm_hour * 3600;
+	if (*s == 'p' || *s == 'P')
+	    h += 12;
+	t += h * 3600 + m * 60;
+	/* If the specified time is before the current time, it must refer to
+	tomorrow. */
+	if (t < time(NULL))
+	    t += 3600 * 24;
+    }
+    /* The time has been calculated; now add the new entry to the linked list
+    of scheduled commands. */
+    sch = (struct schedcmd *) zcalloc(sizeof *sch);
+    sch->time = t;
+    PERMALLOC {
+	sch->cmd = zjoin(argv, ' ');
+    } LASTALLOC;
+    sch->next = NULL;
+    for (sch2 = (struct schedcmd *)&schedcmds; sch2->next; sch2 = sch2->next);
+    sch2->next = sch;
+    return 0;
+}
+
+/* Check scheduled commands; call this function from time to time. */
+
+/**/
+static void
+checksched(void)
+{
+    time_t t;
+    struct schedcmd *sch, *schl;
+
+    if(!schedcmds)
+	return;
+    t = time(NULL);
+    for (schl = (struct schedcmd *)&schedcmds, sch = schedcmds; sch;
+	 sch = (schl = sch)->next) {
+	if (sch->time <= t) {
+	    execstring(sch->cmd, 0, 0);
+	    schl->next = sch->next;
+	    zsfree(sch->cmd);
+	    zfree(sch, sizeof(struct schedcmd));
+	    sch = schl;
+	}
+    }
+}
+
+static void (*p_checksched) _((void)) = checksched;
+static struct linknode n_checksched = { NULL, NULL, &p_checksched };
+
+static struct builtin bintab[] = {
+    BUILTIN("sched", 0, bin_sched, 0, -1, 0, NULL, NULL),
+};
+
+/**/
+int
+boot_sched(Module m)
+{
+    if(!addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)))
+	return 1;
+    uaddlinknode(prepromptfns, &n_checksched);
+    return 0;
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_sched(Module m)
+{
+    struct schedcmd *sch, *schn;
+
+    for (sch = schedcmds; sch; sch = schn) {
+	schn = sch->next;
+	zsfree(sch->cmd);
+	zfree(sch, sizeof(*sch));
+    }
+    uremnode(prepromptfns, &n_checksched);
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+
+#endif
diff --git a/Src/Builtins/sched.mdd b/Src/Builtins/sched.mdd
new file mode 100644
index 000000000..6ed749f32
--- /dev/null
+++ b/Src/Builtins/sched.mdd
@@ -0,0 +1,3 @@
+autobins="sched"
+
+objects="sched.o"
diff --git a/Src/Makefile.in b/Src/Makefile.in
new file mode 100644
index 000000000..453159e17
--- /dev/null
+++ b/Src/Makefile.in
@@ -0,0 +1,195 @@
+#
+# Makefile for Src subdirectory
+#
+# Copyright (c) 1995-1997 Richard Coleman
+# 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 Richard Coleman 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 Richard Coleman and the Zsh Development Group have been advised of
+# the possibility of such damage.
+#
+# Richard Coleman 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 Richard Coleman and the
+# Zsh Development Group have no obligation to provide maintenance,
+# support, updates, enhancements, or modifications.
+#
+
+subdir = Src
+dir_top = ..
+SUBDIRS =
+
+@@version.mk@@
+@@defs.mk@@
+
+sdir_src      = $(sdir)
+dir_src       = .
+
+# ========= DEPENDENCIES FOR BUILDING ==========
+
+LINK        = $(CC) $(LDFLAGS) $(EXELDFLAGS) $(EXTRA_LDFLAGS) -o $@
+DLLINK      = $(DLLD) $(LDFLAGS) $(LIBLDFLAGS) $(DLLDFLAGS) -o $@
+
+all: bin modules
+
+bin: zsh
+
+modules: headers
+
+MAIN_OBJS = main.o
+
+LSTMP =
+LLIST =
+NSTMP = stamp-modobjs
+NLIST = `cat stamp-modobjs`
+
+LIBZSH = libzsh-$(VERSION).$(DL_EXT)
+NIBZSH =
+
+LDRUNPATH = LD_RUN_PATH=$(libdir)/zsh
+NDRUNPATH =
+
+zsh: $(@L@IBZSH) $(@L@STMP) $(MAIN_OBJS)
+	rm -f $@
+	$(@L@DRUNPATH) $(LINK) $(MAIN_OBJS) $(@L@LIST) $(@L@IBZSH) $(LIBS)
+
+$(LIBZSH): $(LIBOBJS) $(NSTMP)
+	rm -f $@
+	$(DLLINK) $(LIBOBJS) $(NLIST)
+
+stamp-modobjs: modobjs
+	@if cmp -s stamp-modobjs.tmp stamp-modobjs; then \
+	    rm -f stamp-modobjs.tmp; \
+	    echo "\`stamp-modobjs' is up to date."; \
+	else \
+	    mv -f stamp-modobjs.tmp stamp-modobjs; \
+	    echo "Updated \`stamp-modobjs'."; \
+	fi
+
+modobjs: headers rm-modobjs-tmp
+
+rm-modobjs-tmp:
+	rm -f stamp-modobjs.tmp
+
+Makemod modules.index prep: modules-bltin
+	( cd $(sdir_top) && $(SHELL) $(subdir)/mkmodindex.sh $(subdir) ) \
+	    > modules.index.tmp
+	@if cmp -s modules.index.tmp modules.index; then \
+	    rm -f modules.index.tmp; \
+	    echo "\`modules.index' is up to date."; \
+	else \
+	    mv -f modules.index.tmp modules.index; \
+	    echo "Updated \`modules.index'."; \
+	fi
+	@case $(sdir_top) in \
+	    /*) top_srcdir=$(sdir_top) ;; \
+	    *) top_srcdir=$(subdir)/$(sdir_top) ;; \
+	esac; \
+	export top_srcdir; \
+	echo 'cd $(dir_top) && $(SHELL)' \
+	    '$$top_srcdir/$(subdir)/mkmakemod.sh $(subdir) Makemod'; \
+	cd $(dir_top) && \
+	    $(SHELL) $$top_srcdir/$(subdir)/mkmakemod.sh $(subdir) Makemod
+	@$(MAKE) -f Makemod $(MAKEDEFS) prep || rm -f Makemod
+
+FORCE:
+
+# ========== LINKING IN MODULES ==========
+
+modules-bltin:
+	if test @D@ = N; then \
+	    cat $(sdir)/xmods.conf > $@; \
+	elif test @RTLD_GLOBAL_OK@ != yes; then \
+	    echo comp1 > $@; \
+	else \
+	    echo > $@; \
+	fi
+
+# ========== ANSI TO K&R CONVERSION ==========
+
+ANSI_KNR = ansi2knr
+ANSIKNR  =
+
+Makemod: $(ANSI@U@KNR)
+
+ansi2knr.o: ansi2knr.c
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $(sdir)/ansi2knr.c
+
+ansi2knr: ansi2knr.o
+	rm -f $@
+	$(CC) $(LDFLAGS) $(EXELDFLAGS) -o $@ ansi2knr.o
+
+# ========== DEPENDENCIES FOR INSTALLING ==========
+
+install: install.bin install.modules
+uninstall: uninstall.bin uninstall.modules
+
+install.bin: install.bin-here
+uninstall.bin: uninstall.bin-here
+
+# install binary, creating install directory if necessary
+install.bin-here: zsh install.bin-@L@
+	$(sdir_top)/mkinstalldirs $(bindir)
+	$(INSTALL_PROGRAM) zsh $(bindir)/zsh-$(VERSION)
+	if test -f $(bindir)/zsh; then \
+	    rm -f $(bindir)/zsh.old; \
+	    ln $(bindir)/zsh $(bindir)/zsh.old; \
+	else :; fi
+	rm -f $(bindir)/zsh.new
+	ln $(bindir)/zsh-$(VERSION) $(bindir)/zsh.new
+	mv $(bindir)/zsh.new $(bindir)/zsh
+
+install.bin-N:
+install.bin-L: $(LIBZSH)
+	$(sdir_top)/mkinstalldirs $(libdir)/zsh
+	$(INSTALL_PROGRAM) $(LIBZSH) $(libdir)/zsh/$(LIBZSH)
+
+# uninstall binary
+uninstall.bin-here: uninstall.bin-@L@
+	rm -f $(bindir)/zsh-$(VERSION) $(bindir)/zsh
+
+uninstall.bin-N:
+uninstall.bin-L:
+	rm -f $(libdir)/zsh/$(LIBZSH)
+
+# ========== DEPENDENCIES FOR CLEANUP ==========
+
+@@clean.mk@@
+
+mostlyclean-here:
+	rm -f stamp-modobjs stamp-modobjs.tmp
+
+clean-here:
+	rm -f modules.index.tmp modules.stamp zsh ansi2knr.o ansi2knr
+	rm -f libzsh-*.$(DL_EXT)
+
+distclean-here:
+	rm -f TAGS tags
+	rm -f modules.index modules-bltin Makefile
+
+mostlyclean: mostlyclean-modules
+clean: clean-modules
+distclean: distclean-modules
+realclean: realclean-modules
+
+mostlyclean-modules clean-modules distclean-modules realclean-modules: Makemod
+	@$(MAKE) -f Makemod $(MAKEDEFS) `echo $@ | sed 's/-modules//'`
+
+# ========== RECURSIVE MAKES ==========
+
+install.modules uninstall.modules \
+modobjs modules headers proto $(MAIN_OBJS): Makemod
+	@$(MAKE) -f Makemod $(MAKEDEFS) $@
+
+# ========== DEPENDENCIES FOR MAINTENANCE ==========
+
+@@config.mk@@
diff --git a/Src/Makemod.in.in b/Src/Makemod.in.in
new file mode 100644
index 000000000..f27a6bd57
--- /dev/null
+++ b/Src/Makemod.in.in
@@ -0,0 +1,180 @@
+#
+# Makemod.in.in
+#
+# Copyright (c) 1995-1997 Richard Coleman
+# 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 Richard Coleman 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 Richard Coleman and the Zsh Development Group have been advised of
+# the possibility of such damage.
+#
+# Richard Coleman 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 Richard Coleman and the
+# Zsh Development Group have no obligation to provide maintenance,
+# support, updates, enhancements, or modifications.
+#
+
+# ========== OVERRIDABLE VARIABLES ==========
+
+# subdir is done by mkmakemod.sh
+# dir_top is done by mkmakemod.sh
+# SUBDIRS is done by mkmakemod.sh
+
+@@version.mk@@
+@@defs.mk@@
+
+sdir_src      = $(sdir_top)/Src
+dir_src       = $(dir_top)/Src
+
+# ========== COMPILATION RULES ==========
+
+DNCFLAGS =
+
+COMPILE     = $(CC) -c -I. $(CPPFLAGS) $(DEFS) $(CFLAGS) $(D@L@CFLAGS)
+DLCOMPILE   = $(CC) -c -I. $(CPPFLAGS) $(DEFS) -DMODULE $(CFLAGS) $(DLCFLAGS)
+LINK        = $(CC) $(LDFLAGS) $(EXELDFLAGS) $(EXTRA_LDFLAGS) -o $@
+DLLINK      = $(DLLD) $(LDFLAGS) $(LIBLDFLAGS) $(DLLDFLAGS) -o $@
+
+KNR_OBJ=.o
+KNROBJ=._foo_
+
+ANSIOBJ=.o
+ANSI_OBJ=._foo_
+
+.SUFFIXES: .c .$(DL_EXT) ..o .._foo_ .o ._foo_ .pro
+
+.c$(ANSI@U@OBJ):
+	$(COMPILE) -o $@ $<
+	@rm -f $(dir_src)/stamp-modobjs
+
+.c$(KNR@U@OBJ):
+	$(dir_src)/ansi2knr $< > $@.c
+	$(COMPILE) -o $@ $@.c
+	rm -f $@.c
+	@rm -f $(dir_src)/stamp-modobjs
+
+.c.$(ANSI@U@OBJ):
+	$(DLCOMPILE) -o $@ $<
+
+.c.$(KNR@U@OBJ):
+	$(dir_src)/ansi2knr $< > $@.c
+	$(DLCOMPILE) -o $@ $@.c
+	rm -f $@.c
+
+.c.pro:
+	$(AWK) -f $(sdir_src)/makepro.awk $< $(subdir) > $@
+
+PROTODEPS = $(sdir_src)/makepro.awk
+
+# ========== DEPENDENCIES FOR BUILDING ==========
+
+all: modobjs modules
+
+modobjs: $(MODOBJS)
+modules: $(MODULES)
+headers: $(MDHS)
+proto: $(PROTOS)
+
+prep:
+	@case $(sdir_top) in \
+	    /*) top_srcdir=$(sdir_top) ;; \
+	    *) top_srcdir=$(subdir)/$(sdir_top) ;; \
+	esac; \
+	export top_srcdir; \
+	cd $(dir_top) || exit 1; \
+	subdirs='$(SUBDIRS)'; \
+	for subdir in $$subdirs; do \
+	    dir=$(subdir)/$$subdir; \
+	    test -d $$dir || mkdir $$dir; \
+	    $(SHELL) $$top_srcdir/Src/mkmakemod.sh $$dir Makefile || exit 1; \
+	    ( cd $$dir && $(MAKE) $(MAKEDEFS) $@ ) || exit 1; \
+	done
+
+headers prep: $(dir_src)/modules.stamp
+$(dir_src)/modules.stamp: $(MDDS)
+	echo 'timestamp for *.mdd files' > $@
+
+FORCE:
+
+# ========== DEPENDENCIES FOR INSTALLING ==========
+
+install: install.bin install.modules
+uninstall: uninstall.bin uninstall.modules
+
+install.bin: install.bin-here
+uninstall.bin: uninstall.bin-here
+install.modules: install.modules-here
+uninstall.modules: uninstall.modules-here
+
+install.bin-here uninstall.bin-here:
+
+install.modules-here:
+	$(sdir_top)/mkinstalldirs $(MODDIR)
+	modules='$(MODULES)'; for mod in $$modules; do \
+	    $(INSTALL_PROGRAM) $$mod $(MODDIR)/$$mod; \
+	done
+
+uninstall.modules-here:
+	modules='$(MODULES)'; for mod in $$modules; do \
+	    if test -f $(MODDIR)/$$mod; then \
+		rm -f $(MODDIR)/$$mod; \
+	    else :; fi; \
+	done
+
+# ========== DEPENDENCIES FOR CLEANUP ==========
+
+@@clean.mk@@
+
+mostlyclean-here:
+	rm -f *.o *.$(DL_EXT)
+
+clean-here:
+	rm -f *.o.c *.pro *.mdh *.mdhi *.mdhs *.mdh.tmp
+
+distclean-here:
+	rm -f $(makefile) $(makefile).in
+
+# ========== RECURSIVE MAKES ==========
+
+install.bin uninstall.bin install.modules uninstall.modules \
+modobjs modules headers proto:
+	@subdirs='$(SUBDIRS)'; for subdir in $$subdirs; do \
+	  ( cd $$subdir && $(MAKE) $(MAKEDEFS) $@ ) || exit 1; \
+	done
+
+# ========== DEPENDENCIES FOR MAINTENANCE ==========
+
+$(makefile): $(makefile).in $(dir_top)/config.status
+	@case $(sdir_top) in \
+	    /*) top_srcdir=$(sdir_top) ;; \
+	    *) top_srcdir=$(subdir)/$(sdir_top) ;; \
+	esac; \
+	export top_srcdir; \
+	echo 'cd $(dir_top) && $(SHELL)' \
+	    '$$top_srcdir/Src/mkmakemod.sh -m $(subdir) $(makefile)'; \
+	cd $(dir_top) && \
+	    $(SHELL) $$top_srcdir/Src/mkmakemod.sh -m $(subdir) $(makefile)
+
+$(makefile).in: $(sdir_src)/mkmakemod.sh $(sdir_src)/Makemod.in.in $(MDDS) $(dir_src)/modules-bltin
+	@case $(sdir_top) in \
+	    /*) top_srcdir=$(sdir_top) ;; \
+	    *) top_srcdir=$(subdir)/$(sdir_top) ;; \
+	esac; \
+	export top_srcdir; \
+	echo 'cd $(dir_top) && $(SHELL)' \
+	    '$$top_srcdir/Src/mkmakemod.sh -i $(subdir) $(makefile)'; \
+	cd $(dir_top) && \
+	    $(SHELL) $$top_srcdir/Src/mkmakemod.sh -i $(subdir) $(makefile)
+
+$(dir_src)/modules-bltin:
+	@cd $(dir_src) && $(MAKE) $(MAKEDEFS) modules-bltin
diff --git a/Src/Modules/.cvsignore b/Src/Modules/.cvsignore
new file mode 100644
index 000000000..169be5ef9
--- /dev/null
+++ b/Src/Modules/.cvsignore
@@ -0,0 +1,10 @@
+Makefile
+Makefile.in
+*.pro
+*.o
+*.o.c
+*.so
+*.mdh
+*.mdhi
+*.mdhs
+*.mdh.tmp
diff --git a/Src/Modules/.distfiles b/Src/Modules/.distfiles
new file mode 100644
index 000000000..4c98f97ea
--- /dev/null
+++ b/Src/Modules/.distfiles
@@ -0,0 +1,8 @@
+DISTFILES_SRC='
+    .cvsignore .distfiles .exrc
+    cap.mdd cap.c
+    clone.mdd clone.c
+    example.mdd example.c
+    files.mdd files.c
+    stat.mdd stat.c
+'
diff --git a/Src/Modules/.exrc b/Src/Modules/.exrc
new file mode 100644
index 000000000..91d0b39ef
--- /dev/null
+++ b/Src/Modules/.exrc
@@ -0,0 +1,2 @@
+set ai
+set sw=4
diff --git a/Src/Modules/cap.c b/Src/Modules/cap.c
new file mode 100644
index 000000000..008b6932d
--- /dev/null
+++ b/Src/Modules/cap.c
@@ -0,0 +1,141 @@
+/*
+ * cap.c - POSIX.1e (POSIX.6) capability set manipulation
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1997 Andrew Main
+ * 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 Andrew Main 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 Andrew Main and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Andrew Main 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 Andrew Main and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "cap.mdh"
+#include "cap.pro"
+
+#ifdef HAVE_CAP_GET_PROC
+
+static int
+bin_cap(char *nam, char **argv, char *ops, int func)
+{
+    int ret = 0;
+    cap_t caps;
+    if(*argv) {
+	caps = cap_from_text(*argv);
+	if(!caps) {
+	    zwarnnam(nam, "invalid capability string", NULL, 0);
+	    return 1;
+	}
+	if(cap_set_proc(caps)) {
+	    zwarnnam(nam, "can't change capabilites: %e", NULL, errno);
+	    ret = 1;
+	}
+    } else {
+	char *result;
+	ssize_t length;
+	caps = cap_get_proc();
+	if(caps)
+	    result = cap_to_text(caps, &length);
+	if(!caps || !result) {
+	    zwarnnam(nam, "can't get capabilites: %e", NULL, errno);
+	    ret = 1;
+	} else
+	    puts(result);
+    }
+    cap_free(&caps);
+    return ret;
+}
+
+static int
+bin_getcap(char *nam, char **argv, char *ops, int func)
+{
+    int ret = 0;
+
+    do {
+	char *result;
+	ssize_t length;
+	cap_t caps = cap_get_file(*argv);
+	if(caps)
+	    result = cap_to_text(caps, &length);
+	if (!caps || !result) {
+	    zwarnnam(nam, "%s: %e", *argv, errno);
+	    ret = 1;
+	} else
+	    printf("%s %s\n", *argv, result);
+	cap_free(&caps);
+    } while(*++argv);
+    return ret;
+}
+
+static int
+bin_setcap(char *nam, char **argv, char *ops, int func)
+{
+    cap_t caps;
+    int ret = 0;
+
+    caps = cap_from_text(*argv++);
+    if(!caps) {
+	zwarnnam(nam, "invalid capability string", NULL, 0);
+	return 1;
+    }
+
+    do {
+	if(cap_set_file(*argv, caps)) {
+	    zwarnnam(nam, "%s: %e", *argv, errno);
+	    ret = 1;
+	}
+    } while(*++argv);
+    cap_free(&caps);
+    return ret;
+}
+
+#else /* !HAVE_CAP_GET_PROC */
+
+# define bin_cap    bin_notavail
+# define bin_getcap bin_notavail
+# define bin_setcap bin_notavail
+
+#endif /* !HAVE_CAP_GET_PROC */
+
+/* module paraphernalia */
+
+static struct builtin bintab[] = {
+    BUILTIN("cap",    0, bin_cap,    0,  1, 0, NULL, NULL),
+    BUILTIN("getcap", 0, bin_getcap, 1, -1, 0, NULL, NULL),
+    BUILTIN("setcap", 0, bin_setcap, 2, -1, 0, NULL, NULL),
+};
+
+/**/
+int
+boot_cap(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_cap(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Modules/cap.mdd b/Src/Modules/cap.mdd
new file mode 100644
index 000000000..97f377e9d
--- /dev/null
+++ b/Src/Modules/cap.mdd
@@ -0,0 +1,3 @@
+autobins="cap getcap setcap"
+
+objects="cap.o"
diff --git a/Src/Modules/clone.c b/Src/Modules/clone.c
new file mode 100644
index 000000000..11387fc90
--- /dev/null
+++ b/Src/Modules/clone.c
@@ -0,0 +1,115 @@
+/*
+ * clone.c - start a forked instance of the current shell on a new terminal
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1997 Zoltán Hidvégi
+ * 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 Zoltán Hidvégi 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 Zoltán Hidvégi and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Zoltán Hidvégi 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 Zoltán Hidvégi and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+/*
+ * The clone builtin can be used to start a forked instance of the current
+ * shell on a new terminal.  The only argument to the builtin is the name
+ * of the new terminal.  In the new shell the PID, PPID and TTY parameters
+ * are changed appropriately.  $! is set to zero in the new instance of the
+ * shell and to the pid of the new instance in the original shell.
+ *
+ */
+
+#include "clone.mdh"
+#include "clone.pro"
+
+/**/
+static int
+bin_clone(char *nam, char **args, char *ops, int func)
+{
+    int ttyfd, pid;
+
+    unmetafy(*args, NULL);
+    ttyfd = open(*args, O_RDWR|O_NOCTTY);
+    if (ttyfd < 0) {
+	zwarnnam(nam, "%s: %e", *args, errno);
+	return 1;
+    }
+    pid = fork();
+    if (!pid) {
+	clearjobtab();
+	ppid = getppid();
+	mypid = getpid();
+#ifdef HAVE_SETSID
+	if (setsid() != mypid) {
+	    zwarnnam(nam, "failed to create new session: %e", NULL, errno);
+#endif
+#ifdef TIOCNOTTY
+	    if (ioctl(SHTTY, TIOCNOTTY))
+		zwarnnam(nam, "%e", NULL, errno);
+	    setpgrp(0L, mypid);
+#endif
+#ifdef HAVE_SETSID
+	}
+#endif
+	if (ttyfd) {
+	    close(0);
+	    dup(ttyfd);
+	} else
+	    ttyfd = -1;
+	close(1);
+	close(2);
+	dup(0);
+	dup(0);
+	closem(0);
+	close(coprocin);
+	close(coprocout);
+	init_io();
+	setsparam("TTY", ztrdup(ttystrname));
+    }
+    close(ttyfd);
+    if (pid < 0) {
+	zerrnam(nam, "fork failed: %e", NULL, errno);
+	return 1;
+    }
+    lastpid = pid;
+    return 0;
+}
+
+static struct builtin bintab[] = {
+    BUILTIN("clone", 0, bin_clone, 1, 1, 0, NULL, NULL),
+};
+
+/**/
+int
+boot_clone(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_clone(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Modules/clone.mdd b/Src/Modules/clone.mdd
new file mode 100644
index 000000000..5277d3151
--- /dev/null
+++ b/Src/Modules/clone.mdd
@@ -0,0 +1,3 @@
+autobins="clone"
+
+objects="clone.o"
diff --git a/Src/Modules/example.c b/Src/Modules/example.c
new file mode 100644
index 000000000..45ef3c28f
--- /dev/null
+++ b/Src/Modules/example.c
@@ -0,0 +1,76 @@
+/*
+ * example.c - an example module for zsh
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1996-1997 Zoltán Hidvégi
+ * 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 Zoltán Hidvégi 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 Zoltán Hidvégi and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Zoltán Hidvégi 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 Zoltán Hidvégi and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "example.mdh"
+#include "example.pro"
+
+/**/
+static int
+bin_example(char *nam, char **args, char *ops, int func)
+{
+    unsigned char c;
+
+    printf("Options: ");
+    for (c = 32; ++c < 128;)
+	if (ops[c])
+	    putchar(c);
+    printf("\nArguments:");
+    for (; *args; args++) {
+	putchar(' ');
+	fputs(*args, stdout);
+    }
+    printf("\nName: %s\n", nam);
+    return 0;
+}
+
+/*
+ * boot_example is executed when the module is loaded.
+ */
+
+static struct builtin bintab[] = {
+    BUILTIN("example", 0, bin_example, 0, -1, 0, "flags", NULL),
+};
+
+/**/
+int
+boot_example(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_example(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Modules/example.mdd b/Src/Modules/example.mdd
new file mode 100644
index 000000000..89f12097c
--- /dev/null
+++ b/Src/Modules/example.mdd
@@ -0,0 +1,3 @@
+autobins="example"
+
+objects="example.o"
diff --git a/Src/Modules/files.c b/Src/Modules/files.c
new file mode 100644
index 000000000..6127c5524
--- /dev/null
+++ b/Src/Modules/files.c
@@ -0,0 +1,528 @@
+/*
+ * files.c - file operation builtins
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1996-1997 Andrew Main
+ * 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 Andrew Main 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 Andrew Main and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Andrew Main 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 Andrew Main and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "files.mdh"
+
+typedef int (*MoveFunc) _((char const *, char const *));
+
+#ifndef STDC_HEADERS
+extern int link _((const char *, const char *));
+extern int symlink _((const char *, const char *));
+extern int rename _((const char *, const char *));
+#endif
+
+#include "files.pro"
+
+/**/
+static int
+ask(void)
+{
+    int a = getchar(), c;
+    for(c = a; c != EOF && c != '\n'; )
+	c = getchar();
+    return a == 'y' || a == 'Y';
+}
+
+/* sync builtin */
+
+/**/
+static int
+bin_sync(char *nam, char **args, char *ops, int func)
+{
+    sync();
+    return 0;
+}
+
+/* mkdir builtin */
+
+/**/
+static int
+bin_mkdir(char *nam, char **args, char *ops, int func)
+{
+    mode_t oumask = umask(0);
+    mode_t mode = 0777 & ~oumask;
+    int err = 0;
+
+    umask(oumask);
+    if(ops['m']) {
+	char *str = *args++, *ptr;
+
+	if(!*args) {
+	    zwarnnam(nam, "not enough arguments", NULL, 0);
+	    return 1;
+	}
+	mode = zstrtol(str, &ptr, 8);
+	if(!*str || *ptr) {
+	    zwarnnam(nam, "invalid mode `%s'", str, 0);
+	    return 1;
+	}
+    }
+    for(; *args; args++) {
+	char *ptr = strchr(*args, 0);
+
+	while(ptr > *args + (**args == '/') && *--ptr == '/')
+	    *ptr = 0;
+	if(ztrlen(*args) > PATH_MAX - 1) {
+	    zwarnnam(nam, "%s: %e", *args, ENAMETOOLONG);
+	    err = 1;
+	    continue;
+	}
+	if(ops['p']) {
+	    char *ptr = *args;
+
+	    for(;;) {
+		while(*ptr == '/')
+		    ptr++;
+		while(*ptr && *ptr != '/')
+		    ptr++;
+		if(!*ptr) {
+		    err |= domkdir(nam, *args, mode, 1);
+		    break;
+		} else {
+		    int e;
+
+		    *ptr = 0;
+		    e = domkdir(nam, *args, mode | 0300, 1);
+		    if(e) {
+			err = 1;
+			break;
+		    }
+		    *ptr = '/';
+		}
+	    }
+	} else
+	    err |= domkdir(nam, *args, mode, 0);
+    }
+    return err;
+}
+
+/**/
+static int
+domkdir(char *nam, char *path, mode_t mode, int p)
+{
+    int err;
+    mode_t oumask;
+    char const *rpath = unmeta(path);
+
+    if(p) {
+	struct stat st;
+
+	if(!lstat(rpath, &st) && S_ISDIR(st.st_mode))
+	    return 0;
+    }
+    oumask = umask(0);
+    err = mkdir(path, mode) ? errno : 0;
+    umask(oumask);
+    if(!err)
+	return 0;
+    zwarnnam(nam, "cannot make directory `%s': %e", path, err);
+    return 1;
+}
+
+/* rmdir builtin */
+
+/**/
+static int
+bin_rmdir(char *nam, char **args, char *ops, int func)
+{
+    int err = 0;
+
+    for(; *args; args++) {
+	char *rpath = unmeta(*args);
+
+	if(!rpath) {
+	    zwarnnam(nam, "%s: %e", *args, ENAMETOOLONG);
+	    err = 1;
+	} else if(rmdir(rpath)) {
+	    zwarnnam(nam, "cannot remove directory `%s': %e", *args, errno);
+	    err = 1;
+	}
+    }
+    return err;
+}
+
+/* ln and mv builtins */
+
+#define BIN_LN 0
+#define BIN_MV 1
+
+#define MV_NODIRS (1<<0)
+#define MV_FORCE  (1<<1)
+#define MV_INTER  (1<<2)
+#define MV_ASKNW  (1<<3)
+#define MV_ATOMIC (1<<4)
+
+/* bin_ln actually does three related jobs: hard linking, symbolic *
+ * linking, and renaming.  If called as mv it renames, otherwise   *
+ * it looks at the -s option.  If hard linking, it will refuse to  *
+ * attempt linking to a directory unless the -d option is given.   */
+
+/**/
+static int
+bin_ln(char *nam, char **args, char *ops, int func)
+{
+    MoveFunc move;
+    int flags, space, err = 0;
+    char **a, *ptr, *rp;
+    struct stat st;
+    char buf[PATH_MAX * 2 + 1];
+
+
+    if(func == BIN_MV) {
+	move = rename;
+	flags = ops['f'] ? 0 : MV_ASKNW;
+	flags |= MV_ATOMIC;
+    } else {
+	flags = ops['f'] ? MV_FORCE : 0;
+#ifdef HAVE_LSTAT
+	if(ops['s'])
+	    move = symlink;
+	else
+#endif
+	     {
+	    move = link;
+	    if(!ops['d'])
+		flags |= MV_NODIRS;
+	}
+    }
+    if(ops['i'] && !ops['f'])
+	flags |= MV_INTER;
+    for(a = args; a[1]; a++) ;
+    if(a != args) {
+	rp = unmeta(*a);
+	if(rp && !stat(rp, &st) && S_ISDIR(st.st_mode))
+	    goto havedir;
+    }
+    if(a > args+1) {
+	zwarnnam(nam, "last of many arguments must be a directory", NULL, 0);
+	return 1;
+    }
+    if(!args[1]) {
+	ptr = strrchr(args[0], '/');
+	if(ptr)
+	    args[1] = ptr+1;
+	else
+	    args[1] = args[0];
+    }
+    return domove(nam, move, args[0], args[1], flags);
+    havedir:
+    strcpy(buf, *a);
+    *a = NULL;
+    space = PATH_MAX - 1 - ztrlen(buf);
+    rp = strchr(buf, 0);
+    *rp++ = '/';
+    for(; *args; args++) {
+	if(ztrlen(*args) > PATH_MAX) {
+	    zwarnnam(nam, "%s: %e", *args, ENAMETOOLONG);
+	    err = 1;
+	    continue;
+	}
+	ptr = strrchr(*args, '/');
+	if(ptr)
+	    ptr++;
+	else
+	    ptr = *args;
+	if(ztrlen(ptr) > space) {
+	    zwarnnam(nam, "%s: %e", ptr, ENAMETOOLONG);
+	    err = 1;
+	    continue;
+	}
+	strcpy(rp, ptr);
+	err |= domove(nam, move, *args, buf, flags);
+    }
+    return err;
+}
+
+/**/
+static int
+domove(char *nam, MoveFunc move, char *p, char *q, int flags)
+{
+    struct stat st;
+    char *qbuf;
+    char pbuf[PATH_MAX + 1];
+    strcpy(pbuf, unmeta(p));
+    qbuf = unmeta(q);
+    if(flags & MV_NODIRS) {
+	errno = EISDIR;
+	if(lstat(pbuf, &st) || S_ISDIR(st.st_mode)) {
+	    zwarnnam(nam, "%s: %e", p, errno);
+	    return 1;
+	}
+    }
+    if(!lstat(qbuf, &st)) {
+	int doit = flags & MV_FORCE;
+	if(S_ISDIR(st.st_mode)) {
+	    zwarnnam(nam, "%s: cannot overwrite directory", q, 0);
+	    return 1;
+	} else if(flags & MV_INTER) {
+	    nicezputs(nam, stderr);
+	    fputs(": replace `", stderr);
+	    nicezputs(q, stderr);
+	    fputs("'? ", stderr);
+	    fflush(stderr);
+	    if(!ask())
+		return 0;
+	    doit = 1;
+	} else if((flags & MV_ASKNW) &&
+		!S_ISLNK(st.st_mode) &&
+		access(qbuf, W_OK)) {
+	    nicezputs(nam, stderr);
+	    fputs(": replace `", stderr);
+	    nicezputs(q, stderr);
+	    fprintf(stderr, "', overriding mode %04o? ",
+		mode_to_octal(st.st_mode));
+	    fflush(stderr);
+	    if(!ask())
+		return 0;
+	    doit = 1;
+	}
+	if(doit && !(flags & MV_ATOMIC))
+	    unlink(qbuf);
+    }
+    if(move(pbuf, qbuf)) {
+	zwarnnam(nam, "%s: %e", p, errno);
+	return 1;
+    }
+    return 0;
+}
+
+/* rm builtin */
+
+/**/
+static int
+bin_rm(char *nam, char **args, char *ops, int func)
+{
+    int err = 0, len;
+    char *rp, *s;
+    struct dirsav ds;
+
+    ds.ino = ds.dev = 0;
+    ds.dirname = NULL;
+    ds.dirfd = ds.level = -1;
+    if (ops['r'] || ops['s']) {
+	if ((ds.dirfd = open(".", O_RDONLY|O_NOCTTY)) < 0 &&
+	    zgetdir(&ds) && *ds.dirname != '/')
+	    ds.dirfd = open("..", O_RDONLY|O_NOCTTY);
+    }
+    for(; !errflag && !(err & 2) && *args; args++) {
+	rp = ztrdup(*args);
+	unmetafy(rp, &len);
+	if (ops['s']) {
+	    s = strrchr(rp, '/');
+	    if (s && !s[1]) {
+		while (*s == '/' && s > rp)
+		    *s-- = '\0';
+		while (*s != '/' && s > rp)
+		    s--;
+	    }
+	    if (s && s[1]) {
+		int e;
+
+		*s = '\0';
+		e = lchdir(s > rp ? rp : "/", &ds, 1);
+		err |= -e;
+		if (!e) {
+		    struct dirsav d;
+
+		    d.ino = d.dev = 0;
+		    d.dirname = NULL;
+		    d.dirfd = d.level = -1;
+		    err |= dorm(nam, *args, s + 1, ops, &d, 0);
+		    zsfree(d.dirname);
+		    if (restoredir(&ds))
+			err |= 2;
+		} else
+		    zwarnnam(nam, "%s: %e", *args, errno);
+	    } else
+		err |= dorm(nam, *args, rp, ops, &ds, 0);
+	} else
+	    err |= dorm(nam, *args, rp, ops, &ds, 1);
+	zfree(rp, len + 1);
+    }
+    if ((err & 2) && ds.dirfd >= 0 && restoredir(&ds) && zchdir(pwd)) {
+	zsfree(pwd);
+	pwd = ztrdup("/");
+	chdir(pwd);
+    }
+    if (ds.dirfd >= 0)
+	close(ds.dirfd);
+    zsfree(ds.dirname);
+    return ops['f'] ? 0 : !!err;
+}
+
+/**/
+static int
+dorm(char *nam, char *arg, char *rp, char *ops, struct dirsav *ds, int first)
+{
+    struct stat st;
+
+    if((!ops['d'] || !ops['f']) && !lstat(rp, &st)) {
+	if(!ops['d'] && S_ISDIR(st.st_mode)) {
+	    if(ops['r'])
+		return dormr(nam, arg, rp, ops, ds, first);
+	    if(!ops['f'])
+		zwarnnam(nam, "%s: %e", arg, EISDIR);
+	    return 1;
+	}
+	if(!ops['f'] && ops['i']) {
+	    nicezputs(nam, stderr);
+	    fputs(": remove `", stderr);
+	    nicezputs(arg, stderr);
+	    fputs("'? ", stderr);
+	    fflush(stderr);
+	    if(!ask())
+		return 0;
+	} else if(!ops['f'] &&
+		!S_ISLNK(st.st_mode) &&
+	    	access(rp, W_OK)) {
+	    nicezputs(nam, stderr);
+	    fputs(": remove `", stderr);
+	    nicezputs(arg, stderr);
+	    fprintf(stderr, "', overriding mode %04o? ",
+		mode_to_octal(st.st_mode));
+	    fflush(stderr);
+	    if(!ask())
+		return 0;
+	}
+    }
+    if(!unlink(rp))
+	return 0;
+    if(!ops['f'])
+	zwarnnam(nam, "%s: %e", arg, errno);
+    return 1;
+}
+
+/**/
+static int
+dormr(char *nam, char *arg, char *rp, char *ops, struct dirsav *ds, int first)
+{
+    char *fn;
+    DIR *d;
+    int err;
+    struct dirsav dsav;
+    char *files = NULL;
+    int fileslen = 0;
+
+    err = -lchdir(rp, ds, !first);
+    if (err) {
+	if (!ops['f'])
+	    zwarnnam(nam, "%s: %e", arg, errno);
+	return err;
+    }
+
+    dsav.ino = dsav.dev = 0;
+    dsav.dirname = NULL;
+    dsav.dirfd = dsav.level = -1;
+    d = opendir(".");
+    if(!d) {
+	if(!ops['f'])
+	    zwarnnam(nam, "%s: %e", arg, errno);
+	err = 1;
+    } else {
+	int arglen = strlen(arg) + 1;
+
+	while (!errflag && (fn = zreaddir(d, 1))) {
+	    int l = strlen(fn) + 1;
+	    files = hrealloc(files, fileslen, fileslen + l);
+	    strcpy(files + fileslen, fn);
+	    fileslen += l;
+	}
+	closedir(d);
+	for (fn = files; !errflag && !(err & 2) && fn < files + fileslen;) {
+	    int l = strlen(fn) + 1;
+	    VARARR(char, narg, arglen + l);
+
+	    strcpy(narg,arg);
+	    narg[arglen-1] = '/';
+	    strcpy(narg + arglen, fn);
+	    unmetafy(fn, NULL);
+	    err |= dorm(nam, narg, fn, ops, &dsav, 0);
+	    fn += l;
+	}
+	hrealloc(files, fileslen, 0);
+    }
+    zsfree(dsav.dirname);
+    if (err & 2)
+	return 2;
+    if (restoredir(ds)) {
+	if(!ops['f'])
+	    zwarnnam(nam, "failed to return to previous directory: %e",
+		     NULL, errno);
+	return 2;
+    }
+    if(!ops['f'] && ops['i']) {
+	nicezputs(nam, stderr);
+	fputs(": remove `", stderr);
+	nicezputs(arg, stderr);
+	fputs("'? ", stderr);
+	fflush(stderr);
+	if(!ask())
+	    return err;
+    }
+    if(!rmdir(rp))
+	return err;
+    if(!ops['f'])
+	zwarnnam(nam, "%s: %e", arg, errno);
+    return 1;
+}
+
+/* module paraphernalia */
+
+#ifdef HAVE_LSTAT
+# define LN_OPTS "dfis"
+#else
+# define LN_OPTS "dfi"
+#endif
+
+static struct builtin bintab[] = {
+    BUILTIN("ln",    0, bin_ln,    1, -1, BIN_LN, LN_OPTS, NULL),
+    BUILTIN("mkdir", 0, bin_mkdir, 1, -1, 0,      "pm",    NULL),
+    BUILTIN("mv",    0, bin_ln,    2, -1, BIN_MV, "fi",    NULL),
+    BUILTIN("rm",    0, bin_rm,    1, -1, 0,      "dfirs", NULL),
+    BUILTIN("rmdir", 0, bin_rmdir, 1, -1, 0,      NULL,    NULL),
+    BUILTIN("sync",  0, bin_sync,  0,  0, 0,      NULL,    NULL),
+};
+
+/**/
+int
+boot_files(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_files(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Modules/files.mdd b/Src/Modules/files.mdd
new file mode 100644
index 000000000..236ca2d5a
--- /dev/null
+++ b/Src/Modules/files.mdd
@@ -0,0 +1,3 @@
+autobins="ln mkdir mv rm rmdir sync"
+
+objects="files.o"
diff --git a/Src/Modules/stat.c b/Src/Modules/stat.c
new file mode 100644
index 000000000..09245b52f
--- /dev/null
+++ b/Src/Modules/stat.c
@@ -0,0 +1,535 @@
+/*
+ * stat.c - stat builtin interface to system call
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1996-1997 Peter Stephenson
+ * 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 Peter Stephenson 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 Peter Stephenson and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Peter Stephenson 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 Peter Stephenson and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "stat.mdh"
+#include "stat.pro"
+
+enum statnum { ST_DEV, ST_INO, ST_MODE, ST_NLINK, ST_UID, ST_GID,
+		   ST_RDEV, ST_SIZE, ST_ATIM, ST_MTIM, ST_CTIM,
+		   ST_BLKSIZE, ST_BLOCKS, ST_READLINK, ST_COUNT };
+enum statflags { STF_NAME = 1,  STF_FILE = 2, STF_STRING = 4, STF_RAW = 8,
+		     STF_PICK = 16, STF_ARRAY = 32, STF_GMT = 64 };
+static char *statelts[] = { "device", "inode", "mode", "nlink",
+				"uid", "gid", "rdev", "size", "atime",
+				"mtime", "ctime", "blksize", "blocks",
+				"link", NULL };
+
+/**/
+static void
+statmodeprint(mode_t mode, char *outbuf, int flags)
+{
+    if (flags & STF_RAW) {
+	sprintf(outbuf, "%lu", (unsigned long)mode);
+	if (flags & STF_STRING)
+	    strcat(outbuf, " (");
+    }
+    if (flags & STF_STRING) {
+	static const char *modes = "?rwxrwxrwx";
+	static const mode_t mflags[] = { S_IRUSR, S_IWUSR, S_IXUSR,
+					 S_IRGRP, S_IWGRP, S_IXGRP,
+					 S_IROTH, S_IWOTH, S_IXOTH };
+	const mode_t *mfp = mflags;
+	char pm[11];
+	int i;
+
+	if (S_ISBLK(mode))
+	    *pm = 'b';
+	else if (S_ISCHR(mode))
+	    *pm = 'c';
+	else if (S_ISDIR(mode))
+	    *pm = 'd';
+	else if (S_ISFIFO(mode))
+	    *pm = 'p';
+	else if (S_ISLNK(mode))
+	    *pm = 'l';
+	else if (S_ISMPC(mode))
+	    *pm = 'm';
+	else if (S_ISNWK(mode))
+	    *pm = 'n';
+	else if (S_ISOFD(mode))
+	    *pm = 'M';
+	else if (S_ISOFL(mode))
+	    *pm = 'M';
+	else if (S_ISREG(mode))
+	    *pm = '-';
+	else if (S_ISSOCK(mode))
+	    *pm = 's';
+	else
+	    *pm = '?';
+
+	for (i = 1; i <= 9; i++)
+	    pm[i] = (mode & *mfp++) ? modes[i] : '-';
+
+	if (mode & S_ISUID)
+	    pm[3] = (mode & S_IXUSR) ? 's' : 'S';
+	if (mode & S_ISGID)
+	    pm[6] = (mode & S_IXGRP) ? 's' : 'S';
+	if (mode & S_ISVTX)
+	    pm[9] = (mode & S_IXOTH) ? 't' : 'T';
+
+	pm[10] = 0;
+	strcat(outbuf, pm);
+	if (flags & STF_RAW)
+	    strcat(outbuf, ")");
+    }
+}
+
+
+/**/
+static void
+statuidprint(uid_t uid, char *outbuf, int flags)
+{
+    if (flags & STF_RAW) {
+	sprintf(outbuf, "%lu", (unsigned long)uid);
+	if (flags & STF_STRING)
+	    strcat(outbuf, " (");
+    }
+    if (flags & STF_STRING) {
+#ifdef HAVE_GETPWUID
+	struct passwd *pwd;
+	pwd = getpwuid(uid);
+	strcat(outbuf, pwd ? pwd->pw_name : "???");
+#else /* !HAVE_GETPWUID */
+	strcat(outbuf, "???");
+#endif /* !HAVE_GETPWUID */
+	if (flags & STF_RAW)
+	    strcat(outbuf, ")");
+    }
+}
+
+
+/**/
+static void
+statgidprint(gid_t gid, char *outbuf, int flags)
+{
+    if (flags & STF_RAW) {
+	sprintf(outbuf, "%lu", (unsigned long)gid);
+	if (flags & STF_STRING)
+	    strcat(outbuf, " (");
+    }
+    if (flags & STF_STRING) {
+#ifdef HAVE_GETGRGID
+	struct group *gr;
+	gr = getgrgid(gid);
+	strcat(outbuf, gr ? gr->gr_name : "???");
+#else /* !HAVE_GETGRGID */
+	strcat(outbuf, "???");
+#endif /* !HAVE_GETGRGID */
+	if (flags & STF_RAW)
+	    strcat(outbuf, ")");
+    }
+}
+
+static char *timefmt;
+
+/**/
+static void
+stattimeprint(time_t tim, char *outbuf, int flags)
+{
+    if (flags & STF_RAW) {
+	sprintf(outbuf, "%ld", (unsigned long)tim);
+	if (flags & STF_STRING)
+	    strcat(outbuf, " (");
+    }
+    if (flags & STF_STRING) {
+	char *oend = outbuf + strlen(outbuf);
+	ztrftime(oend, 40, timefmt, (flags & STF_GMT) ? gmtime(&tim) :
+		 localtime(&tim));
+	if (flags & STF_RAW)
+	    strcat(outbuf, ")");
+    }
+}
+
+
+/**/
+static void
+statulprint(unsigned long num, char *outbuf)
+{
+    sprintf(outbuf, "%lu", num);
+}
+
+
+/**/
+static void
+statlinkprint(struct stat *sbuf, char *outbuf, char *fname)
+{
+    int num;
+
+    /* fname is NULL if we are looking at an fd */
+    if (fname && S_ISLNK(sbuf->st_mode) &&
+ 	(num = readlink(fname, outbuf, PATH_MAX)) > 0) {
+	/* readlink doesn't terminate the buffer itself */
+	outbuf[num] = '\0';
+    }
+}
+
+
+/**/
+static void
+statprint(struct stat *sbuf, char *outbuf, char *fname, int iwhich, int flags)
+{
+    char *optr = outbuf;
+
+    if (flags & STF_NAME) {
+	sprintf(outbuf, (flags & (STF_PICK|STF_ARRAY)) ?
+		"%s " : "%-8s", statelts[iwhich]);
+	optr += strlen(outbuf);
+    }
+    *optr = '\0';
+
+    /* cast values to unsigned long as safest bet */
+    switch (iwhich) {
+    case ST_DEV:
+	statulprint((unsigned long)sbuf->st_dev, optr);
+	break;
+
+    case ST_INO:
+	statulprint((unsigned long)sbuf->st_ino, optr);
+	break;
+
+    case ST_MODE:
+	statmodeprint(sbuf->st_mode, optr, flags);
+	break;
+
+    case ST_NLINK:
+	statulprint((unsigned long)sbuf->st_nlink, optr);
+	break;
+
+    case ST_UID:
+	statuidprint(sbuf->st_uid, optr, flags);
+	break;
+
+    case ST_GID:
+	statgidprint(sbuf->st_gid, optr, flags);
+	break;
+
+    case ST_RDEV:
+	statulprint((unsigned long)sbuf->st_rdev, optr);
+	break;
+
+    case ST_SIZE:
+	statulprint((unsigned long)sbuf->st_size, optr);
+	break;
+
+    case ST_ATIM:
+	stattimeprint(sbuf->st_atime, optr, flags);
+	break;
+
+    case ST_MTIM:
+	stattimeprint(sbuf->st_mtime, optr, flags);
+	break;
+
+    case ST_CTIM:
+	stattimeprint(sbuf->st_ctime, optr, flags);
+	break;
+
+    case ST_BLKSIZE:
+	statulprint((unsigned long)sbuf->st_blksize, optr);
+	break;
+
+    case ST_BLOCKS:
+	statulprint((unsigned long)sbuf->st_blocks, optr);
+	break;
+
+    case ST_READLINK:
+	statlinkprint(sbuf, optr, fname);
+	break;
+
+    case ST_COUNT:			/* keep some compilers happy */
+	break;
+    }
+}
+
+
+/*
+ *
+ * Options:
+ *  -f fd:   stat fd instead of file
+ *  -g:   use GMT rather than local time for time strings (forces -s on).
+ *  -n:   always print file name of file being statted
+ *  -N:   never print file name
+ *  -l:   list stat types
+ *  -L:   do lstat (else links are implicitly dereferenced by stat)
+ *  -t:   always print name of stat type
+ *  -T:   never print name of stat type
+ *  -r:   print raw alongside string data
+ *  -s:   string, print mode, times, uid, gid as appropriate strings:
+ *        harmless but unnecessary when combined with -r.
+ *  -A array:  assign results to given array, one stat result per element.
+ *        File names and type names are only added if explicitly requested:
+ *        file names are returned as a separate array element, type names as
+ *        prefix to element.  Note the formatting deliberately contains
+ *        fewer frills when -A is used.
+ *  -F fmt: specify a $TIME-like format for printing times; the default
+ *        is the (CTIME-like) "%a %b %e %k:%M:%S".  This option implies
+ *        -s as it is not useful for numerical times.
+ *
+ *  +type selects just element type of stat buffer (-l gives list):
+ *        type can be shortened to unambiguous string.  only one type is
+ *        allowed.  The extra type, +link, reads the target of a symbolic
+ *        link; it is empty if the stat was not an lstat or if 
+ *        a file descriptor was stat'd, if the stat'd file is
+ *        not a symbolic link, or if symbolic links are not
+ *        supported.  If +link is explicitly requested, the -L (lstat)
+ *        option is set automatically.
+ */
+/**/
+static int
+bin_stat(char *name, char **args, char *ops, int func)
+{
+    char **aptr, *arrnam = NULL, **array = NULL, **arrptr = NULL;
+    int len, iwhich = -1, ret = 0, flags = 0, arrsize = 0, fd = 0;
+    struct stat statbuf;
+    int found = 0, nargs;
+
+    timefmt = "%a %b %e %k:%M:%S";
+
+    for (; *args && (**args == '+' || **args == '-'); args++) {
+	char *arg = *args+1;
+	if (!*arg || *arg == '-' || *arg == '+') {
+	    args++;
+	    break;
+	}
+
+	if (**args == '+') {
+	    if (found)
+		break;
+	    len = strlen(arg);
+	    for (aptr = statelts; *aptr; aptr++)
+		if (!strncmp(*aptr, arg, len)) {
+		    found++;
+		    iwhich = aptr - statelts;
+		}
+	    if (found > 1) {
+		zerrnam(name, "%s: ambiguous stat element", arg, 0);
+		return 1;
+	    } else if (found == 0) {
+		zerrnam(name, "%s: no such stat element", arg, 0);
+		return 1;
+	    }
+	    /* if name of link requested, turn on lstat */
+	    if (iwhich == ST_READLINK)
+		ops['L'] = 1;
+	    flags |= STF_PICK;
+	} else {
+	    for (; *arg; arg++) {
+		if (strchr("glLnNrstT", *arg))
+		    ops[*arg] = 1;
+		else if (*arg == 'A') {
+		    if (arg[1]) {
+			arrnam = arg+1;
+		    } else if (!(arrnam = *++args)) {
+			zerrnam(name, "missing parameter name\n",
+				NULL, 0);
+			return 1;
+		    }
+		    flags |= STF_ARRAY;
+		    break;
+		} else if (*arg == 'f') {
+		    char *sfd;
+		    ops['f'] = 1;
+		    if (arg[1]) {
+			sfd = arg+1;
+		    } else if (!(sfd = *++args)) {
+			zerrnam(name, "missing file descriptor\n", NULL, 0);
+			return 1;
+		    }
+		    fd = zstrtol(sfd, &sfd, 10);
+		    if (*sfd) {
+			zerrnam(name, "bad file descriptor\n", NULL, 0);
+			return 1;
+		    }
+		    break;
+		} else if (*arg == 'F') {
+		    if (arg[1]) {
+			timefmt = arg+1;
+		    } else if (!(timefmt = *++args)) {
+			zerrnam(name, "missing time format\n", NULL, 0);
+			return 1;
+		    }
+		    /* force string format in order to use time format */
+		    ops['s'] = 1;
+		    break;
+		} else {
+		    zerrnam(name, "bad option: -%c", NULL, *arg);
+		    return 1;
+		}
+	    }
+	}
+    }
+
+    if (ops['l']) {
+	/* list types and return:  can also list to array */
+	if (arrnam) {
+	    arrptr = array = (char **)zalloc((ST_COUNT+1)*sizeof(char *));
+	    array[ST_COUNT] = NULL;
+	}
+	for (aptr = statelts; *aptr; aptr++) {
+	    if (arrnam) {
+		*arrptr++ = ztrdup(*aptr);
+	    } else {
+		printf("%s", *aptr);
+		if (aptr[1])
+		    putchar(' ');
+	    }
+	}
+	if (arrnam) {
+	    setaparam(arrnam, array);
+	    if (errflag)
+		return 1;
+	} else
+	    putchar('\n');
+	return 0;
+    }
+
+    if (!*args && !ops['f']) {
+	zwarnnam(name, "no files given", NULL, 0);
+	return 1;
+    } else if (*args && ops['f']) {
+	zwarnnam(name, "no files allowed with -f", NULL, 0);
+	return 1;
+    }
+
+    nargs = 0;
+    if (ops['f'])
+	nargs = 1;
+    else
+	for (aptr = args; *aptr; aptr++)
+	    nargs++;
+
+    if (ops['s'] || ops['r'])
+	flags |= STF_STRING;
+    if (ops['r'] || !ops['s'])
+	flags |= STF_RAW;
+    if (ops['n'])
+	flags |= STF_FILE;
+    if (ops['t'])
+	flags |= STF_NAME;
+    if (ops['g'])
+	flags |= STF_GMT;
+
+    if (!arrnam) {
+	if (nargs > 1)
+	    flags |= STF_FILE;
+	if (!(flags & STF_PICK))
+	    flags |= STF_NAME;
+    }
+
+    if (ops['N'] || ops['f'])
+	flags &= ~STF_FILE;
+    if (ops['T'])
+	flags &= ~STF_NAME;
+
+    if (arrnam) {
+	arrsize = (flags & STF_PICK) ? 1 : ST_COUNT;
+	if (flags & STF_FILE)
+	    arrsize++;
+	arrsize *= nargs;
+	arrptr = array = (char **)zcalloc((arrsize+1)*sizeof(char *));
+    }
+
+    for (; ops['f'] || *args; args++) {
+	char outbuf[PATH_MAX + 9]; /* "link   " + link name + NULL */
+	int rval = ops['f'] ? fstat(fd, &statbuf) :
+	    ops['L'] ? lstat(*args, &statbuf) : stat(*args, &statbuf);
+	if (rval) {
+	    if (ops['f'])
+		sprintf(outbuf, "%d", fd);
+	    zwarnnam(name, "%s: %e", ops['f'] ? outbuf : *args, errno);
+	    ret = 1;
+	    if (ops['f'] || arrnam)
+		break;
+	    else
+		continue;
+	}
+
+	if (flags & STF_FILE)
+	    if (arrnam)
+		*arrptr++ = ztrdup(*args);
+	    else
+		printf("%s%s", *args, (flags & STF_PICK) ? " " : ":\n");
+	if (iwhich > -1) {
+	    statprint(&statbuf, outbuf, *args, iwhich, flags);
+	    if (arrnam)
+		*arrptr++ = ztrdup(outbuf);
+	    else
+		printf("%s\n", outbuf);
+	} else {
+	    int i;
+	    for (i = 0; i < ST_COUNT; i++) {
+		statprint(&statbuf, outbuf, *args, i, flags);
+		if (arrnam)
+		    *arrptr++= ztrdup(outbuf);
+		else
+		    printf("%s\n", outbuf);
+	    }
+	}
+	if (ops['f'])
+	    break;
+
+	if (!arrnam && args[1] && !(flags & STF_PICK))
+	    putchar('\n');
+    }
+
+    if (arrnam)
+	if (ret) {
+	    for (aptr = array; *aptr; aptr++)
+		zsfree(*aptr);
+	    zfree(array, arrsize+1);
+	} else {
+	    setaparam(arrnam, array);
+	    if (errflag)
+		return 1;
+	}
+
+    return ret;
+}
+
+static struct builtin bintab[] = {
+    BUILTIN("stat", 0, bin_stat, 0, -1, 0, NULL, NULL),
+};
+
+/**/
+int
+boot_stat(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_stat(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+
+#endif
diff --git a/Src/Modules/stat.mdd b/Src/Modules/stat.mdd
new file mode 100644
index 000000000..b775fda09
--- /dev/null
+++ b/Src/Modules/stat.mdd
@@ -0,0 +1,3 @@
+autobins="stat"
+
+objects="stat.o"
diff --git a/Src/Zle/.cvsignore b/Src/Zle/.cvsignore
new file mode 100644
index 000000000..b10adcc3b
--- /dev/null
+++ b/Src/Zle/.cvsignore
@@ -0,0 +1,14 @@
+Makefile
+Makefile.in
+*.pro
+*.o
+*.o.c
+*.so
+*.mdh
+*.mdhi
+*.mdhs
+*.mdh.tmp
+thingies.list
+widgets.list
+zle_things.h
+zle_widget.h
diff --git a/Src/Zle/.distfiles b/Src/Zle/.distfiles
new file mode 100644
index 000000000..42c62efe9
--- /dev/null
+++ b/Src/Zle/.distfiles
@@ -0,0 +1,10 @@
+DISTFILES_SRC='
+    .cvsignore .distfiles .exrc
+    comp1.mdd comp.h comp1.c
+    compctl.mdd compctl.c
+    deltochar.mdd deltochar.c
+    zle.mdd iwidgets.list zle.h zle_bindings.c zle_hist.c
+    zle_keymap.c zle_main.c zle_misc.c zle_move.c zle_params.c
+    zle_refresh.c zle_things.sed zle_thingy.c zle_tricky.c
+    zle_utils.c zle_vi.c zle_widget.sed zle_word.c
+'
diff --git a/Src/Zle/.exrc b/Src/Zle/.exrc
new file mode 100644
index 000000000..91d0b39ef
--- /dev/null
+++ b/Src/Zle/.exrc
@@ -0,0 +1,2 @@
+set ai
+set sw=4
diff --git a/Src/Zle/comp.h b/Src/Zle/comp.h
new file mode 100644
index 000000000..5d7ef74e2
--- /dev/null
+++ b/Src/Zle/comp.h
@@ -0,0 +1,137 @@
+/*
+ * comp.h - header file for completion
+ *
+ * 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.
+ *
+ */
+
+#undef compctlread
+
+typedef struct compctlp  *Compctlp;
+typedef struct compctl   *Compctl;
+typedef struct compcond  *Compcond;
+
+/* node for compctl hash table (compctltab) */
+
+struct compctlp {
+    HashNode next;		/* next in hash chain               */
+    char *nam;			/* command name                     */
+    int flags;			/* CURRENTLY UNUSED                 */
+    Compctl cc;			/* pointer to the compctl desc.     */
+};
+
+/* compctl -x condition */
+
+struct compcond {
+    Compcond and, or;		/* the next or'ed/and'ed conditions    */
+    int type;			/* the type (CCT_*)                    */
+    int n;			/* the array length                    */
+    union {			/* these structs hold the data used to */
+	struct {		/* test this condition                 */
+	    int *a, *b;		/* CCT_POS, CCT_NUMWORDS               */
+	}
+	r;
+	struct {		/* CCT_CURSTR, CCT_CURPAT,... */
+	    int *p;
+	    char **s;
+	}
+	s;
+	struct {		/* CCT_RANGESTR,... */
+	    char **a, **b;
+	}
+	l;
+    }
+    u;
+};
+
+#define CCT_UNUSED     0
+#define CCT_POS        1
+#define CCT_CURSTR     2
+#define CCT_CURPAT     3
+#define CCT_WORDSTR    4
+#define CCT_WORDPAT    5
+#define CCT_CURSUF     6
+#define CCT_CURPRE     7
+#define CCT_CURSUB     8
+#define CCT_CURSUBC    9
+#define CCT_NUMWORDS  10
+#define CCT_RANGESTR  11
+#define CCT_RANGEPAT  12
+
+/* Contains the real description for compctls */
+
+struct compctl {
+    int refc;			/* reference count                         */
+    Compctl next;		/* next compctl for -x                     */
+    unsigned long mask;		/* mask of things to complete (CC_*)       */
+    char *keyvar;		/* for -k (variable)                       */
+    char *glob;			/* for -g (globbing)                       */
+    char *str;			/* for -s (expansion)                      */
+    char *func;			/* for -K (function)                       */
+    char *explain;		/* for -X (explanation)                    */
+    char *ylist;		/* for -y (user-defined desc. for listing) */
+    char *prefix, *suffix;	/* for -P and -S (prefix, suffix)          */
+    char *subcmd;		/* for -l (command name to use)            */
+    char *withd;		/* for -w (with directory                  */
+    char *hpat;			/* for -H (history pattern)                */
+    int hnum;			/* for -H (number of events to search)     */
+    Compctl ext;		/* for -x (first of the compctls after -x) */
+    Compcond cond;		/* for -x (condition for this compctl)     */
+    Compctl xor;		/* for + (next of the xor'ed compctls)     */
+};
+
+/* objects to complete */
+#define CC_FILES	(1<<0)
+#define CC_COMMPATH	(1<<1)
+#define CC_REMOVE	(1<<2)
+#define CC_OPTIONS	(1<<3)
+#define CC_VARS		(1<<4)
+#define CC_BINDINGS	(1<<5)
+#define CC_ARRAYS	(1<<6)
+#define CC_INTVARS	(1<<7)
+#define CC_SHFUNCS	(1<<8)
+#define CC_PARAMS	(1<<9)
+#define CC_ENVVARS	(1<<10)
+#define CC_JOBS		(1<<11)
+#define CC_RUNNING	(1<<12)
+#define CC_STOPPED	(1<<13)
+#define CC_BUILTINS	(1<<14)
+#define CC_ALREG	(1<<15)
+#define CC_ALGLOB	(1<<16)
+#define CC_USERS	(1<<17)
+#define CC_DISCMDS	(1<<18)
+#define CC_EXCMDS	(1<<19)
+#define CC_SCALARS	(1<<20)
+#define CC_READONLYS	(1<<21)
+#define CC_SPECIALS	(1<<22)
+#define CC_DELETE	(1<<23)
+#define CC_NAMED	(1<<24)
+#define CC_QUOTEFLAG	(1<<25)
+#define CC_EXTCMDS	(1<<26)
+#define CC_RESWDS	(1<<27)
+#define CC_DIRS		(1<<28)
+
+#define CC_EXPANDEXPL	(1<<30)
+#define CC_RESERVED	(1<<31)
diff --git a/Src/Zle/comp1.c b/Src/Zle/comp1.c
new file mode 100644
index 000000000..acd1288a6
--- /dev/null
+++ b/Src/Zle/comp1.c
@@ -0,0 +1,291 @@
+/*
+ * comp1.c - base of the completion system
+ *
+ * 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 "comp1.mdh"
+
+#include "comp1.pro"
+
+/* default completion infos */
+ 
+/**/
+struct compctl cc_compos, cc_default, cc_first, cc_dummy;
+ 
+/* hash table for completion info for commands */
+ 
+/**/
+HashTable compctltab;
+
+/* Words on the command line, for use in completion */
+ 
+/**/
+int clwsize, clwnum, clwpos;
+/**/
+char **clwords;
+
+/* != 0 if in a shell function called from completion, such that read -[cl]  *
+ * will work (i.e., the line is metafied, and the above word arrays are OK). */
+
+/**/
+int incompctlfunc;
+
+/**/
+static void
+createcompctltable(void)
+{
+    compctltab = newhashtable(23, "compctltab", NULL);
+
+    compctltab->hash        = hasher;
+    compctltab->emptytable  = emptyhashtable;
+    compctltab->filltable   = NULL;
+    compctltab->addnode     = addhashnode;
+    compctltab->getnode     = gethashnode2;
+    compctltab->getnode2    = gethashnode2;
+    compctltab->removenode  = removehashnode;
+    compctltab->disablenode = NULL;
+    compctltab->enablenode  = NULL;
+    compctltab->freenode    = freecompctlp;
+    compctltab->printnode   = NULL;
+}
+
+/**/
+static void
+freecompctlp(HashNode hn)
+{
+    Compctlp ccp = (Compctlp) hn;
+
+    zsfree(ccp->nam);
+    freecompctl(ccp->cc);
+    zfree(ccp, sizeof(struct compctlp));
+}
+
+/**/
+void
+freecompctl(Compctl cc)
+{
+    if (cc == &cc_default ||
+ 	cc == &cc_first ||
+	cc == &cc_compos ||
+	--cc->refc > 0)
+	return;
+
+    zsfree(cc->keyvar);
+    zsfree(cc->glob);
+    zsfree(cc->str);
+    zsfree(cc->func);
+    zsfree(cc->explain);
+    zsfree(cc->ylist);
+    zsfree(cc->prefix);
+    zsfree(cc->suffix);
+    zsfree(cc->hpat);
+    zsfree(cc->subcmd);
+    if (cc->cond)
+	freecompcond(cc->cond);
+    if (cc->ext) {
+	Compctl n, m;
+
+	n = cc->ext;
+	do {
+	    m = (Compctl) (n->next);
+	    freecompctl(n);
+	    n = m;
+	}
+	while (n);
+    }
+    if (cc->xor && cc->xor != &cc_default)
+	freecompctl(cc->xor);
+    zfree(cc, sizeof(struct compctl));
+}
+
+/**/
+void
+freecompcond(void *a)
+{
+    Compcond cc = (Compcond) a;
+    Compcond and, or, c;
+    int n;
+
+    for (c = cc; c; c = or) {
+	or = c->or;
+	for (; c; c = and) {
+	    and = c->and;
+	    if (c->type == CCT_POS ||
+		c->type == CCT_NUMWORDS) {
+		free(c->u.r.a);
+		free(c->u.r.b);
+	    } else if (c->type == CCT_CURSUF ||
+		       c->type == CCT_CURPRE) {
+		for (n = 0; n < c->n; n++)
+		    if (c->u.s.s[n])
+			zsfree(c->u.s.s[n]);
+		free(c->u.s.s);
+	    } else if (c->type == CCT_RANGESTR ||
+		       c->type == CCT_RANGEPAT) {
+		for (n = 0; n < c->n; n++)
+		    if (c->u.l.a[n])
+			zsfree(c->u.l.a[n]);
+		free(c->u.l.a);
+		for (n = 0; n < c->n; n++)
+		    if (c->u.l.b[n])
+			zsfree(c->u.l.b[n]);
+		free(c->u.l.b);
+	    } else {
+		for (n = 0; n < c->n; n++)
+		    if (c->u.s.s[n])
+			zsfree(c->u.s.s[n]);
+		free(c->u.s.p);
+		free(c->u.s.s);
+	    }
+	    zfree(c, sizeof(struct compcond));
+	}
+    }
+}
+
+/**/
+int
+compctlread(char *name, char **args, char *ops, char *reply)
+{
+    char *buf, *bptr;
+
+    /* only allowed to be called for completion */
+    if (!incompctlfunc) {
+	zwarnnam(name, "option valid only in functions called for completion",
+		NULL, 0);
+	return 1;
+    }
+
+    if (ops['l']) {
+	/* -ln gives the index of the word the cursor is currently on, which is
+	available in cs (but remember that Zsh counts from one, not zero!) */
+	if (ops['n']) {
+	    char nbuf[14];
+
+	    if (ops['e'] || ops['E'])
+		printf("%d\n", cs + 1);
+	    if (!ops['e']) {
+		sprintf(nbuf, "%d", cs + 1);
+		setsparam(reply, ztrdup(nbuf));
+	    }
+	    return 0;
+	}
+	/* without -n, the current line is assigned to the given parameter as a
+	scalar */
+	if (ops['e'] || ops['E']) {
+	    zputs((char *) line, stdout);
+	    putchar('\n');
+	}
+	if (!ops['e'])
+	    setsparam(reply, ztrdup((char *) line));
+    } else {
+	int i;
+
+	/* -cn gives the current cursor position within the current word, which
+	is available in clwpos (but remember that Zsh counts from one, not
+	zero!) */
+	if (ops['n']) {
+	    char nbuf[14];
+
+	    if (ops['e'] || ops['E'])
+		printf("%d\n", clwpos + 1);
+	    if (!ops['e']) {
+		sprintf(nbuf, "%d", clwpos + 1);
+		setsparam(reply, ztrdup(nbuf));
+	    }
+	    return 0;
+	}
+	/* without -n, the words of the current line are assigned to the given
+	parameters separately */
+	if (ops['A'] && !ops['e']) {
+	    /* the -A option means that one array is specified, instead of
+	    many parameters */
+	    char **p, **b = (char **)zcalloc((clwnum + 1) * sizeof(char *));
+
+	    for (i = 0, p = b; i < clwnum; p++, i++)
+		*p = ztrdup(clwords[i]);
+
+	    setaparam(reply, b);
+	    return 0;
+	}
+	if (ops['e'] || ops['E']) {
+	    for (i = 0; i < clwnum; i++) {
+		zputs(clwords[i], stdout);
+		putchar('\n');
+	    }
+
+	    if (ops['e'])
+		return 0;
+	}
+
+	for (i = 0; i < clwnum && *args; reply = *args++, i++)
+	    setsparam(reply, ztrdup(clwords[i]));
+
+	if (i < clwnum) {
+	    int j, len;
+
+	    for (j = i, len = 0; j < clwnum; len += strlen(clwords[j++]));
+	    bptr = buf = zalloc(len + j - i);
+	    while (i < clwnum) {
+		strucpy(&bptr, clwords[i++]);
+		*bptr++ = ' ';
+	    }
+	    bptr[-1] = '\0';
+	} else
+	    buf = ztrdup("");
+	setsparam(reply, buf);
+    }
+    return 0;
+}
+
+/**/
+int
+boot_comp1(Module m)
+{
+    compctlreadptr = compctlread;
+    clwords = (char **) zcalloc((clwsize = 16) * sizeof(char *));
+    createcompctltable();
+    cc_compos.mask = CC_COMMPATH;
+    cc_default.refc = 10000;
+    cc_default.mask = CC_FILES;
+    cc_first.refc = 10000;
+    cc_first.mask = 0;
+    return 0;
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_comp1(Module m)
+{
+    deletehashtable(compctltab);
+    zfree(clwords, clwsize * sizeof(char *));
+    compctlreadptr = fallback_compctlread;
+    return 0;
+}
+
+#endif /* MODULE */
diff --git a/Src/Zle/comp1.mdd b/Src/Zle/comp1.mdd
new file mode 100644
index 000000000..9037e568a
--- /dev/null
+++ b/Src/Zle/comp1.mdd
@@ -0,0 +1,3 @@
+objects="comp1.o"
+
+headers="comp.h"
diff --git a/Src/Zle/compctl.c b/Src/Zle/compctl.c
new file mode 100644
index 000000000..658cf4161
--- /dev/null
+++ b/Src/Zle/compctl.c
@@ -0,0 +1,1085 @@
+/*
+ * compctl.c - the compctl builtin
+ *
+ * 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 "compctl.mdh"
+#include "compctl.pro"
+
+#define COMP_LIST	(1<<0)	/* -L */
+#define COMP_COMMAND	(1<<1)	/* -C */
+#define COMP_DEFAULT	(1<<2)	/* -D */
+#define COMP_FIRST	(1<<3)	/* -T */
+#define COMP_REMOVE	(1<<4)
+
+#define COMP_SPECIAL (COMP_COMMAND|COMP_DEFAULT|COMP_FIRST)
+
+/* Flag for listing, command, default, or first completion */
+static int cclist;
+
+/* Mask for determining what to print */
+static unsigned long showmask = 0;
+
+/* Parse the basic flags for `compctl' */
+
+/**/
+static int
+get_compctl(char *name, char ***av, Compctl cc, int first, int isdef)
+{
+    /* Parse the basic flags for completion:
+     * first is a flag that we are not in extended completion,
+     * while hx indicates or (+) completion (need to know for
+     * default and command completion as the initial compctl is special). 
+     * cct is a temporary just to hold flags; it never needs freeing.
+     */
+    struct compctl cct;
+    char **argv = *av;
+    int ready = 0, hx = 0;
+
+    /* Handle `compctl + foo ...' specially:  turn it into
+     * a default compctl by removing it from the hash table.
+     */
+    if (first && argv[0][0] == '+' && !argv[0][1] &&
+	!(argv[1] && argv[1][0] == '-' && argv[1][1])) {
+	argv++;
+	if(argv[0] && argv[0][0] == '-')
+	    argv++;
+	*av = argv;
+	freecompctl(cc);
+ 	cclist = COMP_REMOVE;
+	return 0;
+    }
+
+    memset((void *)&cct, 0, sizeof(cct));
+
+    /* Loop through the flags until we have no more:        *
+     * those with arguments are not properly allocated yet, *
+     * we just hang on to the argument that was passed.     */
+    for (; !ready && argv[0] && argv[0][0] == '-' && (argv[0][1] || !first);) {
+	if (!argv[0][1])
+	    *argv = "-+";
+	while (!ready && *++(*argv)) {
+	    if(**argv == Meta)
+		*++*argv ^= 32;
+	    switch (**argv) {
+	    case 'f':
+		cct.mask |= CC_FILES;
+		break;
+	    case 'c':
+		cct.mask |= CC_COMMPATH;
+		break;
+	    case 'm':
+		cct.mask |= CC_EXTCMDS;
+		break;
+	    case 'w':
+		cct.mask |= CC_RESWDS;
+		break;
+	    case 'o':
+		cct.mask |= CC_OPTIONS;
+		break;
+	    case 'v':
+		cct.mask |= CC_VARS;
+		break;
+	    case 'b':
+		cct.mask |= CC_BINDINGS;
+		break;
+	    case 'A':
+		cct.mask |= CC_ARRAYS;
+		break;
+	    case 'I':
+		cct.mask |= CC_INTVARS;
+		break;
+	    case 'F':
+		cct.mask |= CC_SHFUNCS;
+		break;
+	    case 'p':
+		cct.mask |= CC_PARAMS;
+		break;
+	    case 'E':
+		cct.mask |= CC_ENVVARS;
+		break;
+	    case 'j':
+		cct.mask |= CC_JOBS;
+		break;
+	    case 'r':
+		cct.mask |= CC_RUNNING;
+		break;
+	    case 'z':
+		cct.mask |= CC_STOPPED;
+		break;
+	    case 'B':
+		cct.mask |= CC_BUILTINS;
+		break;
+	    case 'a':
+		cct.mask |= CC_ALREG | CC_ALGLOB;
+		break;
+	    case 'R':
+		cct.mask |= CC_ALREG;
+		break;
+	    case 'G':
+		cct.mask |= CC_ALGLOB;
+		break;
+	    case 'u':
+		cct.mask |= CC_USERS;
+		break;
+	    case 'd':
+		cct.mask |= CC_DISCMDS;
+		break;
+	    case 'e':
+		cct.mask |= CC_EXCMDS;
+		break;
+	    case 'N':
+		cct.mask |= CC_SCALARS;
+		break;
+	    case 'O':
+		cct.mask |= CC_READONLYS;
+		break;
+	    case 'Z':
+		cct.mask |= CC_SPECIALS;
+		break;
+	    case 'q':
+		cct.mask |= CC_REMOVE;
+		break;
+	    case 'U':
+		cct.mask |= CC_DELETE;
+		break;
+	    case 'n':
+		cct.mask |= CC_NAMED;
+		break;
+	    case 'Q':
+		cct.mask |= CC_QUOTEFLAG;
+		break;
+	    case '/':
+		cct.mask |= CC_DIRS;
+		break;
+	    case 'k':
+		if ((*argv)[1]) {
+		    cct.keyvar = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "variable name expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.keyvar = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'K':
+		if ((*argv)[1]) {
+		    cct.func = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "function name expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.func = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'Y':
+		cct.mask |= CC_EXPANDEXPL;
+		goto expl;
+	    case 'X':
+		cct.mask &= ~CC_EXPANDEXPL;
+	    expl:
+		if ((*argv)[1]) {
+		    cct.explain = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "string expected after -%c", NULL, **argv);
+		    return 1;
+		} else {
+		    cct.explain = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'y':
+		if ((*argv)[1]) {
+		    cct.ylist = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "function/variable expected after -%c",
+			     NULL, **argv);
+		} else {
+		    cct.ylist = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'P':
+		if ((*argv)[1]) {
+		    cct.prefix = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "string expected after -%c", NULL, **argv);
+		    return 1;
+		} else {
+		    cct.prefix = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'S':
+		if ((*argv)[1]) {
+		    cct.suffix = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "string expected after -%c", NULL, **argv);
+		    return 1;
+		} else {
+		    cct.suffix = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'g':
+		if ((*argv)[1]) {
+		    cct.glob = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "glob pattern expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.glob = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 's':
+		if ((*argv)[1]) {
+		    cct.str = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "command string expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.str = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'l':
+		if ((*argv)[1]) {
+		    cct.subcmd = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "command name expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.subcmd = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'W':
+		if ((*argv)[1]) {
+		    cct.withd = (*argv) + 1;
+		    *argv = "" - 1;
+		} else if (!argv[1]) {
+		    zwarnnam(name, "path expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		} else {
+		    cct.withd = *++argv;
+		    *argv = "" - 1;
+		}
+		break;
+	    case 'H':
+		if ((*argv)[1])
+		    cct.hnum = atoi((*argv) + 1);
+		else if (argv[1])
+		    cct.hnum = atoi(*++argv);
+		else {
+		    zwarnnam(name, "number expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		}
+		if (!argv[1]) {
+		    zwarnnam(name, "missing pattern after -%c", NULL,
+			    **argv);
+		    return 1;
+		}
+		cct.hpat = *++argv;
+		if (cct.hnum < 1)
+		    cct.hnum = 0;
+		if (*cct.hpat == '*' && !cct.hpat[1])
+		    cct.hpat = "";
+		*argv = "" - 1;
+		break;
+	    case 'C':
+		if (first && !hx) {
+		    cclist |= COMP_COMMAND;
+		} else {
+		    zwarnnam(name, "misplaced command completion (-C) flag",
+			    NULL, 0);
+		    return 1;
+		}
+		break;
+	    case 'D':
+		if (first && !hx) {
+		    isdef = 1;
+		    cclist |= COMP_DEFAULT;
+		} else {
+		    zwarnnam(name, "misplaced default completion (-D) flag",
+			    NULL, 0);
+		    return 1;
+		}
+		break;
+ 	    case 'T':
+              if (first && !hx) {
+ 		    cclist |= COMP_FIRST;
+ 		} else {
+ 		    zwarnnam(name, "misplaced first completion (-T) flag",
+ 			    NULL, 0);
+ 		    return 1;
+ 		}
+ 		break;
+	    case 'L':
+		if (!first || hx) {
+		    zwarnnam(name, "illegal use of -L flag", NULL, 0);
+		    return 1;
+		}
+		cclist |= COMP_LIST;
+		break;
+	    case 'x':
+		if (!argv[1]) {
+		    zwarnnam(name, "condition expected after -%c", NULL,
+			    **argv);
+		    return 1;
+		}
+		if (first) {
+		    argv++;
+		    if (get_xcompctl(name, &argv, &cct, isdef)) {
+			if (cct.ext)
+			    freecompctl(cct.ext);
+			return 1;
+		    }
+		    ready = 2;
+		} else {
+		    zwarnnam(name, "recursive extended completion not allowed",
+			    NULL, 0);
+		    return 1;
+		}
+		break;
+	    default:
+		if (!first && (**argv == '-' || **argv == '+'))
+		    (*argv)--, argv--, ready = 1;
+		else {
+		    zwarnnam(name, "bad option: -%c", NULL, **argv);
+		    return 1;
+		}
+	    }
+	}
+
+	if (*++argv && (!ready || ready == 2) &&
+	    **argv == '+' && !argv[0][1]) {
+	    /* There's an alternative (+) completion:  assign
+	     * what we have so far before moving on to that.
+	     */
+	    if (cc_assign(name, &cc, &cct, first && !hx))
+		return 1;
+
+	    hx = 1;
+	    ready = 0;
+
+	    if (!*++argv || **argv != '-' ||
+		(**argv == '-' && (!argv[0][1] ||
+				   (argv[0][1] == '-' && !argv[0][2])))) {
+		/* No argument to +, which means do default completion */
+		if (isdef)
+		    zwarnnam(name,
+			    "recursive xor'd default completions not allowed",
+			    NULL, 0);
+		else
+		    cc->xor = &cc_default;
+	    } else {
+		/* more flags follow:  prepare to loop again */
+		cc->xor = (Compctl) zcalloc(sizeof(*cc));
+		cc = cc->xor;
+		memset((void *)&cct, 0, sizeof(cct));
+	    }
+	}
+    }
+    if (!ready && *argv && **argv == '-')
+	argv++;
+
+    if (! (cct.mask & (CC_EXCMDS | CC_DISCMDS)))
+	cct.mask |= CC_EXCMDS;
+
+    /* assign the last set of flags we parsed */
+    if (cc_assign(name, &cc, &cct, first && !hx))
+	return 1;
+
+    *av = argv;
+
+    return 0;
+}
+
+/* Handle the -x ... -- part of compctl. */
+
+/**/
+static int
+get_xcompctl(char *name, char ***av, Compctl cc, int isdef)
+{
+    char **argv = *av, *t, *tt, sav;
+    int n, l = 0, ready = 0;
+    Compcond m, c, o;
+    Compctl *next = &(cc->ext);
+
+    while (!ready) {
+	/* o keeps track of or's, m remembers the starting condition,
+	 * c is the current condition being parsed
+	 */
+	o = m = c = (Compcond) zcalloc(sizeof(*c));
+	/* Loop over each condition:  something like 's[...][...], p[...]' */
+	for (t = *argv; *t;) {
+	    while (*t == ' ')
+		t++;
+	    /* First get the condition code */
+	    switch (*t) {
+	    case 's':
+		c->type = CCT_CURSUF;
+		break;
+	    case 'S':
+		c->type = CCT_CURPRE;
+		break;
+	    case 'p':
+		c->type = CCT_POS;
+		break;
+	    case 'c':
+		c->type = CCT_CURSTR;
+		break;
+	    case 'C':
+		c->type = CCT_CURPAT;
+		break;
+	    case 'w':
+		c->type = CCT_WORDSTR;
+		break;
+	    case 'W':
+		c->type = CCT_WORDPAT;
+		break;
+	    case 'n':
+		c->type = CCT_CURSUB;
+		break;
+	    case 'N':
+		c->type = CCT_CURSUBC;
+		break;
+	    case 'm':
+		c->type = CCT_NUMWORDS;
+		break;
+	    case 'r':
+		c->type = CCT_RANGESTR;
+		break;
+	    case 'R':
+		c->type = CCT_RANGEPAT;
+		break;
+	    default:
+		t[1] = '\0';
+		zwarnnam(name, "unknown condition code: %s", t, 0);
+		zfree(m, sizeof(struct compcond));
+
+		return 1;
+	    }
+	    /* Now get the arguments in square brackets */
+	    if (t[1] != '[') {
+		t[1] = '\0';
+		zwarnnam(name, "expected condition after condition code: %s", t, 0);
+		zfree(m, sizeof(struct compcond));
+
+		return 1;
+	    }
+	    t++;
+	    /* First count how many or'd arguments there are,
+	     * marking the active ]'s and ,'s with unprintable characters.
+	     */
+	    for (n = 0, tt = t; *tt == '['; n++) {
+		for (l = 1, tt++; *tt && l; tt++)
+		    if (*tt == '\\' && tt[1])
+			tt++;
+		    else if (*tt == '[')
+			l++;
+		    else if (*tt == ']')
+			l--;
+		    else if (l == 1 && *tt == ',')
+			*tt = '\201';
+		if (tt[-1] == ']')
+		    tt[-1] = '\200';
+	    }
+
+	    if (l) {
+		t[1] = '\0';
+		zwarnnam(name, "error after condition code: %s", t, 0);
+		zfree(m, sizeof(struct compcond));
+
+		return 1;
+	    }
+	    c->n = n;
+
+	    /* Allocate space for all the arguments of the conditions */
+	    if (c->type == CCT_POS ||
+		c->type == CCT_NUMWORDS) {
+		c->u.r.a = (int *)zcalloc(n * sizeof(int));
+		c->u.r.b = (int *)zcalloc(n * sizeof(int));
+	    } else if (c->type == CCT_CURSUF ||
+		       c->type == CCT_CURPRE)
+		c->u.s.s = (char **)zcalloc(n * sizeof(char *));
+
+	    else if (c->type == CCT_RANGESTR ||
+		     c->type == CCT_RANGEPAT) {
+		c->u.l.a = (char **)zcalloc(n * sizeof(char *));
+		c->u.l.b = (char **)zcalloc(n * sizeof(char *));
+	    } else {
+		c->u.s.p = (int *)zcalloc(n * sizeof(int));
+		c->u.s.s = (char **)zcalloc(n * sizeof(char *));
+	    }
+	    /* Now loop over the actual arguments */
+	    for (l = 0; *t == '['; l++, t++) {
+		for (t++; *t && *t == ' '; t++);
+		tt = t;
+		if (c->type == CCT_POS ||
+		    c->type == CCT_NUMWORDS) {
+		    /* p[...] or m[...]:  one or two numbers expected */
+		    for (; *t && *t != '\201' && *t != '\200'; t++);
+		    if (!(sav = *t)) {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.r.a[l] = atoi(tt);
+		    /* Second argument is optional:  see if it's there */
+		    if (sav == '\200')
+			/* no:  copy first argument */
+			c->u.r.b[l] = c->u.r.a[l];
+		    else {
+			tt = ++t;
+			for (; *t && *t != '\200'; t++);
+			if (!*t) {
+			    zwarnnam(name, "error in condition", NULL, 0);
+			    freecompcond(m);
+			    return 1;
+			}
+			*t = '\0';
+			c->u.r.b[l] = atoi(tt);
+		    }
+		} else if (c->type == CCT_CURSUF ||
+			   c->type == CCT_CURPRE) {
+		    /* -s[..] or -S[..]:  single string expected */
+		    for (; *t && *t != '\200'; t++)
+			if (*t == '\201')
+			    *t = ',';
+		    if (!*t) {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.s.s[l] = ztrdup(tt);
+		} else if (c->type == CCT_RANGESTR ||
+			   c->type == CCT_RANGEPAT) {
+		    /* -r[..,..] or -R[..,..]:  two strings expected */
+		    for (; *t && *t != '\201'; t++);
+		    if (!*t) {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.l.a[l] = ztrdup(tt);
+		    tt = ++t;
+		    /* any more commas are text, not active */
+		    for (; *t && *t != '\200'; t++)
+			if (*t == '\201')
+			    *t = ',';
+		    if (!*t) {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.l.b[l] = ztrdup(tt);
+		} else {
+		    /* remaining patterns are number followed by string */
+		    for (; *t && *t != '\200' && *t != '\201'; t++);
+		    if (!*t || *t == '\200') {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.s.p[l] = atoi(tt);
+		    tt = ++t;
+		    for (; *t && *t != '\200'; t++)
+			if (*t == '\201')
+			    *t = ',';
+		    if (!*t) {
+			zwarnnam(name, "error in condition", NULL, 0);
+			freecompcond(m);
+			return 1;
+		    }
+		    *t = '\0';
+		    c->u.s.s[l] = ztrdup(tt);
+		}
+	    }
+	    while (*t == ' ')
+		t++;
+	    if (*t == ',') {
+		/* Another condition to `or' */
+		o->or = c = (Compcond) zcalloc(sizeof(*c));
+		o = c;
+		t++;
+	    } else if (*t) {
+		/* Another condition to `and' */
+		c->and = (Compcond) zcalloc(sizeof(*c));
+		c = c->and;
+	    }
+	}
+	/* Assign condition to current compctl */
+	*next = (Compctl) zcalloc(sizeof(*cc));
+	(*next)->cond = m;
+	argv++;
+	/* End of the condition; get the flags that go with it. */
+	if (get_compctl(name, &argv, *next, 0, isdef))
+	    return 1;
+ 	if ((!argv || !*argv) && (cclist & COMP_SPECIAL))
+ 	    /* default, first, or command completion finished */
+	    ready = 1;
+	else {
+	    /* see if we are looking for more conditions or are
+	     * ready to return (ready = 1)
+	     */
+	    if (!argv || !*argv || **argv != '-' ||
+		((!argv[0][1] || argv[0][1] == '+') && !argv[1])) {
+		zwarnnam(name, "missing command names", NULL, 0);
+		return 1;
+	    }
+	    if (!strcmp(*argv, "--"))
+		ready = 1;
+	    else if (!strcmp(*argv, "-+") && argv[1] &&
+		     !strcmp(argv[1], "--")) {
+		ready = 1;
+		argv++;
+	    }
+	    argv++;
+	    /* prepare to put the next lot of conditions on the end */
+	    next = &((*next)->next);
+	}
+    }
+    /* save position at end of parsing */
+    *av = argv - 1;
+    return 0;
+}
+
+/**/
+static int
+cc_assign(char *name, Compctl *ccptr, Compctl cct, int reass)
+{
+    /* Copy over the details from the values in cct to those in *ccptr */
+    Compctl cc;
+
+    if (cct->subcmd && (cct->keyvar || cct->glob || cct->str ||
+			cct->func || cct->explain || cct->ylist ||
+			cct->prefix)) {
+	zwarnnam(name, "illegal combination of options", NULL, 0);
+	return 1;
+    }
+
+    /* Handle assignment of new default or command completion */
+    if (reass && !(cclist & COMP_LIST)) {
+	/* if not listing */
+	if (cclist == (COMP_COMMAND|COMP_DEFAULT)
+	    || cclist == (COMP_COMMAND|COMP_FIRST)
+	    || cclist == (COMP_DEFAULT|COMP_FIRST)
+	    || cclist == COMP_SPECIAL) {
+ 	    zwarnnam(name, "can't set -D, -T, and -C simultaneously", NULL, 0);
+	    /* ... because the following code wouldn't work. */
+	    return 1;
+	}
+	if (cclist & COMP_COMMAND) {
+	    /* command */
+	    *ccptr = &cc_compos;
+	    cc_reassign(*ccptr);
+	} else if (cclist & COMP_DEFAULT) {
+	    /* default */
+	    *ccptr = &cc_default;
+	    cc_reassign(*ccptr);
+ 	} else if (cclist & COMP_FIRST) {
+ 	    /* first */
+ 	    *ccptr = &cc_first;
+ 	    cc_reassign(*ccptr);
+	}
+    }
+
+    /* Free the old compctl */
+    cc = *ccptr;
+    zsfree(cc->keyvar);
+    zsfree(cc->glob);
+    zsfree(cc->str);
+    zsfree(cc->func);
+    zsfree(cc->explain);
+    zsfree(cc->ylist);
+    zsfree(cc->prefix);
+    zsfree(cc->suffix);
+    zsfree(cc->subcmd);
+    zsfree(cc->withd);
+    zsfree(cc->hpat);
+    
+    /* and copy over the new stuff, (permanently) allocating
+     * space for strings.
+     */
+    cc->mask = cct->mask;
+    cc->keyvar = ztrdup(cct->keyvar);
+    cc->glob = ztrdup(cct->glob);
+    cc->str = ztrdup(cct->str);
+    cc->func = ztrdup(cct->func);
+    cc->explain = ztrdup(cct->explain);
+    cc->ylist = ztrdup(cct->ylist);
+    cc->prefix = ztrdup(cct->prefix);
+    cc->suffix = ztrdup(cct->suffix);
+    cc->subcmd = ztrdup(cct->subcmd);
+    cc->withd = ztrdup(cct->withd);
+    cc->hpat = ztrdup(cct->hpat);
+    cc->hnum = cct->hnum;
+
+    /* careful with extended completion:  it's already allocated */
+    cc->ext = cct->ext;
+
+    return 0;
+}
+
+/**/
+static void
+cc_reassign(Compctl cc)
+{
+    /* Free up a new default or command completion:
+     * this is a hack to free up the parts which should be deleted,
+     * without removing the basic variable which is statically allocated
+     */
+    Compctl c2;
+
+    c2 = (Compctl) zcalloc(sizeof *cc);
+    c2->xor = cc->xor;
+    c2->ext = cc->ext;
+    c2->refc = 1;
+
+    freecompctl(c2);
+
+    cc->ext = cc->xor = NULL;
+}
+
+/**/
+static void
+compctl_process_cc(char **s, Compctl cc)
+{
+    Compctlp ccp;
+
+    if (cclist & COMP_REMOVE) {
+	/* Delete entries for the commands listed */
+	for (; *s; s++) {
+	    if ((ccp = (Compctlp) compctltab->removenode(compctltab, *s)))
+		compctltab->freenode((HashNode) ccp);
+	}
+    } else {
+	/* Add the compctl just read to the hash table */
+
+	cc->refc = 0;
+	for (; *s; s++) {
+	    cc->refc++;
+	    ccp = (Compctlp) zalloc(sizeof *ccp);
+	    ccp->cc = cc;
+	    compctltab->addnode(compctltab, ztrdup(*s), ccp);
+	}
+    }
+}
+
+/* Print a `compctl' */
+
+/**/
+static void
+printcompctl(char *s, Compctl cc, int printflags)
+{
+    Compctl cc2;
+    char *css = "fcqovbAIFpEjrzBRGudeNOZUnQmw/";
+    char *mss = " pcCwWsSnNmrR";
+    unsigned long t = 0x7fffffff;
+    unsigned long flags = cc->mask;
+    unsigned long oldshowmask;
+
+    if ((flags & CC_EXCMDS) && !(flags & CC_DISCMDS))
+	flags &= ~CC_EXCMDS;
+
+    /* If showmask is non-zero, then print only those *
+     * commands with that flag set.                   */
+    if (showmask && !(flags & showmask))
+	return;
+
+    /* Temporarily clear showmask in case we make *
+     * recursive calls to printcompctl.           */
+    oldshowmask = showmask;
+    showmask = 0;
+
+    /* print either command name or start of compctl command itself */
+    if (s) {
+	if (cclist & COMP_LIST) {
+	    printf("compctl");
+	    if (cc == &cc_compos)
+		printf(" -C");
+	    if (cc == &cc_default)
+		printf(" -D");
+	    if (cc == &cc_first)
+		printf(" -T");
+	} else
+	    quotedzputs(s, stdout);
+    }
+
+    /* loop through flags w/o args that are set, printing them if so */
+    if (flags & t) {
+	printf(" -");
+	if ((flags & (CC_ALREG | CC_ALGLOB)) == (CC_ALREG | CC_ALGLOB))
+	    putchar('a'), flags &= ~(CC_ALREG | CC_ALGLOB);
+	while (*css) {
+	    if (flags & t & 1)
+		putchar(*css);
+	    css++;
+	    flags >>= 1;
+	    t >>= 1;
+	}
+    }
+
+    /* now flags with arguments */
+    flags = cc->mask;
+    printif(cc->keyvar, 'k');
+    printif(cc->func, 'K');
+    printif(cc->explain, (cc->mask & CC_EXPANDEXPL) ? 'Y' : 'X');
+    printif(cc->ylist, 'y');
+    printif(cc->prefix, 'P');
+    printif(cc->suffix, 'S');
+    printif(cc->glob, 'g');
+    printif(cc->str, 's');
+    printif(cc->subcmd, 'l');
+    printif(cc->withd, 'W');
+    if (cc->hpat) {
+	printf(" -H %d ", cc->hnum);
+	quotedzputs(cc->hpat, stdout);
+    }
+
+    /* now the -x ... -- extended completion part */
+    if (cc->ext) {
+	Compcond c, o;
+	int i;
+
+	cc2 = cc->ext;
+	printf(" -x");
+
+	while (cc2) {
+	    /* loop over conditions */
+	    c = cc2->cond;
+
+	    printf(" '");
+	    for (c = cc2->cond; c;) {
+		/* loop over or's */
+		o = c->or;
+		while (c) {
+		    /* loop over and's */
+		    putchar(mss[c->type]);
+
+		    for (i = 0; i < c->n; i++) {
+			/* for all [...]'s of a given condition */
+			putchar('[');
+			switch (c->type) {
+			case CCT_POS:
+			case CCT_NUMWORDS:
+			    printf("%d,%d", c->u.r.a[i], c->u.r.b[i]);
+			    break;
+			case CCT_CURSUF:
+			case CCT_CURPRE:
+			    printqt(c->u.s.s[i]);
+			    break;
+			case CCT_RANGESTR:
+			case CCT_RANGEPAT:
+			    printqt(c->u.l.a[i]);
+			    putchar(',');
+			    printqt(c->u.l.b[i]);
+			    break;
+			default:
+			    printf("%d,", c->u.s.p[i]);
+			    printqt(c->u.s.s[i]);
+			}
+			putchar(']');
+		    }
+		    if ((c = c->and))
+			putchar(' ');
+		}
+		if ((c = o))
+		    printf(" , ");
+	    }
+	    putchar('\'');
+	    c = cc2->cond;
+	    cc2->cond = NULL;
+	    /* now print the flags for the current condition */
+	    printcompctl(NULL, cc2, 0);
+	    cc2->cond = c;
+	    if ((cc2 = (Compctl) (cc2->next)))
+		printf(" -");
+	}
+	if (cclist & COMP_LIST)
+	    printf(" --");
+    }
+    if (cc && cc->xor) {
+	/* print xor'd (+) completions */
+	printf(" +");
+	if (cc->xor != &cc_default)
+	    printcompctl(NULL, cc->xor, 0);
+    }
+    if (s) {
+	if ((cclist & COMP_LIST) && (cc != &cc_compos)
+	    && (cc != &cc_default) && (cc != &cc_first)) {
+	    if(s[0] == '-' || s[0] == '+')
+		printf(" -");
+	    putchar(' ');
+	    quotedzputs(s, stdout);
+	}
+	putchar('\n');
+    }
+
+    showmask = oldshowmask;
+}
+
+/**/
+static void
+printcompctlp(HashNode hn, int printflags)
+{
+    Compctlp ccp = (Compctlp) hn;
+
+    /* Function needed for use by scanhashtable() */
+    printcompctl(ccp->nam, ccp->cc, printflags);
+}
+
+/* Main entry point for the `compctl' builtin */
+
+/**/
+static int
+bin_compctl(char *name, char **argv, char *ops, int func)
+{
+    Compctl cc = NULL;
+    int ret = 0;
+
+    /* clear static flags */
+    cclist = 0;
+    showmask = 0;
+
+    /* Parse all the arguments */
+    if (*argv) {
+	cc = (Compctl) zcalloc(sizeof(*cc));
+	if (get_compctl(name, &argv, cc, 1, 0)) {
+	    freecompctl(cc);
+	    return 1;
+	}
+
+	/* remember flags for printing */
+	showmask = cc->mask;
+	if ((showmask & CC_EXCMDS) && !(showmask & CC_DISCMDS))
+	    showmask &= ~CC_EXCMDS;
+
+	/* if no command arguments or just listing, we don't want cc */
+	if (!*argv || (cclist & COMP_LIST))
+	    freecompctl(cc);
+    }
+
+    /* If no commands and no -C, -T, or -D, print all the compctl's *
+     * If some flags (other than -C, -T, or -D) were given, then    *
+     * only print compctl containing those flags.                   */
+    if (!*argv && !(cclist & COMP_SPECIAL)) {
+	scanhashtable(compctltab, 1, 0, 0, compctltab->printnode, 0);
+	printcompctl((cclist & COMP_LIST) ? "" : "COMMAND", &cc_compos, 0);
+	printcompctl((cclist & COMP_LIST) ? "" : "DEFAULT", &cc_default, 0);
+ 	printcompctl((cclist & COMP_LIST) ? "" : "FIRST", &cc_first, 0);
+	return ret;
+    }
+
+    /* If we're listing and we've made it to here, then there are arguments *
+     * or a COMP_SPECIAL flag (-D, -C, -T), so print only those.            */
+    if (cclist & COMP_LIST) {
+	HashNode hn;
+	char **ptr;
+
+	showmask = 0;
+	for (ptr = argv; *ptr; ptr++) {
+	    if ((hn = compctltab->getnode(compctltab, *ptr))) {
+		compctltab->printnode(hn, 0);
+	    } else {
+		zwarnnam(name, "no compctl defined for %s", *ptr, 0);
+		ret = 1;
+	    }
+	}
+	if (cclist & COMP_COMMAND)
+	    printcompctl("", &cc_compos, 0);
+	if (cclist & COMP_DEFAULT)
+	    printcompctl("", &cc_default, 0);
+	if (cclist & COMP_FIRST)
+	    printcompctl("", &cc_first, 0);
+	return ret;
+    }
+
+    /* Assign the compctl to the commands given */
+    if (*argv) {
+	if(cclist & COMP_SPECIAL)
+	    /* Ideally we'd handle this properly, setting both the *
+	     * special and normal completions.  For the moment,    *
+	     * this is better than silently failing.               */
+	    zwarnnam(name, "extraneous commands ignored", NULL, 0);
+	else
+	    compctl_process_cc(argv, cc);
+    }
+
+    return ret;
+}
+
+static struct builtin bintab[] = {
+    BUILTIN("compctl", 0, bin_compctl, 0, -1, 0, NULL, NULL),
+};
+
+/**/
+int
+boot_compctl(Module m)
+{
+    if(!addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)))
+	return 1;
+    compctltab->printnode = printcompctlp;
+    return 0;
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_compctl(Module m)
+{
+    compctltab->printnode = NULL;
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+#endif
diff --git a/Src/Zle/compctl.mdd b/Src/Zle/compctl.mdd
new file mode 100644
index 000000000..c83ecda29
--- /dev/null
+++ b/Src/Zle/compctl.mdd
@@ -0,0 +1,5 @@
+moddeps="comp1"
+
+autobins="compctl"
+
+objects="compctl.o"
diff --git a/Src/Zle/deltochar.c b/Src/Zle/deltochar.c
new file mode 100644
index 000000000..87f8593b8
--- /dev/null
+++ b/Src/Zle/deltochar.c
@@ -0,0 +1,91 @@
+/*
+ * deltochar.c - ZLE module implementing Emacs' zap-to-char
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1996-1997 Peter Stephenson
+ * 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 Peter Stephenson 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 Peter Stephenson and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Peter Stephenson 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 Peter Stephenson and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "deltochar.mdh"
+#include "deltochar.pro"
+
+static Widget w_deletetochar;
+
+/**/
+static void
+deltochar(void)
+{
+    int c = getkey(0), dest = cs, ok = 0, n = zmult;
+
+    if (n > 0) {
+	while (n-- && dest != ll) {
+	    while (dest != ll && line[dest] != c)
+		dest++;
+	    if (dest != ll) {
+		dest++;
+		if (!n) {
+		    foredel(dest - cs);
+		    ok++;
+		}
+	    }
+	}
+    } else {
+	/* ignore character cursor is on when scanning backwards */
+	if (dest)
+	    dest--;
+	while (n++ && dest != 0) {
+	    while (dest != 0 && line[dest] != c)
+		dest--;
+	    if (line[dest] == c && !n) {
+		backdel(cs - dest);
+		ok++;
+	    }
+	}
+    }
+    if (!ok)
+	feep();
+}
+
+/**/
+int
+boot_deltochar(Module m)
+{
+    w_deletetochar = addzlefunction("delete-to-char", deltochar, ZLE_KEEPSUFFIX);
+    if (w_deletetochar)
+	return 0;
+    zwarnnam(m->nam, "name clash when adding ZLE function `delete-to-char'",
+	     NULL, 0);
+    return -1;
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_deltochar(Module m)
+{
+    deletezlefunction(w_deletetochar);
+    return 0;
+}
+#endif
diff --git a/Src/Zle/deltochar.mdd b/Src/Zle/deltochar.mdd
new file mode 100644
index 000000000..4d1f89d1c
--- /dev/null
+++ b/Src/Zle/deltochar.mdd
@@ -0,0 +1,3 @@
+moddeps="zle"
+
+objects="deltochar.o"
diff --git a/Src/Zle/iwidgets.list b/Src/Zle/iwidgets.list
new file mode 100644
index 000000000..01862160e
--- /dev/null
+++ b/Src/Zle/iwidgets.list
@@ -0,0 +1,172 @@
+#
+# intwidgets.list - list of internally implemented ZLE widgets
+#
+# Each line has the form:
+#
+# "canonical-name" , functionname , ZLE_FLAGS
+#
+# `#' starts a comment.  Blank lines are ignored.
+#
+
+"accept-and-hold", acceptandhold, 0
+"accept-and-infer-next-history", acceptandinfernexthistory, 0
+"accept-and-menu-complete", acceptandmenucomplete, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"accept-line", acceptline, 0
+"accept-line-and-down-history", acceptlineanddownhistory, 0
+"backward-char", backwardchar, 0
+"backward-delete-char", backwarddeletechar, ZLE_KEEPSUFFIX
+"backward-delete-word", backwarddeleteword, ZLE_KEEPSUFFIX
+"backward-kill-line", backwardkillline, ZLE_KILL | ZLE_KEEPSUFFIX
+"backward-kill-word", backwardkillword, ZLE_KILL | ZLE_KEEPSUFFIX
+"backward-word", backwardword, 0
+"beginning-of-buffer-or-history", beginningofbufferorhistory, 0
+"beginning-of-history", beginningofhistory, 0
+"beginning-of-line", beginningofline, 0
+"beginning-of-line-hist", beginningoflinehist, 0
+"capitalize-word", capitalizeword, 0
+"clear-screen", clearscreen, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"complete-word", completeword, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"copy-prev-word", copyprevword, 0
+"copy-region-as-kill", copyregionaskill, ZLE_KEEPSUFFIX
+"delete-char", deletechar, ZLE_KEEPSUFFIX
+"delete-char-or-list", deletecharorlist, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"delete-word", deleteword, ZLE_KEEPSUFFIX
+"describe-key-briefly", describekeybriefly, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"digit-argument", digitargument, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"down-case-word", downcaseword, 0
+"down-history", downhistory, 0
+"down-line-or-history", downlineorhistory, ZLE_LINEMOVE | ZLE_LASTCOL
+"down-line-or-search", downlineorsearch, ZLE_LINEMOVE | ZLE_LASTCOL
+"emacs-backward-word", emacsbackwardword, 0
+"emacs-forward-word", emacsforwardword, 0
+"end-of-buffer-or-history", endofbufferorhistory, 0
+"end-of-history", endofhistory, 0
+"end-of-line", endofline, 0
+"end-of-line-hist", endoflinehist, 0
+"exchange-point-and-mark", exchangepointandmark, 0
+"execute-last-named-cmd", NULL, 0
+"execute-named-cmd", NULL, 0
+"expand-cmd-path", expandcmdpath, 0
+"expand-history", expandhistory, 0
+"expand-or-complete", expandorcomplete, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"expand-or-complete-prefix", expandorcompleteprefix, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"expand-word", expandword, 0
+"forward-char", forwardchar, 0
+"forward-word", forwardword, 0
+"get-line", getline, 0
+"gosmacs-transpose-chars", gosmacstransposechars, 0
+"history-beginning-search-backward", historybeginningsearchbackward, 0
+"history-beginning-search-forward", historybeginningsearchforward, 0
+"history-incremental-search-backward", historyincrementalsearchbackward, 0
+"history-incremental-search-forward", historyincrementalsearchforward, 0
+"history-search-backward", historysearchbackward, 0
+"history-search-forward", historysearchforward, 0
+"infer-next-history", infernexthistory, 0
+"insert-last-word", insertlastword, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"kill-buffer", killbuffer, ZLE_KILL | ZLE_KEEPSUFFIX
+"kill-line", killline, ZLE_KILL | ZLE_KEEPSUFFIX
+"kill-region", killregion, ZLE_KILL | ZLE_KEEPSUFFIX
+"kill-whole-line", killwholeline, ZLE_KILL | ZLE_KEEPSUFFIX
+"kill-word", killword, ZLE_KILL | ZLE_KEEPSUFFIX
+"list-choices", listchoices, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"list-expand", listexpand, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"magic-space", magicspace, 0
+"menu-complete", menucomplete, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"menu-expand-or-complete", menuexpandorcomplete, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"neg-argument", negargument, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"overwrite-mode", overwritemode, 0
+"pound-insert", poundinsert, 0
+"push-input", pushinput, 0
+"push-line", pushline, 0
+"push-line-or-edit", pushlineoredit, 0
+"quoted-insert", quotedinsert, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"quote-line", quoteline, 0
+"quote-region", quoteregion, 0
+"redisplay", redisplay, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"redo", redo, 0
+"reverse-menu-complete", reversemenucomplete, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"run-help", processcmd, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"self-insert", selfinsert, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"self-insert-unmeta", selfinsertunmeta, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"send-break", sendbreak, 0
+"set-mark-command", setmarkcommand, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"spell-word", spellword, 0
+"transpose-chars", transposechars, 0
+"transpose-words", transposewords, 0
+"undefined-key", undefinedkey, 0
+"undo", undo, 0
+"universal-argument", universalargument, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"up-case-word", upcaseword, 0
+"up-history", uphistory, 0
+"up-line-or-history", uplineorhistory, ZLE_LINEMOVE | ZLE_LASTCOL
+"up-line-or-search", uplineorsearch, ZLE_LINEMOVE | ZLE_LASTCOL
+"vi-add-eol", viaddeol, 0
+"vi-add-next", viaddnext, 0
+"vi-backward-blank-word", vibackwardblankword, 0
+"vi-backward-char", vibackwardchar, 0
+"vi-backward-delete-char", vibackwarddeletechar, ZLE_KEEPSUFFIX
+"vi-backward-kill-word", vibackwardkillword, ZLE_KILL | ZLE_KEEPSUFFIX
+"vi-backward-word", vibackwardword, 0
+"vi-beginning-of-line", vibeginningofline, 0
+"vi-caps-lock-panic", vicapslockpanic, 0
+"vi-change", vichange, 0
+"vi-change-eol", vichangeeol, 0
+"vi-change-whole-line", vichangewholeline, 0
+"vi-cmd-mode", vicmdmode, 0
+"vi-delete", videlete, ZLE_KILL | ZLE_KEEPSUFFIX
+"vi-delete-char", videletechar, ZLE_KEEPSUFFIX
+"vi-digit-or-beginning-of-line", vidigitorbeginningofline, 0
+"vi-down-line-or-history", vidownlineorhistory, ZLE_LINEMOVE
+"vi-end-of-line", viendofline, ZLE_LASTCOL
+"vi-fetch-history", vifetchhistory, 0
+"vi-find-next-char", vifindnextchar, 0
+"vi-find-next-char-skip", vifindnextcharskip, 0
+"vi-find-prev-char", vifindprevchar, 0
+"vi-find-prev-char-skip", vifindprevcharskip, 0
+"vi-first-non-blank", vifirstnonblank, 0
+"vi-forward-blank-word", viforwardblankword, 0
+"vi-forward-blank-word-end", viforwardblankwordend, 0
+"vi-forward-char", viforwardchar, 0
+"vi-forward-word", viforwardword, 0
+"vi-forward-word-end", viforwardwordend, 0
+"vi-goto-column", vigotocolumn, 0
+"vi-goto-mark", vigotomark, 0
+"vi-goto-mark-line", vigotomarkline, 0
+"vi-history-search-backward", vihistorysearchbackward, 0
+"vi-history-search-forward", vihistorysearchforward, 0
+"vi-indent", viindent, 0
+"vi-insert", viinsert, 0
+"vi-insert-bol", viinsertbol, 0
+"vi-join", vijoin, 0
+"vi-kill-eol", vikilleol, ZLE_KILL | ZLE_KEEPSUFFIX
+"vi-kill-line", vikillline, ZLE_KILL | ZLE_KEEPSUFFIX
+"vi-match-bracket", vimatchbracket, 0
+"vi-open-line-above", viopenlineabove, 0
+"vi-open-line-below", viopenlinebelow, 0
+"vi-oper-swap-case", vioperswapcase, 0
+"vi-pound-insert", vipoundinsert, 0
+"vi-put-after", viputafter, ZLE_YANK
+"vi-put-before", viputbefore, ZLE_YANK
+"vi-quoted-insert", viquotedinsert, ZLE_MENUCMP | ZLE_KEEPSUFFIX
+"vi-repeat-change", virepeatchange, 0
+"vi-repeat-find", virepeatfind, 0
+"vi-repeat-search", virepeatsearch, 0
+"vi-replace", vireplace, 0
+"vi-replace-chars", vireplacechars, 0
+"vi-rev-repeat-find", virevrepeatfind, 0
+"vi-rev-repeat-search", virevrepeatsearch, 0
+"vi-set-buffer", visetbuffer, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"vi-set-mark", visetmark, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"vi-substitute", visubstitute, 0
+"vi-swap-case", viswapcase, 0
+"vi-undo-change", viundochange, 0
+"vi-unindent", viunindent, 0
+"vi-up-line-or-history", viuplineorhistory, ZLE_LINEMOVE
+"vi-yank", viyank, 0
+"vi-yank-eol", viyankeol, 0
+"vi-yank-whole-line", viyankwholeline, 0
+"what-cursor-position", whatcursorposition, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"where-is", whereis, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"which-command", processcmd, ZLE_MENUCMP | ZLE_KEEPSUFFIX | ZLE_LASTCOL
+"yank", yank, ZLE_YANK
+"yank-pop", yankpop, ZLE_YANK
diff --git a/Src/Zle/zle.h b/Src/Zle/zle.h
new file mode 100644
index 000000000..faf6cf878
--- /dev/null
+++ b/Src/Zle/zle.h
@@ -0,0 +1,137 @@
+/*
+ * zle.h - header file for line editor
+ *
+ * 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.
+ *
+ */
+
+#undef trashzle
+#undef zleread
+#undef spaceinline
+#undef gotword
+#undef refresh
+
+typedef struct widget *Widget;
+typedef struct thingy *Thingy;
+
+/* widgets (ZLE functions) */
+
+typedef void (*ZleIntFunc) _((void));
+
+struct widget {
+    int flags;		/* flags (see below) */
+    Thingy first;	/* `first' thingy that names this widget */
+    union {
+	ZleIntFunc fn;	/* pointer to internally implemented widget */
+	char *fnnam;	/* name of the shell function for user-defined widget */
+    } u;
+};
+
+#define WIDGET_INT	(1<<0)    /* widget is internally implemented */
+#define ZLE_MENUCMP	(1<<1)    /* DON'T invalidate completion list */
+#define ZLE_YANK	(1<<3)
+#define ZLE_LINEMOVE	(1<<4)    /* command is a line-oriented movement */
+#define ZLE_LASTCOL     (1<<5)    /* command maintains lastcol correctly */
+#define ZLE_KILL	(1<<6)
+#define ZLE_KEEPSUFFIX	(1<<9)    /* DON'T remove added suffix */
+
+/* thingies */
+
+struct thingy {
+    HashNode next;	/* next node in the hash chain */
+    char *nam;		/* name of the thingy */
+    int flags;		/* TH_* flags (see below) */
+    int rc;		/* reference count */
+    Widget widget;	/* widget named by this thingy */
+    Thingy samew;	/* `next' thingy (circularly) naming the same widget */
+};
+
+/* DISABLED is (1<<0) */
+#define TH_IMMORTAL	(1<<1)    /* can't refer to a different widget */
+
+/* command modifier prefixes */
+
+struct modifier {
+    int flags;		/* MOD_* flags (see below) */
+    int mult;		/* repeat count */
+    int tmult;		/* repeat count actually being edited */
+    int vibuf;		/* vi cut buffer */
+};
+
+#define MOD_MULT  (1<<0)   /* a repeat count has been selected */
+#define MOD_TMULT (1<<1)   /* a repeat count is being entered */
+#define MOD_VIBUF (1<<2)   /* a vi cut buffer has been selected */
+#define MOD_VIAPP (1<<3)   /* appending to the vi cut buffer */
+#define MOD_NEG   (1<<4)   /* last command was negate argument */
+
+/* current modifier status */
+
+#define zmult (zmod.mult)
+
+/* undo system */
+
+struct change {
+    struct change *prev, *next;	/* adjacent changes */
+    int flags;			/* see below */
+    int hist;			/* history line being changed */
+    int off;			/* offset of the text changes */
+    char *del;			/* characters to delete (metafied) */
+    char *ins;			/* characters to insert (metafied) */
+};
+
+#define CH_NEXT (1<<0)   /* next structure is also part of this change */
+#define CH_PREV (1<<1)   /* previous structure is also part of this change */
+
+/* known thingies */
+
+#define Th(X) (&thingies[X])
+
+/* opaque keymap type */
+
+typedef struct keymap *Keymap;
+
+typedef void (*KeyScanFunc) _((char *, Thingy, char *, void *));
+
+#define invicmdmode() (!strcmp(curkeymapname, "vicmd"))
+
+/* Standard type of suffix removal. */
+
+#define removesuffix() iremovesuffix(256)
+
+/* Cut/kill buffer type.  The buffer itself is purely binary data, *
+ * not NUL-terminated.  len is a length count.  flags uses the     *
+ * CUTBUFFER_* constants defined below.                            */
+
+struct cutbuffer {
+    char *buf;
+    size_t len;
+    char flags;
+};
+
+typedef struct cutbuffer *Cutbuffer;
+
+#define CUTBUFFER_LINE 1   /* for vi: buffer contains whole lines of data */
+
+#define KRINGCT 8   /* number of buffers in the kill ring */
diff --git a/Src/Zle/zle.mdd b/Src/Zle/zle.mdd
new file mode 100644
index 000000000..29f39d363
--- /dev/null
+++ b/Src/Zle/zle.mdd
@@ -0,0 +1,70 @@
+moddeps="comp1"
+
+autobins="bindkey vared zle"
+
+objects="zle_bindings.o zle_hist.o zle_keymap.o zle_main.o \
+zle_misc.o zle_move.o zle_params.o zle_refresh.o \
+zle_thingy.o zle_tricky.o zle_utils.o zle_vi.o zle_word.o"
+
+headers="zle.h zle_things.h"
+
+:<<\Make
+zle_things.h: thingies.list zle_things.sed
+	( \
+	    echo '/** zle_things.h                              **/'; \
+	    echo '/** indices of and pointers to known thingies **/'; \
+	    echo; \
+	    echo 'enum {'; \
+	    sed -n -f $(sdir)/zle_things.sed < thingies.list; \
+	    echo '    ZLE_BUILTIN_THINGY_COUNT'; \
+	    echo '};'; \
+	) > $@
+
+zle_widget.h: widgets.list zle_widget.sed
+	( \
+	    echo '/** zle_widget.h                                **/'; \
+	    echo '/** indices of and pointers to internal widgets **/'; \
+	    echo; \
+	    echo 'enum {'; \
+	    sed -n -f $(sdir)/zle_widget.sed < widgets.list; \
+	    echo '    ZLE_BUILTIN_WIDGET_COUNT'; \
+	    echo '};'; \
+	) > $@
+
+thingies.list: iwidgets.list
+	( \
+	    echo '/** thingies.list                            **/'; \
+	    echo '/** thingy structures for the known thingies **/'; \
+	    echo; \
+	    echo '/* format: T("name", TH_FLAGS, w_widget, t_nextthingy) */'; \
+	    echo; \
+	    sed -e 's/#.*//; /^$$/d; s/" *,.*/"/' \
+		-e 's/^"/T("/; s/$$/, 0,/; h' \
+		-e 's/-//g; s/^.*"\(.*\)".*/w_\1, t_D\1)/' \
+		-e 'H; g; s/\n/ /' \
+		< $(sdir)/iwidgets.list; \
+	    sed -e 's/#.*//; /^$$/d; s/" *,.*/"/' \
+		-e 's/^"/T("./; s/$$/, TH_IMMORTAL,/; h' \
+		-e 's/-//g; s/^.*"\.\(.*\)".*/w_\1, t_\1)/' \
+		-e 'H; g; s/\n/ /' \
+		< $(sdir)/iwidgets.list; \
+	) > $@
+
+widgets.list: iwidgets.list
+	( \
+	    echo '/** widgets.list                               **/'; \
+	    echo '/** widget structures for the internal widgets **/'; \
+	    echo; \
+	    echo '/* format: W(ZLE_FLAGS, t_firstname, functionname) */'; \
+	    echo; \
+	    sed -e 's/#.*//; /^$$/d; s/-//g' \
+		-e 's/^"\(.*\)" *, *\([^ ]*\) *, *\(.*\)/W(\3, t_\1, \2)/' \
+		< $(sdir)/iwidgets.list; \
+	) > $@
+
+zle_bindings.o zle_bindings..o: zle_widget.h widgets.list thingies.list
+
+clean-here: clean.zle
+clean.zle:
+	rm -f zle_things.h zle_widget.h widgets.list thingies.list
+Make
diff --git a/Src/Zle/zle_bindings.c b/Src/Zle/zle_bindings.c
new file mode 100644
index 000000000..40e555ad1
--- /dev/null
+++ b/Src/Zle/zle_bindings.c
@@ -0,0 +1,421 @@
+/*
+ * zle_bindings.c - commands and keymaps
+ *
+ * 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 "zle.mdh"
+#include "zle_widget.h"
+
+#include "zle_bindings.pro"
+
+/*
+ * widgets is the table of internally implemented widgets.  This
+ * table is not used directly, but each widget in it is referenced
+ * by address from within the table of thingies (below).  The only
+ * complication here is that not all systems support union
+ * initialisation.
+ */
+
+static
+#ifdef HAVE_UNION_INIT
+# define BR(X) {X}
+struct widget
+#else /* !HAVE_UNION_INIT */
+# define BR(X) X
+struct intwidget {
+    int flags;
+    Thingy first;
+    ZleIntFunc fn;
+}
+#endif /* !HAVE_UNION_INIT */
+widgets[] = {
+#define W(zle_flags, t_firstname, functionname) \
+    { WIDGET_INT | zle_flags, t_firstname, BR(functionname) },
+#include "widgets.list"
+#undef W
+};
+
+/*
+ * thingies is the table of `known thingies', that exist on startup.
+ * Some bits of ZLE rely on some of these thingies always being the
+ * ones in this table, rather than doing a name lookup and accepting
+ * any semantically identical thingy.  The initial reference count of
+ * these thingies is 2: 1 for the widget they name, and 1 extra to
+ * make sure they never get deleted.
+ */
+
+/**/
+struct thingy thingies[] = {
+#define T(name, th_flags, w_idget, t_next) \
+    { NULL, name, th_flags, 2, w_idget, t_next },
+#include "thingies.list"
+#undef T
+    { NULL, NULL, 0, 0, NULL, NULL }
+};
+
+/*
+ * Default key binding tables:
+ *
+ * In these tables, each element is bound to a single thingy, the index
+ * of which in the above table is stored here.
+ */
+
+/**/
+int emacsbind[32] = {
+    /* ^@ */ z_setmarkcommand,
+    /* ^A */ z_beginningofline,
+    /* ^B */ z_backwardchar,
+    /* ^C */ z_undefinedkey,
+    /* ^D */ z_deletecharorlist,
+    /* ^E */ z_endofline,
+    /* ^F */ z_forwardchar,
+    /* ^G */ z_sendbreak,
+    /* ^H */ z_backwarddeletechar,
+    /* ^I */ z_expandorcomplete,
+    /* ^J */ z_acceptline,
+    /* ^K */ z_killline,
+    /* ^L */ z_clearscreen,
+    /* ^M */ z_acceptline,
+    /* ^N */ z_downlineorhistory,
+    /* ^O */ z_acceptlineanddownhistory,
+    /* ^P */ z_uplineorhistory,
+    /* ^Q */ z_pushline,
+    /* ^R */ z_historyincrementalsearchbackward,
+    /* ^S */ z_historyincrementalsearchforward,
+    /* ^T */ z_transposechars,
+    /* ^U */ z_killwholeline,
+    /* ^V */ z_quotedinsert,
+    /* ^W */ z_backwardkillword,
+    /* ^X */ z_undefinedkey,
+    /* ^Y */ z_yank,
+    /* ^Z */ z_undefinedkey,
+    /* ^[ */ z_undefinedkey,
+    /* ^\ */ z_undefinedkey,
+    /* ^] */ z_undefinedkey,
+    /* ^^ */ z_undefinedkey,
+    /* ^_ */ z_undo,
+};
+
+/**/
+int metabind[128] = {
+    /* M-^@ */ z_undefinedkey,
+    /* M-^A */ z_undefinedkey,
+    /* M-^B */ z_undefinedkey,
+    /* M-^C */ z_undefinedkey,
+    /* M-^D */ z_listchoices,
+    /* M-^E */ z_undefinedkey,
+    /* M-^F */ z_undefinedkey,
+    /* M-^G */ z_sendbreak,
+    /* M-^H */ z_backwardkillword,
+    /* M-^I */ z_selfinsertunmeta,
+    /* M-^J */ z_selfinsertunmeta,
+    /* M-^K */ z_undefinedkey,
+    /* M-^L */ z_clearscreen,
+    /* M-^M */ z_selfinsertunmeta,
+    /* M-^N */ z_undefinedkey,
+    /* M-^O */ z_undefinedkey,
+    /* M-^P */ z_undefinedkey,
+    /* M-^Q */ z_undefinedkey,
+    /* M-^R */ z_undefinedkey,
+    /* M-^S */ z_undefinedkey,
+    /* M-^T */ z_undefinedkey,
+    /* M-^U */ z_undefinedkey,
+    /* M-^V */ z_undefinedkey,
+    /* M-^W */ z_undefinedkey,
+    /* M-^X */ z_undefinedkey,
+    /* M-^Y */ z_undefinedkey,
+    /* M-^Z */ z_undefinedkey,
+    /* M-^[ */ z_undefinedkey,
+    /* M-^\ */ z_undefinedkey,
+    /* M-^] */ z_undefinedkey,
+    /* M-^^ */ z_undefinedkey,
+    /* M-^_ */ z_copyprevword,
+    /* M-  */ z_expandhistory,
+    /* M-! */ z_expandhistory,
+    /* M-" */ z_quoteregion,
+    /* M-# */ z_undefinedkey,
+    /* M-$ */ z_spellword,
+    /* M-% */ z_undefinedkey,
+    /* M-& */ z_undefinedkey,
+    /* M-' */ z_quoteline,
+    /* M-( */ z_undefinedkey,
+    /* M-) */ z_undefinedkey,
+    /* M-* */ z_undefinedkey,
+    /* M-+ */ z_undefinedkey,
+    /* M-, */ z_undefinedkey,
+    /* M-- */ z_negargument,
+    /* M-. */ z_insertlastword,
+    /* M-/ */ z_undefinedkey,
+    /* M-0 */ z_digitargument,
+    /* M-1 */ z_digitargument,
+    /* M-2 */ z_digitargument,
+    /* M-3 */ z_digitargument,
+    /* M-4 */ z_digitargument,
+    /* M-5 */ z_digitargument,
+    /* M-6 */ z_digitargument,
+    /* M-7 */ z_digitargument,
+    /* M-8 */ z_digitargument,
+    /* M-9 */ z_digitargument,
+    /* M-: */ z_undefinedkey,
+    /* M-; */ z_undefinedkey,
+    /* M-< */ z_beginningofbufferorhistory,
+    /* M-= */ z_undefinedkey,
+    /* M-> */ z_endofbufferorhistory,
+    /* M-? */ z_whichcommand,
+    /* M-@ */ z_undefinedkey,
+    /* M-A */ z_acceptandhold,
+    /* M-B */ z_backwardword,
+    /* M-C */ z_capitalizeword,
+    /* M-D */ z_killword,
+    /* M-E */ z_undefinedkey,
+    /* M-F */ z_forwardword,
+    /* M-G */ z_getline,
+    /* M-H */ z_runhelp,
+    /* M-I */ z_undefinedkey,
+    /* M-J */ z_undefinedkey,
+    /* M-K */ z_undefinedkey,
+    /* M-L */ z_downcaseword,
+    /* M-M */ z_undefinedkey,
+    /* M-N */ z_historybeginningsearchforward,
+    /* M-O */ z_undefinedkey,
+    /* M-P */ z_historybeginningsearchbackward,
+    /* M-Q */ z_pushline,
+    /* M-R */ z_undefinedkey,
+    /* M-S */ z_spellword,
+    /* M-T */ z_transposewords,
+    /* M-U */ z_upcaseword,
+    /* M-V */ z_undefinedkey,
+    /* M-W */ z_copyregionaskill,
+    /* M-X */ z_undefinedkey,
+    /* M-Y */ z_undefinedkey,
+    /* M-Z */ z_undefinedkey,
+    /* M-[ */ z_undefinedkey,
+    /* M-\ */ z_undefinedkey,
+    /* M-] */ z_undefinedkey,
+    /* M-^ */ z_undefinedkey,
+    /* M-_ */ z_insertlastword,
+    /* M-` */ z_undefinedkey,
+    /* M-a */ z_acceptandhold,
+    /* M-b */ z_backwardword,
+    /* M-c */ z_capitalizeword,
+    /* M-d */ z_killword,
+    /* M-e */ z_undefinedkey,
+    /* M-f */ z_forwardword,
+    /* M-g */ z_getline,
+    /* M-h */ z_runhelp,
+    /* M-i */ z_undefinedkey,
+    /* M-j */ z_undefinedkey,
+    /* M-k */ z_undefinedkey,
+    /* M-l */ z_downcaseword,
+    /* M-m */ z_undefinedkey,
+    /* M-n */ z_historybeginningsearchforward,
+    /* M-o */ z_undefinedkey,
+    /* M-p */ z_historybeginningsearchbackward,
+    /* M-q */ z_pushline,
+    /* M-r */ z_undefinedkey,
+    /* M-s */ z_spellword,
+    /* M-t */ z_transposewords,
+    /* M-u */ z_upcaseword,
+    /* M-v */ z_undefinedkey,
+    /* M-w */ z_copyregionaskill,
+    /* M-x */ z_executenamedcmd,
+    /* M-y */ z_yankpop,
+    /* M-z */ z_executelastnamedcmd,
+    /* M-{ */ z_undefinedkey,
+    /* M-| */ z_vigotocolumn,
+    /* M-} */ z_undefinedkey,
+    /* M-~ */ z_undefinedkey,
+    /* M-^? */ z_backwardkillword,
+};
+
+/**/
+int viinsbind[32] = {
+    /* ^@ */ z_undefinedkey,
+    /* ^A */ z_selfinsert,
+    /* ^B */ z_selfinsert,
+    /* ^C */ z_selfinsert,
+    /* ^D */ z_listchoices,
+    /* ^E */ z_selfinsert,
+    /* ^F */ z_selfinsert,
+    /* ^G */ z_listexpand,
+    /* ^H */ z_vibackwarddeletechar,
+    /* ^I */ z_expandorcomplete,
+    /* ^J */ z_acceptline,
+    /* ^K */ z_selfinsert,
+    /* ^L */ z_clearscreen,
+    /* ^M */ z_acceptline,
+    /* ^N */ z_selfinsert,
+    /* ^O */ z_selfinsert,
+    /* ^P */ z_selfinsert,
+    /* ^Q */ z_viquotedinsert,
+    /* ^R */ z_redisplay,
+    /* ^S */ z_selfinsert,
+    /* ^T */ z_selfinsert,
+    /* ^U */ z_vikillline,
+    /* ^V */ z_viquotedinsert,
+    /* ^W */ z_vibackwardkillword,
+    /* ^X */ z_selfinsert,
+    /* ^Y */ z_selfinsert,
+    /* ^Z */ z_selfinsert,
+    /* ^[ */ z_vicmdmode,
+    /* ^\ */ z_selfinsert,
+    /* ^] */ z_selfinsert,
+    /* ^^ */ z_selfinsert,
+    /* ^_ */ z_selfinsert,
+};
+
+/**/
+int vicmdbind[128] = {
+    /* ^@ */ z_undefinedkey,
+    /* ^A */ z_undefinedkey,
+    /* ^B */ z_undefinedkey,
+    /* ^C */ z_undefinedkey,
+    /* ^D */ z_listchoices,
+    /* ^E */ z_undefinedkey,
+    /* ^F */ z_undefinedkey,
+    /* ^G */ z_listexpand,
+    /* ^H */ z_vibackwardchar,
+    /* ^I */ z_undefinedkey,
+    /* ^J */ z_acceptline,
+    /* ^K */ z_undefinedkey,
+    /* ^L */ z_clearscreen,
+    /* ^M */ z_acceptline,
+    /* ^N */ z_downhistory,
+    /* ^O */ z_undefinedkey,
+    /* ^P */ z_uphistory,
+    /* ^Q */ z_undefinedkey,
+    /* ^R */ z_redisplay,
+    /* ^S */ z_undefinedkey,
+    /* ^T */ z_undefinedkey,
+    /* ^U */ z_undefinedkey,
+    /* ^V */ z_undefinedkey,
+    /* ^W */ z_undefinedkey,
+    /* ^X */ z_undefinedkey,
+    /* ^Y */ z_undefinedkey,
+    /* ^Z */ z_undefinedkey,
+    /* ^[ */ z_undefinedkey,
+    /* ^\ */ z_undefinedkey,
+    /* ^] */ z_undefinedkey,
+    /* ^^ */ z_undefinedkey,
+    /* ^_ */ z_undefinedkey,
+    /*   */ z_viforwardchar,
+    /* ! */ z_undefinedkey,
+    /* " */ z_visetbuffer,
+    /* # */ z_poundinsert,
+    /* $ */ z_viendofline,
+    /* % */ z_vimatchbracket,
+    /* & */ z_undefinedkey,
+    /* ' */ z_vigotomarkline,
+    /* ( */ z_undefinedkey,
+    /* ) */ z_undefinedkey,
+    /* * */ z_undefinedkey,
+    /* + */ z_vidownlineorhistory,
+    /* , */ z_virevrepeatfind,
+    /* - */ z_viuplineorhistory,
+    /* . */ z_virepeatchange,
+    /* / */ z_vihistorysearchbackward,
+    /* 0 */ z_vidigitorbeginningofline,
+    /* 1 */ z_digitargument,
+    /* 2 */ z_digitargument,
+    /* 3 */ z_digitargument,
+    /* 4 */ z_digitargument,
+    /* 5 */ z_digitargument,
+    /* 6 */ z_digitargument,
+    /* 7 */ z_digitargument,
+    /* 8 */ z_digitargument,
+    /* 9 */ z_digitargument,
+    /* : */ z_undefinedkey,
+    /* ; */ z_virepeatfind,
+    /* < */ z_viunindent,
+    /* = */ z_listchoices,
+    /* > */ z_viindent,
+    /* ? */ z_vihistorysearchforward,
+    /* @ */ z_undefinedkey,
+    /* A */ z_viaddeol,
+    /* B */ z_vibackwardblankword,
+    /* C */ z_vichangeeol,
+    /* D */ z_vikilleol,
+    /* E */ z_viforwardblankwordend,
+    /* F */ z_vifindprevchar,
+    /* G */ z_vifetchhistory,
+    /* H */ z_undefinedkey,
+    /* I */ z_viinsertbol,
+    /* J */ z_vijoin,
+    /* K */ z_undefinedkey,
+    /* L */ z_undefinedkey,
+    /* M */ z_undefinedkey,
+    /* N */ z_virevrepeatsearch,
+    /* O */ z_viopenlineabove,
+    /* P */ z_viputbefore,
+    /* Q */ z_undefinedkey,
+    /* R */ z_vireplace,
+    /* S */ z_vichangewholeline,
+    /* T */ z_vifindprevcharskip,
+    /* U */ z_undefinedkey,
+    /* V */ z_undefinedkey,
+    /* W */ z_viforwardblankword,
+    /* X */ z_vibackwarddeletechar,
+    /* Y */ z_viyankwholeline,
+    /* Z */ z_undefinedkey,
+    /* [ */ z_undefinedkey,
+    /* \ */ z_undefinedkey,
+    /* ] */ z_undefinedkey,
+    /* ^ */ z_vifirstnonblank,
+    /* _ */ z_undefinedkey,
+    /* ` */ z_vigotomark,
+    /* a */ z_viaddnext,
+    /* b */ z_vibackwardword,
+    /* c */ z_vichange,
+    /* d */ z_videlete,
+    /* e */ z_viforwardwordend,
+    /* f */ z_vifindnextchar,
+    /* g */ z_undefinedkey,
+    /* h */ z_vibackwardchar,
+    /* i */ z_viinsert,
+    /* j */ z_downlineorhistory,
+    /* k */ z_uplineorhistory,
+    /* l */ z_viforwardchar,
+    /* m */ z_visetmark,
+    /* n */ z_virepeatsearch,
+    /* o */ z_viopenlinebelow,
+    /* p */ z_viputafter,
+    /* q */ z_undefinedkey,
+    /* r */ z_vireplacechars,
+    /* s */ z_visubstitute,
+    /* t */ z_vifindnextcharskip,
+    /* u */ z_viundochange,
+    /* v */ z_undefinedkey,
+    /* w */ z_viforwardword,
+    /* x */ z_videletechar,
+    /* y */ z_viyank,
+    /* z */ z_undefinedkey,
+    /* { */ z_undefinedkey,
+    /* | */ z_vigotocolumn,
+    /* } */ z_undefinedkey,
+    /* ~ */ z_viswapcase,
+    /* ^? */ z_vibackwardchar,
+};
diff --git a/Src/Zle/zle_hist.c b/Src/Zle/zle_hist.c
new file mode 100644
index 000000000..76e421c1c
--- /dev/null
+++ b/Src/Zle/zle_hist.c
@@ -0,0 +1,1139 @@
+/*
+ * zle_hist.c - history editing
+ *
+ * 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 "zle.mdh"
+#include "zle_hist.pro"
+
+/* Are references to earlier history lines permitted?  == 0 if       *
+ * editing or reading a standalone line, such as in vared or select. */
+
+/**/
+int histallowed;
+
+/* Column position of vi ideal cursor.  -1 if it is unknown -- most *
+ * movements and changes do this.                                   */
+
+/**/
+int lastcol;
+
+/* current history line number */
+
+/**/
+int histline;
+
+/* the last line in the history (the current one), metafied */
+
+/**/
+char *curhistline;
+
+/**/
+void
+remember_edits(void)
+{
+    if (histline == curhist) {
+	zsfree(curhistline);
+	curhistline = metafy((char *) line, ll, META_DUP);
+    }
+    else {
+	Histent ent = gethistent(histline);
+
+	if (metadiffer(ent->zle_text ? ent->zle_text : ent->text,
+		       (char *) line, ll)) {
+	    zsfree(ent->zle_text);
+	    ent->zle_text = metafy((char *) line, ll, META_DUP);
+	}
+    }
+}
+
+/**/
+void
+forget_edits(void)
+{
+    int i;
+
+    for (i = 0; i < histentct; i++) {
+	zsfree(histentarr[i].zle_text);
+	histentarr[i].zle_text = NULL;
+    }
+}
+
+/**/
+void
+uphistory(void)
+{
+    if (zmult < 0) {
+	zmult = -zmult;
+	downhistory();
+	zmult = -zmult;
+    } else if(!zle_goto_hist(histline - zmult) && isset(HISTBEEP))
+	feep();
+}
+
+/**/
+int
+upline(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -zmult;
+	n = downline();
+	zmult = -zmult;
+	return n;
+    }
+    if (lastcol == -1)
+	lastcol = cs - findbol();
+    cs = findbol();
+    while (n) {
+	if (!cs)
+	    break;
+	cs--;
+	cs = findbol();
+	n--;
+    }
+    if (!n) {
+	int x = findeol();
+
+	if ((cs += lastcol) >= x) {
+	    cs = x;
+	    if (cs > findbol() && invicmdmode())
+		cs--;
+	}
+    }
+    return n;
+}
+
+/**/
+void
+uplineorhistory(void)
+{
+    int ocs = cs;
+    int n = upline();
+    if (n) {
+	int m = zmult;
+
+	cs = ocs;
+	if (virangeflag || !histallowed) {
+	    feep();
+	    return;
+	}
+	zmult = n;
+	uphistory();
+	zmult = m;
+    }
+}
+
+/**/
+void
+viuplineorhistory(void)
+{
+    int col = lastcol;
+    uplineorhistory();
+    lastcol = col;
+    vifirstnonblank();
+}
+
+
+/**/
+void
+uplineorsearch(void)
+{
+    int ocs = cs;
+    int n = upline();
+    if (n) {
+	int m = zmult;
+
+	cs = ocs;
+	if (virangeflag || !histallowed) {
+	    feep();
+	    return;
+	}
+	zmult = n;
+	historysearchbackward();
+	zmult = m;
+    }
+}
+
+/**/
+int
+downline(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -zmult;
+	n = upline();
+	zmult = -zmult;
+	return n;
+    }
+    if (lastcol == -1)
+	lastcol = cs - findbol();
+    while (n) {
+	int x = findeol();
+
+	if (x == ll)
+	    break;
+	cs = x + 1;
+	n--;
+    }
+    if (!n) {
+	int x = findeol();
+
+	if ((cs += lastcol) >= x) {
+	    cs = x;
+	    if (cs > findbol() && invicmdmode())
+		cs--;
+	}
+    }
+    return n;
+}
+
+/**/
+void
+downlineorhistory(void)
+{
+    int ocs = cs;
+    int n = downline();
+    if (n) {
+	int m = zmult;
+
+	cs = ocs;
+	if (virangeflag || !histallowed) {
+	    feep();
+	    return;
+	}
+	zmult = n;
+	downhistory();
+	zmult = m;
+    }
+}
+
+/**/
+void
+vidownlineorhistory(void)
+{
+    int col = lastcol;
+    downlineorhistory();
+    lastcol = col;
+    vifirstnonblank();
+}
+
+/**/
+void
+downlineorsearch(void)
+{
+    int ocs = cs;
+    int n = downline();
+    if (n) {
+	int m = zmult;
+
+	cs = ocs;
+	if (virangeflag || !histallowed) {
+	    feep();
+	    return;
+	}
+	zmult = n;
+	historysearchforward();
+	zmult = m;
+    }
+}
+
+/**/
+void
+acceptlineanddownhistory(void)
+{
+    char *s;
+
+    if (!(s = zle_get_event(histline + 1))) {
+	feep();
+	return;
+    }
+    pushnode(bufstack, ztrdup(s));
+    done = 1;
+    stackhist = histline + 1;
+}
+
+/**/
+void
+downhistory(void)
+{
+    if (zmult < 0) {
+	zmult = -zmult;
+	uphistory();
+	zmult = -zmult;
+    } else if(!zle_goto_hist(histline + zmult) && isset(HISTBEEP))
+	feep();
+}
+
+/**/
+void
+historysearchbackward(void)
+{
+    int histpos, histmpos, hl = histline;
+    int n = zmult;
+    char *s;
+
+    if (!n)
+	return;
+    if (n < 0) {
+	zmult = -n;
+	historysearchforward();
+	zmult = n;
+	return;
+    }
+    for (histpos = histmpos = 0; histpos < ll && !iblank(line[histpos]);
+	histpos++, histmpos++)
+	if(imeta(line[histpos]))
+	    histmpos++;
+    for (;;) {
+	hl--;
+	if (!(s = zle_get_event(hl))) {
+	    feep();
+	    return;
+	}
+	if (metadiffer(s, (char *) line, histpos) < 0 &&
+	    iblank(s[histmpos] == Meta ? s[histmpos+1]^32 : s[histmpos]) &&
+	    metadiffer(s, (char *) line, ll) && !--n)
+	    break;
+    }
+    zle_goto_hist(hl);
+}
+
+/**/
+void
+historysearchforward(void)
+{
+    int histpos, histmpos, hl = histline;
+    int n = zmult;
+    char *s;
+
+    if (!n)
+	return;
+    if (n < 0) {
+	zmult = -n;
+	historysearchbackward();
+	zmult = n;
+	return;
+    }
+    for (histpos = histmpos = 0; histpos < ll && !iblank(line[histpos]);
+	histpos++, histmpos++)
+	if(imeta(line[histpos]))
+	    histmpos++;
+    for (;;) {
+	hl++;
+	if (!(s = zle_get_event(hl))) {
+	    feep();
+	    return;
+	}
+	if (metadiffer(s, (char *) line, histpos) < (histline == curhist) &&
+	    (!s[histmpos] ||
+	     iblank(s[histmpos] == Meta ? s[histmpos+1]^32 : s[histmpos])) &&
+	    metadiffer(s, (char *) line, ll) && !--n)
+	    break;
+    }
+    zle_goto_hist(hl);
+}
+
+/**/
+void
+beginningofbufferorhistory(void)
+{
+    if (findbol())
+	cs = 0;
+    else
+	beginningofhistory();
+}
+
+/**/
+void
+beginningofhistory(void)
+{
+    if (!zle_goto_hist(firsthist()) && isset(HISTBEEP))
+	feep();
+}
+
+/**/
+void
+endofbufferorhistory(void)
+{
+    if (findeol() != ll)
+	cs = ll;
+    else
+	endofhistory();
+}
+
+/**/
+void
+endofhistory(void)
+{
+    zle_goto_hist(curhist);
+}
+
+/**/
+void
+insertlastword(void)
+{
+    int n;
+    char *s, *t;
+    Histent he;
+
+/* multiple calls will now search back through the history, pem */
+    static char *lastinsert;
+    static int lasthist, lastpos;
+    int evhist = curhist - 1, save;
+
+    if (lastinsert) {
+	int lastlen = ztrlen(lastinsert);
+	int pos = cs;
+
+	if (lastpos <= pos &&
+	    lastlen == pos - lastpos &&
+	    memcmp(lastinsert, (char *)&line[lastpos], lastlen) == 0) {
+	    evhist = --lasthist;
+	    cs = lastpos;
+	    foredel(pos - cs);
+	}
+	zsfree(lastinsert);
+	lastinsert = NULL;
+    }
+    if (!(he = quietgethist(evhist)) || !he->nwords) {
+	feep();
+	return;
+    }
+    if (zmult > 0) {
+	n = he->nwords - (zmult - 1);
+    } else {
+	n = 1 - zmult;
+    }
+    if (n < 1 || n > he->nwords) {
+	feep();
+	return;
+    }
+    s = he->text + he->words[2*n-2];
+    t = he->text + he->words[2*n-1];
+    save = *t;
+    *t = '\0';			/* ignore trailing whitespace */
+
+    lasthist = evhist;
+    lastpos = cs;
+    lastinsert = ztrdup(s);
+    n = zmult;
+    zmult = 1;
+    doinsert(s);
+    zmult = n;
+    *t = save;
+}
+
+/**/
+char *
+qgetevent(int ev)
+{
+    return ((ev == curhist) ? curhistline : quietgetevent(ev));
+}
+
+/**/
+char *
+zle_get_event(int ev)
+{
+    Histent ent;
+
+    if (ev == curhist)
+	return curhistline;
+    if (! (ent = quietgethist(ev)))
+	return NULL;
+    if (ent->zle_text)
+	return ent->zle_text;
+    return ent->text;
+}
+
+/**/
+static int
+zle_goto_hist(int ev)
+{
+    char *t;
+
+    remember_edits();
+    if(!(t = zle_get_event(ev)))
+	return 0;
+    mkundoent();
+    histline = ev;
+    setline(t);
+    setlastline();
+    return 1;
+}
+
+/**/
+void
+pushline(void)
+{
+    int n = zmult;
+
+    if (n < 0)
+	return;
+    pushnode(bufstack, metafy((char *) line, ll, META_DUP));
+    while (--n)
+	pushnode(bufstack, ztrdup(""));
+    stackcs = cs;
+    *line = '\0';
+    ll = cs = 0;
+}
+
+/**/
+void
+pushlineoredit(void)
+{
+    int ics;
+    unsigned char *s;
+    char *hline = hgetline();
+
+    if (zmult < 0)
+	return;
+    if (hline && *hline) {
+	ics = ztrlen(hline);
+	sizeline(ics + ll + 1);
+	for (s = line + ll; --s >= line; *(s + ics) = *s);
+	for (s = line; *hline; hline++)
+	    *s++ = *hline == Meta ? *++hline ^ 32 : *hline;
+	ll += ics;
+	cs += ics;
+    }
+    pushline();
+    if (!isfirstln) {
+	errflag = done = 1;
+    }
+}
+
+/**/
+void
+pushinput(void)
+{
+    int i;
+
+    if (zmult < 0)
+	return;
+    zmult += i = !isfirstln;
+    pushlineoredit();
+    zmult -= i;
+}
+
+/**/
+void
+getline(void)
+{
+    char *s = (char *)getlinknode(bufstack);
+
+    if (!s)
+	feep();
+    else {
+	int cc;
+
+	unmetafy(s, &cc);
+	spaceinline(cc);
+	memcpy((char *)line + cs, s, cc);
+	cs += cc;
+	free(s);
+    }
+}
+
+/**/
+void
+historyincrementalsearchbackward(void)
+{
+    doisearch(-1);
+}
+
+/**/
+void
+historyincrementalsearchforward(void)
+{
+    doisearch(1);
+}
+
+static struct isrch_spot {
+    int hl;			/* This spot's histline */
+    unsigned short pos;		/* The search position in our metafied str */
+    unsigned short cs;		/* The visible search position to the user */
+    unsigned short len;		/* The search string's length */
+    unsigned short flags;	/* This spot's flags */
+#define ISS_FAILING	1
+#define ISS_FORWARD	2
+} *isrch_spots;
+
+static int max_spot = 0;
+
+#ifdef MODULE
+
+/**/
+void
+free_isrch_spots(void)
+{
+    zfree(isrch_spots, max_spot * sizeof(*isrch_spots));
+}
+
+#endif /* MODULE */
+
+/**/
+static void
+set_isrch_spot(int num, int hl, int pos, int cs, int len, int dir, int nomatch)
+{
+    if (num >= max_spot) {
+	if (!isrch_spots) {
+	    isrch_spots = (struct isrch_spot*)
+			    zalloc((max_spot = 64) * sizeof *isrch_spots);
+	} else {
+	    isrch_spots = (struct isrch_spot*)realloc((char*)isrch_spots,
+			    (max_spot += 64) * sizeof *isrch_spots);
+	}
+    }
+
+    isrch_spots[num].hl = hl;
+    isrch_spots[num].pos = (unsigned short)pos;
+    isrch_spots[num].cs = (unsigned short)cs;
+    isrch_spots[num].len = (unsigned short)len;
+    isrch_spots[num].flags = (dir > 0? ISS_FORWARD : 0)
+			   + (nomatch? ISS_FAILING : 0);
+}
+
+/**/
+static void
+get_isrch_spot(int num, int *hlp, int *posp, int *csp, int *lenp, int *dirp, int *nomatch)
+{
+    *hlp = isrch_spots[num].hl;
+    *posp = (int)isrch_spots[num].pos;
+    *csp = (int)isrch_spots[num].cs;
+    *lenp = (int)isrch_spots[num].len;
+    *dirp = (isrch_spots[num].flags & ISS_FORWARD)? 1 : -1;
+    *nomatch = (isrch_spots[num].flags & ISS_FAILING);
+}
+
+#define ISEARCH_PROMPT		"failing XXX-i-search: "
+#define NORM_PROMPT_POS		8
+#define FIRST_SEARCH_CHAR	(NORM_PROMPT_POS + 14)
+
+/**/
+static void
+doisearch(int dir)
+{
+    char *s, *ibuf = halloc(80), *sbuf = ibuf + FIRST_SEARCH_CHAR;
+    int sbptr = 0, top_spot = 0, pos, sibuf = 80;
+    int nomatch = 0, skip_line = 0, skip_pos = 0;
+    int odir = dir, sens = zmult == 1 ? 3 : 1;
+    int hl = histline;
+    Thingy cmd;
+    char *okeymap = curkeymapname;
+    static char *previous_search = NULL;
+    static int previous_search_len = 0;
+
+    strcpy(ibuf, ISEARCH_PROMPT);
+    memcpy(ibuf + NORM_PROMPT_POS, (dir == 1) ? "fwd" : "bck", 3);
+    remember_edits();
+    s = zle_get_event(hl);
+    selectkeymap("main", 1);
+    pos = metalen(s, cs);
+    for (;;) {
+	/* Remember the current values in case search fails (doesn't push). */
+	set_isrch_spot(top_spot, hl, pos, cs, sbptr, dir, nomatch);
+	if (sbptr == 1 && sbuf[0] == '^') {
+	    cs = 0;
+    	    nomatch = 0;
+	    statusline = ibuf + NORM_PROMPT_POS;
+	} else if (sbptr > 0) {
+	    char *last_line = s;
+
+	    for (;;) {
+		char *t;
+
+		if (skip_pos) {
+		    if (dir < 0) {
+			if (pos == 0)
+			    skip_line = 1;
+			else
+			    pos -= 1 + (pos != 1 && s[pos-2] == Meta);
+		    } else if (sbuf[0] != '^') {
+			if (pos >= strlen(s+1))
+			    skip_line = 1;
+			else
+			    pos += 1 + (s[pos] == Meta);
+		    } else
+			skip_line = 1;
+		    skip_pos = 0;
+		}
+		if (!skip_line && ((sbuf[0] == '^') ?
+		    (t = metadiffer(s, sbuf + 1, sbptr - 1) < sens ? s : NULL) :
+		    (t = hstrnstr(s, pos, sbuf, sbptr, dir, sens)))) {
+		    zle_goto_hist(hl);
+		    pos = t - s;
+		    cs = ztrsub(t, s) + (dir == 1? sbptr - (sbuf[0]=='^') : 0);
+	    	    nomatch = 0;
+		    statusline = ibuf + NORM_PROMPT_POS;
+		    break;
+		}
+		hl += dir;
+		if (!(s = zle_get_event(hl))) {
+		    if (sbptr == (int)isrch_spots[top_spot-1].len
+		     && (isrch_spots[top_spot-1].flags & ISS_FAILING))
+			top_spot--;
+		    get_isrch_spot(top_spot, &hl, &pos, &cs, &sbptr,
+				   &dir, &nomatch);
+		    if (!nomatch) {
+			feep();
+			nomatch = 1;
+		    }
+		    s = last_line;
+		    skip_line = 0;
+		    statusline = ibuf;
+		    break;
+		}
+		pos = dir == 1? 0 : strlen(s);
+		skip_line = !strcmp(last_line, s);
+	    }
+	} else {
+	    top_spot = 0;
+    	    nomatch = 0;
+	    statusline = ibuf + NORM_PROMPT_POS;
+	}
+	sbuf[sbptr] = '_';
+	statusll = sbuf - statusline + sbptr + 1;
+    ref:
+	refresh();
+	if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) {
+	    int i;
+	    get_isrch_spot(0, &hl, &pos, &i, &sbptr, &dir, &nomatch);
+	    s = zle_get_event(hl);
+	    zle_goto_hist(hl);
+	    cs = i;
+	    break;
+	}
+	if(cmd == Th(z_clearscreen)) {
+	    clearscreen();
+	    goto ref;
+	} else if(cmd == Th(z_redisplay)) {
+	    redisplay();
+	    goto ref;
+	} else if(cmd == Th(z_vicmdmode)) {
+	    if(selectkeymap(invicmdmode() ? "main" : "vicmd", 0))
+		feep();
+	    goto ref;
+	} else if(cmd == Th(z_vibackwarddeletechar) ||
+	    	cmd == Th(z_backwarddeletechar)) {
+	    if (top_spot)
+		get_isrch_spot(--top_spot, &hl, &pos, &cs, &sbptr,
+			       &dir, &nomatch);
+	    else
+		feep();
+	    if (nomatch) {
+		statusline = ibuf;
+		skip_pos = 1;
+	    }
+	    s = zle_get_event(hl);
+	    if (nomatch || !sbptr || (sbptr == 1 && sbuf[0] == '^')) {
+		int i = cs;
+		zle_goto_hist(hl);
+		cs = i;
+	    }
+	    memcpy(ibuf + NORM_PROMPT_POS, (dir == 1) ? "fwd" : "bck", 3);
+	    continue;
+	} else if(cmd == Th(z_acceptandhold)) {
+	    acceptandhold();
+	    break;
+	} else if(cmd == Th(z_acceptandinfernexthistory)) {
+	    acceptandinfernexthistory();
+	    break;
+	} else if(cmd == Th(z_acceptlineanddownhistory)) {
+	    acceptlineanddownhistory();
+	    break;
+	} else if(cmd == Th(z_acceptline)) {
+	    acceptline();
+	    break;
+	} else if(cmd == Th(z_historyincrementalsearchbackward)) {
+	    set_isrch_spot(top_spot++, hl, pos, cs, sbptr, dir, nomatch);
+	    if (dir != -1)
+		dir = -1;
+	    else
+		skip_pos = 1;
+	    goto rpt;
+	} else if(cmd == Th(z_historyincrementalsearchforward)) {
+	    set_isrch_spot(top_spot++, hl, pos, cs, sbptr, dir, nomatch);
+	    if (dir != 1)
+		dir = 1;
+	    else
+		skip_pos = 1;
+	    goto rpt;
+	} else if(cmd == Th(z_virevrepeatsearch)) {
+	    set_isrch_spot(top_spot++, hl, pos, cs, sbptr, dir, nomatch);
+	    dir = -odir;
+	    skip_pos = 1;
+	    goto rpt;
+	} else if(cmd == Th(z_virepeatsearch)) {
+	    set_isrch_spot(top_spot++, hl, pos, cs, sbptr, dir, nomatch);
+	    dir = odir;
+	    skip_pos = 1;
+	rpt:
+	    if (!sbptr && previous_search_len) {
+		if (previous_search_len > sibuf - FIRST_SEARCH_CHAR - 2) {
+		    ibuf = hrealloc(ibuf, sibuf, sibuf + previous_search_len);
+		    sbuf = ibuf + FIRST_SEARCH_CHAR;
+		    sibuf += previous_search_len;
+		}
+		memcpy(sbuf, previous_search, sbptr = previous_search_len);
+	    }
+	    memcpy(ibuf + NORM_PROMPT_POS, (dir == 1) ? "fwd" : "bck", 3);
+	    continue;
+	} else if(cmd == Th(z_viquotedinsert) ||
+	    	cmd == Th(z_quotedinsert)) {
+	    if(cmd == Th(z_viquotedinsert)) {
+		sbuf[sbptr] = '^';
+		refresh();
+	    }
+	    if ((c = getkey(0)) == EOF)
+		feep();
+	    else
+		goto ins;
+	} else {
+	    if(cmd == Th(z_selfinsertunmeta)) {
+		c &= 0x7f;
+		if(c == '\r')
+		    c = '\n';
+	    } else if (cmd == Th(z_magicspace))
+		c = ' ';
+	    else if (cmd != Th(z_selfinsert)) {
+		ungetkeycmd();
+		if (cmd == Th(z_sendbreak))
+		    sbptr = 0;
+		break;
+	    }
+	ins:
+	    if (sbptr == PATH_MAX) {
+		feep();
+		continue;
+	    }
+	    set_isrch_spot(top_spot++, hl, pos, cs, sbptr, dir, nomatch);
+	    if (sbptr == sibuf - FIRST_SEARCH_CHAR - 2) {
+		ibuf = hrealloc(ibuf, sibuf, sibuf * 2);
+		sbuf = ibuf + FIRST_SEARCH_CHAR;
+		sibuf *= 2;
+	    }
+	    sbuf[sbptr++] = c;
+	}
+	handlefeep();
+    }
+    if (sbptr) {
+	zfree(previous_search, previous_search_len);
+	previous_search = zalloc(sbptr);
+	memcpy(previous_search, sbuf, previous_search_len = sbptr);
+    }
+    statusline = NULL;
+    selectkeymap(okeymap, 1);
+}
+
+/**/
+void
+acceptandinfernexthistory(void)
+{
+    int t0;
+    char *s;
+
+    done = 1;
+    for (t0 = histline - 2;; t0--) {
+	if (!(s = qgetevent(t0)))
+	    return;
+	if (!metadiffer(s, (char *) line, ll))
+	    break;
+    }
+    if (!(s = qgetevent(t0 + 1)))
+	return;
+    pushnode(bufstack, ztrdup(s));
+    stackhist = t0 + 1;
+}
+
+/**/
+void
+infernexthistory(void)
+{
+    int t0;
+    char *s;
+
+    for (t0 = histline - 2;; t0--) {
+	if (!(s = qgetevent(t0))) {
+	    feep();
+	    return;
+	}
+	if (! metadiffer(s, (char *) line, ll))
+	    break;
+    }
+    if (!(s = qgetevent(t0 + 1))) {
+	feep();
+	return;
+    }
+    zle_goto_hist(t0 + 1);
+}
+
+/**/
+void
+vifetchhistory(void)
+{
+    if (zmult < 0)
+	return;
+    if (histline == curhist) {
+	if (!(zmod.flags & MOD_MULT)) {
+	    cs = ll;
+	    cs = findbol();
+	    return;
+	}
+    }
+    if (!zle_goto_hist((zmod.flags & MOD_MULT) ? zmult : curhist) &&
+	isset(HISTBEEP))
+	feep();
+}
+
+/* the last vi search */
+
+static char *visrchstr;
+static int visrchsense;
+
+/**/
+static int
+getvisrchstr(void)
+{
+    char *sbuf = halloc(80);
+    int sptr = 1, ret = 0, ssbuf = 80;
+    Thingy cmd;
+    char *okeymap = curkeymapname;
+
+    if (visrchstr) {
+	zsfree(visrchstr);
+	visrchstr = NULL;
+    }
+    statusline = sbuf;
+    sbuf[0] = (visrchsense == -1) ? '?' : '/';
+    selectkeymap("main", 1);
+    while (sptr) {
+	sbuf[sptr] = '_';
+	statusll = sptr + 1;
+	refresh();
+	if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) {
+	    ret = 0;
+	    break;
+	}
+	if(cmd == Th(z_magicspace)) {
+	    c = ' ';
+	    cmd = Th(z_selfinsert);
+	}
+	if(cmd == Th(z_redisplay)) {
+	    redisplay();
+	} else if(cmd == Th(z_clearscreen)) {
+	    clearscreen();
+	} else if(cmd == Th(z_acceptline) ||
+	    	cmd == Th(z_vicmdmode)) {
+	    sbuf[sptr] = 0;
+	    visrchstr = metafy(sbuf + 1, sptr - 1, META_DUP);
+	    ret = 1;
+	    sptr = 0;
+	} else if(cmd == Th(z_backwarddeletechar) ||
+	    	cmd == Th(z_vibackwarddeletechar)) {
+	    sptr--;
+	} else if(cmd == Th(z_backwardkillword) ||
+	    	cmd == Th(z_vibackwardkillword)) {
+	    while(sptr != 1 && iblank(sbuf[sptr - 1]))
+		sptr--;
+	    if(iident(sbuf[sptr - 1]))
+		while(sptr != 1 && iident(sbuf[sptr - 1]))
+		    sptr--;
+	    else
+		while(sptr != 1 && !iident(sbuf[sptr - 1]) && !iblank(sbuf[sptr - 1]))
+		    sptr--;
+	} else if(cmd == Th(z_viquotedinsert) || cmd == Th(z_quotedinsert)) {
+	    if(cmd == Th(z_viquotedinsert)) {
+		sbuf[sptr] = '^';
+		refresh();
+	    }
+	    if ((c = getkey(0)) == EOF)
+		feep();
+	    else
+		goto ins;
+	} else if(cmd == Th(z_selfinsertunmeta) || cmd == Th(z_selfinsert)) {
+	    if(cmd == Th(z_selfinsertunmeta)) {
+		c &= 0x7f;
+		if(c == '\r')
+		    c = '\n';
+	    }
+	  ins:
+	    if(sptr == ssbuf - 1) {
+		char *newbuf = halloc(ssbuf *= 2);
+		strcpy(newbuf, sbuf);
+		statusline = sbuf = newbuf;
+	    }
+	    sbuf[sptr++] = c;
+	} else {
+	    feep();
+	}
+	handlefeep();
+    }
+    statusline = NULL;
+    selectkeymap(okeymap, 1);
+    return ret;
+}
+
+/**/
+void
+vihistorysearchforward(void)
+{
+    visrchsense = 1;
+    if (getvisrchstr())
+	virepeatsearch();
+}
+
+/**/
+void
+vihistorysearchbackward(void)
+{
+    visrchsense = -1;
+    if (getvisrchstr())
+	virepeatsearch();
+}
+
+/**/
+void
+virepeatsearch(void)
+{
+    int hl = histline, t0;
+    int n = zmult;
+    char *s;
+
+    if (!visrchstr) {
+	feep();
+	return;
+    }
+    if (!n)
+	return;
+    if (n < 0) {
+	n = -n;
+	visrchsense = -visrchsense;
+    }
+    t0 = strlen(visrchstr);
+    for (;;) {
+	hl += visrchsense;
+	if (!(s = zle_get_event(hl))) {
+	    feep();
+	    return;
+	}
+	if (!metadiffer(s, (char *) line, ll))
+	    continue;
+	if (*visrchstr == '^') {
+	    if (strncmp(s, visrchstr + 1, t0 - 1) != 0)
+		continue;
+	} else if (!hstrnstr(s, 0, visrchstr, t0, 1, 1))
+	    continue;
+	if (--n <= 0)
+	    break;
+    }
+    zle_goto_hist(hl);
+}
+
+/**/
+void
+virevrepeatsearch(void)
+{
+    visrchsense = -visrchsense;
+    virepeatsearch();
+    visrchsense = -visrchsense;
+}
+
+/* Extra function added by A.R. Iano-Fletcher.	*/
+/*The extern variable "cs" is the position of the cursor. */
+/* history-beginning-search-backward */
+
+/**/
+void
+historybeginningsearchbackward(void)
+{
+    int cpos = cs;		/* save cursor position */
+    int hl = histline;
+    int n = zmult;
+    char *s;
+
+    if (!n)
+	return;
+    if (n < 0) {
+	zmult = -n;
+	historybeginningsearchforward();
+	zmult = n;
+	return;
+    }
+    for (;;) {
+	hl--;
+	if (!(s = zle_get_event(hl))) {
+	    feep();
+	    return;
+	}
+	if (metadiffer(s, (char *)line, cs) < 0 &&
+	    metadiffer(s, (char *)line, ll))
+	    if (--n <= 0)
+		break;
+    }
+
+    zle_goto_hist(hl);
+    cs = cpos;
+}
+
+/* Extra function added by A.R. Iano-Fletcher.	*/
+
+/* history-beginning-search-forward */
+/**/
+void
+historybeginningsearchforward(void)
+{
+    int cpos = cs;		/* save cursor position */
+    int hl = histline;
+    int n = zmult;
+    char *s;
+
+    if (!n)
+	return;
+    if (n < 0) {
+	zmult = -n;
+	historybeginningsearchbackward();
+	zmult = n;
+	return;
+    }
+    for (;;) {
+	hl++;
+	if (!(s = zle_get_event(hl))) {
+	    feep();
+	    return;
+	}
+	if (metadiffer(s, (char *)line, cs) < (hl == curhist) &&
+	    metadiffer(s, (char *)line, ll))
+	    if (--n <= 0)
+		break;
+    }
+
+    zle_goto_hist(hl);
+    cs = cpos;
+}
diff --git a/Src/Zle/zle_keymap.c b/Src/Zle/zle_keymap.c
new file mode 100644
index 000000000..7de96bd03
--- /dev/null
+++ b/Src/Zle/zle_keymap.c
@@ -0,0 +1,1238 @@
+/*
+ * zle_keymap.c - keymaps and key bindings
+ *
+ * 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 "zle.mdh"
+
+/*
+ * Keymap structures:
+ *
+ * There is a hash table of keymap names.  Each name just points to a keymap.
+ * More than one name may point to the same keymap.
+ *
+ * Each keymap consists of a table of bindings for each character, and a
+ * hash table of multi-character key bindings.  The keymap has no individual
+ * name, but maintains a reference count.
+ *
+ * In a keymap's table of initial bindings, each character is either bound to
+ * a thingy, or is a prefix (in which case NULL is stored).  Those prefix
+ * entries are matched by more complex entries in the multi-character
+ * binding hash table.  Each entry in this hash table (which is indexed by
+ * metafied key sequence) either has a normal thingy binding or a string to
+ * send (in which case the NULL thingy is used).  Each entry also has a count
+ * of other entries for which it is a prefix.
+ */
+
+typedef struct keymapname *KeymapName;
+typedef struct key *Key;
+
+struct keymapname {
+    HashNode next;	/* next in the hash chain */
+    char *nam;		/* name of the keymap */
+    int flags;		/* various flags (see below) */
+    Keymap keymap;	/* the keymap itsef */
+};
+
+#define KMN_IMMORTAL (1<<1)
+
+struct keymap {
+    Thingy first[256];	/* base binding of each character */
+    HashTable multi;	/* multi-character bindings */
+    int flags;		/* various flags (see below) */
+    int rc;		/* reference count */
+};
+
+#define KM_IMMUTABLE (1<<1)
+
+struct key {
+    HashNode next;	/* next in hash chain */
+    char *nam;		/* key sequence (metafied) */
+    Thingy bind;	/* binding of this key sequence */
+    char *str;		/* string for send-string (metafied) */
+    int prefixct;	/* number of sequences for which this is a prefix */
+};
+
+/* This structure is used when listing keymaps. */
+
+struct bindstate {
+    int flags;
+    char *kmname;
+    char *firstseq;
+    char *lastseq;
+    Thingy bind;
+    char *str;
+};
+
+#define BS_LIST (1<<0)
+#define BS_ALL  (1<<1)
+
+/* local functions */
+
+#include "zle_keymap.pro"
+
+/* currently selected keymap, and its name */
+
+/**/
+Keymap curkeymap;
+/**/
+char *curkeymapname;
+
+/* the hash table of keymap names */
+
+static HashTable keymapnamtab;
+
+/* key sequence reading data */
+
+static char *keybuf;
+static int keybuflen, keybufsz = 20;
+
+/* last command executed with execute-named-command */
+
+static Thingy lastnamed;
+
+/**********************************/
+/* hashtable management functions */
+/**********************************/
+
+/**/
+static void
+createkeymapnamtab(void)
+{
+    keymapnamtab = newhashtable(7, "keymapnamtab", NULL);
+
+    keymapnamtab->hash        = hasher;
+    keymapnamtab->emptytable  = emptyhashtable;
+    keymapnamtab->filltable   = NULL;
+    keymapnamtab->addnode     = addhashnode;
+    keymapnamtab->getnode     = gethashnode2;
+    keymapnamtab->getnode2    = gethashnode2;
+    keymapnamtab->removenode  = removehashnode;
+    keymapnamtab->disablenode = NULL;
+    keymapnamtab->enablenode  = NULL;
+    keymapnamtab->freenode    = freekeymapnamnode;
+    keymapnamtab->printnode   = NULL;
+}
+
+/**/
+static KeymapName
+makekeymapnamnode(Keymap keymap)
+{
+    KeymapName kmn = (KeymapName) zcalloc(sizeof(*kmn));
+
+    kmn->keymap = keymap;
+    return kmn;
+}
+
+/**/
+static void
+freekeymapnamnode(HashNode hn)
+{
+    KeymapName kmn = (KeymapName) hn;
+
+    zsfree(kmn->nam);
+    if(!--kmn->keymap->rc)
+	deletekeymap(kmn->keymap);
+    zfree(kmn, sizeof(*kmn));
+}
+
+/**/
+static HashTable
+newkeytab(char *kmname)
+{
+    HashTable ht = newhashtable(19,
+	kmname ?  dyncat("keytab:", kmname) : "keytab:", NULL);
+
+    ht->hash        = hasher;
+    ht->emptytable  = emptyhashtable;
+    ht->filltable   = NULL;
+    ht->addnode     = addhashnode;
+    ht->getnode     = gethashnode2;
+    ht->getnode2    = gethashnode2;
+    ht->removenode  = removehashnode;
+    ht->disablenode = NULL;
+    ht->enablenode  = NULL;
+    ht->freenode    = freekeynode;
+    ht->printnode   = NULL;
+
+    return ht;
+}
+
+/**/
+static Key
+makekeynode(Thingy t, char *str)
+{
+    Key k = (Key) zcalloc(sizeof(*k));
+
+    k->bind = t;
+    k->str = str;
+    return k;
+}
+
+/**/
+static void
+freekeynode(HashNode hn)
+{
+    Key k = (Key) hn;
+
+    zsfree(k->nam);
+    unrefthingy(k->bind);
+    zsfree(k->str);
+    zfree(k, sizeof(*k));
+}
+
+/**************************/
+/* main keymap operations */
+/**************************/
+
+static HashTable copyto;
+
+/**/
+static Keymap
+newkeymap(Keymap tocopy, char *kmname)
+{
+    Keymap km = zcalloc(sizeof(*km));
+    int i;
+
+    km->rc = 0;
+    km->multi = newkeytab(kmname);
+    if(tocopy) {
+	for(i = 256; i--; )
+	    km->first[i] = refthingy(tocopy->first[i]);
+	copyto = km->multi;
+	scanhashtable(tocopy->multi, 0, 0, 0, scancopykeys, 0);
+    } else {
+	for(i = 256; i--; )
+	    km->first[i] = refthingy(t_undefinedkey);
+    }
+    return km;
+}
+
+/**/
+static void
+scancopykeys(HashNode hn, int flags)
+{
+    Key k = (Key) hn;
+    Key kn = zalloc(sizeof(*k));
+
+    memcpy(kn, k, sizeof(*k));
+    refthingy(kn->bind);
+    kn->str = ztrdup(k->str);
+    copyto->addnode(copyto, ztrdup(k->nam), kn);
+}
+
+/**/
+static void
+deletekeymap(Keymap km)
+{
+    int i;
+
+    deletehashtable(km->multi);
+    for(i = 256; i--; )
+	unrefthingy(km->first[i]);
+    zfree(km, sizeof(*km));
+}
+
+static Keymap skm_km;
+static int skm_last;
+static KeyScanFunc skm_func;
+static void *skm_magic;
+
+/**/
+void
+scankeymap(Keymap km, int sort, KeyScanFunc func, void *magic)
+{
+    char m[3];
+
+    skm_km = km;
+    skm_last = sort ? -1 : 255;
+    skm_func = func;
+    skm_magic = magic;
+    scanhashtable(km->multi, sort, 0, 0, scankeys, 0);
+    if(!sort)
+	skm_last = -1;
+    while(skm_last < 255) {
+	skm_last++;
+	if(km->first[skm_last] && km->first[skm_last] != t_undefinedkey) {
+	    m[0] = skm_last;
+	    metafy(m, 1, META_NOALLOC);
+	    func(m, km->first[skm_last], NULL, magic);
+	}
+    }
+}
+
+/**/
+static void
+scankeys(HashNode hn, int flags)
+{
+    Key k = (Key) hn;
+    int f = k->nam[0] == Meta ? STOUC(k->nam[1])^32 : STOUC(k->nam[0]);
+    char m[3];
+
+    while(skm_last < f) {
+	skm_last++;
+	if(skm_km->first[skm_last] &&
+	   skm_km->first[skm_last] != t_undefinedkey) {
+	    m[0] = skm_last;
+	    metafy(m, 1, META_NOALLOC);
+	    skm_func(m, skm_km->first[skm_last], NULL, skm_magic);
+	}
+    }
+    skm_func(k->nam, k->bind, k->str, skm_magic);
+}
+
+/**************************/
+/* keymap name operations */
+/**************************/
+
+/**/
+Keymap
+openkeymap(char *name)
+{
+    KeymapName n = (KeymapName) keymapnamtab->getnode(keymapnamtab, name);
+    return n ? n->keymap : NULL;
+}
+
+/**/
+static int
+unlinkkeymap(char *name)
+{
+    KeymapName n = (KeymapName) keymapnamtab->getnode(keymapnamtab, name);
+    if(!n)
+	return 2;
+    if(n->flags & KMN_IMMORTAL)
+	return 1;
+    keymapnamtab->freenode(keymapnamtab->removenode(keymapnamtab, name));
+    return 0;
+}
+
+/**/
+static int
+linkkeymap(Keymap km, char *name)
+{
+    KeymapName n = (KeymapName) keymapnamtab->getnode(keymapnamtab, name);
+    if(n) {
+	if(n->flags & KMN_IMMORTAL)
+	    return 1;
+	if(n->keymap == km)
+	    return 0;
+	if(!--n->keymap->rc)
+	    deletekeymap(n->keymap);
+	n->keymap = km;
+    } else
+	keymapnamtab->addnode(keymapnamtab, ztrdup(name),
+	    makekeymapnamnode(km));
+    km->rc++;
+    return 0;
+}
+
+/* Select a keymap as the current ZLE keymap.  Can optionally fall back *
+ * on the guaranteed safe keymap if it fails.                           */
+
+/**/
+int
+selectkeymap(char *name, int fb)
+{
+    Keymap km = openkeymap(name);
+
+    if(!km) {
+	char *nm = niceztrdup(name);
+	char *msg = tricat("No such keymap `", nm, "'");
+
+	zsfree(nm);
+	showmsg(msg);
+	zsfree(msg);
+	if(!fb)
+	    return 1;
+	km = openkeymap(name = ".safe");
+    }
+    curkeymapname = name;
+    curkeymap = km;
+    return 0;
+}
+
+/* Reopen the currently selected keymap, in case it got deleted.  This *
+ * should be called after doing anything that might have run an        *
+ * arbitrary user-specified command.                                   */
+
+/**/
+void
+reselectkeymap(void)
+{
+    selectkeymap(curkeymapname, 1);
+}
+
+/******************************/
+/* operations on key bindings */
+/******************************/
+
+/* Add/delete/change a keybinding in some keymap.  km is the keymap to be *
+ * altered.  seq is the metafied key sequence whose binding is to change. *
+ * bind is the thingy to which the key sequence is to be bound.  For      *
+ * send-string, bind is NULL and str is the metafied key sequence to push *
+ * back onto the input.                                                   */
+
+/**/
+int
+bindkey(Keymap km, char *seq, Thingy bind, char *str)
+{
+    Key k;
+    int f = seq[0] == Meta ? STOUC(seq[1])^32 : STOUC(seq[0]);
+    char *buf, *ptr;
+
+    if(km->flags & KM_IMMUTABLE)
+	return 1;
+    if(!*seq)
+	return 2;
+    if(!bind || ztrlen(seq) > 1) {
+	/* key needs to become a prefix if isn't one already */
+	if(km->first[f]) {
+	    char fs[3];
+	    fs[0] = f;
+	    metafy(fs, 1, META_NOALLOC);
+	    km->multi->addnode(km->multi, ztrdup(fs),
+		makekeynode(km->first[f], NULL));
+	    km->first[f] = NULL;
+	}
+	k = (Key) km->multi->getnode(km->multi, seq);
+    } else {
+	/* If the sequence is a prefix entry only due to being *
+	 * a send-string binding, we can remove that entry.    */
+	if(!km->first[f]) {
+	    k = (Key) km->multi->getnode(km->multi, seq);
+	    if(!k->prefixct)
+		km->multi->freenode(km->multi->removenode(km->multi, seq));
+	    else
+		goto domulti;
+	} else
+	    unrefthingy(km->first[f]);
+	/* Just replace the single-character binding. */
+	km->first[f] = bind;
+	return 0;
+    }
+    domulti:
+    buf = ztrdup(seq);
+    ptr = strchr(buf, 0);
+    if(bind == t_undefinedkey) {
+	if(k) {
+	    zsfree(k->str);
+	    unrefthingy(k->bind);
+	    k->bind = t_undefinedkey;
+	    k->str = NULL;
+	    while(!k->prefixct && k->bind == t_undefinedkey) {
+		km->multi->freenode(km->multi->removenode(km->multi, buf));
+		*--ptr = 0;
+		if(ptr[-1] == Meta)
+		    *--ptr = 0;
+		k = (Key) km->multi->getnode(km->multi, buf);
+		k->prefixct--;
+		if(!k->prefixct && k->bind &&
+		    (!buf[1] || (buf[0] == Meta && !buf[2]))) {
+		    km->first[f] = refthingy(k->bind);
+		    km->multi->freenode(km->multi->removenode(km->multi, buf));
+		    break;
+		}
+	    }
+	}
+    } else {
+	if(!k) {
+	    int added;
+
+	    km->multi->addnode(km->multi, ztrdup(buf), makekeynode(bind, ztrdup(str)));
+	    do {
+		*--ptr = 0;
+		if(ptr > buf && ptr[-1] == Meta)
+		    *--ptr = 0;
+		k = (Key) km->multi->getnode(km->multi, buf);
+		if((added = !k))
+		    km->multi->addnode(km->multi, ztrdup(buf),
+			k = makekeynode(refthingy(t_undefinedkey), NULL));
+		k->prefixct++;
+	    } while(added);
+	} else {
+	    unrefthingy(k->bind);
+	    zsfree(k->str);
+	    k->bind = bind;
+	    k->str = bind ? NULL : ztrdup(str);
+	}
+    }
+    free(buf);
+    return 0;
+}
+
+/* Look up a key binding.  The binding is returned.  In the case of a  *
+ * send-string, NULL is returned and *strp is modified to point to the *
+ * metafied string of characters to be pushed back.                    */
+
+/**/
+Thingy
+keybind(Keymap km, char *seq, char **strp)
+{
+    Key k;
+
+    if(ztrlen(seq) == 1) {
+	int f = seq[0] == Meta ? STOUC(seq[1])^32 : STOUC(seq[0]);
+	Thingy bind = km->first[f];
+
+	if(bind)
+	    return bind;
+    }
+    k = (Key) km->multi->getnode(km->multi, seq);
+    if(!k)
+	return t_undefinedkey;
+    *strp = k->str;
+    return k->bind;
+}
+
+/* Check whether a key sequence is a prefix of a longer bound sequence. *
+ * One oddity: if *nothing* in the keymap is bound, this returns true   *
+ * for the empty sequence, even though this is not strictly accurate.   */
+
+/**/
+static int
+keyisprefix(Keymap km, char *seq)
+{
+    Key k;
+
+    if(!*seq)
+	return 1;
+    if(ztrlen(seq) == 1) {
+	int f = seq[0] == Meta ? STOUC(seq[1])^32 : STOUC(seq[0]);
+
+	if(km->first[f])
+	    return 0;
+    }
+    k = (Key) km->multi->getnode(km->multi, seq);
+    return k && k->prefixct;
+}
+
+/*******************/
+/* bindkey builtin */
+/*******************/
+
+/*
+ * THE BINDKEY BUILTIN
+ *
+ * Keymaps can be specified to bindkey in the following ways:
+ *
+ *   -e   select "emacs", also link it to "main"
+ *   -v   select "viins", also link it to "main"
+ *   -a   select "vicmd"
+ *   -M   first argument gives map name
+ *        defaults to "main"
+ *
+ * These operations cannot have a keymap selected in the normal way:
+ *
+ *   -l   list all the keymap names
+ *   -d   delete all keymaps and reset to the default state (no arguments)
+ *   -D   delete named keymaps
+ *   -A   link the two named keymaps (2 arguments)
+ *   -N   create new empty keymap (1 argument)
+ *   -N   create new keymap, copying the second named keymap (2 arguments)
+ *
+ * Other operations:
+ *
+ *   -m   add the meta bindings to the selected keymap (no arguments)
+ *   -r   unbind each named string in the selected keymap
+ *   -s   bind send-strings in the selected keymap (2+ arguments)
+ *        bind commands in the selected keymap (2+ arguments)
+ *        display one binding in the selected keymap (1 argument)
+ *        display the entire selected keymap (no arguments)
+ *
+ * There is an exception that the entire keymap display will not be performed
+ * if the -e or -v options were used.
+ *
+ * Other options:
+ *
+ *   -L   do listings in the form of bindkey commands
+ *   -R   for the binding operations, accept ranges instead of sequences
+ */
+
+/**/
+int
+bin_bindkey(char *name, char **argv, char *ops, int func)
+{
+    static struct opn {
+	char o;
+	char selp;
+	int (*func) _((char *, char *, Keymap, char **, char *, char));
+	int min, max;
+    } const opns[] = {
+	{ 'l', 0, bin_bindkey_lsmaps, 0,  0 },
+	{ 'd', 0, bin_bindkey_delall, 0,  0 },
+	{ 'D', 0, bin_bindkey_del,    1, -1 },
+	{ 'A', 0, bin_bindkey_link,   2,  2 },
+	{ 'N', 0, bin_bindkey_new,    1,  2 },
+	{ 'm', 1, bin_bindkey_meta,   0,  0 },
+	{ 'r', 1, bin_bindkey_bind,   1, -1 },
+	{ 's', 1, bin_bindkey_bind,   2, -1 },
+	{ 0,   1, bin_bindkey_bind,   0, -1 },
+    };
+    struct opn const *op, *opp;
+    char *kmname;
+    Keymap km;
+    int n;
+
+    /* select operation and ensure no clashing arguments */
+    for(op = opns; op->o && !ops[op->o]; op++) ;
+    if(op->o)
+	for(opp = op; (++opp)->o; )
+	    if(ops[opp->o]) {
+		zwarnnam(name, "incompatible operation selection options",
+		    NULL, 0);
+		return 1;
+	    }
+    n = ops['e'] + ops['v'] + ops['a'] + ops['M'];
+    if(!op->selp && n) {
+	zwarnnam(name, "keymap cannot be selected with -%c", NULL, op->o);
+	return 1;
+    }
+    if(n > 1) {
+	zwarnnam(name, "incompatible keymap selection options", NULL, 0);
+	return 1;
+    }
+
+    /* keymap selection */
+    if(op->selp) {
+	if(ops['e'])
+	    kmname = "emacs";
+	else if(ops['v'])
+	    kmname = "viins";
+	else if(ops['a'])
+	    kmname = "vicmd";
+	else if(ops['M']) {
+	    kmname = *argv++;
+	    if(!kmname) {
+		zwarnnam(name, "-M option requires a keymap argument", NULL, 0);
+		return 1;
+	    }
+	} else
+	    kmname = "main";
+	km = openkeymap(kmname);
+	if(!km) {
+	    zwarnnam(name, "no such keymap `%s'", kmname, 0);
+	    return 1;
+	}
+	if(ops['e'] || ops['v'])
+	    linkkeymap(km, "main");
+    } else {
+	kmname = NULL;
+	km = NULL;
+    }
+
+    /* listing is a special case */
+    if(!op->o && (!argv[0] || !argv[1])) {
+	if(ops['e'] || ops['v'])
+	    return 0;
+	return bin_bindkey_list(name, kmname, km, argv, ops, op->o);
+    }
+
+    /* check number of arguments */
+    for(n = 0; argv[n]; n++) ;
+    if(n < op->min) {
+	zwarnnam(name, "not enough arguments for -%c", NULL, op->o);
+	return 1;
+    } else if(op->max != -1 && n > op->max) {
+	zwarnnam(name, "too many arguments for -%c", NULL, op->o);
+	return 1;
+    }
+
+    /* pass on the work to the operation function */
+    return op->func(name, kmname, km, argv, ops, op->o);
+}
+
+/* list the available keymaps */
+
+/**/
+static int
+bin_bindkey_lsmaps(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    scanhashtable(keymapnamtab, 1, 0, 0, scanlistmaps, ops['L']);
+    return 0;
+}
+
+/**/
+static void
+scanlistmaps(HashNode hn, int list)
+{
+    KeymapName n = (KeymapName) hn;
+
+    if(list) {
+	fputs("bindkey -N ", stdout);
+	if(n->nam[0] == '-')
+	    fputs("-- ", stdout);
+	quotedzputs(n->nam, stdout);
+    } else
+	nicezputs(n->nam, stdout);
+    putchar('\n');
+}
+
+/* reset all keymaps to the default state */
+
+/**/
+static int
+bin_bindkey_delall(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    keymapnamtab->emptytable(keymapnamtab);
+    default_bindings();
+    return 0;
+}
+
+/* delete named keymaps */
+
+/**/
+static int
+bin_bindkey_del(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    int ret = 0;
+
+    do {
+	int r = unlinkkeymap(*argv);
+	if(r == 1)
+	    zwarnnam(name, "keymap name `%s' is protected", *argv, 0);
+	else if(r == 2)
+	    zwarnnam(name, "no such keymap `%s'", *argv, 0);
+	ret |= !!r;
+    } while(*++argv);
+    return ret;
+}
+
+/* link named keymaps */
+
+/**/
+static int
+bin_bindkey_link(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    km = openkeymap(argv[0]);
+    if(!km) {
+	zwarnnam(name, "no such keymap `%s'", argv[0], 0);
+	return 1;
+    } else if(linkkeymap(km, argv[1])) {
+	zwarnnam(name, "keymap name `%s' is protected", argv[1], 0);
+	return 1;
+    }
+    return 0;
+}
+
+/* create a new keymap */
+
+/**/
+static int
+bin_bindkey_new(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    KeymapName kmn = (KeymapName) keymapnamtab->getnode(keymapnamtab, argv[0]);
+
+    if(kmn && (kmn -> flags & KMN_IMMORTAL)) {
+	zwarnnam(name, "keymap name `%s' is protected", argv[0], 0);
+	return 1;
+    }
+    if(argv[1]) {
+	km = openkeymap(argv[1]);
+	if(!km) {
+	    zwarnnam(name, "no such keymap `%s'", argv[0], 0);
+	    return 1;
+	}
+    } else
+	km = NULL;
+    linkkeymap(newkeymap(km, argv[0]), argv[0]);
+    return 0;
+}
+
+/* Add standard meta bindings to a keymap.  Only sequences currently either *
+ * unbound or bound to self-insert are affected.  Note that the use of      *
+ * bindkey() is quite necessary: if this function were to go through the    *
+ * km->first table itself, it would miss any prefix sequences that should   *
+ * be rebound.                                                              */
+
+/**/
+static int
+bin_bindkey_meta(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    char m[3], *str;
+    int i;
+    Thingy fn;
+
+    if(km->flags & KM_IMMUTABLE) {
+	zwarnnam(name, "keymap `%s' is protected", kmname, 0);
+	return 1;
+    }
+    for(i = 128; i < 256; i++)
+	if(metabind[i - 128] != z_undefinedkey) {
+	    m[0] = i;
+	    metafy(m, 1, META_NOALLOC);
+	    fn = keybind(km, m, &str);
+	    if(fn == t_selfinsert || fn == t_undefinedkey)
+		bindkey(km, m, refthingy(Th(metabind[i - 128])), NULL);
+	}
+    return 0;
+}
+
+/* Change key bindings.  func can be:              *
+ *   'r'  bind sequences to undefined-key          *
+ *   's'  bind sequneces to specified send-strings *
+ *   0    bind sequences to specified functions    *
+ * If the -R option is used, bind to key ranges    *
+ * instead of single key sequences.                */
+
+/**/
+static int
+bin_bindkey_bind(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    int ret = 0;
+
+    if(!func || func == 's') {
+	char **a;
+
+	for(a = argv+2; *a; a++)
+	    if(!*++a) {
+		zwarnnam(name, "even number of arguments required", NULL, 0);
+		return 1;
+	    }
+    }
+    if(km->flags & KM_IMMUTABLE) {
+	zwarnnam(name, "keymap `%s' is protected", kmname, 0);
+	return 1;
+    }
+    do {
+	char *useq = *argv, *bseq, *seq, *str;
+	int len;
+	Thingy fn;
+
+	if(func == 'r') {
+	    fn = refthingy(t_undefinedkey);
+	    str = NULL;
+	} else if(func == 's') {
+	    str = getkeystring(*++argv, &len, 2, NULL);
+	    fn = NULL;
+	    str = metafy(str, len, META_HREALLOC);
+	} else {
+	    fn = rthingy(*++argv);
+	    str = NULL;
+	}
+	bseq = getkeystring(useq, &len, 2, NULL);
+	seq = metafy(bseq, len, META_USEHEAP);
+	if(ops['R']) {
+	    int first, last;
+	    char m[3];
+
+	    if(len < 2 || len > 2 + (bseq[1] == '-') ||
+	       (first = STOUC(bseq[0])) > (last = STOUC(bseq[len - 1]))) {
+		zwarnnam(name, "malformed key range `%s'", useq, 0);
+		ret = 1;
+	    } else {
+		for(; first <= last; first++) {
+		    m[0] = first;
+		    metafy(m, 1, META_NOALLOC);
+		    bindkey(km, m, refthingy(fn), str);
+		}
+		unrefthingy(fn);
+	    }
+	} else {
+	    if(bindkey(km, seq, fn, str)) {
+		zwarnnam(name, "cannot bind to an empty key sequence", NULL, 0);
+		ret = 1;
+	    }
+	}
+    } while(*++argv);
+    return ret;
+}
+
+/* List key bindings.  If an argument is given, list just that one *
+ * binding, otherwise list the entire keymap.  If the -L option is *
+ * given, list in the form of bindkey commands.                    */
+
+/**/
+static int
+bin_bindkey_list(char *name, char *kmname, Keymap km, char **argv, char *ops, char func)
+{
+    struct bindstate bs;
+
+    bs.flags = ops['L'] ? BS_LIST : 0;
+    bs.kmname = kmname;
+    if(argv[0]) {
+	int len;
+	char *seq;
+
+	seq = getkeystring(argv[0], &len, 2, NULL);
+	seq = metafy(seq, len, META_HREALLOC);
+	bs.flags |= BS_ALL;
+	bs.firstseq = bs.lastseq = seq;
+	bs.bind = keybind(km, seq, &bs.str);
+	bindlistout(&bs);
+    } else {
+	bs.firstseq = ztrdup("");
+	bs.lastseq = ztrdup("");
+	bs.bind = t_undefinedkey;
+	bs.str = NULL;
+	scankeymap(km, 1, scanbindlist, &bs);
+	bindlistout(&bs);
+	zsfree(bs.firstseq);
+	zsfree(bs.lastseq);
+    }
+    return 0;
+}
+
+/**/
+static void
+scanbindlist(char *seq, Thingy bind, char *str, void *magic)
+{
+    struct bindstate *bs = magic;
+
+    if(bind == bs->bind && (bind || !strcmp(str, bs->str)) &&
+       ztrlen(seq) == 1 && ztrlen(bs->lastseq) == 1) {
+	int l = bs->lastseq[1] ?
+	    STOUC(bs->lastseq[1]) ^ 32 : STOUC(bs->lastseq[0]);
+	int t = seq[1] ? STOUC(seq[1]) ^ 32 : STOUC(seq[0]);
+
+	if(t == l + 1) {
+	    zsfree(bs->lastseq);
+	    bs->lastseq = ztrdup(seq);
+	    return;
+	}
+    }
+    bindlistout(bs);
+    zsfree(bs->firstseq);
+    bs->firstseq = ztrdup(seq);
+    zsfree(bs->lastseq);
+    bs->lastseq = ztrdup(seq);
+    bs->bind = bind;
+    bs->str = str;
+}
+
+/**/
+static void
+bindlistout(struct bindstate *bs)
+{
+    int range;
+
+    if(bs->bind == t_undefinedkey && !(bs->flags & BS_ALL))
+	return;
+    range = strcmp(bs->firstseq, bs->lastseq);
+    if(bs->flags & BS_LIST) {
+	int nodash = 1;
+
+	fputs("bindkey ", stdout);
+	if(range)
+	    fputs("-R ", stdout);
+	if(!bs->bind)
+	    fputs("-s ", stdout);
+	if(!strcmp(bs->kmname, "main"))
+	    ;
+	else if(!strcmp(bs->kmname, "vicmd"))
+	    fputs("-a ", stdout);
+	else {
+	    fputs("-M ", stdout);
+	    quotedzputs(bs->kmname, stdout);
+	    putchar(' ');
+	    nodash = 0;
+	}
+	if(nodash && bs->firstseq[0] == '-')
+	    fputs("-- ", stdout);
+    }
+    printbind(bs->firstseq, stdout);
+    if(range) {
+	putchar('-');
+	printbind(bs->lastseq, stdout);
+    }
+    putchar(' ');
+    if(bs->bind) {
+	((bs->flags & BS_LIST) ? quotedzputs : nicezputs)
+	    (bs->bind->nam, stdout);
+    } else
+	printbind(bs->str, stdout);
+    putchar('\n');
+}
+
+/****************************/
+/* initialisation functions */
+/****************************/
+
+/* main initialisation entry point */
+
+/**/
+void
+init_keymaps(void)
+{
+    createkeymapnamtab();
+    default_bindings();
+    keybuf = (char *)zalloc(keybufsz);
+    lastnamed = refthingy(t_undefinedkey);
+}
+
+#ifdef MODULE
+
+/* cleanup entry point (for unloading the zle module) */
+
+/**/
+void
+cleanup_keymaps(void)
+{
+    unrefthingy(lastnamed);
+    deletehashtable(keymapnamtab);
+    zfree(keybuf, keybufsz);
+}
+
+#endif /* MODULE */
+
+/* Create the default keymaps.  For efficiency reasons, this function   *
+ * assigns directly to the km->first array.  It knows that there are no *
+ * prefix bindings in the way, and that it is using a simple keymap.    */
+
+/**/
+static void
+default_bindings(void)
+{
+    Keymap vmap = newkeymap(NULL, "viins");
+    Keymap emap = newkeymap(NULL, "emacs");
+    Keymap amap = newkeymap(NULL, "vicmd");
+    Keymap smap = newkeymap(NULL, ".safe");
+    char buf[3], *ed;
+    int i;
+
+    /* vi insert mode and emacs mode:  *
+     *   0-31   taken from the tables  *
+     *  32-126  self-insert            *
+     * 127      same as entry[8]       *
+     * 128-255  self-insert            */
+    for (i = 0; i < 32; i++) {
+	vmap->first[i] = refthingy(Th(viinsbind[i]));
+	emap->first[i] = refthingy(Th(emacsbind[i]));
+    }
+    for (i = 32; i < 256; i++) {
+	vmap->first[i] = refthingy(t_selfinsert);
+	emap->first[i] = refthingy(t_selfinsert);
+    }
+    unrefthingy(t_selfinsert);
+    unrefthingy(t_selfinsert);
+    vmap->first[127] = refthingy(vmap->first[8]);
+    emap->first[127] = refthingy(emap->first[8]);
+
+    /* vi command mode:              *
+     *   0-127  taken from the table *
+     * 128-255  undefined-key        */
+    for (i = 0; i < 128; i++)
+	amap->first[i] = refthingy(Th(vicmdbind[i]));
+    for (i = 128; i < 256; i++)
+	amap->first[i] = refthingy(t_undefinedkey);
+
+    /* safe fallback keymap:
+     *   0-255  self-insert, except: *
+     *    '\n'  accept-line          *
+     *    '\r'  accept-line          */
+    for (i = 0; i < 256; i++)
+	smap->first[i] = refthingy(t_selfinsert);
+    unrefthingy(t_selfinsert);
+    unrefthingy(t_selfinsert);
+    smap->first['\n'] = refthingy(t_acceptline);
+    smap->first['\r'] = refthingy(t_acceptline);
+
+    /* vt100 arrow keys are bound by default, for historical reasons. *
+     * Both standard and keypad modes are supported.                  */
+
+    /* vi command mode: arrow keys */
+    bindkey(amap, "\33[A",  refthingy(t_uplineorhistory), NULL);
+    bindkey(amap, "\33[B",  refthingy(t_downlineorhistory), NULL);
+    bindkey(amap, "\33[C",  refthingy(t_viforwardchar), NULL);
+    bindkey(amap, "\33[D",  refthingy(t_vibackwardchar), NULL);
+    bindkey(amap, "\33OA",  refthingy(t_uplineorhistory), NULL);
+    bindkey(amap, "\33OB",  refthingy(t_downlineorhistory), NULL);
+    bindkey(amap, "\33OC",  refthingy(t_viforwardchar), NULL);
+    bindkey(amap, "\33OD",  refthingy(t_vibackwardchar), NULL);
+
+    /* emacs mode: arrow keys */
+    bindkey(emap, "\33[A",  refthingy(t_uplineorhistory), NULL);
+    bindkey(emap, "\33[B",  refthingy(t_downlineorhistory), NULL);
+    bindkey(emap, "\33[C",  refthingy(t_forwardchar), NULL);
+    bindkey(emap, "\33[D",  refthingy(t_backwardchar), NULL);
+    bindkey(emap, "\33OA",  refthingy(t_uplineorhistory), NULL);
+    bindkey(emap, "\33OB",  refthingy(t_downlineorhistory), NULL);
+    bindkey(emap, "\33OC",  refthingy(t_forwardchar), NULL);
+    bindkey(emap, "\33OD",  refthingy(t_backwardchar), NULL);
+   
+    /* emacs mode: ^X sequences */
+    bindkey(emap, "\30*",   refthingy(t_expandword), NULL);
+    bindkey(emap, "\30g",   refthingy(t_listexpand), NULL);
+    bindkey(emap, "\30G",   refthingy(t_listexpand), NULL);
+    bindkey(emap, "\30\16", refthingy(t_infernexthistory), NULL);
+    bindkey(emap, "\30\13", refthingy(t_killbuffer), NULL);
+    bindkey(emap, "\30\6",  refthingy(t_vifindnextchar), NULL);
+    bindkey(emap, "\30\17", refthingy(t_overwritemode), NULL);
+    bindkey(emap, "\30\25", refthingy(t_undo), NULL);
+    bindkey(emap, "\30\26", refthingy(t_vicmdmode), NULL);
+    bindkey(emap, "\30\12", refthingy(t_vijoin), NULL);
+    bindkey(emap, "\30\2",  refthingy(t_vimatchbracket), NULL);
+    bindkey(emap, "\30s",   refthingy(t_historyincrementalsearchforward), NULL);
+    bindkey(emap, "\30r",   refthingy(t_historyincrementalsearchbackward), NULL);
+    bindkey(emap, "\30u",   refthingy(t_undo), NULL);
+    bindkey(emap, "\30\30", refthingy(t_exchangepointandmark), NULL);
+    bindkey(emap, "\30=",   refthingy(t_whatcursorposition), NULL);
+
+    /* emacs mode: ESC sequences, all taken from the meta binding table */
+    buf[0] = '\33';
+    buf[2] = 0;
+    for (i = 0; i < 128; i++)
+	if (metabind[i] != z_undefinedkey) {
+	    buf[1] = i;
+	    bindkey(emap, buf, refthingy(Th(metabind[i])), NULL);
+	}
+
+    /* Put the keymaps in the right namespace.  The "main" keymap  *
+     * will be linked to the "emacs" keymap, except that if VISUAL *
+     * or EDITOR contain the string "vi" then it will be linked to *
+     * the "viins" keymap.                                         */
+    linkkeymap(vmap, "viins");
+    linkkeymap(emap, "emacs");
+    linkkeymap(amap, "vicmd");
+    linkkeymap(smap, ".safe");
+    if (((ed = zgetenv("VISUAL")) && strstr(ed, "vi")) ||
+	((ed = zgetenv("EDITOR")) && strstr(ed, "vi")))
+	linkkeymap(vmap, "main");
+    else
+	linkkeymap(emap, "main");
+
+    /* the .safe map cannot be modified or deleted */
+    smap->flags |= KM_IMMUTABLE;
+    ((KeymapName) keymapnamtab->getnode(keymapnamtab, ".safe"))->flags
+	|= KMN_IMMORTAL;
+}
+
+/*************************/
+/* reading key sequences */
+/*************************/
+
+/* read a sequence of keys that is bound to some command in a keymap */
+
+/**/
+char *
+getkeymapcmd(Keymap km, Thingy *funcp, char **strp)
+{
+    Thingy func = t_undefinedkey;
+    char *str = NULL;
+    int lastlen = 0, lastc = c;
+
+    keybuflen = 0;
+    keybuf[0] = 0;
+    while((c = getkeybuf(!!lastlen)) != EOF) {
+	char *s;
+	Thingy f = keybind(km, keybuf, &s);
+
+	if(f != t_undefinedkey) {
+	    lastlen = keybuflen;
+	    func = f;
+	    str = s;
+	    lastc = c;
+	}
+	if(!keyisprefix(km, keybuf))
+	    break;
+    }
+    if(!lastlen && keybuflen)
+	lastlen = keybuflen;
+    else
+	c = lastc;
+    if(lastlen != keybuflen) {
+	unmetafy(keybuf + lastlen, &keybuflen);
+	ungetkeys(keybuf+lastlen, keybuflen);
+	if(vichgflag)
+	    vichgbufptr -= keybuflen;
+	keybuf[lastlen] = 0;
+    }
+    *funcp = func;
+    *strp = str;
+    return keybuf;
+}
+
+/**/
+static int
+getkeybuf(int w)
+{
+    int c = getkey(w);
+
+    if(c < 0)
+	return EOF;
+    if(keybuflen + 3 > keybufsz)
+	keybuf = realloc(keybuf, keybufsz *= 2);
+    if(imeta(c)) {
+	keybuf[keybuflen++] = Meta;
+	keybuf[keybuflen++] = c ^ 32;
+    } else
+	keybuf[keybuflen++] = c;
+    keybuf[keybuflen] = 0;
+    return c;
+}
+
+/* Push back the last command sequence read by getkeymapcmd(). *
+ * Must be executed at most once after each getkeymapcmd().    */
+
+/**/
+void
+ungetkeycmd(void)
+{
+    ungetkeys(keybuf, keybuflen);
+}
+
+/* read a command from the current keymap, with widgets */
+
+/**/
+Thingy
+getkeycmd(void)
+{
+    Thingy func;
+    int hops = 0;
+    char *seq, *str;
+
+    sentstring:
+    seq = getkeymapcmd(curkeymap, &func, &str);
+    if(!*seq)
+	return NULL;
+    if(!func) {
+	int len;
+	char *pb;
+
+	if (++hops == 20) {
+	    zerr("string inserting another one too many times", NULL, 0);
+	    hops = 0;
+	    return NULL;
+	}
+	pb = unmetafy(ztrdup(str), &len);
+	ungetkeys(pb, len);
+	zfree(pb, strlen(str) + 1);
+	goto sentstring;
+    }
+    if (func == Th(z_executenamedcmd) && !statusline) {
+	while(func == Th(z_executenamedcmd))
+	    func = executenamedcommand("execute: ");
+	if(!func)
+	    func = t_undefinedkey;
+	else if(func != Th(z_executelastnamedcmd)) {
+	    unrefthingy(lastnamed);
+	    lastnamed = refthingy(func);
+	}
+    }
+    if (func == Th(z_executelastnamedcmd))
+	func = lastnamed;
+    return func;
+}
diff --git a/Src/Zle/zle_main.c b/Src/Zle/zle_main.c
new file mode 100644
index 000000000..338cdef41
--- /dev/null
+++ b/Src/Zle/zle_main.c
@@ -0,0 +1,907 @@
+/*
+ * zle_main.c - main routines for line editor
+ *
+ * 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 "zle.mdh"
+#include "zle_main.pro"
+
+/* != 0 if we're done editing */
+
+/**/
+int done;
+
+/* location of mark */
+
+/**/
+int mark;
+
+/* last character pressed */
+
+/**/
+int c;
+
+/* the binding for this key */
+
+/**/
+Thingy bindk;
+
+/* insert mode/overwrite mode flag */
+
+/**/
+int insmode;
+
+static int eofchar, eofsent;
+static long keytimeout;
+
+#ifdef HAVE_SELECT
+/* Terminal baud rate */
+
+static int baud;
+#endif
+
+/* flags associated with last command */
+
+/**/
+int lastcmd;
+
+/* the status line, and its length */
+
+/**/
+char *statusline;
+/**/
+int statusll;
+
+/* The current history line and cursor position for the top line *
+ * on the buffer stack.                                          */
+
+/**/
+int stackhist, stackcs;
+
+/* != 0 if we are making undo records */
+
+/**/
+int undoing;
+
+/* current modifier status */
+
+/**/
+struct modifier zmod;
+
+/* Current command prefix status.  This is normally 0.  Prefixes set *
+ * this to 1.  Each time round the main loop, this is checked: if it *
+ * is 0, the modifier status is reset; if it is 1, the modifier      *
+ * status is left unchanged, and this flag is reset to 0.  The       *
+ * effect is that several prefix commands can be executed, and have  *
+ * cumulative effect, but any other command execution will clear the *
+ * modifiers.                                                        */
+
+/**/
+int prefixflag;
+
+/* != 0 if there is a pending beep (usually indicating an error) */
+
+/**/
+int feepflag;
+
+/* set up terminal */
+
+/**/
+void
+setterm(void)
+{
+    struct ttyinfo ti;
+
+#if defined(CLOBBERS_TYPEAHEAD) && defined(FIONREAD)
+    int val;
+
+    ioctl(SHTTY, FIONREAD, (char *)&val);
+    if (val)
+	return;
+#endif
+
+/* sanitize the tty */
+#ifdef HAS_TIO
+    shttyinfo.tio.c_lflag |= ICANON | ECHO;
+# ifdef FLUSHO
+    shttyinfo.tio.c_lflag &= ~FLUSHO;
+# endif
+#else				/* not HAS_TIO */
+    shttyinfo.sgttyb.sg_flags = (shttyinfo.sgttyb.sg_flags & ~CBREAK) | ECHO;
+    shttyinfo.lmodes &= ~LFLUSHO;
+#endif
+
+    attachtty(mypgrp);
+    ti = shttyinfo;
+#ifdef HAS_TIO
+    if (unset(FLOWCONTROL))
+	ti.tio.c_iflag &= ~IXON;
+    ti.tio.c_lflag &= ~(ICANON | ECHO
+# ifdef FLUSHO
+			| FLUSHO
+# endif
+	);
+# ifdef TAB3
+    ti.tio.c_oflag &= ~TAB3;
+# else
+#  ifdef OXTABS
+    ti.tio.c_oflag &= ~OXTABS;
+#  else
+    ti.tio.c_oflag &= ~XTABS;
+#  endif
+# endif
+    ti.tio.c_oflag |= ONLCR;
+    ti.tio.c_cc[VQUIT] =
+# ifdef VDISCARD
+	ti.tio.c_cc[VDISCARD] =
+# endif
+# ifdef VSUSP
+	ti.tio.c_cc[VSUSP] =
+# endif
+# ifdef VDSUSP
+	ti.tio.c_cc[VDSUSP] =
+# endif
+# ifdef VSWTCH
+	ti.tio.c_cc[VSWTCH] =
+# endif
+# ifdef VLNEXT
+	ti.tio.c_cc[VLNEXT] =
+# endif
+	VDISABLEVAL;
+# if defined(VSTART) && defined(VSTOP)
+    if (unset(FLOWCONTROL))
+	ti.tio.c_cc[VSTART] = ti.tio.c_cc[VSTOP] = VDISABLEVAL;
+# endif
+    eofchar = ti.tio.c_cc[VEOF];
+    ti.tio.c_cc[VMIN] = 1;
+    ti.tio.c_cc[VTIME] = 0;
+    ti.tio.c_iflag |= (INLCR | ICRNL);
+ /* this line exchanges \n and \r; it's changed back in getkey
+	so that the net effect is no change at all inside the shell.
+	This double swap is to allow typeahead in common cases, eg.
+
+	% bindkey -s '^J' 'echo foo^M'
+	% sleep 10
+	echo foo<return>  <--- typed before sleep returns
+
+	The shell sees \n instead of \r, since it was changed by the kernel
+	while zsh wasn't looking. Then in getkey() \n is changed back to \r,
+	and it sees "echo foo<accept line>", as expected. Without the double
+	swap the shell would see "echo foo\n", which is translated to
+	"echo fooecho foo<accept line>" because of the binding.
+	Note that if you type <line-feed> during the sleep the shell just sees
+	\n, which is translated to \r in getkey(), and you just get another
+	prompt. For type-ahead to work in ALL cases you have to use
+	stty inlcr.
+
+	Unfortunately it's IMPOSSIBLE to have a general solution if both
+	<return> and <line-feed> are mapped to the same character. The shell
+	could check if there is input and read it before setting it's own
+	terminal modes but if we get a \n we don't know whether to keep it or
+	change to \r :-(
+	*/
+
+#else				/* not HAS_TIO */
+    ti.sgttyb.sg_flags = (ti.sgttyb.sg_flags | CBREAK) & ~ECHO & ~XTABS;
+    ti.lmodes &= ~LFLUSHO;
+    eofchar = ti.tchars.t_eofc;
+    ti.tchars.t_quitc =
+	ti.ltchars.t_suspc =
+	ti.ltchars.t_flushc =
+	ti.ltchars.t_dsuspc = ti.ltchars.t_lnextc = -1;
+#endif
+
+#if defined(TTY_NEEDS_DRAINING) && defined(TIOCOUTQ) && defined(HAVE_SELECT)
+    if (baud) {			/**/
+	int n = 0;
+
+	while ((ioctl(SHTTY, TIOCOUTQ, (char *)&n) >= 0) && n) {
+	    struct timeval tv;
+
+	    tv.tv_sec = n / baud;
+	    tv.tv_usec = ((n % baud) * 1000000) / baud;
+	    select(0, NULL, NULL, NULL, &tv);
+	}
+    }
+#endif
+
+    settyinfo(&ti);
+}
+
+static char *kungetbuf;
+static int kungetct, kungetsz;
+
+/**/
+void
+ungetkey(int ch)
+{
+    if (kungetct == kungetsz)
+	kungetbuf = realloc(kungetbuf, kungetsz *= 2);
+    kungetbuf[kungetct++] = ch;
+}
+
+/**/
+void
+ungetkeys(char *s, int len)
+{
+    s += len;
+    while (len--)
+	ungetkey(*--s);
+}
+
+#if defined(pyr) && defined(HAVE_SELECT)
+static int
+breakread(int fd, char *buf, int n)
+{
+    fd_set f;
+
+    FD_ZERO(&f);
+    FD_SET(fd, &f);
+    return (select(fd + 1, (SELECT_ARG_2_T) & f, NULL, NULL, NULL) == -1 ?
+	    EOF : read(fd, buf, n));
+}
+
+# define read    breakread
+#endif
+
+/**/
+int
+getkey(int keytmout)
+{
+    char cc;
+    unsigned int ret;
+    long exp100ths;
+    int die = 0, r, icnt = 0;
+    int old_errno = errno;
+
+#ifdef HAVE_SELECT
+    fd_set foofd;
+
+#else
+# ifdef HAS_TIO
+    struct ttyinfo ti;
+
+# endif
+#endif
+
+    if (kungetct)
+	ret = STOUC(kungetbuf[--kungetct]);
+    else {
+	if (keytmout) {
+	    if (keytimeout > 500)
+		exp100ths = 500;
+	    else if (keytimeout > 0)
+		exp100ths = keytimeout;
+	    else
+		exp100ths = 0;
+#ifdef HAVE_SELECT
+	    if (exp100ths) {
+		struct timeval expire_tv;
+
+		expire_tv.tv_sec = exp100ths / 100;
+		expire_tv.tv_usec = (exp100ths % 100) * 10000L;
+		FD_ZERO(&foofd);
+		FD_SET(SHTTY, &foofd);
+		if (select(SHTTY+1, (SELECT_ARG_2_T) & foofd,
+			   NULL, NULL, &expire_tv) <= 0)
+		    return EOF;
+	    }
+#else
+# ifdef HAS_TIO
+	    ti = shttyinfo;
+	    ti.tio.c_lflag &= ~ICANON;
+	    ti.tio.c_cc[VMIN] = 0;
+	    ti.tio.c_cc[VTIME] = exp100ths / 10;
+#  ifdef HAVE_TERMIOS_H
+	    tcsetattr(SHTTY, TCSANOW, &ti.tio);
+#  else
+	    ioctl(SHTTY, TCSETA, &ti.tio);
+#  endif
+	    r = read(SHTTY, &cc, 1);
+#  ifdef HAVE_TERMIOS_H
+	    tcsetattr(SHTTY, TCSANOW, &shttyinfo.tio);
+#  else
+	    ioctl(SHTTY, TCSETA, &shttyinfo.tio);
+#  endif
+	    return (r <= 0) ? EOF : cc;
+# endif
+#endif
+	}
+	while ((r = read(SHTTY, &cc, 1)) != 1) {
+	    if (r == 0) {
+		/* The test for IGNOREEOF was added to make zsh ignore ^Ds
+		   that were typed while commands are running.  Unfortuantely
+		   this caused trouble under at least one system (SunOS 4.1).
+		   Here shells that lost their xterm (e.g. if it was killed
+		   with -9) didn't fail to read from the terminal but instead
+		   happily continued to read EOFs, so that the above read
+		   returned with 0, and, with IGNOREEOF set, this caused
+		   an infinite loop.  The simple way around this was to add
+		   the counter (icnt) so that this happens 20 times and than
+		   the shell gives up (yes, this is a bit dirty...). */
+		if (isset(IGNOREEOF) && icnt++ < 20)
+		    continue;
+		stopmsg = 1;
+		zexit(1, 0);
+	    }
+	    icnt = 0;
+	    if (errno == EINTR) {
+		die = 0;
+		if (!errflag && !retflag && !breaks)
+		    continue;
+		errflag = 0;
+		errno = old_errno;
+		return EOF;
+	    } else if (errno == EWOULDBLOCK) {
+		fcntl(0, F_SETFL, 0);
+	    } else if (errno == EIO && !die) {
+		ret = opts[MONITOR];
+		opts[MONITOR] = 1;
+		attachtty(mypgrp);
+		refresh();	/* kludge! */
+		opts[MONITOR] = ret;
+		die = 1;
+	    } else if (errno != 0) {
+		zerr("error on TTY read: %e", NULL, errno);
+		stopmsg = 1;
+		zexit(1, 0);
+	    }
+	}
+	if (cc == '\r')		/* undo the exchange of \n and \r determined by */
+	    cc = '\n';		/* setterm() */
+	else if (cc == '\n')
+	    cc = '\r';
+
+	ret = STOUC(cc);
+    }
+    if (vichgflag) {
+	if (vichgbufptr == vichgbufsz)
+	    vichgbuf = realloc(vichgbuf, vichgbufsz *= 2);
+	vichgbuf[vichgbufptr++] = ret;
+    }
+    errno = old_errno;
+    return ret;
+}
+
+/* Read a line.  It is returned metafied. */
+
+/**/
+unsigned char *
+zleread(char *lp, char *rp, int ha)
+{
+    unsigned char *s;
+    int old_errno = errno;
+    int tmout = getiparam("TMOUT");
+
+#ifdef HAVE_SELECT
+    long costmult;
+    struct timeval tv;
+    fd_set foofd;
+
+    baud = getiparam("BAUD");
+    costmult = (baud) ? 3840000L / baud : 0;
+    tv.tv_sec = 0;
+#endif
+
+    /* ZLE doesn't currently work recursively.  This is needed in case a *
+     * select loop is used in a function called from ZLE.  vared handles *
+     * this differently itself.                                          */
+    if(zleactive) {
+	char *pptbuf;
+	int pptlen;
+
+	pptbuf = unmetafy(promptexpand(lp, 0, NULL, NULL), &pptlen);
+	write(2, (WRITE_ARG_2_T)pptbuf, pptlen);
+	free(pptbuf);
+	return (unsigned char *)shingetline();
+    }
+
+    keytimeout = getiparam("KEYTIMEOUT");
+    if (!shout) {
+	if (SHTTY != -1)
+	    init_shout();
+
+	if (!shout)
+	    return NULL;
+	/* We could be smarter and default to a system read. */
+
+	/* If we just got a new shout, make sure the terminal is set up. */
+	if (termflags & TERM_UNKNOWN)
+	    init_term();
+    }
+
+    fflush(shout);
+    fflush(stderr);
+    intr();
+    insmode = unset(OVERSTRIKE);
+    eofsent = 0;
+    resetneeded = 0;
+    lpptbuf = promptexpand(lp, 1, NULL, NULL);
+    pmpt_attr = txtchange;
+    rpptbuf = promptexpand(rp, 1, NULL, NULL);
+    rpmpt_attr = txtchange;
+    histallowed = ha;
+    PERMALLOC {
+	histline = curhist;
+#ifdef HAVE_SELECT
+	FD_ZERO(&foofd);
+#endif
+	undoing = 1;
+	line = (unsigned char *)zalloc((linesz = 256) + 2);
+	virangeflag = lastcmd = done = cs = ll = mark = 0;
+	curhistline = NULL;
+	vichgflag = 0;
+	viinsbegin = 0;
+	statusline = NULL;
+	selectkeymap("main", 1);
+	fixsuffix();
+	if ((s = (unsigned char *)getlinknode(bufstack))) {
+	    setline((char *)s);
+	    zsfree((char *)s);
+	    if (stackcs != -1) {
+		cs = stackcs;
+		stackcs = -1;
+		if (cs > ll)
+		    cs = ll;
+	    }
+	    if (stackhist != -1) {
+		histline = stackhist;
+		stackhist = -1;
+	    }
+	}
+	initundo();
+	if (isset(PROMPTCR))
+	    putc('\r', shout);
+	if (tmout)
+	    alarm(tmout);
+	zleactive = 1;
+	resetneeded = 1;
+	errflag = retflag = 0;
+	lastcol = -1;
+	initmodifier(&zmod);
+	prefixflag = 0;
+	feepflag = 0;
+	refresh();
+	while (!done && !errflag) {
+
+	    statusline = NULL;
+	    vilinerange = 0;
+	    reselectkeymap();
+	    bindk = getkeycmd();
+	    if (!ll && isfirstln && c == eofchar) {
+		eofsent = 1;
+		break;
+	    }
+	    if (bindk) {
+		execzlefunc(bindk);
+		handleprefixes();
+		/* for vi mode, make sure the cursor isn't somewhere illegal */
+		if (invicmdmode() && cs > findbol() &&
+		    (cs == ll || line[cs] == '\n'))
+		    cs--;
+		if (undoing)
+		    handleundo();
+	    } else {
+		errflag = 1;
+		break;
+	    }
+#ifdef HAVE_SELECT
+	    if (baud && !(lastcmd & ZLE_MENUCMP)) {
+		FD_SET(SHTTY, &foofd);
+		if ((tv.tv_usec = cost * costmult) > 500000)
+		    tv.tv_usec = 500000;
+		if (!kungetct && select(SHTTY+1, (SELECT_ARG_2_T) & foofd,
+					NULL, NULL, &tv) <= 0)
+		    refresh();
+	    } else
+#endif
+		if (!kungetct)
+		    refresh();
+	    handlefeep();
+	}
+	statusline = NULL;
+	invalidatelist();
+	trashzle();
+	free(lpptbuf);
+	free(rpptbuf);
+	zleactive = 0;
+	alarm(0);
+    } LASTALLOC;
+    zsfree(curhistline);
+    freeundo();
+    if (eofsent) {
+	free(line);
+	line = NULL;
+    } else {
+	line[ll++] = '\n';
+	line = (unsigned char *) metafy((char *) line, ll, META_REALLOC);
+    }
+    forget_edits();
+    errno = old_errno;
+    return line;
+}
+
+/* execute a widget */
+
+/**/
+void
+execzlefunc(Thingy func)
+{
+    Widget w;
+
+    if(func->flags & DISABLED) {
+	/* this thingy is not the name of a widget */
+	char *nm = niceztrdup(func->nam);
+	char *msg = tricat("No such widget `", nm, "'");
+
+	zsfree(nm);
+	showmsg(msg);
+	zsfree(msg);
+	feep();
+    } else if((w = func->widget)->flags & WIDGET_INT) {
+	int wflags = w->flags;
+
+	if(!(wflags & ZLE_KEEPSUFFIX))
+	    removesuffix();
+	if(!(wflags & ZLE_MENUCMP)) {
+	    fixsuffix();
+	    invalidatelist();
+	}
+	if (wflags & ZLE_LINEMOVE)
+	    vilinerange = 1;
+	if(!(wflags & ZLE_LASTCOL))
+	    lastcol = -1;
+	w->u.fn();
+	lastcmd = wflags;
+    } else {
+	List l = getshfunc(w->u.fnnam);
+
+	if(l == &dummy_list) {
+	    /* the shell function doesn't exist */
+	    char *nm = niceztrdup(w->u.fnnam);
+	    char *msg = tricat("No such shell function `", nm, "'");
+
+	    zsfree(nm);
+	    showmsg(msg);
+	    zsfree(msg);
+	    feep();
+	} else {
+	  startparamscope();
+	  makezleparams();
+	  doshfunc(l, NULL, 0, 1);
+	  endparamscope();
+	  lastcmd = 0;
+	}
+    }
+}
+
+/* initialise command modifiers */
+
+/**/
+static void
+initmodifier(struct modifier *mp)
+{
+    mp->flags = 0;
+    mp->mult = 1;
+    mp->tmult = 1;
+    mp->vibuf = 0;
+}
+
+/* Reset command modifiers, unless the command just executed was a prefix. *
+ * Also set zmult, if the multiplier has been amended.                     */
+
+/**/
+static void
+handleprefixes(void)
+{
+    if (prefixflag) {
+	prefixflag = 0;
+	if(zmod.flags & MOD_TMULT) {
+	    zmod.flags |= MOD_MULT;
+	    zmod.mult = zmod.tmult;
+	}
+    } else
+	initmodifier(&zmod);
+}
+
+/* vared: edit (literally) a parameter value */
+
+/**/
+static int
+bin_vared(char *name, char **args, char *ops, int func)
+{
+    char *s;
+    char *t;
+    Param pm;
+    int create = 0;
+    char *p1 = NULL, *p2 = NULL;
+
+    /* all options are handled as arguments */
+    while (*args && **args == '-') {
+	while (*++(*args))
+	    switch (**args) {
+	    case 'c':
+		/* -c option -- allow creation of the parameter if it doesn't
+		yet exist */
+		create = 1;
+		break;
+	    case 'p':
+		/* -p option -- set main prompt string */
+		if ((*args)[1])
+		    p1 = *args + 1, *args = "" - 1;
+		else if (args[1])
+		    p1 = *(++args), *args = "" - 1;
+		else {
+		    zwarnnam(name, "prompt string expected after -%c", NULL,
+			     **args);
+		    return 1;
+		}
+		break;
+	    case 'r':
+		/* -r option -- set right prompt string */
+		if ((*args)[1])
+		    p2 = *args + 1, *args = "" - 1;
+		else if (args[1])
+		    p2 = *(++args), *args = "" - 1;
+		else {
+		    zwarnnam(name, "prompt string expected after -%c", NULL,
+			     **args);
+		    return 1;
+		}
+		break;
+	    case 'h':
+		/* -h option -- enable history */
+		ops['h'] = 1;
+		break;
+	    default:
+		/* unrecognised option character */
+		zwarnnam(name, "unknown option: %s", *args, 0);
+		return 1;
+	    }
+	args++;
+    }
+
+    /* check we have a parameter name */
+    if (!*args) {
+	zwarnnam(name, "missing variable", NULL, 0);
+	return 1;
+    }
+    /* handle non-existent parameter */
+    if (!(s = getsparam(args[0]))) {
+	if (create)
+	    createparam(args[0], PM_SCALAR);
+	else {
+	    zwarnnam(name, "no such variable: %s", args[0], 0);
+	    return 1;
+	}
+    }
+
+    if(zleactive) {
+	zwarnnam(name, "ZLE cannot be used recursively (yet)", NULL, 0);
+	return 1;
+    }
+
+    /* edit the parameter value */
+    PERMALLOC {
+	pushnode(bufstack, ztrdup(s));
+    } LASTALLOC;
+    t = (char *) zleread(p1, p2, ops['h']);
+    if (!t || errflag) {
+	/* error in editing */
+	errflag = 0;
+	return 1;
+    }
+    /* strip off trailing newline, if any */
+    if (t[strlen(t) - 1] == '\n')
+	t[strlen(t) - 1] = '\0';
+    /* final assignment of parameter value */
+    pm = (Param) paramtab->getnode(paramtab, args[0]);
+    if (pm && PM_TYPE(pm->flags) == PM_ARRAY) {
+	char **a;
+
+	PERMALLOC {
+	    a = spacesplit(t, 1);
+	} LASTALLOC;
+	setaparam(args[0], a);
+    } else
+	setsparam(args[0], t);
+    return 0;
+}
+
+/**/
+void
+describekeybriefly(void)
+{
+    char *seq, *str, *msg, *is;
+    Thingy func;
+
+    if (statusline)
+	return;
+    statusline = "Describe key briefly: _";
+    statusll = strlen(statusline);
+    refresh();
+    seq = getkeymapcmd(curkeymap, &func, &str);
+    statusline = NULL;
+    if(!*seq)
+	return;
+    msg = bindztrdup(seq);
+    msg = appstr(msg, " is ");
+    if (!func)
+	is = bindztrdup(str);
+    else
+	is = niceztrdup(func->nam);
+    msg = appstr(msg, is);
+    zsfree(is);
+    showmsg(msg);
+    zsfree(msg);
+}
+
+#define MAXFOUND 4
+
+struct findfunc {
+    Thingy func;
+    int found;
+    char *msg;
+};
+
+/**/
+static void
+scanfindfunc(char *seq, Thingy func, char *str, void *magic)
+{
+    struct findfunc *ff = magic;
+
+    if(func != ff->func)
+	return;
+    if (!ff->found++)
+	ff->msg = appstr(ff->msg, " is on");
+    if(ff->found <= MAXFOUND) {
+	char *b = bindztrdup(seq);
+
+	ff->msg = appstr(ff->msg, " ");
+	ff->msg = appstr(ff->msg, b);
+	zsfree(b);
+    }
+}
+
+/**/
+void
+whereis(void)
+{
+    struct findfunc ff;
+
+    if (!(ff.func = executenamedcommand("Where is: ")))
+	return;
+    ff.found = 0;
+    ff.msg = niceztrdup(ff.func->nam);
+    scankeymap(curkeymap, 1, scanfindfunc, &ff);
+    if (!ff.found)
+	ff.msg = appstr(ff.msg, " is not bound to any key");
+    else if(ff.found > MAXFOUND)
+	ff.msg = appstr(ff.msg, " et al");
+    showmsg(ff.msg);
+    zsfree(ff.msg);
+}
+
+/**/
+void
+trashzle(void)
+{
+    if (zleactive) {
+	/* This refresh() is just to get the main editor display right and *
+	 * get the cursor in the right place.  For that reason, we disable *
+	 * list display (which would otherwise result in infinite          *
+	 * recursion [at least, it would if refresh() didn't have its      *
+	 * extra `inlist' check]).                                         */
+	int sl = showinglist;
+	showinglist = 0;
+	refresh();
+	showinglist = sl;
+	moveto(nlnct, 0);
+	if (clearflag && tccan(TCCLEAREOD)) {
+	    tcout(TCCLEAREOD);
+	    clearflag = 0;
+	}
+	if (postedit)
+	    fprintf(shout, "%s", postedit);
+	fflush(shout);
+	resetneeded = 1;
+	settyinfo(&shttyinfo);
+    }
+    if (errflag)
+	kungetct = 0;
+}
+
+static struct builtin bintab[] = {
+    BUILTIN("bindkey", 0, bin_bindkey, 0, -1, 0, "evaMldDANmrsLR", NULL),
+    BUILTIN("vared",   0, bin_vared,   1,  7, 0, NULL,             NULL),
+    BUILTIN("zle",     0, bin_zle,     0, -1, 0, "lDANL",          NULL),
+};
+
+/**/
+int
+boot_zle(Module m)
+{
+    /* Set up editor entry points */
+    trashzleptr = trashzle;
+    gotwordptr = gotword;
+    refreshptr = refresh;
+    spaceinlineptr = spaceinline;
+    zlereadptr = zleread;
+
+    /* initialise the thingies */
+    init_thingies();
+
+    /* miscellaneous initialisations */
+    stackhist = stackcs = -1;
+    kungetbuf = (char *) zalloc(kungetsz = 32);
+
+    /* initialise the keymap system */
+    init_keymaps();
+
+    addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_zle(Module m)
+{
+    int i;
+
+    if(zleactive) {
+	zerrnam(m->nam, "can't unload the zle module while zle is active",
+	    NULL, 0);
+	return 1;
+    }
+
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    cleanup_keymaps();
+    deletehashtable(thingytab);
+
+    zfree(vichgbuf, vichgbufsz);
+    zfree(kungetbuf, kungetsz);
+    free_isrch_spots();
+
+    zfree(cutbuf.buf, cutbuf.len);
+    for(i = KRINGCT; i--; )
+	zfree(kring[i].buf, kring[i].len);
+    for(i = 35; i--; )
+	zfree(vibuf[i].buf, vibuf[i].len);
+
+    /* editor entry points */
+    trashzleptr = noop_function;
+    gotwordptr = noop_function;
+    refreshptr = noop_function;
+    spaceinlineptr = noop_function_int;
+    zlereadptr = fallback_zleread;
+
+    return 0;
+}
+
+#endif /* MODULE */
diff --git a/Src/Zle/zle_misc.c b/Src/Zle/zle_misc.c
new file mode 100644
index 000000000..42953852f
--- /dev/null
+++ b/Src/Zle/zle_misc.c
@@ -0,0 +1,816 @@
+/*
+ * zle_misc.c - miscellaneous editor routines
+ *
+ * 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 "zle.mdh"
+#include "zle_misc.pro"
+
+/* insert a metafied string, with repetition and suffix removal */
+
+/**/
+void
+doinsert(char *str)
+{
+    char *s;
+    int len = ztrlen(str);
+    int c1 = *str == Meta ? STOUC(str[1])^32 : STOUC(*str);/* first character */
+    int neg = zmult < 0;             /* insert *after* the cursor? */
+    int m = neg ? -zmult : zmult;    /* number of copies to insert */
+
+    iremovesuffix(c1);
+    invalidatelist();
+
+    if(insmode)
+	spaceinline(m * len);
+    else if(cs + m * len > ll)
+	spaceinline(cs + m * len - ll);
+    while(m--)
+	for(s = str; *s; s++)
+	    line[cs++] = *s == Meta ? *++s ^ 32 : *s;
+    if(neg)
+	cs += zmult * len;
+}
+
+/**/
+void
+selfinsert(void)
+{
+    char s[3], *p = s;
+
+    if(imeta(c)) {
+	*p++ = Meta;
+	c ^= 32;
+    }
+    *p++ = c;
+    *p = 0;
+    doinsert(s);
+}
+
+/**/
+void
+selfinsertunmeta(void)
+{
+    c &= 0x7f;
+    if (c == '\r')
+	c = '\n';
+    selfinsert();
+}
+
+/**/
+void
+deletechar(void)
+{
+    if (zmult < 0) {
+	zmult = -zmult;
+	backwarddeletechar();
+	zmult = -zmult;
+	return;
+    }
+    if (cs + zmult <= ll) {
+	cs += zmult;
+	backdel(zmult);
+    } else
+	feep();
+}
+
+/**/
+void
+backwarddeletechar(void)
+{
+    if (zmult < 0) {
+	zmult = -zmult;
+	deletechar();
+	zmult = -zmult;
+	return;
+    }
+    backdel(zmult > cs ? cs : zmult);
+}
+
+/**/
+void
+killwholeline(void)
+{
+    int i, fg, n = zmult;
+
+    if (n < 0)
+	return;
+    while (n--) {
+	if ((fg = (cs && cs == ll)))
+	    cs--;
+	while (cs && line[cs - 1] != '\n')
+	    cs--;
+	for (i = cs; i != ll && line[i] != '\n'; i++);
+	forekill(i - cs + (i != ll), fg);
+    }
+}
+
+/**/
+void
+killbuffer(void)
+{
+    cs = 0;
+    forekill(ll, 0);
+}
+
+/**/
+void
+backwardkillline(void)
+{
+    int i = 0, n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	killline();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (cs && line[cs - 1] == '\n')
+	    cs--, i++;
+	else
+	    while (cs && line[cs - 1] != '\n')
+		cs--, i++;
+    }
+    forekill(i, 1);
+}
+
+/**/
+void
+gosmacstransposechars(void)
+{
+    int cc;
+
+    if (cs < 2 || line[cs - 1] == '\n' || line[cs - 2] == '\n') {
+	if (cs == ll || line[cs] == '\n' ||
+	    ((cs + 1 == ll || line[cs + 1] == '\n') &&
+	     (!cs || line[cs - 1] == '\n'))) {
+	    feep();
+	    return;
+	}
+	cs += (cs == 0 || line[cs - 1] == '\n') ? 2 : 1;
+    }
+    cc = line[cs - 2];
+    line[cs - 2] = line[cs - 1];
+    line[cs - 1] = cc;
+}
+
+/**/
+void
+transposechars(void)
+{
+    int cc, ct;
+    int n = zmult;
+    int neg = n < 0;
+
+    if (neg)
+	n = -n;
+    while (n--) {
+	if (!(ct = cs) || line[cs - 1] == '\n') {
+	    if (ll == cs || line[cs] == '\n') {
+		feep();
+		return;
+	    }
+	    if (!neg)
+		cs++;
+	    ct++;
+	}
+	if (neg) {
+	    if (cs && line[cs - 1] != '\n') {
+		cs--;
+		if (ct > 1 && line[ct - 2] != '\n')
+		    ct--;
+	    }
+	} else {
+	    if (cs != ll && line[cs] != '\n')
+		cs++;
+	}
+	if (ct == ll || line[ct] == '\n')
+	    ct--;
+	if (ct < 1 || line[ct - 1] == '\n') {
+	    feep();
+	    return;
+	}
+	cc = line[ct - 1];
+	line[ct - 1] = line[ct];
+	line[ct] = cc;
+    }
+}
+
+/**/
+void
+poundinsert(void)
+{
+    cs = 0;
+    vifirstnonblank();
+    if (line[cs] != '#') {
+	spaceinline(1);
+	line[cs] = '#';
+	cs = findeol();
+	while(cs != ll) {
+	    cs++;
+	    vifirstnonblank();
+	    spaceinline(1);
+	    line[cs] = '#';
+	    cs = findeol();
+	}
+    } else {
+	foredel(1);
+	cs = findeol();
+	while(cs != ll) {
+	    cs++;
+	    vifirstnonblank();
+	    if(line[cs] == '#')
+		foredel(1);
+	    cs = findeol();
+	}
+    }
+    done = 1;
+}
+
+/**/
+void
+acceptline(void)
+{
+    done = 1;
+}
+
+/**/
+void
+acceptandhold(void)
+{
+    pushnode(bufstack, metafy((char *)line, ll, META_DUP));
+    stackcs = cs;
+    done = 1;
+}
+
+/**/
+void
+killline(void)
+{
+    int i = 0, n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardkillline();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (line[cs] == '\n')
+	    cs++, i++;
+	else
+	    while (cs != ll && line[cs] != '\n')
+		cs++, i++;
+    }
+    backkill(i, 0);
+}
+
+/**/
+void
+killregion(void)
+{
+    if (mark > ll)
+	mark = ll;
+    if (mark > cs)
+	forekill(mark - cs, 0);
+    else
+	backkill(cs - mark, 1);
+}
+
+/**/
+void
+copyregionaskill(void)
+{
+    if (mark > ll)
+	mark = ll;
+    if (mark > cs)
+	cut(cs, mark - cs, 0);
+    else
+	cut(mark, cs - mark, 1);
+}
+
+static int kct, yankb, yanke;
+
+/**/
+void
+yank(void)
+{
+    Cutbuffer buf = &cutbuf;
+    int n = zmult;
+
+    if (n < 0)
+	return;
+    if (zmod.flags & MOD_VIBUF)
+	buf = &vibuf[zmod.vibuf];
+    if (!buf->buf) {
+	feep();
+	return;
+    }
+    mark = cs;
+    yankb = cs;
+    while (n--) {
+	kct = kringnum;
+	spaceinline(buf->len);
+	memcpy((char *)line + cs, buf->buf, buf->len);
+	cs += buf->len;
+	yanke = cs;
+    }
+}
+
+/**/
+void
+yankpop(void)
+{
+    int cc;
+
+    if (!(lastcmd & ZLE_YANK) || !kring[kct].buf) {
+	feep();
+	return;
+    }
+    cs = yankb;
+    foredel(yanke - yankb);
+    cc = kring[kct].len;
+    spaceinline(cc);
+    memcpy((char *)line + cs, kring[kct].buf, cc);
+    cs += cc;
+    yanke = cs;
+    kct = (kct + KRINGCT - 1) % KRINGCT;
+}
+
+/**/
+void
+overwritemode(void)
+{
+    insmode ^= 1;
+}
+/**/
+void
+whatcursorposition(void)
+{
+    char msg[100];
+    char *s = msg;
+    int bol = findbol();
+    int c = STOUC(line[cs]);
+
+    if (cs == ll)
+	strucpy(&s, "EOF");
+    else {
+	strucpy(&s, "Char: ");
+	switch (c) {
+	case ' ':
+	    strucpy(&s, "SPC");
+	    break;
+	case '\t':
+	    strucpy(&s, "TAB");
+	    break;
+	case '\n':
+	    strucpy(&s, "LFD");
+	    break;
+	default:
+	    if (imeta(c)) {
+		*s++ = Meta;
+		*s++ = c ^ 32;
+	    } else
+		*s++ = c;
+	}
+	sprintf(s, " (0%o, %d, 0x%x)", c, c, c);
+	s += strlen(s);
+    }
+    sprintf(s, "  point %d of %d(%d%%)  column %d", cs+1, ll+1,
+	    ll ? 100 * cs / ll : 0, cs - bol);
+    showmsg(msg);
+}
+
+/**/
+void
+undefinedkey(void)
+{
+    feep();
+}
+
+/**/
+void
+quotedinsert(void)
+{
+#ifndef HAS_TIO
+    struct sgttyb sob;
+
+    sob = shttyinfo.sgttyb;
+    sob.sg_flags = (sob.sg_flags | RAW) & ~ECHO;
+    ioctl(SHTTY, TIOCSETN, &sob);
+#endif
+    c = getkey(0);
+#ifndef HAS_TIO
+    setterm();
+#endif
+    if (c < 0)
+	feep();
+    else
+	selfinsert();
+}
+
+/**/
+void
+digitargument(void)
+{
+    int sign = (zmult < 0) ? -1 : 1;
+
+    if (!(zmod.flags & MOD_TMULT))
+	zmod.tmult = 0;
+    if (zmod.flags & MOD_NEG) {
+	/* If we just had a negative argument, this is the digit, *
+	 * rather than the -1 assumed by negargument()            */
+	zmod.tmult = sign * (c & 0xf);
+	zmod.flags &= ~MOD_NEG;
+    } else
+	zmod.tmult = zmod.tmult * 10 + sign * (c & 0xf);
+    zmod.flags |= MOD_TMULT;
+    prefixflag = 1;
+}
+
+/**/
+void
+negargument(void)
+{
+    if(zmod.flags & MOD_TMULT) {
+	feep();
+	return;
+    }
+    zmod.tmult = -1;
+    zmod.flags |= MOD_TMULT|MOD_NEG;
+    prefixflag = 1;
+}
+
+/**/
+void
+universalargument(void)
+{
+    int digcnt = 0, pref = 0, minus = 1, gotk;
+    while ((gotk = getkey(0)) != EOF) {
+	if (gotk == '-' && !digcnt) {
+	    minus = -1;
+	    digcnt++;
+	} else if (gotk >= '0' && gotk <= '9') {
+	    pref = pref * 10 + (gotk & 0xf);
+	    digcnt++;
+	} else {
+	    ungetkey(gotk);
+	    break;
+	}
+    }
+    if (digcnt)
+	zmod.tmult = minus * (pref ? pref : 1);
+    else
+	zmod.tmult *= 4;
+    zmod.flags |= MOD_TMULT;
+    prefixflag = 1;
+}
+
+/**/
+void
+copyprevword(void)
+{
+    int len, t0;
+
+    for (t0 = cs - 1; t0 >= 0; t0--)
+	if (iword(line[t0]))
+	    break;
+    for (; t0 >= 0; t0--)
+	if (!iword(line[t0]))
+	    break;
+    if (t0)
+	t0++;
+    len = cs - t0;
+    spaceinline(len);
+    memcpy((char *)&line[cs], (char *)&line[t0], len);
+    cs += len;
+}
+
+/**/
+void
+sendbreak(void)
+{
+    errflag = 1;
+}
+
+/**/
+void
+quoteregion(void)
+{
+    char *str;
+    size_t len;
+
+    if (mark > ll)
+	mark = ll;
+    if (mark < cs) {
+	int tmp = mark;
+	mark = cs;
+	cs = tmp;
+    }
+    str = (char *)hcalloc(len = mark - cs);
+    memcpy(str, (char *)&line[cs], len);
+    foredel(len);
+    str = makequote(str, &len);
+    spaceinline(len);
+    memcpy((char *)&line[cs], str, len);
+    mark = cs;
+    cs += len;
+}
+
+/**/
+void
+quoteline(void)
+{
+    char *str;
+    size_t len = ll;
+
+    str = makequote((char *)line, &len);
+    sizeline(len);
+    memcpy(line, str, len);
+    cs = ll = len;
+}
+
+/**/
+static char *
+makequote(char *str, size_t *len)
+{
+    int qtct = 0;
+    char *l, *ol;
+    char *end = str + *len;
+
+    for (l = str; l < end; l++)
+	if (*l == '\'')
+	    qtct++;
+    *len += 2 + qtct*3;
+    l = ol = (char *)halloc(*len);
+    *l++ = '\'';
+    for (; str < end; str++)
+	if (*str == '\'') {
+	    *l++ = '\'';
+	    *l++ = '\\';
+	    *l++ = '\'';
+	    *l++ = '\'';
+	} else
+	    *l++ = *str;
+    *l++ = '\'';
+    return ol;
+}
+
+static char *cmdbuf;
+static LinkList cmdll;
+static int cmdambig;
+
+/**/
+static void
+scancompcmd(HashNode hn, int flags)
+{
+    int l;
+    Thingy t = (Thingy) hn;
+
+    if(strpfx(cmdbuf, t->nam)) {
+	addlinknode(cmdll, t->nam);
+	l = pfxlen(peekfirst(cmdll), t->nam);
+	if (l < cmdambig)
+	    cmdambig = l;
+    }
+
+}
+
+#define NAMLEN 60
+
+/**/
+Thingy
+executenamedcommand(char *prmt)
+{
+    Thingy cmd;
+    int len, l = strlen(prmt);
+    char *ptr;
+    char *okeymap = curkeymapname;
+
+    cmdbuf = halloc(l + NAMLEN + 2);
+    strcpy(cmdbuf, prmt);
+    statusline = cmdbuf;
+    selectkeymap("main", 1);
+    ptr = cmdbuf += l;
+    len = 0;
+    for (;;) {
+	*ptr = '_';
+	statusll = l + len + 1;
+	refresh();
+	if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) {
+	    statusline = NULL;
+	    selectkeymap(okeymap, 1);
+	    return NULL;
+	}
+	if(cmd == Th(z_clearscreen)) {
+	    clearscreen();
+	} else if(cmd == Th(z_redisplay)) {
+	    redisplay();
+	} else if(cmd == Th(z_viquotedinsert)) {
+	    *ptr = '^';
+	    refresh();
+	    c = getkey(0);
+	    if(c == EOF || !c || len == NAMLEN)
+		feep();
+	    else
+		*ptr++ = c, len++;
+	} else if(cmd == Th(z_quotedinsert)) {
+	    if((c = getkey(0)) == EOF || !c || len == NAMLEN)
+		feep();
+	    else
+		*ptr++ = c, len++;
+	} else if(cmd == Th(z_backwarddeletechar) ||
+	    	cmd == Th(z_vibackwarddeletechar)) {
+	    if (len)
+		len--, ptr--;
+	} else if(cmd == Th(z_killregion) || cmd == Th(z_backwardkillword) ||
+	    	cmd == Th(z_vibackwardkillword)) {
+	    while (len && (len--, *--ptr != '-'));
+	} else if(cmd == Th(z_killwholeline) || cmd == Th(z_vikillline) ||
+	    	cmd == Th(z_backwardkillline)) {
+	    len = 0;
+	    ptr = cmdbuf;
+	} else {
+	    if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) {
+		Thingy r;
+		unambiguous:
+		*ptr = 0;
+		r = rthingy(cmdbuf);
+		if (!(r->flags & DISABLED)) {
+		    unrefthingy(r);
+		    statusline = NULL;
+		    selectkeymap(okeymap, 1);
+		    return r;
+		}
+		unrefthingy(r);
+	    }
+	    if(cmd == Th(z_selfinsertunmeta)) {
+		c &= 0x7f;
+		if(c == '\r')
+		    c = '\n';
+		cmd = Th(z_selfinsert);
+	    }
+	    if (cmd == Th(z_listchoices) || cmd == Th(z_deletecharorlist) ||
+		cmd == Th(z_expandorcomplete) || cmd == Th(z_completeword) ||
+		cmd == Th(z_expandorcompleteprefix) || cmd == Th(z_vicmdmode) ||
+		cmd == Th(z_acceptline) || c == ' ' || c == '\t') {
+		cmdambig = 100;
+
+		HEAPALLOC {
+		    cmdll = newlinklist();
+		    *ptr = 0;
+
+		    scanhashtable(thingytab, 1, 0, DISABLED, scancompcmd, 0);
+		} LASTALLOC;
+		if (empty(cmdll))
+		    feep();
+		else if (cmd == Th(z_listchoices) ||
+		    cmd == Th(z_deletecharorlist)) {
+		    int zmultsav = zmult;
+		    *ptr = '_';
+		    statusll = l + len + 1;
+		    zmult = 1;
+		    listlist(cmdll);
+		    zmult = zmultsav;
+		} else if (!nextnode(firstnode(cmdll))) {
+		    strcpy(ptr = cmdbuf, peekfirst(cmdll));
+		    ptr += (len = strlen(ptr));
+		    if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode))
+			goto unambiguous;
+		} else {
+		    strcpy(cmdbuf, peekfirst(cmdll));
+		    ptr = cmdbuf + cmdambig;
+		    *ptr = '_';
+		    if (isset(AUTOLIST) &&
+			!(isset(LISTAMBIGUOUS) && cmdambig > len)) {
+			int zmultsav = zmult;
+			if (isset(LISTBEEP))
+			    feep();
+			statusll = l + cmdambig + 1;
+			zmult = 1;
+			listlist(cmdll);
+			zmult = zmultsav;
+		    }
+		    len = cmdambig;
+		}
+	    } else {
+		if (len == NAMLEN || icntrl(c) || cmd != Th(z_selfinsert))
+		    feep();
+		else
+		    *ptr++ = c, len++;
+	    }
+	}
+	handlefeep();
+    }
+}
+
+/*****************/
+/* Suffix system */
+/*****************/
+
+/*
+ * The completion system sometimes tentatively adds a suffix to a word,
+ * which can be removed depending on what is inserted next.  These
+ * functions provide the capability to handle a removable suffix.
+ *
+ * Any removable suffix consists of characters immediately before the
+ * cursor.  Whether it is removed depends on the next editing action.
+ * There can be more than one suffix simultaneously present, with
+ * different actions deleting different numbers of characters.
+ *
+ * If the next editing action changes the buffer other than by inserting
+ * characters, normally the suffix should be removed so as to leave a
+ * meaningful complete word.  The behaviour should be the same if the
+ * next character inserted is a word separator.  If the next character
+ * reasonably belongs where it is typed, or if the next editing action
+ * is a deletion, the suffix should not be removed.  Other reasons for
+ * suffix removal may have other behaviour.
+ *
+ * In order to maintain a consistent state, after a suffix has been added
+ * the table *must* be zeroed, one way or another, before the buffer is
+ * changed.  If the suffix is not being removed, call fixsuffix() to
+ * indicate that it is being permanently fixed.
+ */
+
+/* Length of suffix to remove when inserting each possible character value.  *
+ * suffixlen[256] is the length to remove for non-insertion editing actions. */
+
+/**/
+int suffixlen[257];
+
+/* Set up suffix: the last n characters are a suffix that should be *
+ * removed in the usual word end conditions.                        */
+
+/**/
+void
+makesuffix(int n)
+{
+    suffixlen[256] = suffixlen[' '] = suffixlen['\t'] = suffixlen['\n'] = n;
+}
+
+/* Set up suffix for parameter names: the last n characters are a suffix *
+ * that should be removed if the next character is one of the ones that  *
+ * needs to go immediately after the parameter name.  br indicates that  *
+ * the name is in braces (${PATH} instead of $PATH), so the extra        *
+ * characters that can only be used in braces are included.              */
+
+/**/
+void
+makeparamsuffix(int br, int n)
+{
+    if(br || unset(KSHARRAYS))
+	suffixlen[':'] = suffixlen['['] = n;
+    if(br) {
+	suffixlen['#'] = suffixlen['%'] = suffixlen['?'] = n;
+	suffixlen['-'] = suffixlen['+'] = suffixlen['='] = n;
+	/*{*/ suffixlen['}'] = n;
+    }
+}
+
+/* Remove suffix, if there is one, when inserting character c. */
+
+/**/
+void
+iremovesuffix(int c)
+{
+    int sl = suffixlen[c];
+    if(sl) {
+	backdel(sl);
+	invalidatelist();
+    }
+    fixsuffix();
+}
+
+/* Fix the suffix in place, if there is one, making it non-removable. */
+
+/**/
+void
+fixsuffix(void)
+{
+    memset(suffixlen, 0, sizeof(suffixlen));
+}
diff --git a/Src/Zle/zle_move.c b/Src/Zle/zle_move.c
new file mode 100644
index 000000000..8ed4c657a
--- /dev/null
+++ b/Src/Zle/zle_move.c
@@ -0,0 +1,502 @@
+/*
+ * zle_move.c - editor movement
+ *
+ * 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 "zle.mdh"
+#include "zle_move.pro"
+
+static vimarkcs[27], vimarkline[27];
+
+/**/
+void
+beginningofline(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	endofline();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (cs == 0)
+	    return;
+	if (line[cs - 1] == '\n')
+	    if (!--cs)
+		return;
+	while (cs && line[cs - 1] != '\n')
+	    cs--;
+    }
+}
+
+/**/
+void
+endofline(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	beginningofline();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (cs >= ll) {
+	    cs = ll;
+	    return;
+	}
+	if (line[cs] == '\n')
+	    if (++cs == ll)
+		return;
+	while (cs != ll && line[cs] != '\n')
+	    cs++;
+    }
+}
+
+/**/
+void
+beginningoflinehist(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	endoflinehist();
+	zmult = n;
+	return;
+    }
+    while (n) {
+	if (cs == 0)
+	    break;
+	if (line[cs - 1] == '\n')
+	    if (!--cs)
+		break;
+	while (cs && line[cs - 1] != '\n')
+	    cs--;
+	n--;
+    }
+    if (n) {
+	int m = zmult;
+
+	zmult = n;
+	uphistory();
+	zmult = m;
+	cs = 0;
+    }
+}
+
+/**/
+void
+endoflinehist(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	beginningoflinehist();
+	zmult = n;
+	return;
+    }
+    while (n) {
+	if (cs >= ll) {
+	    cs = ll;
+	    break;
+	}
+	if (line[cs] == '\n')
+	    if (++cs == ll)
+		break;
+	while (cs != ll && line[cs] != '\n')
+	    cs++;
+	n--;
+    }
+    if (n) {
+	int m = zmult;
+
+	zmult = n;
+	downhistory();
+	zmult = m;
+    }
+}
+
+/**/
+void
+forwardchar(void)
+{
+    cs += zmult;
+    if (cs > ll)
+	cs = ll;
+    if (cs < 0)
+	cs = 0;
+}
+
+/**/
+void
+backwardchar(void)
+{
+    cs -= zmult;
+    if (cs > ll)
+	cs = ll;
+    if (cs < 0)
+	cs = 0;
+}
+
+/**/
+void
+setmarkcommand(void)
+{
+    mark = cs;
+}
+
+/**/
+void
+exchangepointandmark(void)
+{
+    int x;
+
+    x = mark;
+    mark = cs;
+    cs = x;
+    if (cs > ll)
+	cs = ll;
+}
+
+/**/
+void
+vigotocolumn(void)
+{
+    int x, y;
+
+    findline(&x, &y);
+    if (zmult >= 0)
+	cs = x + zmult - (zmult > 0);
+    else
+	cs = y + zmult;
+    if (cs > y)
+	cs = y;
+    if (cs < x)
+	cs = x;
+}
+
+/**/
+void
+vimatchbracket(void)
+{
+    int ocs = cs, dir, ct;
+    unsigned char oth, me;
+
+  otog:
+    if (cs == ll || line[cs] == '\n') {
+	feep();
+	cs = ocs;
+	return;
+    }
+    switch (me = line[cs]) {
+    case '{':
+	dir = 1;
+	oth = '}';
+	break;
+    case /*{*/ '}':
+	virangeflag = -virangeflag;
+	dir = -1;
+	oth = '{'; /*}*/
+	break;
+    case '(':
+	dir = 1;
+	oth = ')';
+	break;
+    case ')':
+	virangeflag = -virangeflag;
+	dir = -1;
+	oth = '(';
+	break;
+    case '[':
+	dir = 1;
+	oth = ']';
+	break;
+    case ']':
+	virangeflag = -virangeflag;
+	dir = -1;
+	oth = '[';
+	break;
+    default:
+	cs++;
+	goto otog;
+    }
+    ct = 1;
+    while (cs >= 0 && cs < ll && ct) {
+	cs += dir;
+	if (line[cs] == oth)
+	    ct--;
+	else if (line[cs] == me)
+	    ct++;
+    }
+    if (cs < 0 || cs >= ll) {
+	feep();
+	cs = ocs;
+    } else if(dir > 0 && virangeflag)
+	cs++;
+}
+
+/**/
+void
+viforwardchar(void)
+{
+    int lim = findeol() - invicmdmode();
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	vibackwardchar();
+	zmult = n;
+	return;
+    }
+    if (cs >= lim) {
+	feep();
+	return;
+    }
+    while (n-- && cs < lim)
+	cs++;
+}
+
+/**/
+void
+vibackwardchar(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	viforwardchar();
+	zmult = n;
+	return;
+    }
+    if (cs == findbol()) {
+	feep();
+	return;
+    }
+    while (n--) {
+	cs--;
+	if (cs < 0 || line[cs] == '\n') {
+	    cs++;
+	    break;
+	}
+    }
+}
+
+/**/
+void
+viendofline(void)
+{
+    int oldcs = cs, n = zmult;
+
+    if (n < 1) {
+	feep();
+	return;
+    }
+    while(n--) {
+	if (cs > ll) {
+	    cs = oldcs;
+	    feep();
+	    return;
+	}
+	cs = findeol() + 1;
+    }
+    cs--;
+    lastcol = 1<<30;
+}
+
+/**/
+void
+vibeginningofline(void)
+{
+    cs = findbol();
+}
+
+static int vfindchar, vfinddir, tailadd;
+
+/**/
+void
+vifindnextchar(void)
+{
+    if ((vfindchar = vigetkey()) != -1) {
+	vfinddir = 1;
+	tailadd = 0;
+	virepeatfind();
+    }
+}
+
+/**/
+void
+vifindprevchar(void)
+{
+    if ((vfindchar = vigetkey()) != -1) {
+	vfinddir = -1;
+	tailadd = 0;
+	virepeatfind();
+    }
+}
+
+/**/
+void
+vifindnextcharskip(void)
+{
+    if ((vfindchar = vigetkey()) != -1) {
+	vfinddir = 1;
+	tailadd = -1;
+	virepeatfind();
+    }
+}
+
+/**/
+void
+vifindprevcharskip(void)
+{
+    if ((vfindchar = vigetkey()) != -1) {
+	vfinddir = -1;
+	tailadd = 1;
+	virepeatfind();
+    }
+}
+
+/**/
+void
+virepeatfind(void)
+{
+    int ocs = cs, n = zmult;
+
+    if (!vfinddir) {
+	feep();
+	return;
+    }
+    if (n < 0) {
+	zmult = -n;
+	virevrepeatfind();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	do
+	    cs += vfinddir;
+	while (cs >= 0 && cs < ll && line[cs] != vfindchar && line[cs] != '\n');
+	if (cs < 0 || cs >= ll || line[cs] == '\n') {
+	    feep();
+	    cs = ocs;
+	    return;
+	}
+    }
+    cs += tailadd;
+    if (vfinddir == 1 && virangeflag)
+	cs++;
+}
+
+/**/
+void
+virevrepeatfind(void)
+{
+    if (zmult < 0) {
+	zmult = -zmult;
+	virepeatfind();
+	zmult = -zmult;
+	return;
+    }
+    vfinddir = -vfinddir;
+    virepeatfind();
+    vfinddir = -vfinddir;
+}
+
+/**/
+void
+vifirstnonblank(void)
+{
+    cs = findbol();
+    while (cs != ll && iblank(line[cs]))
+	cs++;
+}
+
+/**/
+void
+visetmark(void)
+{
+    int ch;
+
+    ch = getkey(0);
+    if (ch < 'a' || ch > 'z') {
+	feep();
+	return;
+    }
+    ch -= 'a';
+    vimarkcs[ch] = cs;
+    vimarkline[ch] = histline;
+}
+
+/**/
+void
+vigotomark(void)
+{
+    int ch;
+
+    ch = getkey(0);
+    if (ch == c)
+	ch = 26;
+    else {
+	if (ch < 'a' || ch > 'z') {
+	    feep();
+	    return;
+	}
+	ch -= 'a';
+    }
+    if (!vimarkline[ch]) {
+	feep();
+	return;
+    }
+    if (curhist != vimarkline[ch]) {
+	char *s;
+
+	remember_edits();
+	if (!(s = qgetevent(vimarkline[ch]))) {
+	    vimarkline[ch] = 0;
+	    feep();
+	    return;
+	}
+	histline = vimarkline[ch];
+	setline(s);
+    }
+    cs = vimarkcs[ch];
+    if (cs > ll)
+	cs = ll;
+}
+
+/**/
+void
+vigotomarkline(void)
+{
+    vigotomark();
+    vifirstnonblank();
+}
diff --git a/Src/Zle/zle_params.c b/Src/Zle/zle_params.c
new file mode 100644
index 000000000..ed1420829
--- /dev/null
+++ b/Src/Zle/zle_params.c
@@ -0,0 +1,196 @@
+/*
+ * zle_params.c - ZLE special parameters
+ *
+ * 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 "zle.mdh"
+
+#include "zle_params.pro"
+
+/*
+ * ZLE SPECIAL PARAMETERS:
+ *
+ * These special parameters are created, with a local scope, when
+ * running user-defined widget functions.  Reading and writing them
+ * reads and writes bits of ZLE state.  The parameters are:
+ *
+ * BUFFER   (scalar)   entire buffer contents
+ * CURSOR   (integer)  cursor position; 0 <= $CURSOR <= $#BUFFER
+ * LBUFFER  (scalar)   portion of buffer to the left of the cursor
+ * RBUFFER  (scalar)   portion of buffer to the right of the cursor
+ */
+
+#define FN(X) ( (void (*) _((void))) (X) )
+static struct zleparam {
+    char *name;
+    int type;
+    void (*setfn) _((void));
+    void (*getfn) _((void));
+    void (*unsetfn) _((Param, int));
+    void *data;
+} zleparams[] = {
+    { "BUFFER",  PM_SCALAR,  FN(set_buffer),  FN(get_buffer),
+	zleunsetfn, NULL },
+    { "CURSOR",  PM_INTEGER, FN(set_cursor),  FN(get_cursor),
+	zleunsetfn, NULL },
+    { "LBUFFER", PM_SCALAR,  FN(set_lbuffer), FN(get_lbuffer),
+	zleunsetfn, NULL },
+    { "RBUFFER", PM_SCALAR,  FN(set_rbuffer), FN(get_rbuffer),
+	zleunsetfn, NULL },
+    { NULL, 0, NULL, NULL, NULL, NULL }
+};
+
+/**/
+void
+makezleparams(void)
+{
+    struct zleparam *zp;
+
+    for(zp = zleparams; zp->name; zp++) {
+	Param pm = createparam(zp->name, zp->type | PM_SPECIAL);
+
+	pm->level = locallevel;
+	pm->u.data = zp->data;
+	switch(PM_TYPE(zp->type)) {
+	    case PM_SCALAR:
+		pm->sets.cfn = (void (*) _((Param, char *))) zp->setfn;
+		pm->gets.cfn = (char *(*) _((Param))) zp->getfn;
+		break;
+	    case PM_ARRAY:
+		pm->sets.afn = (void (*) _((Param, char **))) zp->setfn;
+		pm->gets.afn = (char **(*) _((Param))) zp->getfn;
+		break;
+	    case PM_INTEGER:
+		pm->sets.ifn = (void (*) _((Param, long))) zp->setfn;
+		pm->gets.ifn = (long (*) _((Param))) zp->getfn;
+		break;
+	}
+	pm->unsetfn = zp->unsetfn;
+    }
+}
+
+/* Special unset function for ZLE special parameters: act like the standard *
+ * unset function if this is a user-initiated unset, but nothing is done if *
+ * the parameter is merely going out of scope (which it will do).           */
+
+/**/
+static void
+zleunsetfn(Param pm, int exp)
+{
+    if(exp)
+	stdunsetfn(pm, exp);
+}
+
+/**/
+static void
+set_buffer(Param pm, char *x)
+{
+    if(x) {
+	unmetafy(x, &ll);
+	sizeline(ll);
+	strcpy((char *)line, x);
+	zsfree(x);
+	if(cs > ll)
+	    cs = ll;
+    } else
+	cs = ll = 0;
+}
+
+/**/
+static char *
+get_buffer(Param pm)
+{
+    return metafy((char *)line, ll, META_HEAPDUP);
+}
+
+/**/
+static void
+set_cursor(Param pm, long x)
+{
+    if(x < 0)
+	cs = 0;
+    else if(x > ll)
+	cs = ll;
+    else
+	cs = x;
+}
+
+/**/
+static long
+get_cursor(Param pm)
+{
+    return cs;
+}
+
+/**/
+static void
+set_lbuffer(Param pm, char *x)
+{
+    char *y;
+    int len;
+
+    if(x)
+	unmetafy(y = x, &len);
+    else
+	y = "", len = 0;
+    sizeline(ll - cs + len);
+    memmove(line + len, line + cs, ll - cs);
+    memcpy(line, y, len);
+    ll = ll - cs + len;
+    cs = len;
+    zsfree(x);
+}
+
+/**/
+static char *
+get_lbuffer(Param pm)
+{
+    return metafy((char *)line, cs, META_HEAPDUP);
+}
+
+/**/
+static void
+set_rbuffer(Param pm, char *x)
+{
+    char *y;
+    int len;
+
+    if(x)
+	unmetafy(y = x, &len);
+    else
+	y = "", len = 0;
+    sizeline(ll = cs + len);
+    memcpy(line + cs, y, len);
+    zsfree(x);
+}
+
+/**/
+static char *
+get_rbuffer(Param pm)
+{
+    return metafy((char *)line + cs, ll - cs, META_HEAPDUP);
+}
diff --git a/Src/Zle/zle_refresh.c b/Src/Zle/zle_refresh.c
new file mode 100644
index 000000000..4621b5124
--- /dev/null
+++ b/Src/Zle/zle_refresh.c
@@ -0,0 +1,1116 @@
+/*
+ * zle_refresh.c - screen update
+ *
+ * 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 "zle.mdh"
+#include "zle_refresh.pro"
+
+/* Expanded prompts */
+
+/**/
+char *lpptbuf, *rpptbuf;
+
+/* Text attributes after displaying prompts */
+
+/**/
+unsigned pmpt_attr, rpmpt_attr;
+
+/* number of lines displayed */
+
+/**/
+int nlnct;
+
+/* Most lines of the buffer we've shown at once with the current list *
+ * showing.  == 0 if there is no list.  == -1 if a new list has just  *
+ * been put on the screen.  == -2 if refresh() needs to put up a new  *
+ * list.                                                              */
+
+/**/
+int showinglist;
+
+/* Non-zero if ALWAYS_LAST_PROMPT has been used, meaning that the *
+ * screen below the buffer display should not be cleared by       *
+ * refresh(), but should be by trashzle().                        */
+
+/**/
+int clearflag;
+
+#ifdef HAVE_SELECT
+/* cost of last update */
+/**/
+int cost;
+
+# define SELECT_ADD_COST(X)	cost += X
+# define zputc(a, b)		putc(a, b), cost++
+# define zwrite(a, b, c, d)	fwrite(a, b, c, d), cost += (b * c)
+#else
+# define SELECT_ADD_COST(X)
+# define zputc(a, b)		putc(a, b)
+# define zwrite(a, b, c, d)	fwrite(a, b, c, d)
+#endif
+
+/* Oct/Nov 94: <mason> some code savagely redesigned to fix several bugs -
+   refreshline() & tc_rightcurs() majorly rewritten; refresh() fixed -
+   I've put my fingers into just about every routine in here -
+   any queries about updates to mason@werple.net.au */
+
+static char **nbuf = NULL,	/* new video buffer line-by-line char array */
+    **obuf = NULL;		/* old video buffer line-by-line char array */
+static int more_start,		/* more text before start of screen?	    */
+    more_end,			/* more stuff after end of screen?	    */
+    lppth,			/* lines taken up by the prompt		    */
+    olnct,			/* previous number of lines		    */
+    ovln,			/* previous video cursor position line	    */
+    pptw, rpw,                  /* prompt widths on screen                  */
+    rppth,			/* right prompt height                      */
+    vcs, vln,			/* video cursor position column & line	    */
+    vmaxln,			/* video maximum number of lines	    */
+    winw, winh, rwinh,		/* window width & height		    */
+    winpos;			/* singlelinezle: line's position in window */
+
+/**/
+void
+resetvideo(void)
+{
+    int ln;
+    static int lwinw = -1, lwinh = -1;	/* last window width & height */
+ 
+    genprompts();
+    winw = columns;  /* terminal width */
+    if (termflags & TERM_SHORT)
+	winh = 1;
+    else
+	winh = (lines < 2) ? 24 : lines;
+    rwinh = lines;		/* keep the real number of lines */
+    winpos = vln = vmaxln = 0;
+    if (lwinw != winw || lwinh != winh) {
+	if (nbuf) {
+	    for (ln = 0; ln != lwinh; ln++) {
+		zfree(nbuf[ln], lwinw + 2);
+		zfree(obuf[ln], lwinw + 2);
+	    }
+	    free(nbuf);
+	    free(obuf);
+	}
+	nbuf = (char **)zcalloc((winh + 1) * sizeof(char *));
+	obuf = (char **)zcalloc((winh + 1) * sizeof(char *));
+	nbuf[0] = (char *)zalloc(winw + 2);
+	obuf[0] = (char *)zalloc(winw + 2);
+
+	lwinw = winw;
+	lwinh = winh;
+    }
+    for (ln = 0; ln != winh + 1; ln++) {
+	if (nbuf[ln])
+	    *nbuf[ln] = '\0';
+	if (obuf[ln])
+	    *obuf[ln] = '\0';
+    }
+
+    if (pptw) {
+    	memset(nbuf[0], ' ', pptw);
+	memset(obuf[0], ' ', pptw);
+	nbuf[0][pptw] = obuf[0][pptw] = '\0';
+    }
+
+    vcs = pptw;
+    olnct = nlnct = 0;
+    if (showinglist > 0)
+	showinglist = -2;
+}
+
+/*
+ * Nov 96: <mason> changed to single line scroll
+ */
+
+/**/
+static void
+scrollwindow(int tline)
+{
+    int t0;
+    char *s;
+
+    s = nbuf[tline];
+    for (t0 = tline; t0 < winh - 1; t0++)
+	nbuf[t0] = nbuf[t0 + 1];
+    nbuf[winh - 1] = s;
+    if (!tline)
+	more_start = 1;
+    return;
+}
+
+/* this is the messy part. */
+/* this define belongs where it's used!!! */
+
+#define nextline					\
+{							\
+    *s = '\0';						\
+    if (ln != winh - 1)					\
+	ln++;						\
+    else {						\
+	if (!canscroll)	{				\
+	    if (nvln != -1 && nvln != winh - 1		\
+		&& (numscrolls != onumscrolls - 1	\
+		    || nvln <= winh / 2))		\
+	        break;					\
+	    numscrolls++;				\
+	    canscroll = winh / 2;			\
+	}						\
+	canscroll--;					\
+	scrollwindow(0);				\
+	if (nvln != -1)					\
+	    nvln--;					\
+    }							\
+    if (!nbuf[ln])					\
+	nbuf[ln] = (char *)zalloc(winw + 2);		\
+    s = (unsigned char *)nbuf[ln];			\
+    sen = s + winw;					\
+}
+
+#define snextline					\
+{							\
+    *s = '\0';						\
+    if (ln != winh - 1)					\
+	ln++;						\
+    else						\
+	if (tosln < 3) {				\
+	    more_status = 1;				\
+	    scrollwindow(tosln + 1);			\
+	} else if (tosln - 1 <= nvln) {			\
+	    scrollwindow(0);				\
+	    if (nvln)					\
+		nvln--, tosln--;			\
+	} else {					\
+	    tosln--;					\
+	    scrollwindow(tosln);			\
+	}						\
+    if (!nbuf[ln])					\
+	nbuf[ln] = (char *)zalloc(winw + 2);		\
+    s = (unsigned char *)nbuf[ln];			\
+    sen = s + winw;					\
+}
+
+static int cleareol,		/* clear to end-of-line (if can't cleareod) */
+    clearf,			/* alwayslastprompt used immediately before */
+    put_rpmpt,			/* whether we should display right-prompt   */
+    oput_rpmpt,			/* whether displayed right-prompt last time */
+    oxtabs,			/* oxtabs - tabs expand to spaces if set    */
+    numscrolls, onumscrolls;
+
+/**/
+void
+refresh(void)
+{
+    static int inlist;		/* avoiding recursion                        */
+    int canscroll = 0,		/* number of lines we are allowed to scroll  */
+	ln = 0,			/* current line we're working on	     */
+	more_status = 0,	/* more stuff in status line		     */
+	nvcs = 0, nvln = -1,	/* video cursor column and line		     */
+	t0 = -1,		/* tmp					     */
+	tosln = 0;		/* tmp in statusline stuff		     */
+    unsigned char *s,		/* pointer into the video buffer	     */
+	*t,			/* pointer into the real buffer		     */
+	*sen,			/* pointer to end of the video buffer (eol)  */
+	*scs;			/* pointer to cursor position in real buffer */
+    char **qbuf;		/* tmp					     */
+
+    /* If this is called from listmatches() (indirectly via trashzle()), and *
+     * that was called from the end of refresh(), then we don't need to do   *
+     * anything.  All this `inlist' code is actually unnecessary, but it     *
+     * improves speed a little in a common case.                             */
+    if (inlist)
+	return;
+
+#ifdef HAVE_SELECT
+    cost = 0;			/* reset */
+#endif
+
+/* Nov 96: <mason>  I haven't checked how complete this is.  sgtty stuff may
+   or may not work */
+    oxtabs = ((SGTTYFLAG & SGTABTYPE) == SGTABTYPE);
+
+    cleareol = 0;		/* unset */
+    more_start = more_end = 0;	/* unset */
+    if (isset(SINGLELINEZLE) || lines < 3
+	|| (termflags & (TERM_NOUP | TERM_BAD | TERM_UNKNOWN)))
+	termflags |= TERM_SHORT;
+    else
+	termflags &= ~TERM_SHORT;
+    if (resetneeded) {
+	onumscrolls = 0;
+	setterm();
+#ifdef TIOCGWINSZ
+	if (winchanged) {
+	    moveto(0, 0);
+	    t0 = olnct;		/* this is to clear extra lines even when */
+	    winchanged = 0;	/* the terminal cannot TCCLEAREOD	  */
+	}
+#endif
+	resetvideo();
+	resetneeded = 0;	/* unset */
+	oput_rpmpt = 0;		/* no right-prompt currently on screen */
+
+	/* we probably should only have explicitly set attributes */
+	tsetcap(TCALLATTRSOFF, 0);
+	tsetcap(TCSTANDOUTEND, 0);
+	tsetcap(TCUNDERLINEEND, 0);
+
+        if (!clearflag)
+            if (tccan(TCCLEAREOD))
+                tcout(TCCLEAREOD);
+            else
+                cleareol = 1;   /* request: clear to end of line */
+        if (t0 > -1)
+            olnct = t0;
+        if (termflags & TERM_SHORT)
+            vcs = 0;
+        else if (!clearflag && lpptbuf[0])
+            zputs(lpptbuf, shout);
+	if (clearflag) {
+	    zputc('\r', shout);
+	    vcs = 0;
+	    moveto(0, pptw);
+	}
+	fflush(shout);
+	clearf = clearflag;
+    } else if (winw != columns || rwinh != lines)
+	resetvideo();
+
+/* now winw equals columns and winh equals lines 
+   width comparisons can be made with winw, height comparisons with winh */
+
+    if (termflags & TERM_SHORT) {
+	singlerefresh();
+	return;
+    }
+
+    if (cs < 0) {
+#ifdef DEBUG
+	fprintf(stderr, "BUG: negative cursor position\n");
+	fflush(stderr); 
+#endif
+	cs = 0;
+    }
+    scs = line + cs;
+    numscrolls = 0;
+
+/* first, we generate the video line buffers so we know what to put on
+   the screen - also determine final cursor position (nvln, nvcs) */
+
+    /* Deemed necessary by PWS 1995/05/15 due to kill-line problems */
+    if (!*nbuf)
+	*nbuf = (char *)zalloc(winw + 2);
+
+    s = (unsigned char *)(nbuf[ln = 0] + pptw);
+    t = line;
+    sen = (unsigned char *)(*nbuf + winw);
+    for (; t < line+ll; t++) {
+	if (t == scs)			/* if cursor is here, remember it */
+	    nvcs = s - (unsigned char *)(nbuf[nvln = ln]);
+
+	if (*t == '\n')	{		/* newline */
+	    nbuf[ln][winw + 1] = '\0';	/* text not wrapped */
+	    nextline
+	} else if (*t == '\t') {		/* tab */
+	    t0 = (char *)s - nbuf[ln];
+	    if ((t0 | 7) + 1 >= winw) {
+		nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+		nextline
+	    } else
+		do
+		    *s++ = ' ';
+		while ((++t0) & 7);
+	} else if (icntrl(*t)) {	/* other control character */
+	    *s++ = '^';
+	    if (s == sen) {
+		nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+		nextline
+	    }
+	    *s++ = (*t == 127) ? '?' : (*t | '@');
+	} else				/* normal character */
+	    *s++ = *t;
+	if (s == sen) {
+	    nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+	    nextline
+	}
+    }
+
+/* if we're really on the next line, don't fake it; do everything properly */
+    if (t == scs && (nvcs = s - (unsigned char *)(nbuf[nvln = ln])) == winw) {
+	nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+	switch ('\0') { 	/* a sad hack to make the break */
+	case '\0':		/* in nextline work */
+	    nextline
+	}
+	*s = '\0';
+	nvcs = 0;
+	nvln++;
+    }
+
+    if (t != line + ll)
+	more_end = 1;
+
+    if (statusline) {
+	tosln = ln + 1;
+        if (ln == winh - 1) {
+	    if (nvln > 0) {
+		scrollwindow(0);
+		nvln--;
+	    }
+	    tosln--;
+	}
+	nbuf[ln][winw + 1] = '\0';	/* text not wrapped */
+	snextline
+	t = (unsigned char *)statusline;
+	for (; t < (unsigned char *)statusline + statusll; t++) {
+	    if (icntrl(*t)) {	/* simplified processing in the status line */
+		*s++ = '^';
+		if (s == sen) {
+		    nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+		    snextline
+		}
+		*s++ = (*t == 127) ? '?' : (*t | '@');
+	    } else
+		*s++ = *t;
+	    if (s == sen) {
+		nbuf[ln][winw + 1] = '\n';	/* text wrapped */
+		snextline
+	    }
+	}
+    }
+
+/* insert <.... at end of last line if there is more text past end of screen */
+    if (more_end) {
+	if (!statusline)
+	    tosln = winh;
+	strncpy(nbuf[tosln - 1] + winw - 7, " <.... ", 7);
+	nbuf[tosln - 1][winw] = nbuf[tosln - 1][winw + 1] = '\0';
+    }
+
+/* insert <....> at end of first status line if status is too big */
+    if (more_status) {
+	strncpy(nbuf[tosln] + winw - 8, " <....> ", 8);
+	nbuf[tosln][winw] = nbuf[tosln][winw + 1] = '\0';
+    }
+
+    *s = '\0';
+    nlnct = ln + 1;
+    for (ln = nlnct; ln < winh; ln++)
+	zfree(nbuf[ln], winw + 2), nbuf[ln] = NULL;
+
+/* determine whether the right-prompt exists and can fit on the screen */
+    if (!more_start)
+	put_rpmpt = rppth == 1 && rpptbuf[0] && !strchr(rpptbuf, '\t') &&
+	    (int)strlen(nbuf[0]) + rpw < winw - 1;
+    else {
+/* insert >.... on first line if there is more text before start of screen */
+	memset(nbuf[0], ' ', pptw);
+	t0 = winw - pptw;
+	t0 = t0 > 5 ? 5 : t0;
+	strncpy(nbuf[0] + pptw, ">....", t0);
+	memset(nbuf[0] + pptw + t0, ' ', winw - t0 - pptw);
+	nbuf[0][winw] = nbuf[0][winw + 1] = '\0';
+    }
+
+    for (ln = 0; !clearf && (ln < nlnct); ln++) {
+	/* if we have more lines than last time, clear the newly-used lines */
+	if (ln >= olnct)
+	    cleareol = 1;
+
+    /* if old line and new line are different,
+       see if we can insert/delete a line to speed up update */
+
+	if (ln < olnct - 1 && !(hasam && vcs == winw) &&
+	    nbuf[ln] && obuf[ln] &&
+	    strncmp(nbuf[ln], obuf[ln], 16)) {
+	    if (tccan(TCDELLINE) && obuf[ln + 1] && obuf[ln + 1][0] &&
+		nbuf[ln] && !strncmp(nbuf[ln], obuf[ln + 1], 16)) {
+		moveto(ln, 0);
+		tcout(TCDELLINE);
+		zfree(obuf[ln], winw + 2);
+		for (t0 = ln; t0 != olnct; t0++)
+		    obuf[t0] = obuf[t0 + 1];
+		obuf[--olnct] = NULL;
+	    }
+	/* don't try to insert a line if olnct = vmaxln (vmaxln is the number
+	   of lines that have been displayed by this routine) so that we don't
+	   go off the end of the screen. */
+
+	    else if (tccan(TCINSLINE) && olnct < vmaxln && nbuf[ln + 1] &&
+		     obuf[ln] && !strncmp(nbuf[ln + 1], obuf[ln], 16)) {
+		moveto(ln, 0);
+		tcout(TCINSLINE);
+		for (t0 = olnct; t0 != ln; t0--)
+		    obuf[t0] = obuf[t0 - 1];
+		obuf[ln] = NULL;
+		olnct++;
+	    }
+	}
+
+    /* update the single line */
+	refreshline(ln);
+
+    /* output the right-prompt if appropriate */
+	if (put_rpmpt && !ln && !oput_rpmpt) {
+	    moveto(0, winw - 1 - rpw);
+	    zputs(rpptbuf, shout);
+	    vcs = winw - 1;
+	/* reset character attributes to that set by the main prompt */
+	    txtchange = pmpt_attr;
+	    if (txtchangeisset(TXTNOBOLDFACE) && (rpmpt_attr & TXTBOLDFACE))
+		tsetcap(TCALLATTRSOFF, 0);
+	    if (txtchangeisset(TXTNOSTANDOUT) && (rpmpt_attr & TXTSTANDOUT))
+		tsetcap(TCSTANDOUTEND, 0);
+	    if (txtchangeisset(TXTNOUNDERLINE) && (rpmpt_attr & TXTUNDERLINE))
+		tsetcap(TCUNDERLINEEND, 0);
+	    if (txtchangeisset(TXTBOLDFACE) && (rpmpt_attr & TXTNOBOLDFACE))
+		tsetcap(TCBOLDFACEBEG, 0);
+	    if (txtchangeisset(TXTSTANDOUT) && (rpmpt_attr & TXTNOSTANDOUT))
+		tsetcap(TCSTANDOUTBEG, 0);
+	    if (txtchangeisset(TXTUNDERLINE) && (rpmpt_attr & TXTNOUNDERLINE))
+		tsetcap(TCUNDERLINEBEG, 0);
+	}
+    }
+
+/* if old buffer had extra lines, set them to be cleared and refresh them
+individually */
+
+    if (olnct > nlnct) {
+	cleareol = 1;
+	for (ln = nlnct; ln < olnct; ln++)
+	    refreshline(ln);
+    }
+
+/* reset character attributes */
+    if (clearf && postedit) {
+	if ((txtchange = pmpt_attr ? pmpt_attr : rpmpt_attr)) {
+	    if (txtchangeisset(TXTNOBOLDFACE))
+		tsetcap(TCALLATTRSOFF, 0);
+	    if (txtchangeisset(TXTNOSTANDOUT))
+		tsetcap(TCSTANDOUTEND, 0);
+	    if (txtchangeisset(TXTNOUNDERLINE))
+		tsetcap(TCUNDERLINEEND, 0);
+	    if (txtchangeisset(TXTBOLDFACE))
+		tsetcap(TCBOLDFACEBEG, 0);
+	    if (txtchangeisset(TXTSTANDOUT))
+		tsetcap(TCSTANDOUTBEG, 0);
+	    if (txtchangeisset(TXTUNDERLINE))
+		tsetcap(TCUNDERLINEBEG, 0);
+	}
+    }
+    clearf = 0;
+
+/* move to the new cursor position */
+    moveto(nvln, nvcs);
+
+/* swap old and new buffers - better than freeing/allocating every time */
+    qbuf = nbuf;
+    nbuf = obuf;
+    obuf = qbuf;
+/* store current values so we can use them next time */
+    ovln = nvln;
+    olnct = nlnct;
+    oput_rpmpt = put_rpmpt;
+    onumscrolls = numscrolls;
+    if (nlnct > vmaxln)
+	vmaxln = nlnct;
+    fflush(shout);		/* make sure everything is written out */
+
+    /* if we have a new list showing, note it; if part of the list has been
+    overwritten, redisplay it. */
+    if (showinglist == -2 || (showinglist > 0 && showinglist < nlnct)) {
+	inlist = 1;
+	listmatches();
+	inlist = 0;
+	refresh();
+    }
+    if (showinglist == -1)
+	showinglist = nlnct;
+}
+
+#define tcinscost(X)   (tccan(TCMULTINS) ? tclen[TCMULTINS] : (X)*tclen[TCINS])
+#define tcdelcost(X)   (tccan(TCMULTDEL) ? tclen[TCMULTDEL] : (X)*tclen[TCDEL])
+#define tc_delchars(X)	(void) tcmultout(TCDEL, TCMULTDEL, (X))
+#define tc_inschars(X)	(void) tcmultout(TCINS, TCMULTINS, (X))
+#define tc_upcurs(X)	(void) tcmultout(TCUP, TCMULTUP, (X))
+#define tc_leftcurs(X)	(void) tcmultout(TCLEFT, TCMULTLEFT, (X))
+
+/* refresh one line, using whatever speed-up tricks are provided by the tty */
+
+/**/
+static void
+refreshline(int ln)
+{
+    char *nl, *ol, *p1;		/* line buffer pointers			 */
+    int ccs = 0,		/* temporary count for cursor position	 */
+	char_ins = 0,		/* number of characters inserted/deleted */
+	col_cleareol,		/* clear to end-of-line from this column */
+	i, j,			/* tmp					 */
+	ins_last,		/* insert pushed last character off line */
+	nllen, ollen,		/* new and old line buffer lengths	 */
+	rnllen;			/* real new line buffer length		 */
+
+/* 0: setup */
+    nl = nbuf[ln];
+    rnllen = nllen = nl ? strlen(nl) : 0;
+    ol = obuf[ln] ? obuf[ln] : "";
+    ollen = strlen(ol);
+
+/* optimisation: can easily happen for clearing old lines.  If the terminal has
+   the capability, then this is the easiest way to skip unnecessary stuff */
+    if (cleareol && !nllen && !(hasam && ln < nlnct - 1)
+	&& tccan(TCCLEAREOL)) {
+	moveto(ln, 0);
+	tcout(TCCLEAREOL);
+	return;	
+    }
+
+/* 1: pad out the new buffer with spaces to contain _all_ of the characters
+      which need to be written. do this now to allow some pre-processing */
+
+    if (cleareol 		/* request to clear to end of line */
+	|| !nllen 		/* no line buffer given */
+	|| (ln == 0 && (put_rpmpt != oput_rpmpt))) {	/* prompt changed */
+	p1 = halloc(winw + 2);
+	if (nllen)
+	    strncpy(p1, nl, nllen);
+	memset(p1 + nllen, ' ', winw - nllen);
+	p1[winw] = '\0';
+	p1[winw + 1] = (nllen < winw) ? '\0' : nl[winw + 1];
+	if (ln && nbuf[ln])
+	    memcpy(nl, p1, winw + 2);	/* next time obuf will be up-to-date */
+	else
+	    nl = p1;		/* don't keep the padding for prompt line */
+	nllen = winw;
+    } else if (ollen > nllen) { /* make new line at least as long as old */
+	p1 = halloc(ollen + 1);
+	strncpy(p1, nl, nllen);
+	memset(p1 + nllen, ' ', ollen - nllen);
+	p1[ollen] = '\0';
+	nl = p1;
+	nllen = ollen;
+    }
+
+/* 2: see if we can clear to end-of-line, and if it's faster, work out where
+   to do it from - we can normally only do so if there's no right-prompt.
+   With automatic margins, we shouldn't do it if there is another line, in
+   case it messes up cut and paste. */
+
+    if (hasam && ln < nlnct - 1 && rnllen == winw)
+	col_cleareol = -2;	/* clearing eol would be evil so don't */
+    else {
+	col_cleareol = -1;
+	if (tccan(TCCLEAREOL) && (nllen == winw || put_rpmpt != oput_rpmpt)) {
+	    for (i = nllen; i && nl[i - 1] == ' '; i--);
+	    for (j = ollen; j && ol[j - 1] == ' '; j--);
+	    if ((j > i + tclen[TCCLEAREOL])	/* new buf has enough spaces */
+		|| (nllen == winw && nl[winw - 1] == ' '))
+		col_cleareol = i;
+	}
+    }
+
+/* 2b: first a new trick for automargin niceness - good for cut and paste */
+
+    if (hasam && vcs == winw) {
+	if (nbuf[vln] && nbuf[vln][vcs + 1] == '\n') {
+	    vln++, vcs = 1;
+            if (nbuf[vln]  && *nbuf[vln])
+		zputc(*nbuf[vln], shout);
+	    else
+		zputc(' ', shout);  /* I don't think this should happen */
+	    if (ln == vln) {	/* better safe than sorry */
+		nl++;
+		if (*ol)
+		    ol++;
+		ccs = 1;
+	    }			/* else  hmmm... I wonder what happened */
+	} else {
+	    vln++, vcs = 0;
+	    zputc('\n', shout);
+	}
+    }
+    ins_last = 0;
+
+/* 2c: if we're on the first line, start checking at the end of the prompt;
+   we shouldn't be doing anything within the prompt */
+
+    if (ln == 0 && pptw) {
+	i = pptw - ccs;
+	j = strlen(ol);
+	nl += i;
+	ol += (i > j ? j : i);	/* if ol is too short, point it to '\0' */
+	ccs = pptw;
+    }
+
+/* 3: main display loop - write out the buffer using whatever tricks we can */
+
+    for (;;) {
+	if (*nl && *ol && nl[1] == ol[1]) /* skip only if second chars match */
+	/* skip past all matching characters */
+	    for (; *nl && (*nl == *ol); nl++, ol++, ccs++) ;
+
+	if (!*nl) {
+	    if (ccs == winw && hasam && char_ins > 0 && ins_last
+		&& vcs != winw) {
+		nl--;           /* we can assume we can go back here */
+		moveto(ln, winw - 1);
+		zputc(*nl, shout);
+		vcs++;
+		return;         /* write last character in line */
+	    }
+	    if ((char_ins <= 0) || (ccs >= winw))    /* written everything */
+		return;
+	    if (tccan(TCCLEAREOL) && (char_ins >= tclen[TCCLEAREOL])
+	    	&& col_cleareol != -2)
+	    /* we've got junk on the right yet to clear */
+		col_cleareol = 0;	/* force a clear to end of line */
+	}
+
+	moveto(ln, ccs);	/* move to where we do all output from */
+
+    /* if we can finish quickly, do so */
+	if ((col_cleareol >= 0) && (ccs >= col_cleareol)) {
+	    tcout(TCCLEAREOL);
+	    return;
+	}
+
+    /* we've written out the new but yet to clear rubbish due to inserts */
+	if (!*nl) {
+	    i = (winw - ccs < char_ins) ? (winw - ccs) : char_ins;
+	    if (tccan(TCDEL) && (tcdelcost(i) <= i + 1))
+		tc_delchars(i);
+	    else {
+		vcs += i;
+		while (i-- > 0)
+		    zputc(' ', shout);
+	    }
+	    return;
+	}
+
+    /* if we've reached the end of the old buffer, then there are few tricks
+       we can do, so we just dump out what we must and clear if we can */
+	if (!*ol) {
+	    i = (col_cleareol >= 0) ? col_cleareol : nllen;
+	    i -= vcs;
+	    zwrite(nl, i, 1, shout);
+	    vcs += i;
+	    if (col_cleareol >= 0)
+		tcout(TCCLEAREOL);
+	    return;
+	}
+
+    /* inserting & deleting chars: we can if there's no right-prompt */
+	if ((ln || !put_rpmpt || !oput_rpmpt) 
+	    && (nl[1] && ol[1] && nl[1] != ol[1])) { 
+
+	/* deleting characters - see if we can find a match series that
+	   makes it cheaper to delete intermediate characters
+	   eg. oldline: hifoobar \ hopefully cheaper here to delete two
+	       newline: foobar	 / characters, then we have six matches */
+	    if (tccan(TCDEL)) {
+		for (i = 1; *(ol + i); i++)
+		    if (tcdelcost(i) < pfxlen(ol + i, nl)) {
+			tc_delchars(i);
+			ol += i;
+			char_ins -= i;
+			i = 0;
+			break;
+		    }
+		if (!i)
+		    continue;
+	    }
+	/* inserting characters - characters pushed off the right should be
+	   annihilated, but we don't do this if we're on the last line lest
+	   undesired scrolling occurs due to `illegal' characters on screen */
+
+	    if (tccan(TCINS) && (vln != lines - 1)) {	/* not on last line */
+		for (i = 1; *(nl + i); i++)
+		    if (tcinscost(i) < pfxlen(nl + i, ol)) {
+			tc_inschars(i);
+			zwrite(nl, i, 1, shout);
+			nl += i;
+			char_ins += i;
+			ccs = (vcs += i);
+		    /* if we've pushed off the right, truncate oldline */
+			for (i = 0; *(ol + i) && i < winw - ccs; i++);
+			if (i == winw - ccs) {
+			    *(ol + i) = '\0';
+			    ins_last = 1;
+			}
+			i = 0;
+			break;
+		    }
+		if (!i)
+		    continue;
+	    }
+	}
+    /* we can't do any fancy tricks, so just dump the single character
+       and keep on trying */
+	zputc(*nl, shout);
+	nl++, ol++;
+	ccs++, vcs++;
+    }
+}
+
+/* move the cursor to line ln (relative to the prompt line),
+   absolute column cl; update vln, vcs - video line and column */
+
+/**/
+void
+moveto(int ln, int cl)
+{
+    int c;
+
+    if (vcs == winw) {
+	vln++, vcs = 0;
+	if (!hasam) {
+	    zputc('\r', shout);
+	    zputc('\n', shout);
+	} else {
+	    if ((vln < nlnct) && nbuf[vln] && *nbuf[vln])
+		c = *nbuf[vln];
+	    else
+		c = ' ';
+	    zputc(c, shout);
+	    zputc('\r', shout);
+	    if ((vln < olnct) && obuf[vln] && *obuf[vln])
+		*obuf[vln] = c;
+	}
+    }
+
+    if (ln == vln && cl == vcs)
+	return;
+
+/* move up */
+    if (ln < vln) {
+	tc_upcurs(vln - ln);
+	vln = ln;
+    }
+/* move down; if we might go off the end of the screen, use newlines
+   instead of TCDOWN */
+
+    while (ln > vln) {
+	if (vln < vmaxln - 1)
+	    if (ln > vmaxln - 1) {
+		if (tc_downcurs(vmaxln - 1 - vln))
+		    vcs = 0;
+		vln = vmaxln - 1;
+	    } else {
+		if (tc_downcurs(ln - vln))
+		    vcs = 0;
+		vln = ln;
+		continue;
+	    }
+	zputc('\r', shout), vcs = 0; /* safety precaution */
+	while (ln > vln) {
+	    zputc('\n', shout);
+	    vln++;
+	}
+    }
+
+    if (cl == vcs)
+	return;
+
+/* choose cheapest movements for ttys without multiple movement capabilities -
+   do this now because it's easier (to code) */
+    if (cl <= vcs / 2) {
+	zputc('\r', shout);
+	vcs = 0;
+    }
+    if (vcs < cl)
+	tc_rightcurs(cl);
+    else if (vcs > cl)
+	tc_leftcurs(vcs - cl);
+    vcs = cl;
+}
+
+/**/
+int
+tcmultout(int cap, int multcap, int ct)
+{
+    if (tccan(multcap) && (!tccan(cap) || tclen[multcap] <= tclen[cap] * ct)) {
+	tcoutarg(multcap, ct);
+	return 1;
+    } else if (tccan(cap)) {
+	while (ct--)
+	    tcout(cap);
+	return 1;
+    }
+    return 0;
+}
+
+/**/
+static void
+tc_rightcurs(int cl)
+{
+    int ct,			/* number of characters to move across	    */
+	i = vcs,		/* cursor position after initial movements  */
+	j;
+    char *t;
+
+    ct = cl - vcs;
+
+/* do a multright if we can - it's the most reliable */
+    if (tccan(TCMULTRIGHT)) {
+	tcoutarg(TCMULTRIGHT, ct);
+	return;
+    }
+
+/* try tabs if tabs are non destructive and multright is not possible */
+    if (!oxtabs && tccan(TCNEXTTAB) && ((vcs | 7) < cl)) {
+	i = (vcs | 7) + 1;
+	tcout(TCNEXTTAB);
+	for ( ; i + 8 <= cl; i += 8)
+	    tcout(TCNEXTTAB);
+	if ((ct = cl - i) == 0) /* number of chars still to move across */
+	    return;
+    }
+
+/* otherwise _carefully_ write the contents of the video buffer.
+   if we're anywhere in the prompt, goto the left column and write the whole
+   prompt out unless ztrlen(lpptbuf) == pptw : we can cheat then */
+    if (vln == 0 && i < pptw) {
+	if (strlen(lpptbuf) == pptw)
+	    fputs(lpptbuf + i, shout);
+	else if (tccan(TCRIGHT) && (tclen[TCRIGHT] * ct <= ztrlen(lpptbuf)))
+	    /* it is cheaper to send TCRIGHT than reprint the whole prompt */
+	    for (ct = pptw - i; ct--; )
+		tcout(TCRIGHT);
+        else {
+	    if (i != 0)
+		zputc('\r', shout);
+	    tc_upcurs(lppth - 1);
+	    zputs(lpptbuf, shout);
+	}
+	i = pptw;
+	ct = cl - i;
+    }
+
+    if (nbuf[vln]) {
+	for (j = 0, t = nbuf[vln]; *t && (j < i); j++, t++);
+	if (j == i)
+	    for ( ; *t && ct; ct--, t++)
+		zputc(*t, shout);
+    }
+    while (ct--)
+	zputc(' ', shout);	/* not my fault your terminal can't go right */
+}
+
+/**/
+static int
+tc_downcurs(int ct)
+{
+    int ret = 0;
+
+    if (ct && !tcmultout(TCDOWN, TCMULTDOWN, ct)) {
+	while (ct--)
+	    zputc('\n', shout);
+	zputc('\r', shout), ret = -1;
+    }
+    return ret;
+}
+
+/**/
+void
+tcout(int cap)
+{
+    tputs(tcstr[cap], 1, putshout);
+    SELECT_ADD_COST(tclen[cap]);
+}
+
+/**/
+static void
+tcoutarg(int cap, int arg)
+{
+    char *result;
+
+    result = tgoto(tcstr[cap], arg, arg);
+    tputs(result, 1, putshout);
+    SELECT_ADD_COST(strlen(result));
+}
+
+/**/
+void
+clearscreen(void)
+{
+    tcout(TCCLEARSCREEN);
+    resetneeded = 1;
+    clearflag = 0;
+}
+
+/**/
+void
+redisplay(void)
+{
+    moveto(0, 0);
+    zputc('\r', shout);		/* extra care */
+    tc_upcurs(lppth - 1);
+    resetneeded = 1;
+    clearflag = 0;
+}
+
+/**/
+static void
+singlerefresh(void)
+{
+    char *vbuf, *vp,		/* video buffer and pointer    */
+	**qbuf,			/* tmp			       */
+	*refreshop = *obuf;	/* pointer to old video buffer */
+    int t0,			/* tmp			       */
+	vsiz,			/* size of new video buffer    */
+	nvcs = 0;		/* new video cursor column     */
+
+    nlnct = 1;
+/* generate the new line buffer completely */
+    for (vsiz = 1 + pptw, t0 = 0; t0 != ll; t0++, vsiz++)
+	if (line[t0] == '\t')
+	    vsiz = (vsiz | 7) + 1;
+	else if (icntrl(line[t0]))
+	    vsiz++;
+    vbuf = (char *)zalloc(vsiz);
+
+    if (cs < 0) {
+#ifdef DEBUG
+	fprintf(stderr, "BUG: negative cursor position\n");
+	fflush(stderr); 
+#endif
+	cs = 0;
+    }
+
+    memcpy(vbuf, strchr(lpptbuf, 0) - pptw, pptw); /* only use last part of prompt */
+    vbuf[pptw] = '\0';
+    vp = vbuf + pptw;
+
+    for (t0 = 0; t0 != ll; t0++) {
+	if (line[t0] == '\t')
+	    for (*vp++ = ' '; (vp - vbuf) & 7; )
+		*vp++ = ' ';
+	else if (line[t0] == '\n') {
+	    *vp++ = '\\';
+	    *vp++ = 'n';
+	} else if (line[t0] == 0x7f) {
+	    *vp++ = '^';
+	    *vp++ = '?';
+	} else if (icntrl(line[t0])) {
+	    *vp++ = '^';
+	    *vp++ = line[t0] | '@';
+	} else
+	    *vp++ = line[t0];
+	if (t0 == cs)
+	    nvcs = vp - vbuf - 1;
+    }
+    if (t0 == cs)
+	nvcs = vp - vbuf;
+    *vp = '\0';
+
+/* determine which part of the new line buffer we want for the display */
+    if ((winpos && nvcs < winpos + 1) || (nvcs > winpos + winw - 2)) {
+	if ((winpos = nvcs - ((winw - hasam) / 2)) < 0)
+	    winpos = 0;
+    }
+    if (winpos)
+	vbuf[winpos] = '<';	/* line continues to the left */
+    if ((int)strlen(vbuf + winpos) > (winw - hasam)) {
+	vbuf[winpos + winw - hasam - 1] = '>';	/* line continues to right */
+	vbuf[winpos + winw - hasam] = '\0';
+    }
+    strcpy(nbuf[0], vbuf + winpos);
+    zfree(vbuf, vsiz);
+    nvcs -= winpos;
+
+/* display the `visable' portion of the line buffer */
+    for (t0 = 0, vp = *nbuf;;) {
+    /* skip past all matching characters */
+	for (; *vp && *vp == *refreshop; t0++, vp++, refreshop++) ;
+
+	if (!*vp && !*refreshop)
+	    break;
+
+	singmoveto(t0);		/* move to where we do all output from */
+
+	if (!*refreshop) {
+	    if ((t0 = strlen(vp)))
+		zwrite(vp, t0, 1, shout);
+	    vcs += t0;
+	    break;
+	}
+	if (!*vp) {
+	    if (tccan(TCCLEAREOL))
+		tcout(TCCLEAREOL);
+	    else
+		for (; *refreshop++; vcs++)
+		    zputc(' ', shout);
+	    break;
+	}
+	zputc(*vp, shout);
+	vcs++, t0++;
+	vp++, refreshop++;
+    }
+/* move to the new cursor position */
+    singmoveto(nvcs);
+
+    qbuf = nbuf;
+    nbuf = obuf;
+    obuf = qbuf;
+    fflush(shout);		/* make sure everything is written out */
+}
+
+/**/
+static void
+singmoveto(int pos)
+{
+    if (pos == vcs)
+	return;
+    if (pos <= vcs / 2) {
+	zputc('\r', shout);
+	vcs = 0;
+    }
+    if (pos < vcs) {
+	tc_leftcurs(vcs - pos);
+	vcs = pos;
+    }
+    if (pos > vcs) {
+	if (tcmultout(TCRIGHT, TCMULTRIGHT, pos - vcs))
+	    vcs = pos;
+	else
+	    while (pos > vcs) {
+		zputc(nbuf[0][vcs], shout);
+		vcs++;
+	    }
+    }
+}
+
+/* recheck size of prompts */
+
+/**/
+static void
+genprompts(void)
+{
+    countprompt(lpptbuf, &pptw, &lppth);
+    countprompt(rpptbuf, &rpw, &rppth);
+}
diff --git a/Src/Zle/zle_things.sed b/Src/Zle/zle_things.sed
new file mode 100644
index 000000000..781d23704
--- /dev/null
+++ b/Src/Zle/zle_things.sed
@@ -0,0 +1,9 @@
+/^ *T("/{
+    s/^[^"]*"/    z_/
+    s/".*$/,/
+    s/-//g
+    s/\./D/g
+    P
+    s/    z_\(.*\),/#define t_\1 (\&thingies[z_\1])/
+    P
+}
diff --git a/Src/Zle/zle_thingy.c b/Src/Zle/zle_thingy.c
new file mode 100644
index 000000000..c4f2e25e1
--- /dev/null
+++ b/Src/Zle/zle_thingy.c
@@ -0,0 +1,491 @@
+/*
+ * zle_thingy.c - thingies
+ *
+ * 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 "zle.mdh"
+#include "zle_thingy.pro"
+
+/*
+ * Thingies:
+ *
+ * From the user's point of view, a thingy is just a string.  Internally,
+ * the thingy is a struct thingy; these structures are in a hash table
+ * indexed by the string the user sees.  This hash table contains all
+ * thingies currently referenced anywhere; each has a reference count,
+ * and is deleted when it becomes unused.  Being the name of a function
+ * counts as a reference.
+ *
+ * The DISABLED flag on a thingy indicates that it is not the name of a
+ * widget.  This makes it easy to generate completion lists;
+ * looking only at the `enabled' nodes makes the thingy table look like
+ * a table of widgets.
+ */
+
+/* Hashtable of thingies.  Enabled nodes are those that refer to widgets. */
+
+/**/
+HashTable thingytab;
+
+/**********************************/
+/* hashtable management functions */
+/**********************************/
+
+/**/
+static void
+createthingytab(void)
+{
+    thingytab = newhashtable(199, "thingytab", NULL);
+
+    thingytab->hash        = hasher;
+    thingytab->emptytable  = emptythingytab;
+    thingytab->filltable   = NULL;
+    thingytab->addnode     = addhashnode;
+    thingytab->getnode     = gethashnode;
+    thingytab->getnode2    = gethashnode2;
+    thingytab->removenode  = removehashnode;
+    thingytab->disablenode = NULL;
+    thingytab->enablenode  = NULL;
+    thingytab->freenode    = freethingynode;
+    thingytab->printnode   = NULL;
+}
+
+/**/
+static void
+emptythingytab(HashTable ht)
+{
+    /* This will only be called when deleting the thingy table, which *
+     * is only done to unload the zle module.  A normal emptytable()  *
+     * function would free all the thingies, but we don't want to do  *
+     * that because some of them are the known thingies in the fixed  *
+     * `thingies' table.  As the module cleanup code deletes all the  *
+     * keymaps and so on before deleting the thingy table, we can     *
+     * just remove the user-defined widgets and then be sure that     *
+     * *all* the thingies left are the fixed ones.  This has the side *
+     * effect of freeing all resources used by user-defined widgets.  */
+    scanhashtable(thingytab, 0, 0, DISABLED, scanemptythingies, 0);
+}
+
+/**/
+static void
+scanemptythingies(HashNode hn, int flags)
+{
+    Thingy t = (Thingy) hn;
+
+    /* Mustn't unbind internal widgets -- we wouldn't want to free the *
+     * memory they use.                                                */
+    if(!(t->widget->flags & WIDGET_INT))
+	unbindwidget(t, 1);
+}
+
+/**/
+static Thingy
+makethingynode(void)
+{
+    Thingy t = (Thingy) zcalloc(sizeof(*t));
+
+    t->flags = DISABLED;
+    return t;
+}
+
+/**/
+static void
+freethingynode(HashNode hn)
+{
+    Thingy th = (Thingy) hn;
+
+    zsfree(th->nam);
+    zfree(th, sizeof(*th));
+}
+
+/************************/
+/* referencing thingies */
+/************************/
+
+/* It is important to maintain the reference counts on thingies.  When *
+ * copying a reference to a thingy, wrap the copy in refthingy(), to   *
+ * increase its reference count.  When removing a reference,           *
+ * unrefthingy() it.  Both of these functions handle NULL arguments    *
+ * correctly.                                                          */
+
+/**/
+Thingy
+refthingy(Thingy th)
+{
+    if(th)
+	th->rc++;
+    return th;
+}
+
+/**/
+void
+unrefthingy(Thingy th)
+{
+    if(th && !--th->rc)
+	thingytab->freenode(thingytab->removenode(thingytab, th->nam));
+}
+
+/* Use rthingy() to turn a string into a thingy.  It increases the reference *
+ * count, after creating the thingy structure if necessary.                  */
+
+/**/
+Thingy
+rthingy(char *nam)
+{
+    Thingy t = (Thingy) thingytab->getnode2(thingytab, nam);
+
+    if(!t)
+	thingytab->addnode(thingytab, ztrdup(nam), t = makethingynode());
+    return refthingy(t);
+}
+
+/***********/
+/* widgets */
+/***********/
+
+/*
+ * Each widget is attached to one or more thingies.  Each thingy
+ * names either zero or one widgets.  Thingies that name a widget
+ * are treated as being referenced.  The widget type, flags and pointer
+ * are stored in a separate structure pointed to by the thingies.  Each
+ * thingy also has a pointer to the `next' thingy (in a circular list)
+ * that references the same widget.  The DISABLED flag is unset in these
+ * thingies.
+ */
+
+/* Bind a widget to a thingy.  The thingy's reference count must already *
+ * have been incremented.  The widget may already be bound to other      *
+ * thingies; if it is not, then its `first' member must be NULL.  Return *
+ * is 0 on success, or -1 if the thingy has the TH_IMMORTAL flag set.    */
+
+/**/
+static int
+bindwidget(Widget w, Thingy t)
+{
+    if(t->flags & TH_IMMORTAL) {
+	unrefthingy(t);
+	return -1;
+    }
+    if(!(t->flags & DISABLED)) {
+	if(t->widget == w)
+	    return 0;
+	unbindwidget(t, 1);
+    }
+    if(w->first) {
+	t->samew = w->first->samew;
+	w->first->samew = t;
+    } else {
+	w->first = t;
+	t->samew = t;
+    }
+    t->widget = w;
+    t->flags &= ~DISABLED;
+    return 0;
+}
+
+/* Unbind a widget from a thingy.  This decrements the thingy's reference *
+ * count.  The widget will be destroyed if this is its last name.         *
+ * TH_IMMORTAL thingies won't be touched, unless override is non-zero.    *
+ * Returns 0 on success, or -1 if the thingy is protected.  If the thingy *
+ * doesn't actually reference a widget, this is considered successful.    */
+
+/**/
+static int
+unbindwidget(Thingy t, int override)
+{
+    Widget w;
+
+    if(t->flags & DISABLED)
+	return 0;
+    if(!override && (t->flags & TH_IMMORTAL))
+	return -1;
+    w = t->widget;
+    if(t->samew == t)
+	freewidget(w);
+    else {
+	Thingy p;
+	for(p = w->first; p->samew != t; p = p->samew) ;
+	w->first = p;   /* optimised for deletezlefunction() */
+	p->samew = t->samew;
+    }
+    t->flags &= ~TH_IMMORTAL;
+    t->flags |= DISABLED;
+    unrefthingy(t);
+    return 0;
+}
+
+/* Free a widget. */
+
+/**/
+static void
+freewidget(Widget w)
+{
+    if(!(w->flags & WIDGET_INT))
+	zsfree(w->u.fnnam);
+    zfree(w, sizeof(*w));
+}
+
+/* Add am internal widget provided by a module.  The name given is the  *
+ * canonical one, which must not begin with a dot.  The widget is first *
+ * bound to the dotted canonical name; if that name is already taken by *
+ * an internal widget, failure is indicated.  The same widget is then   *
+ * bound to the canonical name, and a pointer to the widget structure   *
+ * returned.                                                            */
+
+/**/
+Widget
+addzlefunction(char *name, ZleIntFunc ifunc, int flags)
+{
+    VARARR(char, dotn, strlen(name) + 2);
+    Widget w;
+    Thingy t;
+
+    if(name[0] == '.')
+	return NULL;
+    dotn[0] = '.';
+    strcpy(dotn + 1, name);
+    t = (Thingy) thingytab->getnode(thingytab, dotn);
+    if(t && (t->flags & TH_IMMORTAL))
+	return NULL;
+    w = zalloc(sizeof(*w));
+    w->flags = WIDGET_INT | flags;
+    w->first = NULL;
+    w->u.fn = ifunc;
+    t = rthingy(dotn);
+    bindwidget(w, t);
+    t->flags |= TH_IMMORTAL;
+    bindwidget(w, rthingy(name));
+    return w;
+}
+
+#ifdef DYNAMIC
+
+/* Delete an internal widget provided by a module.  Don't try to delete *
+ * a widget from the fixed table -- it would be bad.  (Thanks, Egon.)   */
+
+/**/
+void
+deletezlefunction(Widget w)
+{
+    Thingy p, n;
+
+    p = w->first;
+    while(1) {
+	n = p->samew;
+	if(n == p) {
+	    unbindwidget(p, 1);
+	    return;
+	}
+	unbindwidget(p, 1);
+	p = n;
+    }
+}
+
+#endif /* DYNAMIC */
+
+/***************/
+/* zle builtin */
+/***************/
+
+/*
+ * The available operations are:
+ *
+ *   -l   list user-defined widgets (no arguments)
+ *   -D   delete widget names
+ *   -A   link the two named widgets (2 arguments)
+ *   -N   create new user-defined widget (1 or 2 arguments)
+ *        invoke a widget (1 argument)
+ */
+
+/**/
+int
+bin_zle(char *name, char **args, char *ops, int func)
+{
+    static struct opn {
+	char o;
+	int (*func) _((char *, char **, char *, char));
+	int min, max;
+    } const opns[] = {
+	{ 'l', bin_zle_list, 0,  0 },
+	{ 'D', bin_zle_del,  1, -1 },
+	{ 'A', bin_zle_link, 2,  2 },
+	{ 'N', bin_zle_new,  1,  2 },
+	{ 0,   bin_zle_call, 0, -1 },
+    };
+    struct opn const *op, *opp;
+    int n;
+
+    /* select operation and ensure no clashing arguments */
+    for(op = opns; op->o && !ops[op->o]; op++) ;
+    if(op->o)
+	for(opp = op; (++opp)->o; )
+	    if(ops[opp->o]) {
+		zerrnam(name, "incompatible operation selection options",
+		    NULL, 0);
+		return 1;
+	    }
+
+    /* check number of arguments */
+    for(n = 0; args[n]; n++) ;
+    if(!op->o && n != 1) {
+	zerrnam(name, "wrong number of arguments", NULL, 0);
+	return 1;
+    }
+    if(n < op->min) {
+	zerrnam(name, "not enough arguments for -%c", NULL, op->o);
+	return 1;
+    } else if(op->max != -1 && n > op->max) {
+	zerrnam(name, "too many arguments for -%c", NULL, op->o);
+	return 1;
+    }
+
+    /* pass on the work to the operation function */
+    return op->func(name, args, ops, op->o);
+}
+
+/**/
+static int
+bin_zle_list(char *name, char **args, char *ops, char func)
+{
+    scanhashtable(thingytab, 1, 0, DISABLED, scanlistwidgets, ops['L']);
+    return 0;
+}
+
+/**/
+static void
+scanlistwidgets(HashNode hn, int list)
+{
+    Thingy t = (Thingy) hn;
+    Widget w = t->widget;
+
+    if(w->flags & WIDGET_INT)
+	return;
+    if(list) {
+	fputs("zle -N ", stdout);
+	if(t->nam[0] == '-')
+	    fputs("-- ", stdout);
+	quotedzputs(t->nam, stdout);
+	if(strcmp(t->nam, w->u.fnnam)) {
+	    fputc(' ', stdout);
+	    quotedzputs(w->u.fnnam, stdout);
+	}
+    } else {
+	nicezputs(t->nam, stdout);
+	if(strcmp(t->nam, w->u.fnnam)) {
+	    fputs(" (", stdout);
+	    nicezputs(w->u.fnnam, stdout);
+	    fputc(')', stdout);
+	}
+    }
+    putchar('\n');
+}
+
+/**/
+static int
+bin_zle_del(char *name, char **args, char *ops, char func)
+{
+    int ret = 0;
+
+    do {
+	Thingy t = (Thingy) thingytab->getnode(thingytab, *args);
+	if(!t) {
+	    zwarnnam(name, "no such widget `%s'", *args, 0);
+	    ret = 1;
+	} else if(unbindwidget(t, 0)) {
+	    zwarnnam(name, "widget name `%s' is protected", *args, 0);
+	    ret = 1;
+	}
+    } while(*++args);
+    return ret;
+}
+
+/**/
+static int
+bin_zle_link(char *name, char **args, char *ops, char func)
+{
+    Thingy t = (Thingy) thingytab->getnode(thingytab, args[0]);
+
+    if(!t) {
+	zerrnam(name, "no such widget `%s'", args[0], 0);
+	return 1;
+    } else if(bindwidget(t->widget, rthingy(args[1]))) {
+	zerrnam(name, "widget name `%s' is protected", args[1], 0);
+	return 1;
+    }
+    return 0;
+
+}
+
+/**/
+static int
+bin_zle_new(char *name, char **args, char *ops, char func)
+{
+    Widget w = zalloc(sizeof(*w));
+
+    w->flags = 0;
+    w->first = NULL;
+    w->u.fnnam = ztrdup(args[1] ? args[1] : args[0]);
+    if(!bindwidget(w, rthingy(args[0])))
+	return 0;
+    freewidget(w);
+    zerrnam(name, "widget name `%s' is protected", args[0], 0);
+    return 1;
+}
+
+/**/
+static int
+bin_zle_call(char *name, char **args, char *ops, char func)
+{
+    Thingy t;
+
+    if(!zleactive || incompctlfunc) {
+	zerrnam(name, "widgets can only be called when ZLE is active",
+	    NULL, 0);
+	return 1;
+    }
+    t = rthingy(args[0]);
+    PERMALLOC {
+      execzlefunc(t);
+    } LASTALLOC;
+    unrefthingy(t);
+    return 0;
+}
+
+/*******************/
+/* initialiasation */
+/*******************/
+
+/**/
+void
+init_thingies(void)
+{
+    Thingy t;
+
+    createthingytab();
+    for(t = thingies; t->nam; t++)
+	thingytab->addnode(thingytab, t->nam, t);
+}
diff --git a/Src/Zle/zle_tricky.c b/Src/Zle/zle_tricky.c
new file mode 100644
index 000000000..1aa1a008c
--- /dev/null
+++ b/Src/Zle/zle_tricky.c
@@ -0,0 +1,4015 @@
+/*
+ * zle_tricky.c - expansion and completion
+ *
+ * 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 "zle.mdh"
+#include "zle_tricky.pro"
+
+/* The main part of ZLE maintains the line being edited as binary data, *
+ * but here, where we interface with the lexer and other bits of zsh,   *
+ * we need the line metafied.  The technique used is quite simple: on   *
+ * entry to the expansion/completion system, we metafy the line in      *
+ * place, adjusting ll and cs to match.  All completion and expansion   *
+ * is done on the metafied line.  Immediately before returning, the     *
+ * line is unmetafied again, changing ll and cs back.  (ll and cs might *
+ * have changed during completion, so they can't be merely saved and    *
+ * restored.)  The various indexes into the line that are used in this  *
+ * file only are not translated: they remain indexes into the metafied  *
+ * line.                                                                */
+
+#ifdef HAVE_NIS_PLUS
+# include <rpcsvc/nis.h>
+#else
+# ifdef HAVE_NIS
+#  include	<rpc/types.h>
+#  include	<rpc/rpc.h>
+#  include	<rpcsvc/ypclnt.h>
+#  include	<rpcsvc/yp_prot.h>
+
+/* This is used when getting usernames from the NIS. */
+typedef struct {
+    int len;
+    char *s;
+}
+dopestring;
+# endif
+#endif
+
+#define inststr(X) inststrlen((X),1,-1)
+
+/* wb and we hold the beginning/end position of the word we are completing. */
+
+static int wb, we;
+
+/* offs is the cursor position within the tokenized *
+ * current word after removing nulargs.             */
+
+static int offs;
+
+/* These control the type of completion that will be done.  They are    *
+ * affected by the choice of ZLE command and by relevant shell options. */
+
+static int usemenu, useglob;
+
+/* != 0 if we are in the middle of a menu completion */
+
+static int menucmp;
+
+/* A pointer to the current position in the menu-completion array (the one *
+ * that was put in the command line last).                                 */
+
+static char **menucur;
+
+/* menupos is the point (in the command line) where the menu-completion   *
+ * strings are inserted.  menulen is the length of the string that was    *
+ * inserted last.  menuend is the end position of this string in the      *
+ * command line.  menuwe is non-zero if the cursor was at the end of the  *
+ * word (meaning that suffixes should go before the cursor).  menuinsc is *
+ * the length of any suffix that has been temporarily added.              */
+
+static int menupos, menulen, menuend, menuwe, menuinsc;
+
+/* This is used as a flag from get_comp_string() that we are doing *
+ * completion inside a brace expansion.                            */
+
+static int complinbrace;
+
+/* The list of matches.  fmatches contains the matches we first ignore *
+ * because of fignore.                                                 */
+
+static LinkList matches, fmatches;
+
+/* The list of matches turned into an array.  This is used to sort this *
+ * list and when menu-completion is used (directly or via automenu).    */
+
+static char **amatches;
+
+/* The number of matches. */
+
+static int nmatches;
+
+/* A list of user-defined explanations for the completions to be shown *
+ * instead of amatches when listing completions.                       */
+
+static char **aylist;
+
+/* !=0 if we have a valid completion list. */
+
+static int validlist;
+
+/* This flag is non-zero if we are completing a pattern (with globcomplete) */
+
+static int ispattern;
+
+/* Two patterns used when doing glob-completion.  The first one is built *
+ * from the whole word we are completing and the second one from that    *
+ * part of the word that was identified as a possible filename.          */
+
+static Comp patcomp, filecomp;
+
+/* We store the following prefixes/suffixes:                             *
+ * lpre/lsuf -- what's on the line                                       *
+ * rpre/rsuf -- same as lpre/lsuf, but expanded                          *
+ *                                                                       *
+ * ... and if we are completing files, too:                              *
+ * ppre/psuf -- the path prefix/suffix                                   *
+ * fpre/fsuf -- prefix/suffix of the pathname component the cursor is in *
+ * prpre     -- ppre in expanded form usable for opendir                 *
+ *                                                                       *
+ * The integer variables hold the lengths of lpre, lsuf, rpre, rsuf,     *
+ * fpre, and fsuf.  noreal is non-zero if we have rpre/rsuf.             */
+
+static char *lpre, *lsuf;
+static char *rpre, *rsuf;
+static char *ppre, *psuf, *prpre;
+static char *fpre, *fsuf;
+static int lpl, lsl, rpl, rsl, fpl, fsl;
+static int noreal;
+
+/* This is used when completing after `$' and holds the whole prefix,   *
+ * used in do_single() to check whether the word expands to a directory *
+ * name (in that case and if autoparamslash is set, we add a `/').      *
+ * qparampre is the same but quoted. The length of it is in qparprelen. *
+ * parambr is != 0 if the parameter name is in braces.                  */
+
+static char *parampre = NULL, *qparampre = NULL;
+static int qparprelen, parambr;
+
+/* This is either zero or equal to the special character the word we are *
+ * trying to complete starts with (e.g. Tilde or Equals).                */
+
+static char ic;
+
+/* These hold the minimum common prefix/suffix lengths (normal and for *
+ * fignore ignored).                                                   */
+
+static int ab, ae, fab, fae;
+
+/* This variable says what we are currently adding to the list of matches. */
+
+static int addwhat;
+
+/* firstm hold the first match we found, shortest contains the shortest *
+ * one (normal and for fignore ignored).                                */
+
+static char *firstm, *shortest, *ffirstm, *fshortest;
+
+/* This holds the word we are completing in quoted from. */
+
+static char *qword;
+
+/* This is the length of the shortest match we found (normal and for *
+ * fignore ignored).                                                 */
+
+static int shortl, fshortl;
+
+/* This is non-zero if we are doing a menu-completion and this is not the *
+ * first call (e.g. when automenu is set and menu-completion was entered  *
+ * due to this). */
+
+static int amenu;
+
+/* Find out if we have to insert a tab (instead of trying to complete). */
+
+/**/
+static int
+usetab(void)
+{
+    unsigned char *s = line + cs - 1;
+
+    for (; s >= line && *s != '\n'; s--)
+	if (*s != '\t' && *s != ' ')
+	    return 0;
+    return 1;
+}
+
+#define COMP_COMPLETE 0
+#define COMP_LIST_COMPLETE 1
+#define COMP_SPELL 2
+#define COMP_EXPAND 3
+#define COMP_EXPAND_COMPLETE 4
+#define COMP_LIST_EXPAND 5
+#define COMP_ISEXPAND(X) ((X) >= COMP_EXPAND)
+
+/**/
+void
+completeword(void)
+{
+    usemenu = isset(MENUCOMPLETE);
+    useglob = isset(GLOBCOMPLETE);
+    if (c == '\t' && usetab())
+	selfinsert();
+    else
+	docomplete(COMP_COMPLETE);
+}
+
+/**/
+void
+menucomplete(void)
+{
+    usemenu = 1;
+    useglob = isset(GLOBCOMPLETE);
+    if (c == '\t' && usetab())
+	selfinsert();
+    else
+	docomplete(COMP_COMPLETE);
+}
+
+/**/
+void
+listchoices(void)
+{
+    usemenu = isset(MENUCOMPLETE);
+    useglob = isset(GLOBCOMPLETE);
+    docomplete(COMP_LIST_COMPLETE);
+}
+
+/**/
+void
+spellword(void)
+{
+    usemenu = useglob = 0;
+    docomplete(COMP_SPELL);
+}
+
+/**/
+void
+deletecharorlist(void)
+{
+    char **mc = menucur;
+
+    usemenu = isset(MENUCOMPLETE);
+    useglob = isset(GLOBCOMPLETE);
+    if (cs != ll)
+	deletechar();
+    else
+	docomplete(COMP_LIST_COMPLETE);
+
+    menucur = mc;
+}
+
+/**/
+void
+expandword(void)
+{
+    usemenu = useglob = 0;
+    if (c == '\t' && usetab())
+	selfinsert();
+    else
+	docomplete(COMP_EXPAND);
+}
+
+/**/
+void
+expandorcomplete(void)
+{
+    usemenu = isset(MENUCOMPLETE);
+    useglob = isset(GLOBCOMPLETE);
+    if (c == '\t' && usetab())
+	selfinsert();
+    else
+	docomplete(COMP_EXPAND_COMPLETE);
+}
+
+/**/
+void
+menuexpandorcomplete(void)
+{
+    usemenu = 1;
+    useglob = isset(GLOBCOMPLETE);
+    if (c == '\t' && usetab())
+	selfinsert();
+    else
+	docomplete(COMP_EXPAND_COMPLETE);
+}
+
+/**/
+void
+listexpand(void)
+{
+    usemenu = isset(MENUCOMPLETE);
+    useglob = isset(GLOBCOMPLETE);
+    docomplete(COMP_LIST_EXPAND);
+}
+
+/**/
+void
+reversemenucomplete(void)
+{
+    if (!menucmp) {
+	menucomplete();
+	return;
+    }
+    HEAPALLOC {
+	if (menucur == amatches)
+	    menucur = amatches + nmatches - 1;
+	else
+	    menucur--;
+	metafy_line();
+	do_single(*menucur);
+	unmetafy_line();
+    } LASTALLOC;
+}
+
+/* Accepts the current completion and starts a new arg, *
+ * with the next completions. This gives you a way to   *
+ * accept several selections from the list of matches.  */
+
+/**/
+void
+acceptandmenucomplete(void)
+{
+    if (!menucmp) {
+	feep();
+	return;
+    }
+    cs = menuend + menuinsc;
+    inststrlen(" ", 1, 1);
+    if (qparampre)
+	inststrlen(qparampre, 1, qparprelen);
+    if (lpre && !ispattern)
+	inststrlen(lpre, 1, -1);
+    if (lsuf && !ispattern)
+	inststrlen(lsuf, 0, -1);
+    menupos = cs;
+    menuend = cs + (lsuf ? strlen(lsuf) : 0);
+    menulen = 0;
+    menuinsc = 0;
+    menuwe = 1;
+    menucomplete();
+}
+
+/* These are flags saying if we are completing in the command *
+ * position or in a redirection.                              */
+
+static int lincmd, linredir;
+
+/* Non-zero if the last completion done was ambiguous (used to find   *
+ * out if AUTOMENU should start).  More precisely, it's nonzero after *
+ * successfully doing any completion, unless the completion was       *
+ * unambiguous and did not cause the display of a completion list.    *
+ * From the other point of view, it's nonzero iff AUTOMENU (if set)   *
+ * should kick in on another completion.                              */
+
+static int lastambig;
+
+/* This describes some important things collected during the last *
+ * completion.  Its value is zero or the inclusive OR of some of  *
+ * the HAS_* things below.                                        */
+
+static int haswhat;
+
+/* We have a suffix to add (given with compctl -S). */
+
+#define HAS_SUFFIX  1
+
+/* We have filenames in the completion list. */
+
+#define HAS_FILES   2
+
+/* We have other things than files in the completion list.  If this is *
+ * not set but HAS_FILES is, we probably put the file type characters  *
+ * in the completion list (if listtypes is set) and we attempt to add  *
+ * a slash to completed directories.                                   */
+
+#define HAS_MISC    4
+
+/* This is set if we have filenames in the completion list that were *
+ * generated by a globcompletion pattern.                            */
+
+#define HAS_PATHPAT 8
+
+
+/* This holds the naem of the current command (used to find the right *
+ * compctl).                                                          */
+
+static char *cmdstr;
+
+
+/* Check if the given string is the name of a parameter and if this *
+ * parameter is one worth expanding.                                */
+
+/**/
+static int
+checkparams(char *p)
+{
+    int t0, n, l = strlen(p), e = 0;
+    struct hashnode *hn;
+
+    for (t0 = paramtab->hsize - 1, n = 0; n < 2 && t0 >= 0; t0--)
+	for (hn = paramtab->nodes[t0]; n < 2 && hn; hn = hn->next)
+	    if (pfxlen(p, hn->nam) == l) {
+		n++;
+		if (strlen(hn->nam) == l)
+		    e = 1;
+	    }
+    return (n == 1) ? (getsparam(p) != NULL) :
+	(!menucmp && e && isset(RECEXACT));
+}
+
+/* Check if the given string has wildcards.  The difficulty is that we *
+ * have to treat things like job specifications (%...) and parameter   *
+ * expressions correctly.                                              */
+
+/**/
+static int
+cmphaswilds(char *str)
+{
+    if ((*str == Inbrack || *str == Outbrack) && !str[1])
+	return 0;
+
+    /* If a leading % is immediately followed by ?, then don't *
+     * treat that ? as a wildcard.  This is so you don't have  *
+     * to escape job references such as %?foo.                 */
+    if (str[0] == '%' && str[1] ==Quest)
+	str += 2;
+
+    for (; *str;) {
+	if (*str == String || *str == Qstring) {
+	    /* A parameter expression. */
+
+	    if (*++str == Inbrace)
+		skipparens(Inbrace, Outbrace, &str);
+	    else if (*str == String || *str == Qstring)
+		str++;
+	    else {
+		/* Skip all the things a parameter expression might start *
+		 * with (before we come to the parameter name).           */
+		for (; *str; str++)
+		    if (*str != '^' && *str != Hat &&
+			*str != '=' && *str != Equals &&
+			*str != '~' && *str != Tilde)
+			break;
+		if (*str == '#' || *str == Pound)
+		    str++;
+		/* Star and Quest are parameter names here, not wildcards */
+		if (*str == Star || *str == Quest)
+		    str++;
+	    }
+	} else {
+	    /* Not a parameter expression so we check for wildcards */
+	    if (((*str == Pound || *str == Hat) && isset(EXTENDEDGLOB)) ||
+		*str == Star || *str == Bar || *str == Quest ||
+		!skipparens(Inbrack, Outbrack, &str) ||
+		!skipparens(Inang,   Outang,   &str) ||
+		(unset(IGNOREBRACES) &&
+		 !skipparens(Inbrace, Outbrace, &str)) ||
+		(*str == Inpar && str[1] == ':' &&
+		 !skipparens(Inpar, Outpar, &str)))
+		return 1;
+	    if (*str)
+		str++;
+	}
+    }
+    return 0;
+}
+
+/* The main entry point for completion. */
+
+/**/
+static void
+docomplete(int lst)
+{
+    char *s, *ol;
+    int olst = lst, chl = 0, ne = noerrs, ocs;
+
+    /* If we are doing a menu-completion... */
+
+    if (menucmp && lst != COMP_LIST_EXPAND) {
+	do_menucmp(lst);
+	return;
+    }
+
+    /* Check if we have to start a menu-completion (via automenu). */
+
+    if ((amenu = (isset(AUTOMENU) && lastambig)))
+	usemenu = 1;
+
+    /* Expand history references before starting completion.  If anything *
+     * changed, do no more.                                               */
+
+    if (doexpandhist())
+	return;
+
+    metafy_line();
+
+    ocs = cs;
+    if (!isfirstln && chline != NULL) {
+	/* If we are completing in a multi-line buffer (which was not  *
+	 * taken from the history), we have to prepend the stuff saved *
+	 * in chline to the contents of line.                          */
+
+	ol = dupstring((char *)line);
+	/* Make sure that chline is zero-terminated. */
+	*hptr = '\0';
+	cs = 0;
+	inststr(chline);
+	chl = cs;
+	cs += ocs;
+    } else
+	ol = NULL;
+    inwhat = IN_NOTHING;
+    qword = NULL;
+    /* Get the word to complete. */
+    noerrs = 1;
+    s = get_comp_string();
+    DPUTS(wb < 0 || cs < wb || cs > we,
+	  "BUG: 0 <= wb <= cs <= we is not true!");
+    noerrs = ne;
+    /* For vi mode, reset the start-of-insertion pointer to the beginning *
+     * of the word being completed, if it is currently later.  Vi itself  *
+     * would never change the pointer in the middle of an insertion, but  *
+     * then vi doesn't have completion.  More to the point, this is only  *
+     * an emulation.                                                      */
+    if (viinsbegin > ztrsub((char *) line + wb, (char *) line))
+	viinsbegin = ztrsub((char *) line + wb, (char *) line);
+    /* If we added chline to the line buffer, reset the original contents. */
+    if (ol) {
+	cs -= chl;
+	wb -= chl;
+	we -= chl;
+	if (wb < 0) {
+	    strcpy((char *) line, ol);
+	    ll = strlen((char *) line);
+	    cs = ocs;
+	    unmetafy_line();
+	    feep();
+	    return;
+	}
+	ocs = cs;
+	cs = 0;
+	foredel(chl);
+	cs = ocs;
+    }
+    freeheap();
+    /* Save the lexer state, in case the completion code uses the lexer *
+     * somewhere (e.g. when processing a compctl -s flag).              */
+    lexsave();
+    if (inwhat == IN_ENV)
+	lincmd = 0;
+    if (s) {
+	if (lst == COMP_EXPAND_COMPLETE) {
+	    /* Check if we have to do expansion or completion. */
+	    char *q = s;
+
+	    if (*q == Equals) {
+		/* The word starts with `=', see if we can expand it. */
+		q = s + 1;
+		if (cmdnamtab->getnode(cmdnamtab, q) || hashcmd(q, pathchecked))
+		    if (isset(RECEXACT))
+			lst = COMP_EXPAND;
+		    else {
+			int t0, n = 0;
+			char *fc;
+			struct hashnode *hn;
+
+			for (t0 = cmdnamtab->hsize - 1; t0 >= 0; t0--)
+			    for (hn = cmdnamtab->nodes[t0]; hn;
+				 hn = hn->next) {
+				if (strpfx(q, hn->nam) && (fc = findcmd(hn->nam))) {
+				    zsfree(fc);
+				    n++;
+				}
+				if (n == 2)
+				    break;
+			    }
+
+			if (n == 1)
+			    lst = COMP_EXPAND;
+		    }
+	    }
+	    if (lst == COMP_EXPAND_COMPLETE)
+		do {
+		    /* check if there is a parameter expresiion. */
+		    for (; *q && *q != String; q++);
+		    if (*q == String && q[1] != Inpar && q[1] != Inbrack) {
+			if (*++q == Inbrace) {
+			    if (! skipparens(Inbrace, Outbrace, &q) &&
+				q == s + cs - wb)
+				lst = COMP_EXPAND;
+			} else {
+			    char *t, sav, sav2;
+
+			    /* Skip the things parameter expressions might *
+			     * start with (the things before the parameter *
+			     * name).                                      */
+			    for (; *q; q++)
+				if (*q != '^' && *q != Hat &&
+				    *q != '=' && *q != Equals &&
+				    *q != '~' && *q != Tilde)
+				    break;
+			    if ((*q == '#' || *q == Pound || *q == '+') &&
+				q[1] != String)
+				q++;
+
+			    sav2 = *(t = q);
+			    if (*q == Quest || *q == Star || *q == String ||
+				*q == Qstring)
+				*q = ztokens[*q - Pound], ++q;
+			    else if (*q == '?' || *q == '*' || *q == '$' ||
+				     *q == '-' || *q == '!' || *q == '@')
+				q++;
+			    else if (idigit(*q))
+				do q++; while (idigit(*q));
+			    else
+				while (iident(*q))
+				    q++;
+			    sav = *q;
+			    *q = '\0';
+			    if (cs - wb == q - s &&
+				(idigit(sav2) || checkparams(t)))
+				lst = COMP_EXPAND;
+			    *q = sav;
+			    *t = sav2;
+			}
+			if (lst != COMP_EXPAND)
+			    lst = COMP_COMPLETE;
+		    } else
+			break;
+		} while (q < s + cs - wb);
+	    if (lst == COMP_EXPAND_COMPLETE) {
+		/* If it is still not clear if we should use expansion or   *
+		 * completion and there is a `$' or a backtick in the word, *
+		 * than do expansion.                                       */
+		for (q = s; *q; q++)
+		    if (*q == Tick || *q == Qtick ||
+			*q == String || *q == Qstring)
+			break;
+		lst = *q ? COMP_EXPAND : COMP_COMPLETE;
+	    }
+	    /* And do expansion if there are wildcards and globcomplete is *
+	     * not used.                                                   */
+	    if (unset(GLOBCOMPLETE) && cmphaswilds(s))
+		lst = COMP_EXPAND;
+	}
+	if (lincmd && (inwhat == IN_NOTHING))
+	    inwhat = IN_CMD;
+
+	if (lst == COMP_SPELL) {
+	    char *x, *q;
+
+	    for (q = s; *q; q++)
+		if (INULL(*q))
+		    *q = Nularg;
+	    cs = wb;
+	    foredel(we - wb);
+	    HEAPALLOC {
+		untokenize(x = dupstring(s));
+		if (*s == Tilde || *s == Equals || *s == String)
+		    *x = *s;
+		spckword(&x, 0, lincmd, 0);
+	    } LASTALLOC;
+	    untokenize(x);
+	    inststr(x);
+	} else if (COMP_ISEXPAND(lst)) {
+	    /* Do expansion. */
+	    char *ol = (olst == COMP_EXPAND_COMPLETE) ?
+		dupstring((char *)line) : (char *)line;
+	    int ocs = cs, ne = noerrs;
+
+	    noerrs = 1;
+	    doexpansion(s, lst, olst, lincmd);
+	    lastambig = 0;
+	    noerrs = ne;
+
+	    /* If expandorcomplete was invoked and the expansion didn't *
+	     * change the command line, do completion.                  */
+	    if (olst == COMP_EXPAND_COMPLETE &&
+		!strcmp(ol, (char *)line)) {
+		char *p;
+
+		cs = ocs;
+		errflag = 0;
+
+		p = s;
+		if (*p == Tilde || *p == Equals)
+		    p++;
+		for (; *p; p++)
+		    if (itok(*p))
+			if (*p != String && *p != Qstring)
+			    *p = ztokens[*p - Pound];
+			else if (p[1] == Inbrace)
+			    p++, skipparens(Inbrace, Outbrace, &p);
+		docompletion(s, lst, lincmd, 1);
+	    }
+	} else
+	    /* Just do completion. */
+	    docompletion(s, lst, lincmd, 0);
+	zsfree(s);
+    }
+    /* Reset the lexer state, pop the heap. */
+    lexrestore();
+    popheap();
+    zsfree(qword);
+    unmetafy_line();
+}
+
+/* Do completion, given that we are in the middle of a menu completion.  We *
+ * don't need to generate a list of matches, because that's already been    *
+ * done by previous commands.  We will either list the completions, or      *
+ * insert the next completion.                                              */
+
+/**/
+static void
+do_menucmp(int lst)
+{
+    /* Just list the matches if the list was requested. */
+    if (lst == COMP_LIST_COMPLETE) {
+	showinglist = -2;
+	return;
+    }
+    /* Otherwise go to the next match in the array... */
+    HEAPALLOC {
+	if (!*++menucur)
+	    menucur = amatches;
+	/* ... and insert it into the command line. */
+	metafy_line();
+	do_single(*menucur);
+	unmetafy_line();
+    } LASTALLOC;
+}
+
+/* 1 if we are completing in a string */
+static int instring;
+
+/* 1 if we are completing the prefix */
+static int comppref;
+
+/* This function inserts an `x' in the command line at the cursor position. *
+ *                                                                          *
+ * Oh, you want to know why?  Well, if completion is tried somewhere on an  *
+ * empty part of the command line, the lexer code would normally not be     *
+ * able to give us the `word' we want to complete, since there is no word.  *
+ * But we need to call the lexer to find out where we are (and for which    *
+ * command we are completing and such things).  So we temporarily add a `x' *
+ * (any character without special meaning would do the job) at the cursor   *
+ * position, than the lexer gives us the word `x' and its beginning and end *
+ * positions and we can remove the `x'.                                     *
+ *									    *
+ * If we are just completing the prefix (comppref set), we also insert a    *
+ * space after the x to end the word.  We never need to remove the space:   *
+ * anywhere we are able to retrieve a word for completion it will be	    *
+ * discarded as whitespace.  It has the effect of making any suffix	    *
+ * referrable to as the next word on the command line when indexing	    *
+ * from a completion function.                                              */
+
+/**/
+static void
+addx(char **ptmp)
+{
+    int addspace = 0;
+
+    if (!line[cs] || line[cs] == '\n' ||
+	(iblank(line[cs]) && (!cs || line[cs-1] != '\\')) ||
+	line[cs] == ')' || line[cs] == '`' ||
+	(instring && (line[cs] == '"' || line[cs] == '\'')) ||
+	(addspace = (comppref && !iblank(line[cs])))) {
+	*ptmp = (char *)line;
+	line = (unsigned char *)halloc(strlen((char *)line) + 3 + addspace);
+	memcpy(line, *ptmp, cs);
+	line[cs] = 'x';
+	if (addspace)
+	    line[cs+1] = ' ';
+	strcpy((char *)line + cs + 1 + addspace, (*ptmp) + cs);
+	addedx = 1 + addspace;
+    } else {
+	addedx = 0;
+	*ptmp = NULL;
+    }
+}
+
+/* Like dupstring, but add an extra space at the end of the string. */
+
+/**/
+static char *
+dupstrspace(const char *str)
+{
+    int len = strlen((char *)str);
+    char *t = (char *)ncalloc(len + 2);
+    strcpy(t, str);
+    strcpy(t+len, " ");
+    return t;
+}
+
+/* These functions metafy and unmetafy the ZLE buffer, as described at the *
+ * top of this file.  Note that ll and cs are translated.  They *must* be  *
+ * called in matching pairs, around all the expansion/completion code.     *
+ * Currently, there are four pairs: in history expansion, in the main      *
+ * completion function, and one in each of the middle-of-menu-completion   *
+ * functions (there's one for each direction).                             */
+
+/**/
+static void
+metafy_line(void)
+{
+    int len = ll;
+    char *s;
+
+    for (s = (char *) line; s < (char *) line + ll;)
+	if (imeta(*s++))
+	    len++;
+    sizeline(len);
+    (void) metafy((char *) line, ll, META_NOALLOC);
+    ll = len;
+    cs = metalen((char *) line, cs);
+}
+
+/**/
+static void
+unmetafy_line(void)
+{
+    cs = ztrsub((char *) line + cs, (char *) line);
+    (void) unmetafy((char *) line, &ll);
+}
+
+/* Lasciate ogni speranza.                                                  *
+ * This function is a nightmare.  It works, but I'm sure that nobody really *
+ * understands why.  The problem is: to make it cleaner we would need       *
+ * changes in the lexer code (and then in the parser, and then...).         */
+
+/**/
+static char *
+get_comp_string(void)
+{
+    int t0, tt0, i, j, k, cp, rd, sl, ocs;
+    char *s = NULL, *linptr, *tmp, *p, *tt = NULL;
+
+    complinbrace = 0;
+    /* This global flag is used to signal the lexer code if it should *
+     * expand aliases or not.                                         */
+    noaliases = isset(COMPLETEALIASES);
+
+    /* Find out if we are somewhere in a `string', i.e. inside '...', *
+     * "...", `...`, or ((...)).                                      */
+
+    for (i = j = k = 0, p = (char *)line; p < (char *)line + cs; p++)
+	if (*p == '`' && !(k & 1))
+	    i++;
+	else if (*p == '\"' && !(k & 1) && !(i & 1))
+	    j++;
+	else if (*p == '\'' && !(j & 1))
+	    k++;
+	else if (*p == '\\' && p[1] && !(k & 1))
+	    p++;
+    instring = (j & 1) ? 2 : (k & 1);
+    addx(&tmp);
+    if (instring) {
+	/* Yes, we are in a string. */
+	if (!tmp) {
+	    tmp = (char *)line;
+	    line = (unsigned char *) dupstring((char *) line);
+	}
+	/* Now remove the quotes.                                   *
+	 * What??  Why that??  Well, we want to be able to complete *
+	 * inside strings.  The lexer code gives us no help here,   *
+	 * so we have to cheat.  We remove the quotes, the lexer    *
+	 * will than treat the words in the strings normally and we *
+	 * can complete them.                                       *
+	 * This is completely the wrong thing to do, but it's       *
+	 * occasionally useful, and we can't handle quotes properly *
+	 * yet anyway.                                              */
+	for (p = (char *)line; *p; p++)
+	    if (*p == '"' || *p == '\'')
+		*p = ' ';
+    }
+    linptr = (char *)line;
+    pushheap();
+    HEAPALLOC {
+      start:
+	inwhat = IN_NOTHING;
+	/* Now set up the lexer and start it. */
+	parbegin = parend = -1;
+	lincmd = incmdpos;
+	linredir = inredir;
+	zsfree(cmdstr);
+	cmdstr = NULL;
+	zleparse = 1;
+	clwpos = -1;
+	lexsave();
+	inpush(dupstrspace((char *) linptr), 0, NULL);
+	strinbeg();
+	stophist = 2;
+	i = tt0 = cp = rd = 0;
+
+	/* This loop is possibly the wrong way to do this.  It goes through *
+	 * the previously massaged command line using the lexer.  It stores *
+	 * each token in each command (commands being regarded, roughly, as *
+	 * being separated by tokens | & &! |& || &&).  The loop stops when *
+	 * the end of the command containing the cursor is reached.  It's a *
+	 * simple way to do things, but suffers from an inability to        *
+	 * distinguish actual command arguments from, for example,          *
+	 * filenames in redirections.  (But note that code elsewhere checks *
+	 * if we are completing *in* a redirection.)  The only way to fix   *
+	 * this would be to pass the command line through the parser too,   *
+	 * and get the arguments that way.  Maybe in 3.1...                 */
+	do {
+	    lincmd = incmdpos;
+	    linredir = inredir;
+	    /* Get the next token. */
+	    ctxtlex();
+	    if (tok == DINPAR)
+		tokstr = NULL;
+
+	    /* We reached the end. */
+	    if (tok == ENDINPUT)
+		break;
+	    if (tok == BAR    || tok == AMPER     ||
+		tok == BARAMP || tok == AMPERBANG ||
+		((tok == DBAR || tok == DAMPER) && !incond)) {
+		/* This is one of the things that separate commands.  If we  *
+		 * already have the things we need (e.g. the token strings), *
+		 * leave the loop.                                           */
+		if (tt)
+		    break;
+		/* Otherwise reset the variables we are collecting data in. */
+		i = tt0 = cp = rd = 0;
+	    }
+	    if (lincmd && tok == STRING) {
+		/* The lexer says, this token is in command position, so *
+		 * store the token string (to find the right compctl).   */
+		zsfree(cmdstr);
+		cmdstr = ztrdup(tokstr);
+		i = 0;
+	    }
+	    if (!zleparse && !tt0) {
+		/* This is done when the lexer reached the word the cursor is on. */
+		tt = tokstr ? dupstring(tokstr) : NULL;
+		/* If we added a `x', remove it. */
+		if (addedx && tt)
+		    chuck(tt + cs - wb);
+		tt0 = tok;
+		/* Store the number of this word. */
+		clwpos = i;
+		cp = lincmd;
+		rd = linredir;
+		if (inwhat == IN_NOTHING && incond)
+		    inwhat = IN_COND;
+	    }
+	    if (!tokstr)
+		continue;
+	    /* We need to store the token strings of all words (for some of *
+	     * the more complicated compctl -x things).  They are stored in *
+	     * the clwords array.  Make this array big enough.              */
+	    if (i + 1 == clwsize) {
+		int n;
+		clwords = (char **)realloc(clwords,
+					   (clwsize *= 2) * sizeof(char *));
+		for(n = clwsize; --n > i; )
+		    clwords[n] = NULL;
+	    }
+	    zsfree(clwords[i]);
+	    /* And store the current token string. */
+	    clwords[i] = ztrdup(tokstr);
+	    sl = strlen(tokstr);
+	    /* Sometimes the lexer gives us token strings ending with *
+	     * spaces we delete the spaces.                           */
+	    while (sl && clwords[i][sl - 1] == ' ' &&
+		   (sl < 2 || (clwords[i][sl - 2] != Bnull &&
+			       clwords[i][sl - 2] != Meta)))
+		clwords[i][--sl] = '\0';
+	    /* If this is the word the cursor is in and we added a `x', *
+	     * remove it.                                               */
+	    if (clwpos == i++ && addedx)
+		chuck(&clwords[i - 1][((cs - wb) >= sl) ?
+				     (sl - 1) : (cs - wb)]);
+	} while (tok != LEXERR && tok != ENDINPUT &&
+		 (tok != SEPER || (zleparse && !tt0)));
+	/* Calculate the number of words stored in the clwords array. */
+	clwnum = (tt || !i) ? i : i - 1;
+	zsfree(clwords[clwnum]);
+	clwords[clwnum] = NULL;
+	t0 = tt0;
+	lincmd = cp;
+	linredir = rd;
+	strinend();
+	inpop();
+	errflag = zleparse = 0;
+	if (parbegin != -1) {
+	    /* We are in command or process substitution */
+	    if (parend >= 0 && !tmp)
+		line = (unsigned char *) dupstring(tmp = (char *)line);
+	    linptr = (char *) line + ll + addedx - parbegin + 1;
+	    if (parend >= 0) {
+		ll -= parend;
+		line[ll + addedx] = '\0';
+	    }
+	    lexrestore();
+	    goto start;
+	}
+
+	if (inwhat == IN_MATH)
+	    s = NULL;
+	else if (!t0 || t0 == ENDINPUT) {
+	    /* There was no word (empty line). */
+	    s = ztrdup("");
+	    we = wb = cs;
+	    clwpos = clwnum;
+	    t0 = STRING;
+	} else if (t0 == STRING) {
+	    /* We found a simple string. */
+	    s = ztrdup(clwords[clwpos]);
+	} else if (t0 == ENVSTRING) {
+	    /* The cursor was inside a parameter assignment. */
+	    for (s = tt; iident(*s); s++);
+	    if (skipparens(Inbrack, Outbrack, &s) > 0 || s > tt + cs - wb)
+		s = NULL, inwhat = IN_MATH;
+	    else if (*s == '=') {
+		s++;
+		wb += s - tt;
+		t0 = STRING;
+		s = ztrdup(s);
+		inwhat = IN_ENV;
+	    }
+	    lincmd = 1;
+	}
+	if (we > ll)
+	    we = ll;
+	tt = (char *)line;
+	if (tmp) {
+	    line = (unsigned char *)tmp;
+	    ll = strlen((char *)line);
+	}
+	if (t0 != STRING && inwhat != IN_MATH) {
+	    if (tmp) {
+		tmp = NULL;
+		linptr = (char *)line;
+		lexrestore();
+		goto start;
+	    }
+	    feep();
+	    noaliases = 0;
+	    lexrestore();
+	    LASTALLOC_RETURN NULL;
+	}
+
+	noaliases = 0;
+
+	/* Check if we are in an array subscript.  We simply assume that  *
+	 * we are in a subscript if we are in brackets.  Correct solution *
+	 * is very difficult.  This is quite close, but gets things like  *
+	 * foo[_ wrong (note no $).  If we are in a subscript, treat it   *
+	 * as being in math.                                              */
+	if (inwhat != IN_MATH) {
+	    int i = 0;
+	    for (tt = s; ++tt < s + cs - wb;)
+		if (*tt == Inbrack)
+		    i++;
+		else if (i && *tt == Outbrack)
+		    i--;
+	    if (i)
+		inwhat = IN_MATH;
+	}
+	if (inwhat == IN_MATH) {
+	    /* In mathematical expression, we complete parameter names (even *
+	     * if they don't have a `$' in front of them).  So we have to    *
+	     * find that name.                                               */
+	    for (we = cs; iident(line[we]); we++);
+	    for (wb = cs; --wb >= 0 && iident(line[wb]););
+	    wb++;
+	    zsfree(s);
+	    s = zalloc(we - wb + 1);
+	    strncpy(s, (char *) line + wb, we - wb);
+	    s[we - wb] = '\0';
+	}
+	/* This variable will hold the current word in quoted form. */
+	qword = ztrdup(s);
+	/* While building the quoted form, we also clean up the command line. */
+	offs = cs - wb;
+	for (p = s, tt = qword, i = wb; *p; p++, tt++, i++)
+	    if (INULL(*p)) {
+		if (i < cs)
+		    offs--;
+		if (p[1] || *p != Bnull) {
+		    if (*p == Bnull) {
+			*tt = '\\';
+			if (cs == i + 1)
+			    cs++, offs++;
+		    } else {
+			ocs = cs;
+			cs = i;
+			foredel(1);
+			chuck(tt--);
+			if ((cs = ocs) > i--)
+			    cs--;
+			we--;
+		    }
+		} else {
+		    ocs = cs;
+		    *tt = '\0';
+		    cs = we;
+		    backdel(1);
+		    if (ocs == we)
+			cs = we - 1;
+		    else
+			cs = ocs;
+		    we--;
+		}
+		chuck(p--);
+	    }
+
+	if (!isset(IGNOREBRACES)) {
+	    /* Try and deal with foo{xxx etc.; only simple cases
+	     * (only one inbrace, completion after inbrace and before outbrace
+	     * if present).
+	     */
+	    int myoffs = isset(COMPLETEINWORD) ? offs : strlen(s);
+	    tt = NULL;
+	    /* First check the conditions mentioned above
+	     * and locate opening brace
+	     */
+	    for (i = 0, p = s; *p; p++, i++) {
+		/* careful, ${... is not a brace expansion...
+		 * in fact, if it's got a substitution in it's too
+		 * hard for us anyway.  sorry.
+		 */
+		if (*p == String || *p == Qstring) {
+		    tt = NULL;
+		    break;
+		} else if (*p == Inbrace) {
+		    if (tt) {
+			/* too many inbraces */
+			tt = NULL;
+			break;
+		    }
+		    tt = p;
+		} else if (*p == Outbrace && i < myoffs) {
+		    /* outbrace is before cursor pos, so nothing to complete */
+		    tt = NULL;
+		    break;
+		}
+	    }
+
+	    if (tt && tt < s + myoffs) {
+		/* Braces are go:  delete opening brace */
+		char *com = NULL;
+		chuck(tt);
+		offs--;
+		myoffs--;
+
+		/* Look for text up to comma before cursor and delete it */
+		for (i = tt - s, p = tt; *p && i < myoffs; p++, i++)
+		    if (*p == Comma)
+			com = p;
+		if (com) {
+		    i = com - tt + 1;
+		    while (i--)
+			chuck(tt), offs--, myoffs--;
+		}
+
+		/* Look for text between subsequent comma
+		 * and closing brace or end of string and delete it
+		 */
+		for (p = s + myoffs; *p && *p != Outbrace; p++)
+		    if (*p == Comma) {
+			while (*p && *p != Outbrace)
+			    chuck(p);
+			break;
+		    }
+		if (*p == Outbrace)
+		    chuck(p);
+		else {
+		    /* we are still waiting for an outbrace and maybe commas */
+		    complinbrace = 1;
+		}
+	    }
+	}
+
+    } LASTALLOC;
+    lexrestore();
+
+    return (char *)s;
+}
+
+/* Expand the current word. */
+
+/**/
+static void
+doexpansion(char *s, int lst, int olst, int explincmd)
+{
+    LinkList vl;
+    char *ss;
+
+    DPUTS(useheap, "BUG: useheap in doexpansion()");
+    HEAPALLOC {
+	pushheap();
+	vl = newlinklist();
+	ss = dupstring(s);
+	addlinknode(vl, ss);
+	prefork(vl, 0);
+	if (errflag)
+	    goto end;
+	if ((lst == COMP_LIST_EXPAND) || (lst == COMP_EXPAND)) {
+	    int ng = opts[NULLGLOB];
+
+	    opts[NULLGLOB] = 1;
+	    globlist(vl);
+	    opts[NULLGLOB] = ng;
+	}
+	if (errflag)
+	    goto end;
+	if (empty(vl) || !*(char *)peekfirst(vl)) {
+	    if (!noerrs)
+		feep();
+	    goto end;
+	}
+	if (peekfirst(vl) == (void *) ss ||
+		(olst == COMP_EXPAND_COMPLETE &&
+		 !nextnode(firstnode(vl)) && *s == Tilde &&
+		 (ss = dupstring(s), filesubstr(&ss, 0)) &&
+		 !strcmp(ss, (char *)peekfirst(vl)))) {
+	    /* If expansion didn't change the word, try completion if *
+	     * expandorcomplete was called, otherwise, just beep.     */
+	    if (lst == COMP_EXPAND_COMPLETE)
+		docompletion(s, COMP_COMPLETE, explincmd, 0);
+	    else
+		feep();
+	    goto end;
+	}
+	if (lst == COMP_LIST_EXPAND) {
+	    /* Only the list of expansions was requested. */
+	    listlist(vl);
+	    goto end;
+	}
+	/* Remove the current word and put the expansions there. */
+	cs = wb;
+	foredel(we - wb);
+	while ((ss = (char *)ugetnode(vl))) {
+	    untokenize(ss);
+	    ss = quotename(ss, NULL, NULL, NULL);
+	    inststr(ss);
+#if 0
+	    if (nonempty(vl)) {
+		spaceinline(1);
+		line[cs++] = ' ';
+	    }
+#endif
+	    if (olst != COMP_EXPAND_COMPLETE || nonempty(vl) ||
+		(cs && line[cs-1] != '/')) {
+		spaceinline(1);
+		line[cs++] = ' ';
+	    }
+	}
+      end:
+	popheap();
+    } LASTALLOC;
+}
+
+/* This is called from the lexer to give us word positions. */
+
+/**/
+void
+gotword(void)
+{
+    we = ll + 1 - inbufct + (addedx == 2 ? 1 : 0);
+    if (cs <= we) {
+	wb = ll - wordbeg + addedx;
+	zleparse = 0;
+    }
+}
+
+/* Insert the given string into the command line.  If move is non-zero, *
+ * the cursor position is changed and len is the length of the string   *
+ * to insert (if it is -1, the length is calculated here).              */
+
+/**/
+static void
+inststrlen(char *str, int move, int len)
+{
+    if (!len)
+	return;
+    if (len == -1)
+	len = strlen(str);
+    spaceinline(len);
+    strncpy((char *)(line + cs), str, len);
+    if (move)
+	cs += len;
+}
+
+/* Quote the string s and return the result.  If e is non-zero, it the    *
+ * pointer it points to may point to aposition in s and in e the position *
+ * of the corresponding character in the quoted string is returned.  Like *
+ * e, te may point to a position in the string and pl is used to return   *
+ * the position of the character pointed to by te in the quoted string.   *
+ * The string is metafied and may contain tokens.                         */
+
+/**/
+static char *
+quotename(const char *s, char **e, char *te, int *pl)
+{
+    const char *u, *tt;
+    char *v, buf[PATH_MAX * 2];
+    int sf = 0;
+
+    tt = v = buf;
+    u = s;
+    for (; *u; u++) {
+	if (e && *e == u)
+	    *e = v, sf |= 1;
+	if (te == u)
+	    *pl = v - tt, sf |= 2;
+	if (ispecial(*u) &&
+	    (!instring || (isset(BANGHIST) &&
+			   *u == (char)bangchar) ||
+	     (instring == 2 &&
+	      (*u == '$' || *u == '`' || *u == '\"')) ||
+	     (instring == 1 && *u == '\'')))
+	    if (*u == '\n' || (instring == 1 && *u == '\'')) {
+		if (unset(RCQUOTES)) {
+		    *v++ = '\'';
+		    if (*u == '\'')
+			*v++ = '\\';
+		    *v++ = *u;
+		    *v++ = '\'';
+		} else if (*u == '\n')
+		    *v++ = '"', *v++ = '\n', *v++ = '"';
+		else
+		    *v++ = '\'', *v++ = '\'';
+		continue;
+	    } else
+		*v++ = '\\';
+	if(*u == Meta)
+	    *v++ = *u++;
+	*v++ = *u;
+    }
+    *v = '\0';
+    if (strcmp(buf, s))
+	tt = dupstring(buf);
+    else
+	tt = s;
+    v += tt - buf;
+    if (e && (sf & 1))
+	*e += tt - buf;
+
+    if (e && *e == u)
+	*e = v;
+    if (te == u)
+	*pl = v - tt;
+
+    return (char *) tt;
+}
+
+/* This adds a match to the list of matches.  The string to add is given   *
+ * in s, the type of match is given in the global variable addwhat and     *
+ * the parameter t (if not NULL) is a pointer to a hash node node which    *
+ * may be used to give other information to this function.                 *
+ *                                                                         *
+ * addwhat contains either one of the special values (negative, see below) *
+ * or the inclusive OR of some of the CC_* flags used for compctls.        */
+
+/**/
+static void
+addmatch(char *s, char *t)
+{
+    int test = 0, sl = strlen(s), pl = rpl, cc = 0, *bp, *ep, *sp;
+    char *e = NULL, *tt, *te, *fc, **fm;
+    Comp cp = patcomp;
+    HashNode hn;
+    Param pm;
+    LinkList l = matches;
+
+/*
+ * addwhat: -5 is for files,
+ *          -6 is for glob expansions,
+ *          -8 is for executable files (e.g. command paths),
+ *          -9 is for parameters
+ *          -7 is for command names (from cmdnamtab)
+ *          -4 is for a cdable parameter
+ *          -3 is for executable command names.
+ *          -2 is for anything unquoted
+ *          -1 is for other file specifications
+ *          (things with `~' of `=' at the beginning, ...).
+ */
+
+    /* Just to make the code cleaner */
+    hn = (HashNode) t;
+    pm = (Param) t;
+
+    if (!addwhat) {
+	test = 1;
+    } else if (addwhat == -1 || addwhat == -5 || addwhat == -6 ||
+	       addwhat == CC_FILES || addwhat == -7 || addwhat == -8) {
+	if (sl < fpl + fsl)
+	    return;
+
+	if ((addwhat == CC_FILES ||
+	     addwhat == -5) && !*psuf && !*fsuf) {
+	    /* If this is a filename, do the fignore check. */
+	    char **pt = fignore;
+	    int filell;
+
+	    for (test = 1; test && *pt; pt++)
+		if ((filell = strlen(*pt)) < sl
+		    && !strcmp(*pt, s + sl - filell))
+		    test = 0;
+
+	    if (!test)
+		l = fmatches;
+	}
+	pl = fpl;
+	if (addwhat == -5 || addwhat == -8) {
+	    test = 1;
+	    cp = filecomp;
+	    cc = cp || ispattern;
+	    e = s + sl - fsl;
+	} else {
+	    if ((cp = filecomp)) {
+		if ((test = domatch(s, filecomp, 0)))
+		    cc = 1;
+	    } else {
+		e = s + sl - fsl;
+		if ((test = !strncmp(s, fpre, fpl)))
+		    test = !strcmp(e, fsuf);
+		if (ispattern)
+		    cc = 1;
+	    }
+	}
+	if (test) {
+	    fc = NULL;
+	    if (addwhat == -7 && !(fc = findcmd(s)))
+		return;
+	    if (fc)
+		zsfree(fc);
+	    haswhat |= HAS_FILES;
+
+	    if (addwhat == CC_FILES || addwhat == -6 ||
+		addwhat == -5 || addwhat == -8) {
+		te = s + pl;
+		s = quotename(s, &e, te, &pl);
+		sl = strlen(s);
+	    } else if (!cc) {
+		s = dupstring(t = s);
+		e += s - t;
+	    }
+	    if (cc) {
+		tt = (char *)halloc(strlen(ppre) + strlen(psuf) + sl + 1);
+		strcpy(tt, ppre);
+		strcat(tt, s);
+		strcat(tt, psuf);
+		untokenize(s = tt);
+	    }
+	}
+    } else if (addwhat == CC_QUOTEFLAG || addwhat == -2  ||
+	      (addwhat == -3 && !(hn->flags & DISABLED)) ||
+	      (addwhat == -4 && (PM_TYPE(pm->flags) == PM_SCALAR) &&
+	       (tt = pm->gets.cfn(pm)) && *tt == '/')    ||
+	      (addwhat == -9 && !(hn->flags & PM_UNSET)) ||
+	      (addwhat > 0 &&
+	       ((!(hn->flags & PM_UNSET) &&
+		 (((addwhat & CC_ARRAYS)    &&  (hn->flags & PM_ARRAY))    ||
+		  ((addwhat & CC_INTVARS)   &&  (hn->flags & PM_INTEGER))  ||
+		  ((addwhat & CC_ENVVARS)   &&  (hn->flags & PM_EXPORTED)) ||
+		  ((addwhat & CC_SCALARS)   &&  (hn->flags & PM_SCALAR))   ||
+		  ((addwhat & CC_READONLYS) &&  (hn->flags & PM_READONLY)) ||
+		  ((addwhat & CC_SPECIALS)  &&  (hn->flags & PM_SPECIAL))  ||
+		  ((addwhat & CC_PARAMS)    && !(hn->flags & PM_EXPORTED)))) ||
+		((( addwhat & CC_SHFUNCS)				  ||
+		  ( addwhat & CC_BUILTINS)				  ||
+		  ( addwhat & CC_EXTCMDS)				  ||
+		  ( addwhat & CC_RESWDS)				  ||
+		  ((addwhat & CC_ALREG)   && !(hn->flags & ALIAS_GLOBAL)) ||
+		  ((addwhat & CC_ALGLOB)  &&  (hn->flags & ALIAS_GLOBAL))) &&
+		 (((addwhat & CC_DISCMDS) && (hn->flags & DISABLED)) ||
+		  ((addwhat & CC_EXCMDS)  && !(hn->flags & DISABLED)))) ||
+		((addwhat & CC_BINDINGS) && !(hn->flags & DISABLED))))) {
+	if (sl >= rpl + rsl) {
+	    if (cp)
+		test = domatch(s, patcomp, 0);
+	    else {
+		e = s + sl - rsl;
+		if ((test = !strncmp(s, rpre, rpl)))
+		    test = !strcmp(e, rsuf);
+	    }
+	}
+	if (!test && sl < lpl + lsl)
+	    return;
+	if (!test && lpre && lsuf && sl >= lpl + lsl) {
+	    e = s + sl - lsl;
+	    if ((test = !strncmp(s, lpre, lpl)))
+		test = !strcmp(e, lsuf);
+	    pl = lpl;
+	}
+	if (addwhat == CC_QUOTEFLAG) {
+	    te = s + pl;
+	    s = quotename(s, &e, te, &pl);
+	    sl = strlen(s);
+	}
+	if (test)
+	    haswhat |= HAS_MISC;
+    }
+    if (!test)
+	return;
+
+    if (ispattern) {
+	t = s;
+    } else {
+	t = s += pl;
+	if (*e)
+	    t = s = dupstrpfx(t, e - t);
+    }
+
+    if (l == fmatches) {
+	bp = &fab;
+	ep = &fae;
+	sp = &fshortl;
+	fm = &ffirstm;
+    } else {
+	bp = &ab;
+	ep = &ae;
+	sp = &shortl;
+	fm = &firstm;
+    }
+
+    if (!ispattern && *fm) {
+	if ((test = pfxlen(*fm, s)) < *bp)
+	    *bp = test;
+	if ((test = sfxlen(*fm, s)) < *ep)
+	    *ep = test;
+	if (*ep > *sp - *bp)
+	    *ep = *sp - *bp;
+    }
+
+    /* If we are doing a glob completion we store the whole string in *
+     * the list. Otherwise only the part that fits between the prefix *
+     * and the suffix is stored.                                      */
+    addlinknode(l, t);
+    if (!*fm) {
+	*bp = *ep = 10000;
+	*fm = t;
+	*sp = 100000;
+    }
+    if (!ispattern && (sl = strlen(t)) < *sp) {
+	*sp = sl;
+	if (l == fmatches)
+	    fshortest = t;
+	else
+	    shortest = t;
+    }
+}
+
+#ifdef HAVE_NIS_PLUS
+static int
+match_username(nis_name table, nis_object *object, void *userdata)
+{
+    if (errflag)
+	return 1;
+    else {
+	static char buf[40];
+	register entry_col *ec =
+	    object->zo_data.objdata_u.en_data.en_cols.en_cols_val;
+	register int l = minimum(ec->ec_value.ec_value_len, 39);
+
+	memcpy(buf, ec->ec_value.ec_value_val, l);
+	buf[l] = '\0';
+
+	addmatch(dupstring(buf), NULL);
+    }
+    return 0;
+}
+#else
+# ifdef HAVE_NIS
+static int
+match_username(int status, char *key, int keylen, char *val, int vallen, dopestring *data)
+{
+    if (errflag || status != YP_TRUE)
+	return 1;
+
+    if (vallen > keylen && val[keylen] == ':') {
+	val[keylen] = '\0';
+	addmatch(dupstring(val), NULL);
+    }
+    return 0;
+}
+# endif /* HAVE_NIS */
+#endif  /* HAVE_NIS_PLUS */
+
+/**/
+static void
+maketildelist(void)
+{
+#if defined(HAVE_NIS) || defined(HAVE_NIS_PLUS)
+    FILE *pwf;
+    char buf[BUFSIZ], *p;
+    int skipping;
+
+# ifndef HAVE_NIS_PLUS
+    char domain[YPMAXDOMAIN];
+    struct ypall_callback cb;
+    dopestring data;
+
+    data.s = fpre;
+    data.len = fpl;
+    /* Get potential matches from NIS and cull those without local accounts */
+    if (getdomainname(domain, YPMAXDOMAIN) == 0) {
+	cb.foreach = (int (*)()) match_username;
+	cb.data = (char *)&data;
+	yp_all(domain, PASSWD_MAP, &cb);
+    }
+# else  /* HAVE_NIS_PLUS */
+       /* Maybe we should turn this string into a #define'd constant...? */
+
+    nis_list("passwd.org_dir", EXPAND_NAME|ALL_RESULTS|FOLLOW_LINKS|FOLLOW_PATH,
+	     match_username, 0);
+# endif
+    /* Don't forget the non-NIS matches from the flat passwd file */
+    if ((pwf = fopen(PASSWD_FILE, "r")) != NULL) {
+	skipping = 0;
+	while (fgets(buf, BUFSIZ, pwf) != NULL) {
+	    if (strchr(buf, '\n') != NULL) {
+		if (!skipping) {
+		    if ((p = strchr(buf, ':')) != NULL) {
+			*p = '\0';
+			addmatch(dupstring(buf), NULL);
+		    }
+		} else
+		    skipping = 0;
+	    } else
+		skipping = 1;
+	}
+	fclose(pwf);
+    }
+#else  /* no NIS or NIS_PLUS */
+    /* add all the usernames to the named directory table */
+    nameddirtab->filltable(nameddirtab);
+#endif
+
+    scanhashtable(nameddirtab, 0, (addwhat==-1) ? 0 : ND_USERNAME, 0,
+	    addhnmatch, 0);
+}
+
+/* Copy the given string and remove backslashes from the copy and return it. */
+
+/**/
+static char *
+rembslash(char *s)
+{
+    char *t = s = dupstring(s);
+
+    while (*s)
+	if (*s == '\\') {
+	    chuck(s);
+	    if (*s)
+		s++;
+	} else
+	    s++;
+
+    return t;
+}
+
+/* This does the check for compctl -x `n' and `N' patterns. */
+
+/**/
+static int
+getcpat(char *wrd, int cpatindex, char *cpat, int class)
+{
+    char *str, *s, *t, *p;
+    int d = 0;
+
+    if (!wrd || !*wrd)
+	return -1;
+
+    cpat = rembslash(cpat);
+
+    str = ztrdup(wrd);
+    untokenize(str);
+    if (!cpatindex)
+	cpatindex++, d = 0;
+    else if ((d = (cpatindex < 0)))
+	cpatindex = -cpatindex;
+
+    for (s = d ? str + strlen(str) - 1 : str;
+	 d ? (s >= str) : *s;
+	 d ? s-- : s++) {
+	for (t = s, p = cpat; *t && *p; p++) {
+	    if (class) {
+		if (*p == *s && !--cpatindex) {
+		    zsfree(str);
+		    return (int)(s - str + 1);
+		}
+	    } else if (*t++ != *p)
+		break;
+	}
+	if (!class && !*p && !--cpatindex) {
+	    zsfree(str);
+	    t += wrd - str;
+	    for (d = 0; --t >= wrd;)
+		if (! INULL(*t))
+		    d++;
+	    return d;
+	}
+    }
+    zsfree(str);
+    return -1;
+}
+
+/* This holds a pointer to the compctl we are using. */
+
+static Compctl ccmain;
+
+
+/* Find the compctl to use and return it.  The first argument gives a *
+ * compctl to start searching with (if it is zero, the hash table is  *
+ * searched).  compadd is used to return a number of characters that  *
+ * should be ignored at the beginning of the word and incmd is        *
+ * non-zero if we are in command position.                            */
+
+/**/
+static Compctl
+get_ccompctl(Compctl occ, int *compadd, int incmd)
+{
+    Compctl compc, ret;
+    Compctlp ccp;
+    int t, i, a, b, tt, ra, rb, j, isf = 1;
+    Compcond or, cc;
+    char *s, *ss, *sc, *cmd = dupstring(cmdstr);
+    Comp comp;
+
+   first_rec:
+    *compadd = 0;
+    ra = 0;
+    rb = clwnum - 1;
+    sc = NULL;
+
+    if (!(ret = compc = occ)) {
+      if (isf) {
+        isf = 0;
+        ret = &cc_first;
+      }
+      else if (inwhat == IN_ENV)
+        /* Default completion for parameter values. */
+        ret = &cc_default;
+      else if (inwhat == IN_MATH) {
+        /* Parameter names inside mathematical expression. */
+        cc_dummy.mask = CC_PARAMS;
+	    ret = &cc_dummy;
+	    cc_dummy.refc = 10000;
+	} else if (inwhat == IN_COND) {
+	    /* We try to be clever here: in conditions we complete option   *
+	     * names after a `-o', file names after `-nt', `-ot', and `-ef' *
+	     * and file names and parameter names elsewhere.                */
+	    s = clwpos ? clwords[clwpos - 1] : "";
+	    cc_dummy.mask = !strcmp("-o", s) ? CC_OPTIONS :
+		((*s == '-' && s[1] && !s[2]) ||
+		 !strcmp("-nt", s) ||
+		 !strcmp("-ot", s) ||
+		 !strcmp("-ef", s)) ? CC_FILES :
+		(CC_FILES | CC_PARAMS);
+	    ret = &cc_dummy;
+	    cc_dummy.refc = 10000;
+	} else if (incmd)
+	    ret = &cc_compos;
+	/* And in redirections or if there is no command name (and we are *
+	 * not in command position) or if no special compctl was given    *
+	 * for the command: use default completion.  Note that we first   *
+	 * search the complete command name and than the trailing         *
+	 * pathname component.                                            */
+	else if (linredir ||
+ 		 !(cmd &&
+ 		   (((ccp = (Compctlp) compctltab->getnode(compctltab, cmd)) &&
+		     (compc = ret = ccp->cc)) ||
+ 		    ((s = dupstring(cmd)) && remlpaths(&s) &&
+		     (ccp = (Compctlp) compctltab->getnode(compctltab, s)) &&
+		     (compc = ret = ccp->cc)))))
+	    ret = &cc_default;
+
+	ccmain = compc = ret;
+	ccmain->refc++;
+    }
+    /* The compctl we found has extended completion patterns, check them. */
+    if (compc && compc->ext) {
+	compc = compc->ext;
+	/* This loops over the patterns separated by `--'. */
+	for (t = 0; compc && !t; compc = compc->next) {
+	    /* This loops over OR'ed patterns. */
+	    for (cc = compc->cond; cc && !t; cc = or) {
+		or = cc->or;
+		/* This loops over AND'ed patterns. */
+		for (t = 1; cc && t; cc = cc->and) {
+		    /* And this loops of [...] pairs. */
+		    for (t = i = 0; i < cc->n && !t; i++) {
+			s = NULL;
+			ra = 0;
+			rb = clwnum - 1;
+			switch (cc->type) {
+			case CCT_POS:
+			    tt = clwpos;
+			    goto cct_num;
+			case CCT_NUMWORDS:
+			    tt = clwnum;
+			  cct_num:
+			    if ((a = cc->u.r.a[i]) < 0)
+				a += clwnum;
+			    if ((b = cc->u.r.b[i]) < 0)
+				b += clwnum;
+			    if (cc->type == CCT_POS)
+				ra = a, rb = b;
+			    t = (tt >= a && tt <= b);
+			    break;
+			case CCT_CURSUF:
+			case CCT_CURPRE:
+			    s = ztrdup(clwpos < clwnum ? clwords[clwpos] : "");
+			    untokenize(s);
+			    sc = rembslash(cc->u.s.s[i]);
+			    a = strlen(sc);
+			    if (!strncmp(s, sc, a)) {
+				*compadd = (cc->type == CCT_CURSUF ? a : 0);
+				t = 1;
+			    }
+			    break;
+			case CCT_CURSUB:
+			case CCT_CURSUBC:
+			    if (clwpos < 0 || clwpos > clwnum)
+				t = 0;
+			    else {
+				a = getcpat(clwords[clwpos],
+					    cc->u.s.p[i],
+					    cc->u.s.s[i],
+					    cc->type == CCT_CURSUBC);
+				if (a != -1)
+				    *compadd = a, t = 1;
+			    }
+			    break;
+
+			case CCT_CURPAT:
+			case CCT_CURSTR:
+			    tt = clwpos;
+			    goto cct_str;
+			case CCT_WORDPAT:
+			case CCT_WORDSTR:
+			    tt = 0;
+			  cct_str:
+			    if ((a = tt + cc->u.s.p[i]) < 0)
+				a += clwnum;
+			    s = ztrdup((a < 0 || a >= clwnum) ? "" :
+				       clwords[a]);
+			    untokenize(s);
+
+			    if (cc->type == CCT_CURPAT ||
+				cc->type == CCT_WORDPAT) {
+				tokenize(ss = dupstring(cc->u.s.s[i]));
+				t = ((comp = parsereg(ss)) &&
+				     domatch(s, comp, 0));
+			    } else
+				t = (!strcmp(s, rembslash(cc->u.s.s[i])));
+			    break;
+			case CCT_RANGESTR:
+			case CCT_RANGEPAT:
+			    if (cc->type == CCT_RANGEPAT)
+				tokenize(sc = dupstring(cc->u.l.a[i]));
+			    for (j = clwpos; j; j--) {
+				untokenize(s = ztrdup(clwords[j]));
+				if (cc->type == CCT_RANGESTR)
+				    sc = rembslash(cc->u.l.a[i]);
+				if (cc->type == CCT_RANGESTR ?
+				    !strncmp(s, sc, strlen(sc)) :
+				    ((comp = parsereg(sc)) &&
+				     domatch(s, comp, 0))) {
+				    zsfree(s);
+				    ra = j + 1;
+				    t = 1;
+				    break;
+				}
+				zsfree(s);
+			    }
+			    if (t) {
+				if (cc->type == CCT_RANGEPAT)
+				    tokenize(sc = dupstring(cc->u.l.b[i]));
+				for (j++; j < clwnum; j++) {
+				    untokenize(s = ztrdup(clwords[j]));
+				    if (cc->type == CCT_RANGESTR)
+					sc = rembslash(cc->u.l.b[i]);
+				    if (cc->type == CCT_RANGESTR ?
+					!strncmp(s, sc, strlen(sc)) :
+					((comp = parsereg(sc)) &&
+					 domatch(s, comp, 0))) {
+					zsfree(s);
+					rb = j - 1;
+					t = clwpos <= rb;
+					break;
+				    }
+				    zsfree(s);
+				}
+			    }
+			    s = NULL;
+			}
+			zsfree(s);
+		    }
+		}
+	    }
+	    if (t)
+		break;
+	}
+	if (compc)
+	    /* We found a matching pattern, we may return it. */
+	    ret = compc;
+    }
+    if (ret->subcmd) {
+	/* The thing we want to return has a subcmd flag (-l). */
+	char **ow = clwords, *os = cmdstr, *ops = NULL;
+	int oldn = clwnum, oldp = clwpos;
+
+	/* So we restrict the words-array. */
+	if (ra >= clwnum)
+	    ra = clwnum - 1;
+	if (ra < 1)
+	    ra = 1;
+	if (rb >= clwnum)
+	    rb = clwnum - 1;
+	if (rb < 1)
+	    rb = 1;
+	clwnum = rb - ra + 1;
+	clwpos = clwpos - ra;
+
+	if (ret->subcmd[0]) {
+	    /* And probably put the command name given to the flag *
+	     * in the array.                                       */
+	    clwpos++;
+	    clwnum++;
+	    incmd = 0;
+	    ops = clwords[ra - 1];
+	    clwords[ra - 1] = cmdstr = ret->subcmd;
+	    clwords += ra - 1;
+	} else {
+	    cmdstr = clwords[ra];
+	    incmd = !clwpos;
+	    clwords += ra;
+	}
+	*compadd = 0;
+	if (ccmain != &cc_dummy)
+	    freecompctl(ccmain);
+	/* Then we call this function recursively. */
+
+	ret = get_ccompctl(NULL, compadd, incmd);
+	/* And restore the things we changed. */
+	clwords = ow;
+	cmdstr = os;
+	clwnum = oldn;
+	clwpos = oldp;
+	if (ops)
+	    clwords[ra - 1] = ops;
+    }
+    if (ret == &cc_first)
+      goto first_rec;
+    return ret;
+}
+
+/* Dump a hash table (without sorting).  For each element the addmatch  *
+ * function is called and at the beginning the addwhat variable is set. *
+ * This could be done using scanhashtable(), but this is easy and much  *
+ * more efficient.                                                      */
+
+/**/
+static void
+dumphashtable(HashTable ht, int what)
+{
+    HashNode hn;
+    int i;
+
+    addwhat = what;
+
+    for (i = 0; i < ht->hsize; i++)
+	for (hn = ht->nodes[i]; hn; hn = hn->next)
+	    addmatch(hn->nam, (char *) hn);
+
+}
+
+/* ScanFunc used by maketildelist() et al. */
+
+/**/
+static void
+addhnmatch(HashNode hn, int flags)
+{
+    addmatch(hn->nam, NULL);
+}
+
+/* Perform expansion on the given string and return the result. *
+ * During this errors are not reported.                         */
+
+/**/
+static char *
+getreal(char *str)
+{
+    LinkList l = newlinklist();
+    int ne = noerrs;
+
+    noerrs = 1;
+    addlinknode(l, dupstring(str));
+    prefork(l, 0);
+    noerrs = ne;
+    if (!errflag && nonempty(l))
+	return ztrdup(peekfirst(l));
+    errflag = 0;
+
+    return ztrdup(str);
+}
+
+/* This reads a directory and adds the files to the list of  *
+ * matches.  The parameters say which files should be added. */
+
+/**/
+static void
+gen_matches_files(int dirs, int execs, int all)
+{
+    DIR *d;
+    struct stat buf;
+    char *n, p[PATH_MAX], *q = NULL, *e;
+    LinkList l = NULL;
+    int ns = 0, ng = opts[NULLGLOB], test, aw = addwhat;
+
+    addwhat = execs ? -8 : -5;
+    opts[NULLGLOB] = 1;
+
+    if (*psuf) {
+	/* If there is a path suffix, check if it doesn't have a `*' or *
+	 * `)' at the end (this is used to determine if we should use   *
+	 * globbing).                                                   */
+	q = psuf + strlen(psuf) - 1;
+	ns = !(*q == Star || *q == Outpar);
+	l = newlinklist();
+	/* And generate only directory names. */
+	dirs = 1;
+	all = execs = 0;
+    }
+    /* Open directory. */
+    if ((d = opendir((prpre && *prpre) ? prpre : "."))) {
+	/* If we search only special files, prepare a path buffer for stat. */
+	if (!all && prpre) {
+	    strcpy(p, prpre);
+	    q = p + strlen(prpre);
+	}
+	/* Fine, now read the directory. */
+	while ((n = zreaddir(d, 1)) && !errflag) {
+	    /* Ignore files beginning with `.' unless the thing we found on *
+	     * the command line also starts with a dot or GLOBDOTS is set.  */
+	    if (*n != '.' || *fpre == '.' || isset(GLOBDOTS)) {
+		if (filecomp)
+		    /* If we have a pattern for the filename check, use it. */
+		    test = domatch(n, filecomp, 0);
+		else {
+		    /* Otherwise use the prefix and suffix strings directly. */
+		    e = n + strlen(n) - fsl;
+		    if ((test = !strncmp(n, fpre, fpl)))
+			test = !strcmp(e, fsuf);
+		}
+		/* Filename didn't match? */
+		if (!test)
+		    continue;
+		if (!all) {
+		    /* We still have to check the file type, so prepare *
+		     * the path buffer by appending the filename.       */
+		    strcpy(q, n);
+		    /* And do the stat. */
+		    if (stat(p, &buf) < 0)
+			continue;
+		}
+		if (all ||
+		    (dirs && S_ISDIR(buf.st_mode)) ||
+		    (execs && S_ISREG(buf.st_mode) && (buf.st_mode&S_IXUGO))) {
+		    /* If we want all files or the file has the right type... */
+		    if (*psuf) {
+			/* We have to test for a path suffix. */
+			int o = strlen(p), tt;
+
+			/* Append it to the path buffer. */
+			strcpy(p + o, psuf);
+
+			/* Do we have to use globbing? */
+			if (ispattern || (ns && isset(GLOBCOMPLETE))) {
+			    /* Yes, so append a `*' if needed. */
+			    if (ns) {
+				int tl = strlen(p);
+
+				p[tl] = Star;
+				p[tl + 1] = '\0';
+			    }
+			    /* Do the globbing... */
+			    remnulargs(p);
+			    addlinknode(l, p);
+			    globlist(l);
+			    /* And see if that produced a filename. */
+			    tt = nonempty(l);
+			    while (ugetnode(l));
+			} else
+			    /* Otherwise just check, if we have access *
+			     * to the file.                            */
+			    tt = !access(p, F_OK);
+
+			p[o] = '\0';
+			if (tt)
+			    /* Ok, we can add the filename to the *
+			     * list of matches.                   */
+			    addmatch(dupstring(n), NULL);
+		    } else
+			/* We want all files, so just add the name *
+			 * to the matches.                         */
+			addmatch(dupstring(n), NULL);
+		}
+	    }
+	}
+	closedir(d);
+    }
+    opts[NULLGLOB] = ng;
+    addwhat = aw;
+}
+
+/* This holds the explanation string we have to print. */
+
+static char *expl;
+
+/* This holds the suffix to add (given with compctl -S). */
+
+static char *ccsuffix;
+
+/* This s non-zero if the compctl -q flag was given (the suffix should *
+ * be removed when a space or something like that is typed next).      */
+
+static int remsuffix;
+
+/**/
+static void
+quotepresuf(char **ps)
+{
+    if (*ps) {
+	char *p = quotename(*ps, NULL, NULL, NULL);
+
+	if (p != *ps) {
+	    zsfree(*ps);
+	    *ps = ztrdup(p);
+	}
+    }
+}
+
+/**/
+static void
+docompletion(char *s, int lst, int incmd, int untokenized)
+{
+    static int delit, compadd;
+
+    fixsuffix();
+    HEAPALLOC {
+	pushheap();
+
+	/* Make sure we have the completion list and compctl. */
+	if(makecomplist(s, incmd, &delit, &compadd, untokenized)) {
+	    /* Error condition: feeeeeeeeeeeeep(). */
+	    feep();
+	    goto compend;
+	}
+
+	if (lst == COMP_LIST_COMPLETE)
+	    /* All this and the guy only wants to see the list, sigh. */
+	    showinglist = -2;
+	else {
+	    /* We have matches. */
+	    if (delit) {
+		/* If we have to delete the word from the command line, *
+		 * do it now.                                           */
+		wb -= compadd;
+		strcpy((char *)line + wb, (char *)line + we);
+		we = cs = wb;
+	    }
+	    if (nmatches > 1)
+		/* There are more than one match. */
+		do_ambiguous();
+	    else if (nmatches == 1) {
+		/* Only one match. */
+		do_single(amatches[0]);
+		invalidatelist();
+	    }
+	}
+
+	/* Print the explanation string if needed. */
+	if (!showinglist && expl && nmatches != 1) {
+	    int up;
+
+	    if (!nmatches)
+		feep();
+	    trashzle();
+
+	    clearflag = (isset(USEZLE) && !termflags &&
+			 (isset(ALWAYSLASTPROMPT) && zmult == 1)) ||
+			(unset(ALWAYSLASTPROMPT) && zmult != 1);
+
+	    up = printfmt(expl, nmatches, 1);
+
+	    if (clearflag)
+		tcmultout(TCUP, TCMULTUP, up + nlnct);
+	    else
+		putc('\n', shout);
+	    fflush(shout);
+	}
+      compend:
+	ll = strlen((char *)line);
+	if (cs > ll)
+	    cs = ll;
+	popheap();
+    } LASTALLOC;
+}
+
+/* Create the completion list.  This is called whenever some bit of  *
+ * completion code needs the list.  If the list is already available *
+ * (validlist!=0), this function doesn't do anything.  Along with    *
+ * the list is maintained the prefixes/suffixes etc.  When any of    *
+ * this becomes invalid -- e.g. if some text is changed on the       *
+ * command line -- invalidatelist() should be called, to set         *
+ * validlist to zero and free up the memory used.  This function     *
+ * returns non-zero on error.  delit and compadd return information  *
+ * about bits of the command line that need to be deleted.           */
+
+/**/
+static int
+makecomplist(char *s, int incmd, int *delit, int *compadd, int untokenized)
+{
+    Compctl cc = NULL;
+    int oloffs = offs, owe = we, owb = wb, ocs = cs, oll = ll, isf = 1;
+    int t, sf1, sf2, ooffs;
+    char *p, *sd = NULL, *tt, *s1, *s2, *os = NULL;
+    unsigned char *ol = NULL;
+
+    /* If we already have a list from a previous execution of this *
+     * function, skip the list building code.                      */
+    if (validlist)
+	return !nmatches;
+
+    os = dupstring(s);
+    ol = (unsigned char *)dupstring((char *)line);
+
+  xorrec:
+
+    DPUTS(ll != strlen((char *) line), "BUG: xorrec: ll != strlen(line)");
+
+    /* Go to the end of the word if complete_in_word is not set. */
+    if (unset(COMPLETEINWORD) && cs != we)
+	cs = we, offs = strlen(s);
+
+    ispattern = haswhat = lastambig = 0;
+    patcomp = filecomp = NULL;
+    menucur = NULL;
+    shortest = NULL;
+    fshortest = NULL;
+    rpre = rsuf = lpre = lsuf = ppre = psuf = prpre =
+	fpre = fsuf = firstm = ffirstm = parampre = qparampre = NULL;
+
+    /* Blank out the lists. */
+    matches = newlinklist();
+    fmatches = newlinklist();
+
+    /* If we don't have a compctl definition yet or we have a compctl *
+     * with extended completion, get it (or the next one, resp.).     */
+    if (!cc || cc->ext)
+	cc = get_ccompctl(cc, compadd, incmd);
+
+    /* *compadd is the number of characters we have to ignore at the *
+     * beginning of the word.                                        */
+    wb += *compadd;
+    s += *compadd;
+    if ((offs -= *compadd) < 0)
+	/* It's bigger than our word prefix, so we can't help here... */
+	return 1;
+
+    /* Insert the prefix (compctl -P), if any. */
+    if (cc->prefix) {
+	int pl = 0, sl = strlen(cc->prefix);
+
+	if (*s) {
+	    /* First find out how much of the prefix is already on the line. */
+	    sd = dupstring(s);
+	    untokenize(sd);
+	    pl = pfxlen(cc->prefix, sd);
+	    s += pl;
+	}
+	if (pl < sl) {
+	    int savecs = cs;
+
+	    /* Then insert the prefix. */
+	    cs = wb + pl;
+	    inststrlen(cc->prefix + pl, 0, sl - pl);
+	    cs = savecs + sl - pl;
+	}
+	/* And adjust the word beginning/end variables. */
+	wb += sl;
+	we += sl - pl;
+	offs -= pl;
+    }
+    /* Does this compctl have a suffix (compctl -S)? */
+    if ((ccsuffix = cc->suffix) && *ccsuffix) {
+	char *sdup = dupstring(ccsuffix);
+	int sl = strlen(sdup), suffixll;
+
+	/* Ignore trailing spaces. */
+	for (p = sdup + sl - 1; p >= sdup && *p == ' '; p--, sl--);
+	p[1] = '\0';
+
+	if (!sd) {
+	    sd = dupstring(s);
+	    untokenize(sd);
+	}
+	/* If the suffix is already there, ignore it (and don't add *
+	 * it again).                                               */
+	if (*sd && (suffixll = strlen(sd)) >= sl &&
+	    offs <= suffixll - sl && !strcmp(sdup, sd + suffixll - sl)) {
+	    ccsuffix = NULL;
+	    haswhat |= HAS_SUFFIX;
+	    s[suffixll - sl] = '\0';
+	}
+    }
+    /* Do we have one of the special characters `~' and `=' at the beginning? */
+    if ((ic = *s) != Tilde && ic != Equals)
+	ic = 0;
+
+    /* Check if we have to complete a parameter name... */
+
+    /* Try to find a `$'. */
+    for (p = s + offs; p > s && *p != String; p--);
+    if (*p == String) {
+	/* Handle $$'s */
+	while (p > s && p[-1] == String)
+	    p--;
+	while (p[1] == String && p[2] == String)
+	    p += 2;
+    }
+    if (*p == String &&	p[1] != Inpar && p[1] != Inbrack) {
+	/* This is really a parameter expression (not $(...) or $[...]). */
+	char *b = p + 1, *e = b;
+	int n = 0, br = 1;
+
+	if (*b == Inbrace) {
+	    /* If this is a ${...}, ignore the possible (...) flags. */
+	    b++, br++;
+	    n = skipparens(Inpar, Outpar, &b);
+	}
+
+	/* Ignore the stuff before the parameter name. */
+	for (; *b; b++)
+	    if (*b != '^' && *b != Hat &&
+		*b != '=' && *b != Equals &&
+		*b != '~' && *b != Tilde)
+		break;
+	if (*b == '#' || *b == Pound || *b == '+')
+	    b++;
+
+	e = b;
+	/* Find the end of the name. */
+	if (*e == Quest || *e == Star || *e == String || *e == Qstring ||
+	    *e == '?'   || *e == '*'  || *e == '$'    ||
+	    *e == '-'   || *e == '!'  || *e == '@')
+	    e++;
+	else if (idigit(*e))
+	    while (idigit(*e))
+		e++;
+	else if (iident(*e))
+	    while (iident(*e) ||
+		   (useglob && (*e == Star || *e == Quest)))
+		e++;
+
+	/* Now make sure that the cursor is inside the name. */
+	if (offs <= e - s && offs >= b - s && n <= 0) {
+	    /* It is. */
+	    parambr = br - 1;
+	    /* Get the prefix (anything up to the character before the name). */
+	    *e = '\0';
+	    parampre = ztrduppfx(s, b - s);
+	    qparampre = ztrdup(quotename(parampre, NULL, NULL, NULL));
+	    untokenize(qparampre);
+	    qparprelen = strlen(qparampre);
+	    /* And adjust wb, we, and offs again. */
+	    offs -= b - s;
+	    wb = cs - offs;
+	    we = wb + e - b;
+	    s = b;
+	    /* And now make sure that we complete parameter names. */
+	    cc = ccmain = &cc_dummy;
+	    cc_dummy.refc = 10000;
+	    cc_dummy.mask = CC_PARAMS | CC_ENVVARS;
+	}
+    }
+    ooffs = offs;
+    /* If we have to ignore the word, do that. */
+    if (cc->mask & CC_DELETE) {
+	*delit = 1;
+	*s = '\0';
+	offs = 0;
+    } else
+	*delit = 0;
+
+    /* Compute line prefix/suffix. */
+
+    lpl = offs;
+    lpre = zalloc(lpl + 1);
+    memcpy(lpre, s, lpl);
+    lpre[lpl] = '\0';
+    p = quotename(lpre, NULL, NULL, NULL);
+    if (strcmp(p, lpre) && !strpfx(p, qword)) {
+	int l1, l2;
+
+	backdel(l1 = cs - wb);
+	untokenize(p);
+	inststrlen(p, 1, l2 = strlen(p));
+	we += l2 - l1;
+    }
+    lsuf = ztrdup(s + offs);
+    lsl = strlen(lsuf);
+    if (lsl && (p = quotename(lsuf, NULL, NULL, NULL)) &&
+	(strcmp(p, lsuf) && !strsfx(p, qword))) {
+	int l1, l2;
+
+	foredel(l1 = strlen(s + offs));
+	untokenize(p);
+	inststrlen(p, 0, l2 = strlen(p));
+	we += l2 - l1;
+    }
+
+    /* First check for ~.../... */
+    if (ic == Tilde) {
+	for (p = lpre + lpl; p > lpre; p--)
+	    if (*p == '/')
+		break;
+
+	if (*p == '/')
+	    ic = 0;
+    }
+    /* Compute real prefix/suffix. */
+
+    noreal = !*delit;
+    for (p = lpre; *p && *p != String && *p != Tick; p++);
+    tt = ic && !parampre ? lpre + 1 : lpre;
+    rpre = (*p || *lpre == Tilde || *lpre == Equals) ?
+	(noreal = 0, getreal(tt)) :
+	ztrdup(tt);
+
+    for (p = lsuf; *p && *p != String && *p != Tick; p++);
+    rsuf = *p ? (noreal = 0, getreal(lsuf)) : ztrdup(lsuf);
+
+    /* Check if word is a pattern. */
+
+    for (s1 = NULL, sf1 = 0, p = rpre + (rpl = strlen(rpre)) - 1;
+	 p >= rpre && (ispattern != 3 || !sf1);
+	 p--)
+	if (itok(*p) && (p > rpre || (*p != Equals && *p != Tilde)))
+	    ispattern |= sf1 ? 1 : 2;
+	else if (*p == '/') {
+	    sf1++;
+	    if (!s1)
+		s1 = p;
+	}
+    for (s2 = NULL, sf2 = t = 0, p = rsuf; *p && (!t || !sf2); p++)
+	if (itok(*p))
+	    t |= sf2 ? 4 : 2;
+	else if (*p == '/') {
+	    sf2++;
+	    if (!s2)
+		s2 = p;
+	}
+    ispattern = ispattern | t;
+
+    /* But if we were asked not to do glob completion, we never treat the *
+     * thing as a pattern.                                                */
+    if (!useglob)
+	ispattern = 0;
+
+    if (ispattern) {
+	/* The word should be treated as a pattern, so compute the matcher. */
+	p = (char *)ncalloc(rpl + rsl + 2);
+	strcpy(p, rpre);
+	if (rpl && p[rpl - 1] != Star) {
+	    p[rpl] = Star;
+	    strcpy(p + rpl + 1, rsuf);
+	} else
+	    strcpy(p + rpl, rsuf);
+	patcomp = parsereg(p);
+    }
+    if (!patcomp) {
+	untokenize(rpre);
+	untokenize(rsuf);
+
+	rpl = strlen(rpre);
+	rsl = strlen(rsuf);
+    }
+    untokenize(lpre);
+    untokenize(lsuf);
+
+    /* Handle completion of files specially (of course). */
+
+    if ((cc->mask & (CC_FILES | CC_DIRS | CC_COMMPATH)) || cc->glob) {
+	/* s1 and s2 point to the last/first slash in the prefix/suffix. */
+	if (!s1)
+	    s1 = rpre;
+	if (!s2)
+	    s2 = rsuf + rsl;
+
+	/* Compute the path prefix/suffix. */
+	if (*s1 != '/')
+	    ppre = ztrdup("");
+	else
+	    ppre = ztrduppfx(rpre, s1 - rpre + 1);
+	psuf = ztrdup(s2);
+
+	/* And get the file prefix. */
+	fpre = ztrdup(((s1 == s || s1 == rpre || ic) &&
+		       (*s != '/' || cs == wb)) ? s1 : s1 + 1);
+	/* And the suffix. */
+	fsuf = ztrduppfx(rsuf, s2 - rsuf);
+
+	if (useglob && (ispattern & 2)) {
+	    int t2;
+
+	    /* We have to use globbing, so compute the pattern from *
+	     * the file prefix and suffix with a `*' between them.  */
+	    p = (char *)ncalloc((t2 = strlen(fpre)) + strlen(fsuf) + 2);
+	    strcpy(p, fpre);
+	    if ((!t2 || p[t2 - 1] != Star) && *fsuf != Star)
+		p[t2++] = Star;
+	    strcpy(p + t2, fsuf);
+	    filecomp = parsereg(p);
+	}
+	if (!filecomp) {
+	    untokenize(fpre);
+	    untokenize(fsuf);
+
+	    fpl = strlen(fpre);
+	    fsl = strlen(fsuf);
+	}
+	addwhat = -1;
+
+	/* Completion after `~', maketildelist adds the usernames *
+	 * and named directories.                                 */
+	if (ic == Tilde)
+	    maketildelist();
+	else if (ic == Equals) {
+	    /* Completion after `=', get the command names from *
+	     * the cmdnamtab and aliases from aliastab.         */
+	    if (isset(HASHLISTALL))
+		cmdnamtab->filltable(cmdnamtab);
+	    dumphashtable(cmdnamtab, -7);
+	    dumphashtable(aliastab, -2);
+	} else {
+	    /* Normal file completion... */
+	    if (ispattern & 1) {
+		/* But with pattern matching. */
+		LinkList l = newlinklist();
+		LinkNode n;
+		int ng = opts[NULLGLOB];
+
+		opts[NULLGLOB] = 1;
+
+		addwhat = 0;
+		p = (char *)ncalloc(lpl + lsl + 3);
+		strcpy(p, lpre);
+		if (*lsuf != '*' && *lpre && lpre[lpl - 1] != '*')
+		    strcat(p, "*");
+		strcat(p, lsuf);
+		if (*lsuf && lsuf[lsl - 1] != '*' && lsuf[lsl - 1] != ')')
+		    strcat(p, "*");
+
+		/* Do the globbing. */
+		tokenize(p);
+		remnulargs(p);
+		addlinknode(l, p);
+		globlist(l);
+
+		if (nonempty(l)) {
+		    /* And add the resulting words. */
+		    haswhat |= HAS_PATHPAT;
+		    for (n = firstnode(l); n; incnode(n))
+			addmatch(getdata(n), NULL);
+		}
+		opts[NULLGLOB] = ng;
+	    } else {
+		/* No pattern matching. */
+		addwhat = CC_FILES;
+		if (cc->withd) {
+		    prpre = tricat(cc->withd, "/", ppre);
+		} else
+		    prpre = ztrdup(ppre);
+
+		if (sf2)
+		    /* We are in the path, so add only directories. */
+		    gen_matches_files(1, 0, 0);
+		else {
+		    if (cc->mask & CC_FILES)
+			/* Add all files. */
+			gen_matches_files(0, 0, 1);
+		    else if (cc->mask & CC_COMMPATH) {
+			/* Completion of command paths. */
+			if (sf1 || cc->withd)
+			    /* There is a path prefix, so add *
+			     * directories and executables.   */
+			    gen_matches_files(1, 1, 0);
+			else {
+			    /* No path prefix, so add the things *
+			     * reachable via the PATH variable.  */
+			    char **pc = path, *pp = prpre;
+
+			    for (; *pc; pc++)
+				if (!**pc || (pc[0][0] == '.' && !pc[0][1]))
+				    break;
+			    if (*pc) {
+				prpre = "./";
+				gen_matches_files(1, 1, 0);
+				prpre = pp;
+			    }
+			}
+		    } else if (cc->mask & CC_DIRS)
+			gen_matches_files(1, 0, 0);
+		    /* The compctl has a glob pattern (compctl -g). */
+		    if (cc->glob) {
+			int ns, pl = strlen(prpre), o;
+			char *g = dupstring(cc->glob), pa[PATH_MAX];
+			char *p2, *p3;
+			int ne = noerrs, md = opts[MARKDIRS];
+
+			/* These are used in the globbing code to make *
+			 * things a bit faster.                        */
+			glob_pre = fpre;
+			glob_suf = fsuf;
+
+			noerrs = 1;
+			addwhat = -6;
+			strcpy(pa, prpre);
+			o = strlen(pa);
+			opts[MARKDIRS] = 0;
+
+			/* The compctl -g string may contain more than *
+			 * one pattern, so we need a loop.             */
+			while (*g) {
+			    LinkList l = newlinklist();
+			    int ng;
+
+			    /* Find the blank terminating the pattern. */
+			    while (*g && inblank(*g))
+				g++;
+			    /* Oops, we already reached the end of the
+			       string. */
+			    if (!*g)
+				break;
+			    for (p = g + 1; *p && !inblank(*p); p++)
+				if (*p == '\\' && p[1])
+				    p++;
+			    /* Get the pattern string. */
+			    tokenize(g = dupstrpfx(g, p - g));
+			    if (*g == '=')
+				*g = Equals;
+			    if (*g == '~')
+				*g = Tilde;
+			    remnulargs(g);
+			    if ((*g == Equals || *g == Tilde) && !cc->withd) {
+				/* The pattern has a `~' or `=' at the  *
+				 * beginning, so we expand this and use *
+				 * the result.                          */
+				filesub(&g, 0);
+				addlinknode(l, dupstring(g));
+			    } else if (*g == '/' && !cc->withd)
+				/* The pattern is a full path (starting *
+				 * with '/'), so add it unchanged.      */
+				addlinknode(l, dupstring(g));
+			    else {
+				/* It's a simple pattern, so append it to *
+				 * the path we have on the command line.  */
+				strcpy(pa + o, g);
+				addlinknode(l, dupstring(pa));
+			    }
+			    /* Do the globbing. */
+			    ng = opts[NULLGLOB];
+			    opts[NULLGLOB] = 1;
+			    globlist(l);
+			    opts[NULLGLOB] = ng;
+			    /* Get the results. */
+			    if (nonempty(l) && peekfirst(l)) {
+				for (p2 = (char *)peekfirst(l); *p2; p2++)
+				    if (itok(*p2))
+					break;
+				if (!*p2) {
+				    if ((*g == Equals || *g == Tilde ||
+					*g == '/') || cc->withd) {
+					/* IF the pattern started with `~',  *
+					 * `=', or `/', add the result only, *
+					 * if it really matches what we have *
+					 * on the line.                      *
+					 * Do this if an initial directory   *
+					 * was specified, too.               */
+					while ((p2 = (char *)ugetnode(l)))
+					    if (strpfx(prpre, p2))
+						addmatch(p2 + pl, NULL);
+				    } else {
+					/* Otherwise ignore the path we *
+					 * prepended to the pattern.    */
+					while ((p2 = p3 =
+						(char *)ugetnode(l))) {
+					    for (ns = sf1; *p3 && ns; p3++)
+						if (*p3 == '/')
+						    ns--;
+
+					    addmatch(p3, NULL);
+					}
+				    }
+				}
+			    }
+			    pa[o] = '\0';
+			    g = p;
+			}
+			glob_pre = glob_suf = NULL;
+			noerrs = ne;
+			opts[MARKDIRS] = md;
+		    }
+		}
+	    }
+	}
+    }
+    /* Use tricat() instead of dyncat() to get zalloc()'d memory. */
+    if (ic) {
+	/* Now change the `~' and `=' tokens to the real characters so *
+	 * that things starting with these characters will be added.   */
+	char *orpre = rpre;
+
+	rpre = tricat("", (ic == Tilde) ? "~" : "=", rpre);
+	rpl++;
+	zsfree(orpre);
+    }
+    if (!ic && (cc->mask & CC_COMMPATH) && !*ppre && !*psuf) {
+	/* If we have to complete commands, add alias names, *
+	 * shell functions and builtins too.                 */
+	dumphashtable(aliastab, -3);
+	dumphashtable(reswdtab, -3);
+	dumphashtable(shfunctab, -3);
+	dumphashtable(builtintab, -3);
+	if (isset(HASHLISTALL))
+	    cmdnamtab->filltable(cmdnamtab);
+	dumphashtable(cmdnamtab, -3);
+	/* And parameter names if autocd and cdablevars are set. */
+	if (isset(AUTOCD) && isset(CDABLEVARS))
+	    dumphashtable(paramtab, -4);
+    }
+    addwhat = (cc->mask & CC_QUOTEFLAG) ? -2 : CC_QUOTEFLAG;
+
+    if (cc->mask & CC_NAMED)
+	/* Add named directories. */
+	dumphashtable(nameddirtab, addwhat);
+    if (cc->mask & CC_OPTIONS)
+	/* Add option names. */
+	dumphashtable(optiontab, addwhat);
+    if (cc->mask & CC_VARS)
+	/* And parameter names. */
+	dumphashtable(paramtab, -9);
+    if (cc->mask & CC_BINDINGS)
+	/* And zle function names... */
+	dumphashtable(thingytab, CC_BINDINGS);
+    if (cc->keyvar) {
+	/* This adds things given to the compctl -k flag *
+	 * (from a parameter or a list of words).        */
+	char **usr = get_user_var(cc->keyvar);
+
+	if (usr)
+	    while (*usr)
+		addmatch(*usr++, NULL);
+    }
+    if (cc->mask & CC_USERS)
+	/* Add user names. */
+	maketildelist();
+    if (cc->func) {
+	/* This handles the compctl -K flag. */
+	List list;
+	char **r;
+	int lv = lastval;
+
+	/* Get the function. */
+	if ((list = getshfunc(cc->func)) != &dummy_list) {
+	    /* We have it, so build a argument list. */
+	    LinkList args = newlinklist();
+
+	    addlinknode(args, cc->func);
+
+	    if (*delit) {
+		p = dupstrpfx(os, ooffs);
+		untokenize(p);
+		addlinknode(args, p);
+		p = dupstring(os + ooffs);
+		untokenize(p);
+		addlinknode(args, p);
+	    } else {
+		addlinknode(args, lpre);
+		addlinknode(args, lsuf);
+	    }
+
+	    /* This flag allows us to use read -l and -c. */
+	    incompctlfunc = 1;
+	    /* Call the function. */
+	    doshfunc(list, args, 0, 1);
+	    incompctlfunc = 0;
+	    /* And get the result from the reply parameter. */
+	    if ((r = get_user_var("reply")))
+		while (*r)
+		    addmatch(*r++, NULL);
+	}
+	lastval = lv;
+    }
+    if (cc->mask & (CC_JOBS | CC_RUNNING | CC_STOPPED)) {
+	/* Get job names. */
+	int i;
+	char *j, *jj;
+
+	for (i = 0; i < MAXJOB; i++)
+	    if (jobtab[i].stat & STAT_INUSE) {
+		int stopped = jobtab[i].stat & STAT_STOPPED;
+
+		j = jj = dupstring(jobtab[i].procs->text);
+		/* Find the first word. */
+		for (; *jj; jj++)
+		    if (*jj == ' ') {
+			*jj = '\0';
+			break;
+		    }
+		if ((cc->mask & CC_JOBS) ||
+		    (stopped && (cc->mask & CC_STOPPED)) ||
+		    (!stopped && (cc->mask & CC_RUNNING)))
+		    addmatch(j, NULL);
+	    }
+    }
+    if (cc->str) {
+	/* Get the stuff from a compctl -s. */
+	LinkList foo = newlinklist();
+	LinkNode n;
+	int first = 1, ng = opts[NULLGLOB], oowe = we, oowb = wb;
+	char *tmpbuf;
+
+	opts[NULLGLOB] = 1;
+
+	/* Put the strin in the lexer buffer and call the lexer to *
+	 * get the words we have to expand.                        */
+	zleparse = 1;
+	lexsave();
+	tmpbuf = (char *)halloc(strlen(cc->str) + 5);
+	sprintf(tmpbuf, "foo %s", cc->str); /* KLUDGE! */
+	inpush(tmpbuf, 0, NULL);
+	strinbeg();
+	noaliases = 1;
+	do {
+	    ctxtlex();
+	    if (tok == ENDINPUT || tok == LEXERR)
+		break;
+	    if (!first && tokstr && *tokstr)
+		addlinknode(foo, ztrdup(tokstr));
+	    first = 0;
+	} while (tok != ENDINPUT && tok != LEXERR);
+	noaliases = 0;
+	strinend();
+	inpop();
+	errflag = zleparse = 0;
+	lexrestore();
+	/* Fine, now do full expansion. */
+	prefork(foo, 0);
+	if (!errflag) {
+	    globlist(foo);
+	    if (!errflag)
+		/* And add the resulting words as matches. */
+		for (n = firstnode(foo); n; incnode(n))
+		    addmatch((char *)n->dat, NULL);
+	}
+	opts[NULLGLOB] = ng;
+	we = oowe;
+	wb = oowb;
+    }
+    if (cc->hpat) {
+	/* We have a pattern to take things from the history. */
+	Comp compc = NULL;
+	char *e, *h, hpatsav;
+	Histent he;
+	int i = curhist - 1, n = cc->hnum;
+
+	/* Parse the pattern, if it isn't the null string. */
+	if (*(cc->hpat)) {
+	    char *thpat = dupstring(cc->hpat);
+
+	    tokenize(thpat);
+	    compc = parsereg(thpat);
+	}
+	/* n holds the number of history line we have to search. */
+	if (!n)
+	    n = -1;
+
+	/* Now search the history. */
+	while (n-- && (he = quietgethist(i--))) {
+	    int iwords;
+	    for (iwords = 0; iwords < he->nwords; iwords++) {
+		h = he->text + he->words[iwords*2];
+		e = he->text + he->words[iwords*2+1];
+		hpatsav = *e;
+		*e = '\0';
+		/* We now have a word from the history, ignore it *
+		 * if it begins with a quote or `$'.              */
+		if (*h != '\'' && *h != '"' && *h != '`' && *h != '$' &&
+		    (!compc || domatch(h, compc, 0)))
+		    /* Otherwise add it if it was matched. */
+		    addmatch(dupstring(h), NULL);
+		if (hpatsav)
+		    *e = hpatsav;
+	    }
+	}
+    }
+    if ((t = cc->mask & (CC_ARRAYS | CC_INTVARS | CC_ENVVARS | CC_SCALARS |
+			 CC_READONLYS | CC_SPECIALS | CC_PARAMS)))
+	/* Add various flavours of parameters. */
+	dumphashtable(paramtab, t);
+    if ((t = cc->mask & CC_SHFUNCS))
+	/* Add shell functions. */
+	dumphashtable(shfunctab, t | (cc->mask & (CC_DISCMDS|CC_EXCMDS)));
+    if ((t = cc->mask & CC_BUILTINS))
+	/* Add builtins. */
+	dumphashtable(builtintab, t | (cc->mask & (CC_DISCMDS|CC_EXCMDS)));
+    if ((t = cc->mask & CC_EXTCMDS))
+	/* Add external commands */
+	dumphashtable(cmdnamtab, t | (cc->mask & (CC_DISCMDS|CC_EXCMDS)));
+    if ((t = cc->mask & CC_RESWDS))
+	/* Add reserved words */
+	dumphashtable(reswdtab, t | (cc->mask & (CC_DISCMDS|CC_EXCMDS)));
+    if ((t = cc->mask & (CC_ALREG | CC_ALGLOB)))
+	/* Add the two types of aliases. */
+	dumphashtable(aliastab, t | (cc->mask & (CC_DISCMDS|CC_EXCMDS)));
+
+    /* If we have no matches, ignore fignore. */
+    if (empty(matches)) {
+	matches = fmatches;
+	firstm = ffirstm;
+	shortest = fshortest;
+	ab = fab;
+	ae = fae;
+	shortl = fshortl;
+    }
+
+    /* Make an array from the list of matches. */
+    makearray(matches);
+    PERMALLOC {
+	amatches = arrdup(amatches);
+	if (firstm)
+	    firstm = ztrdup(firstm);
+	/* And quote the prefixes/suffixes. */
+	if (hasspecial(s)) {
+	    zfree(lpre, lpl);
+	    zfree(lsuf, lsl);
+	    lpre = zalloc(lpl + 1);
+	    memcpy(lpre, s, lpl);
+	    lpre[lpl] = '\0';
+	    lsuf = ztrdup(s + offs);
+	    quotepresuf(&lpre);
+	    quotepresuf(&lsuf);
+	    untokenize(lpre);
+	    untokenize(lsuf);
+	}
+	quotepresuf(&fpre);
+	quotepresuf(&fsuf);
+	quotepresuf(&ppre);
+	quotepresuf(&psuf);
+    } LASTALLOC;
+
+    if (!errflag && cc->ylist) {
+	/* generate the user-defined display list: if anything fails, *
+	 * we silently allow the normal completion list to be used.   */
+	char **yaptr, *uv = NULL;
+	List list;
+
+	if (cc->ylist[0] == '$' || cc->ylist[0] == '(') {
+	    /* from variable */
+	    uv = cc->ylist + (cc->ylist[0] == '$');
+	} else if ((list = getshfunc(cc->ylist)) != &dummy_list) {
+	    /* from function:  pass completions as arg list */
+	    LinkList args = newlinklist();
+	    int addlen = strlen(rpre) + strlen(rsuf) + 1;
+
+	    addlinknode(args, cc->ylist);
+	    for (yaptr = amatches; *yaptr; yaptr++) {
+		/* can't use tricat(). rats. */
+		char *ptr = (char *)halloc(addlen + strlen(*yaptr));
+		sprintf(ptr, "%s%s%s", rpre, *yaptr, rsuf);
+		addlinknode(args, ptr);
+	    }
+
+	    /* No harm in allowing read -l and -c here, too */
+	    incompctlfunc = 1;
+	    doshfunc(list, args, 0, 1);
+	    incompctlfunc = 0;
+	    uv = "reply";
+	}
+	if (uv && (yaptr = get_user_var(uv))) {
+	    PERMALLOC {
+		aylist = arrdup(yaptr);
+	    } LASTALLOC;
+	}
+    }
+
+    /* Get the explanation string we will have to print:    *
+     * do this here in case a -y function alters the messge */
+    if ((expl = cc->explain)) {
+	if (cc->mask & CC_EXPANDEXPL && !parsestr(expl = dupstring(expl))) {
+	    singsub(&expl);
+	    untokenize(expl);
+	}
+	expl = ztrdup(expl);
+    }
+
+    remsuffix = (cc->mask & CC_REMOVE);
+    ccsuffix = cc->suffix;
+
+    validlist = 1;
+    if (nmatches && !errflag)
+	return 0;
+
+    if ((isf || cc->xor) && !parampre) {
+	/* We found no matches, but there is a xor'ed completion: *
+	 * fine, so go back and continue with that compctl.       */
+	errflag = 0;
+	cc = cc->xor;
+	isf = 0;
+	wb = owb;
+	we = owe;
+	cs = ocs;
+	ll = oll;
+	strcpy((char *)line, (char *)ol);
+	offs = oloffs;
+	s = dupstring(os);
+	free(amatches);
+	zsfree(rpre);
+	zsfree(rsuf);
+	zsfree(lpre);
+	zsfree(lsuf);
+	zsfree(ppre);
+	zsfree(psuf);
+	zsfree(fpre);
+	zsfree(fsuf);
+	zsfree(prpre);
+	zsfree(parampre);
+	zsfree(qparampre);
+	zsfree(firstm);
+	if (expl)
+	    zsfree(expl);
+	expl = NULL;
+	if (aylist)
+	    freearray(aylist);
+	aylist = NULL;
+	goto xorrec;
+    }
+
+    /* No matches and xor'ed completion: restore the command line if  *
+     * it was alredy quoted, which is the case when s is untokenized. */
+    if (untokenized)
+	strcpy((char *)line, (char *)ol);
+    return 1;
+}
+
+/* Invalidate the completion list. */
+
+/**/
+void
+invalidatelist(void)
+{
+    if(showinglist == -2)
+	listmatches();
+    if(validlist) {
+	freearray(amatches);
+	if (aylist)
+	    freearray(aylist);
+	aylist = NULL;
+	if (expl)
+	    zsfree(expl);
+	expl = 0;
+	zsfree(rpre);
+	zsfree(rsuf);
+	zsfree(lpre);
+	zsfree(lsuf);
+	zsfree(ppre);
+	zsfree(psuf);
+	zsfree(fpre);
+	zsfree(fsuf);
+	zsfree(prpre);
+	zsfree(parampre);
+	zsfree(qparampre);
+	zsfree(firstm);
+	if (ccmain != &cc_dummy)
+	    freecompctl(ccmain);
+    }
+    lastambig = menucmp = showinglist = validlist = 0;
+    menucur = NULL;
+}
+
+/* Get the words from a variable or a compctl -k list. */
+
+/**/
+static char **
+get_user_var(char *nam)
+{
+    if (!nam)
+	return NULL;
+    else if (*nam == '(') {
+	/* It's a (...) list, not a parameter name. */
+	char *ptr, *s, **uarr, **aptr;
+	int count = 0, notempty = 0, brk = 0;
+	LinkList arrlist = newlinklist();
+
+	ptr = dupstring(nam);
+	s = ptr + 1;
+	while (*++ptr) {
+	    if (*ptr == '\\' && ptr[1])
+		chuck(ptr), notempty = 1;
+	    else if (*ptr == ',' || inblank(*ptr) || *ptr == ')') {
+		if (*ptr == ')')
+		    brk++;
+		if (notempty) {
+		    *ptr = '\0';
+		    count++;
+		    if (*s == '\n')
+			s++;
+		    addlinknode(arrlist, s);
+		}
+		s = ptr + 1;
+		notempty = 0;
+	    } else {
+		notempty = 1;
+		if(*ptr == Meta)
+		    ptr++;
+	    }
+	    if (brk)
+		break;
+	}
+	if (!brk || !count)
+	    return NULL;
+	*ptr = '\0';
+	aptr = uarr = (char **)ncalloc(sizeof(char *) * (count + 1));
+
+	while ((*aptr++ = (char *)ugetnode(arrlist)));
+	uarr[count] = NULL;
+	return uarr;
+    } else {
+	/* Otherwise it should be a parameter name. */
+	char **arr = NULL, *val;
+	if (!(arr = getaparam(nam)) && (val = getsparam(nam))) {
+	    arr = (char **)ncalloc(2*sizeof(char *));
+	    arr[0] = val;
+	    arr[1] = NULL;
+	}
+	return arr;
+    }
+
+}
+
+/* This is strcmp with ignoring backslashes. */
+
+/**/
+static int
+strbpcmp(const void *a, const void *b)
+{
+    char *aa = *((char **)a), *bb = *((char **)b);
+
+    while (*aa && *bb) {
+	if (*aa == '\\')
+	    aa++;
+	if (*bb == '\\')
+	    bb++;
+	if (*aa != *bb)
+	    return (int)(*aa - *bb);
+	if (*aa)
+	    aa++;
+	if (*bb)
+	    bb++;
+    }
+    return (int)(*aa - *bb);
+}
+
+/* Make an array from a linked list */
+
+/**/
+static void
+makearray(LinkList l)
+{
+    char **ap, **bp, **cp;
+    LinkNode nod;
+
+    /* Build an array for the matches. */
+    ap = amatches = (char **)ncalloc(((nmatches = countlinknodes(l)) + 1) *
+				     sizeof(char *));
+
+    /* And copy them into it. */
+    for (nod = firstnode(l); nod; incnode(nod))
+	*ap++ = (char *)getdata(nod);
+    *ap = NULL;
+
+    /* Now sort the array. */
+    qsort((void *) amatches, nmatches, sizeof(char *),
+	       (int (*) _((const void *, const void *)))strbpcmp);
+
+    /* And delete the ones that occur more than once. */
+    for (ap = cp = amatches; *ap; ap++) {
+	*cp++ = *ap;
+	for (bp = ap; bp[1] && !strcmp(*ap, bp[1]); bp++);
+	ap = bp;
+    }
+    *cp = NULL;
+    nmatches = arrlen(amatches);
+}
+
+/* Handle the case were we found more than one match. */
+
+/**/
+static void
+do_ambiguous(void)
+{
+    int p = (usemenu || ispattern), atend = (cs == we);
+    int inv = 0;
+
+    menucmp = 0;
+
+    /* If we have to insert the first match, call do_single().  This is *
+     * how REC_EXACT takes effect.  We effectively turn the ambiguous   *
+     * completion into an unambiguous one.                              */
+    if (shortest && shortl == 0 && isset(RECEXACT) &&
+	(usemenu == 0 || unset(AUTOMENU))) {
+	do_single(shortest);
+	invalidatelist();
+	return;
+    }
+    /* Setting lastambig here means that the completion is ambiguous and *
+     * AUTO_MENU might want to start a menu completion next time round,  *
+     * but this might be overridden below if we can complete an          *
+     * unambiguous prefix.                                               */
+    lastambig = 1;
+    if(p) {
+	/* p is set if we are in a position to start using menu completion *
+	 * due to one of the menu completion options, or due to the        *
+	 * menu-complete-word command, or due to using GLOB_COMPLETE which *
+	 * does menu-style completion regardless of the setting of the     *
+	 * normal menu completion options.                                 */
+	do_ambig_menu();
+    } else {
+	/* Sort-of general case: we have an ambiguous completion, and aren't *
+	 * starting menu completion or doing anything really weird.  We need *
+	 * to insert any unambiguous prefix and suffix, if possible.         */
+	if(ab)
+	    inststrlen(firstm, 1, ab);
+	if(ae && !atend)
+	    inststrlen(firstm + strlen(firstm) - ae, 0, ae);
+	if(ab || (ae && !atend))
+	    inv = 1;
+	/* If the LIST_AMBIGUOUS option (meaning roughly `show a list only *
+	 * if the completion is completely ambiguous') is set, and some    *
+	 * prefix was inserted, return now, bypassing the list-displaying  *
+	 * code.  On the way, invalidate the list and note that we don't   *
+	 * want to enter an AUTO_MENU imediately.                          */
+	if(isset(LISTAMBIGUOUS) && inv) {
+	    invalidatelist();
+	    lastambig = 0;
+	    return;
+	}
+    }
+    /* At this point, we might want a completion listing.  Show the listing *
+     * if it is needed.                                                     */
+    if (isset(LISTBEEP))
+	feep();
+    if (isset(AUTOLIST) && !amenu && !showinglist)
+	showinglist = -2;
+    if(inv)
+	invalidatelist();
+}
+
+/* This is a stat that ignores backslashes in the filename.  The `ls' *
+ * parameter says if we have to do lstat() or stat().  I think this   *
+ * should instead be done by use of a general function to expand a    *
+ * filename (stripping backslashes), combined with the actual         *
+ * (l)stat().                                                         */
+
+/**/
+static int
+ztat(char *nam, struct stat *buf, int ls)
+{
+    char b[PATH_MAX], *p;
+
+    for (p = b; p < b + sizeof(b) - 1 && *nam; nam++)
+	if (*nam == '\\' && nam[1])
+	    *p++ = *++nam;
+	else
+	    *p++ = *nam;
+    *p = '\0';
+
+    return ls ? lstat(b, buf) : stat(b, buf);
+}
+
+/* Insert a single match in the command line. */
+
+/**/
+static void
+do_single(char *str)
+{
+    int l;
+    int havesuff = 0;
+
+    fixsuffix();
+
+    if (!menucur) {
+	/* We are currently not in a menu-completion, *
+	 * so set the position variables.             */
+	if (ispattern) {
+	    cs = we;
+	    menupos = wb;
+	} else
+	    menupos = cs;
+	menuwe = (cs == we) || isset(ALWAYSTOEND);
+	menuend = we;
+    }
+    /* If we are already in a menu-completion or if we have done a *
+     * glob completion, we have to delete some of the stuff on the *
+     * command line.                                               */
+    if (menucur) {
+	if (menuinsc) {
+	    cs = menuend + lsl;
+	    foredel(menuinsc);
+	}
+	l = menulen;
+    } else if (ispattern)
+	l = we - wb;
+    else
+	l = 0;
+
+    menuinsc = 0;
+    cs = menupos;
+    foredel(l);
+
+    /* And than we insert the new string. */
+    inststrlen(str, 1, menulen = strlen(str));
+    menuend = cs;
+
+    cs += lsl;
+
+    if (ccsuffix) {
+	/* There is a compctl -S suffix.  Add it. */
+	if (!(haswhat & HAS_SUFFIX) && *ccsuffix) {
+	    havesuff = 1;
+	    inststr(ccsuffix);
+	    menuinsc = ztrlen(ccsuffix);
+	    if (remsuffix && menuwe)
+		makesuffix(menuinsc);
+	}
+	havesuff = 1;
+    } else {
+	/* There is no user-specified suffix, *
+	 * so generate one automagically.     */
+	if(parampre && parambr) {
+	    /*{{*/
+	    /* Completing a parameter in braces.  Add a removable `}' suffix. */
+	    inststrlen("}", 1, 1);
+	    menuinsc++;
+	}
+	if(!(haswhat & HAS_MISC) ||
+	    	  (parampre && isset(AUTOPARAMSLASH))) {
+	    /* If we have only filenames or we completed a parameter name  *
+	     * and AUTO_PARAM_SLASH is set, lets see if it is a directory. *
+	     * If it is, we append a slash.                                */
+	    char *p;
+	    struct stat buf;
+
+	    /* Build the path name. */
+	    if (ispattern || ic || parampre) {
+		int ne = noerrs;
+
+		noerrs = 1;
+
+		if (parampre) {
+		    int pl = strlen(parampre);
+		    p = (char *) ncalloc(pl + strlen(lpre) + strlen(str) +
+					 strlen(lsuf) + 1);
+		    sprintf(p, "%s%s%s%s", parampre, lpre, str, lsuf);
+		    if (pl && p[pl-1] == Inbrace)
+			strcpy(p+pl-1, p+pl);
+		}
+		else if (ic) {
+		    p = (char *) ncalloc(strlen(ppre) + strlen(fpre) + strlen(str) +
+					 strlen(fsuf) + strlen(psuf) + 2);
+		    sprintf(p, "%c%s%s%s%s%s", ic,
+			    ppre, fpre, str, fsuf, psuf);
+		}
+		else
+		    p = dupstring(str);
+		parsestr(p);
+		if (ic)
+		    *p = ic;
+		singsub(&p);
+
+		noerrs = ne;
+	    } else {
+		p = (char *) ncalloc((prpre ? strlen(prpre) : 0) + strlen(fpre) +
+				     strlen(str) + strlen(fsuf) + strlen(psuf) + 3);
+		sprintf(p, "%s%s%s%s%s",
+			(prpre && *prpre) ? prpre : "./", fpre, str,
+			fsuf, psuf);
+	    }
+	    /* And do the stat. */
+	    if (!ztat(p, &buf, 0) && S_ISDIR(buf.st_mode)) {
+		/* It is a directory, so add the slash. */
+		havesuff = 1;
+		inststrlen("/", 1, 1);
+		menuinsc++;
+		if(menuwe && isset(AUTOREMOVESLASH)) {
+		    makesuffix(1);
+		    suffixlen['/'] = 1;
+		}
+	    }
+	}
+    }
+    /* If completing in a brace expansion... */
+    if(complinbrace) {
+	if(havesuff) {
+	    /*{{*/
+	    /* If a suffix was added, and is removable, let *
+	     * `,' and `}' remove it.                       */
+	    if(isset(AUTOPARAMKEYS))
+		suffixlen[','] = suffixlen['}'] = suffixlen[256];
+	} else {
+	    /*{{*/
+	    /* Otherwise, add a `,' suffix, and let `}' remove it. */
+	    havesuff = 1;
+	    inststrlen(",", 1, 1);
+	    menuinsc++;
+	    if(menuwe && isset(AUTOPARAMKEYS))
+		suffixlen[','] = suffixlen['}'] = 1;
+	}
+    } else if(!menucmp && !havesuff) {
+	/* If we didn't add a suffix, add a space, unless we are *
+	 * doing menu completion.                                */
+	inststrlen(" ", 1, 1);
+	menuinsc++;
+	if(menuwe)
+	    makesuffix(1);
+    }
+    if(menuwe && parampre && isset(AUTOPARAMKEYS))
+	makeparamsuffix(parambr, menuinsc);
+
+    if (!menuwe)
+	cs = menuend;
+}
+
+/* This handles the beginning of menu-completion. */
+
+/**/
+static void
+do_ambig_menu(void)
+{
+    menucmp = 1;
+    menucur = NULL;
+    do_single(amatches[0]);
+    menucur = amatches;
+}
+
+/* Return the length of the common prefix of s and t. */
+
+/**/
+int
+pfxlen(char *s, char *t)
+{
+    int i = 0;
+
+    while (*s && *s == *t)
+	s++, t++, i++;
+    return i;
+}
+
+/* Return the length of the common suffix of s and t. */
+
+/**/
+static int
+sfxlen(char *s, char *t)
+{
+    if (*s && *t) {
+	int i = 0;
+	char *s2 = s + strlen(s) - 1, *t2 = t + strlen(t) - 1;
+
+	while (s2 >= s && t2 >= t && *s2 == *t2)
+	    s2--, t2--, i++;
+
+	return i;
+    } else
+	return 0;
+}
+
+/* This is used to print the explanation string. *
+ * It returns the number of lines printed.       */
+
+/**/
+static int
+printfmt(char *fmt, int n, int dopr)
+{
+    char *p = fmt, nc[DIGBUFSIZE];
+    int l = 0, cc = 0;
+
+    for (; *p; p++) {
+	/* Handle the `%' stuff (%% == %, %n == <number of matches>). */
+	if (*p == '%') {
+	    if (*++p) {
+		switch (*p) {
+		case '%':
+		    if (dopr)
+			putc('%', shout);
+		    cc++;
+		    break;
+		case 'n':
+		    sprintf(nc, "%d", n);
+		    if (dopr)
+			fprintf(shout, nc);
+		    cc += strlen(nc);
+		    break;
+		}
+	    } else
+		break;
+	} else {
+	    cc++;
+	    if (*p == '\n') {
+		l += 1 + (cc / columns);
+		cc = 0;
+	    }
+	    if (dopr)
+		putc(*p, shout);
+	}
+    }
+
+    return l + (cc / columns);
+}
+
+/* List the matches.  Note that the list entries are metafied. */
+
+/**/
+void
+listmatches(void)
+{
+    int longest = 1, fct, fw, colsz, t0, t1, ct, up, cl, xup = 0;
+    int off = 0, boff = 0, nboff = 0;
+    int of = (!aylist && isset(LISTTYPES) && !(haswhat & HAS_MISC));
+    char **arr, **ap, sav;
+    int nfpl, nfsl, nlpl, nlsl;
+    int listmax = getiparam("LISTMAX"), litnl = 0;
+    size_t (*strlenfn) _((char const *));
+
+#ifdef DEBUG
+    /* Sanity check */
+    if(!validlist) {
+	showmsg("BUG: listmatches called with bogus list");
+	return;
+    }
+#endif
+
+    /* Calculate lengths of prefixes/suffixes to be added */
+    nfpl = fpre ? niceztrlen(fpre) : 0;
+    nfsl = fsuf ? niceztrlen(fsuf) : 0;
+    nlpl = lpre ? niceztrlen(lpre) : 0;
+    nlsl = lsuf ? niceztrlen(lsuf) : 0;
+
+    /* Calculate the lengths of the prefixes/suffixes we have to ignore
+       during printing. */
+    if (ispattern && !aylist && !(haswhat & (HAS_MISC | HAS_PATHPAT))) {
+	if (ppre && *ppre)
+	    off = strlen(ppre);
+	if (psuf && *psuf) {
+	    boff = strlen(psuf);
+	    nboff = niceztrlen(psuf);
+	}
+    }
+
+    /* Set the cursor below the prompt. */
+    trashzle();
+    showinglist = 0;
+
+    clearflag = (isset(USEZLE) && !termflags &&
+		 (isset(ALWAYSLASTPROMPT) && zmult == 1)) ||
+	(unset(ALWAYSLASTPROMPT) && zmult != 1);
+
+    /* just to keep gcc happy */
+    fw = colsz = up = 0;
+    if (aylist) {
+	arr = aylist;
+	/* If no literal newlines, the remaining code should use strlen() */
+	strlenfn = (size_t (*) _((char const *)))strlen;
+
+	/* The hard bit here is that we are handling newlines literally.   *
+	 * In fact, we are in principle handling all characters literally, *
+	 * but it's quite enough work with just newlines.                  *
+	 * If there are such, we give up trying to print the list as       *
+	 * columns and print as rows, counting the extra newlines.         */
+	ct = 0;
+	for (ap = arr; *ap; ap++) {
+	    ct++;
+	    if (strchr(*ap, '\n'))
+		litnl++;
+	}
+	if (litnl) {
+	    colsz = ct;
+	    up = colsz + nlnct - clearflag;
+	    /* Count real newlines, as well as overflowing lines. */
+	    for (ap = arr; *ap; ap++) {
+		char *nlptr, *sptr = *ap;
+		while (sptr && *sptr) {
+		    up += (nlptr = strchr(sptr, '\n'))
+			? 1 + (nlptr-sptr)/columns
+			   : strlen(sptr)/columns;
+		    sptr = nlptr ? nlptr+1 : NULL;
+		}
+	    }
+	}
+    } else {
+	arr = amatches;
+	ct = nmatches;
+	strlenfn = niceztrlen;
+    }
+
+
+    if (!litnl) {
+	/* Calculate the column width, the number of columns and the
+	   number of lines. */
+	for (ap = arr; *ap; ap++)
+	    if ((cl = strlenfn(*ap + off) - nboff +
+		 ((ispattern || aylist) ? 0 :
+		  (!(haswhat & HAS_MISC) ?
+		   nfpl + nfsl : nlpl + nlsl))) > longest)
+		longest = cl;
+	if (of)
+	    longest++;
+
+	fw = longest + 2;
+	fct = (columns + 1) / fw;
+	if (fct == 0) {
+	    fct = 1;
+	    colsz = ct;
+	    up = colsz + nlnct - clearflag;
+	    for (ap = arr; *ap; ap++)
+		up += (strlenfn(*ap + off) - nboff + of +
+		       ((ispattern || aylist) ? 0 :
+			(!(haswhat & HAS_MISC) ?
+			 nfpl + nfsl : nlpl + nlsl))) / columns;
+	} else {
+	    colsz = (ct + fct - 1) / fct;
+	    up = colsz + nlnct - clearflag + (ct == 0);
+	}
+    }
+
+    /* Print the explanation string, if any. */
+    if (expl) {
+	xup = printfmt(expl, ct, 1) + 1;
+	putc('\n', shout);
+	up += xup;
+    }
+
+    /* Maybe we have to ask if the user wants to see the list. */
+    if ((listmax && ct > listmax) || (!listmax && up >= lines)) {
+	int qup;
+	setterm();
+	qup = printfmt("zsh: do you wish to see all %n possibilities? ", ct, 1);
+	fflush(shout);
+	if (getzlequery() != 'y') {
+	    if (clearflag) {
+		putc('\r', shout);
+		tcmultout(TCUP, TCMULTUP, qup);
+		if (tccan(TCCLEAREOD))
+		    tcout(TCCLEAREOD);
+		tcmultout(TCUP, TCMULTUP, nlnct + xup);
+	    } else
+		putc('\n', shout);
+	    return;
+	}
+	if (clearflag) {
+	    putc('\r', shout);
+	    tcmultout(TCUP, TCMULTUP, qup);
+	    if (tccan(TCCLEAREOD))
+		tcout(TCCLEAREOD);
+	} else
+	    putc('\n', shout);
+	settyinfo(&shttyinfo);
+    }
+
+    /* Now print the matches. */
+    for (t1 = 0; t1 != colsz; t1++) {
+	ap = arr + t1;
+	if (of) {
+	    /* We have to print the file types. */
+	    while (*ap) {
+		int t2;
+		char *pb;
+		struct stat buf;
+
+		/* Build the path name for the stat. */
+		if (ispattern) {
+		    int cut = strlen(*ap) - boff;
+
+		    sav = ap[0][cut];
+		    ap[0][cut] = '\0';
+		    nicezputs(*ap + off, shout);
+		    t2 = niceztrlen(*ap + off);
+		    ap[0][cut] = sav;
+		    pb = *ap;
+		} else {
+		    nicezputs(fpre, shout);
+		    nicezputs(*ap, shout);
+		    nicezputs(fsuf, shout);
+		    t2 = nfpl + niceztrlen(*ap) + nfsl;
+		    pb = (char *) halloc((prpre ? strlen(prpre) : 0) + 3 +
+					 strlen(fpre) + strlen(*ap) + strlen(fsuf));
+		    sprintf(pb, "%s%s%s%s",
+			    (prpre && *prpre) ? prpre : "./", fpre, *ap, fsuf);
+		}
+		if (ztat(pb, &buf, 1))
+		    putc(' ', shout);
+		else
+		    /* Print the file type character. */
+		    putc(file_type(buf.st_mode), shout);
+		for (t0 = colsz; t0 && *ap; t0--, ap++);
+		if (*ap)
+		    /* And add spaces to make the columns aligned. */
+		    for (++t2; t2 < fw; t2++)
+			putc(' ', shout);
+	    }
+	} else
+	    while (*ap) {
+		int t2;
+
+		if (aylist) {
+		    zputs(*ap, shout);
+		    t2 = strlen(*ap);
+		} else if (ispattern) {
+		    int cut = strlen(*ap) - boff;
+
+		    sav = ap[0][cut];
+		    ap[0][cut] = '\0';
+		    nicezputs(*ap + off, shout);
+		    t2 = niceztrlen(*ap + off);
+		    ap[0][cut] = sav;
+		} else if (!(haswhat & HAS_MISC)) {
+		    nicezputs(fpre, shout);
+		    nicezputs(*ap, shout);
+		    nicezputs(fsuf, shout);
+		    t2 = nfpl + niceztrlen(*ap) + nfsl;
+		} else {
+		    nicezputs(lpre, shout);
+		    nicezputs(*ap, shout);
+		    nicezputs(lsuf, shout);
+		    t2 = nlpl + niceztrlen(*ap) + nlsl;
+		}
+		for (t0 = colsz; t0 && *ap; t0--, ap++);
+		if (*ap)
+		    for (; t2 < fw; t2++)
+			putc(' ', shout);
+	    }
+	if (t1 != colsz - 1 || !clearflag)
+	    putc('\n', shout);
+    }
+    if (clearflag)
+	/* Move the cursor up to the prompt, if always_last_prompt *
+	 * is set and all that...                                  */
+	if (up < lines) {
+	    tcmultout(TCUP, TCMULTUP, up);
+	    showinglist = -1;
+	} else
+	    clearflag = 0, putc('\n', shout);
+}
+
+/* This is used to print expansions. */
+
+/**/
+void
+listlist(LinkList l)
+{
+    int hw = haswhat, ip = ispattern;
+    char *lp = lpre, *ls = lsuf;
+    int nm = nmatches, vl = validlist;
+    char **am = amatches, **ay = aylist;
+    char *ex = expl;
+
+    haswhat = HAS_MISC;
+    ispattern = 0;
+    validlist = 1;
+    lpre = lsuf = "";
+    aylist = NULL;
+    expl = NULL;
+
+    makearray(l);
+    listmatches();
+    showinglist = 0;
+
+    expl = ex;
+    amatches = am;
+    aylist = ay;
+    nmatches = nm;
+    validlist = vl;
+    lpre = lp;
+    lsuf = ls;
+    ispattern = ip;
+    haswhat = hw;
+}
+
+/* Expand the history references. */
+
+/**/
+int
+doexpandhist(void)
+{
+    unsigned char *ol;
+    int oll, ocs, ne = noerrs, err;
+
+    DPUTS(useheap, "BUG: useheap in doexpandhist()");
+    HEAPALLOC {
+	pushheap();
+	metafy_line();
+	oll = ll;
+	ocs = cs;
+	ol = (unsigned char *)dupstring((char *)line);
+	expanding = 1;
+	excs = cs;
+	ll = cs = 0;
+	lexsave();
+	/* We push ol as it will remain unchanged */
+	inpush((char *) ol, 0, NULL);
+	strinbeg();
+	noaliases = 1;
+	noerrs = 1;
+	exlast = inbufct;
+	do {
+	    ctxtlex();
+	} while (tok != ENDINPUT && tok != LEXERR);
+	stophist = 2;
+	while (!lexstop)
+	    hgetc();
+	/* We have to save errflags because it's reset in lexrestore. Since  *
+	 * noerrs was set to 1 errflag is true if there was a habort() which *
+	 * means that the expanded string is unusable.                       */
+	err = errflag;
+	noerrs = ne;
+	noaliases = 0;
+	strinend();
+	inpop();
+	zleparse = 0;
+	lexrestore();
+	expanding = 0;
+
+	if (!err) {
+	    cs = excs;
+	    if (strcmp((char *)line, (char *)ol)) {
+		unmetafy_line();
+		/* For vi mode -- reset the beginning-of-insertion pointer   *
+		 * to the beginning of the line.  This seems a little silly, *
+		 * if we are, for example, expanding "exec !!".              */
+		if (viinsbegin > findbol())
+		    viinsbegin = findbol();
+		popheap();
+		LASTALLOC_RETURN 1;
+	    }
+	}
+
+	strcpy((char *)line, (char *)ol);
+	ll = oll;
+	cs = ocs;
+	unmetafy_line();
+
+	popheap();
+    } LASTALLOC;
+    return 0;
+}
+
+/**/
+void
+magicspace(void)
+{
+    c = ' ';
+    selfinsert();
+    doexpandhist();
+}
+
+/**/
+void
+expandhistory(void)
+{
+    if (!doexpandhist())
+	feep();
+}
+
+static int cmdwb, cmdwe;
+
+/**/
+static char *
+getcurcmd(void)
+{
+    int curlincmd;
+    char *s = NULL;
+
+    DPUTS(useheap, "BUG: useheap in getcurcmd()");
+    HEAPALLOC {
+	zleparse = 2;
+	lexsave();
+	metafy_line();
+	inpush(dupstrspace((char *) line), 0, NULL);
+	unmetafy_line();
+	strinbeg();
+	pushheap();
+	do {
+	    curlincmd = incmdpos;
+	    ctxtlex();
+	    if (tok == ENDINPUT || tok == LEXERR)
+		break;
+	    if (tok == STRING && curlincmd) {
+		zsfree(s);
+		s = ztrdup(tokstr);
+		cmdwb = ll - wordbeg;
+		cmdwe = ll + 1 - inbufct;
+	    }
+	}
+	while (tok != ENDINPUT && tok != LEXERR && zleparse);
+	popheap();
+	strinend();
+	inpop();
+	errflag = zleparse = 0;
+	lexrestore();
+    } LASTALLOC;
+    return s;
+}
+
+/**/
+void
+processcmd(void)
+{
+    char *s;
+    int m = zmult;
+
+    s = getcurcmd();
+    if (!s) {
+	feep();
+	return;
+    }
+    zmult = 1;
+    pushline();
+    zmult = m;
+    inststr(bindk->nam);
+    inststr(" ");
+    untokenize(s);
+    HEAPALLOC {
+	inststr(quotename(s, NULL, NULL, NULL));
+    } LASTALLOC;
+    zsfree(s);
+    done = 1;
+}
+
+/**/
+void
+expandcmdpath(void)
+{
+    int oldcs = cs, na = noaliases;
+    char *s, *str;
+
+    noaliases = 1;
+    s = getcurcmd();
+    noaliases = na;
+    if (!s || cmdwb < 0 || cmdwe < cmdwb) {
+	feep();
+	return;
+    }
+    str = findcmd(s);
+    zsfree(s);
+    if (!str) {
+	feep();
+	return;
+    }
+    cs = cmdwb;
+    foredel(cmdwe - cmdwb);
+    spaceinline(strlen(str));
+    strncpy((char *)line + cs, str, strlen(str));
+    cs = oldcs;
+    if (cs >= cmdwe - 1)
+	cs += cmdwe - cmdwb + strlen(str);
+    if (cs > ll)
+	cs = ll;
+    zsfree(str);
+}
+
+/* Extra function added by AR Iano-Fletcher. */
+/* This is a expand/complete in the vein of wash. */
+
+/**/
+void
+expandorcompleteprefix(void)
+{
+    comppref = 1;
+    expandorcomplete();
+    comppref = 0;
+}
diff --git a/Src/Zle/zle_utils.c b/Src/Zle/zle_utils.c
new file mode 100644
index 000000000..8fe3e7f0b
--- /dev/null
+++ b/Src/Zle/zle_utils.c
@@ -0,0 +1,650 @@
+/*
+ * zle_utils.c - miscellaneous line editor utilities
+ *
+ * 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 "zle.mdh"
+#include "zle_utils.pro"
+
+/* Primary cut buffer */
+
+/**/
+struct cutbuffer cutbuf;
+
+/* Emacs-style kill buffer ring */
+
+/**/
+struct cutbuffer kring[KRINGCT];
+/**/
+int kringnum;
+
+/* Vi named cut buffers.  0-25 are the named buffers "a to "z, and *
+ * 26-34 are the numbered buffer stack "1 to "9.                   */
+
+/**/
+struct cutbuffer vibuf[35];
+
+/* the line before last mod (for undo purposes) */
+
+/**/
+char *lastline;
+/**/
+int lastlinesz, lastll;
+
+/* size of line buffer */
+
+/**/
+int linesz;
+
+/* make sure that the line buffer has at least sz chars */
+
+/**/
+void
+sizeline(int sz)
+{
+    while (sz > linesz)
+	line = (unsigned char *)realloc(line, (linesz *= 4) + 2);
+}
+
+/* insert space for ct chars at cursor position */
+
+/**/
+void
+spaceinline(int ct)
+{
+    int i;
+
+    sizeline(ct + ll);
+    for (i = ll; --i >= cs;)
+	line[i + ct] = line[i];
+    ll += ct;
+    line[ll] = '\0';
+
+    if (mark > cs)
+	mark += ct;
+}
+
+/**/
+static void
+shiftchars(int to, int cnt)
+{
+    if (mark >= to + cnt)
+	mark -= cnt;
+    else if (mark > to)
+	mark = to;
+
+    while (to + cnt < ll) {
+	line[to] = line[to + cnt];
+	to++;
+    }
+    line[ll = to] = '\0';
+}
+
+/**/
+void
+backkill(int ct, int dir)
+{
+    int i = (cs -= ct);
+
+    cut(i, ct, dir);
+    shiftchars(i, ct);
+}
+
+/**/
+void
+forekill(int ct, int dir)
+{
+    int i = cs;
+
+    cut(i, ct, dir);
+    shiftchars(i, ct);
+}
+
+/**/
+void
+cut(int i, int ct, int dir)
+{
+    if (zmod.flags & MOD_VIBUF) {
+	struct cutbuffer *b = &vibuf[zmod.vibuf];
+
+	if (!(zmod.flags & MOD_VIAPP) || !b->buf) {
+	    zfree(b->buf, b->len);
+	    b->buf = (char *)zalloc(ct);
+	    memcpy(b->buf, (char *) line + i, ct);
+	    b->len = ct;
+	    b->flags = vilinerange ? CUTBUFFER_LINE : 0;
+	} else {
+	    int len = b->len;
+
+	    if(vilinerange)
+		b->flags |= CUTBUFFER_LINE;
+	    b->buf = realloc(b->buf, ct + len + !!(b->flags & CUTBUFFER_LINE));
+	    if (b->flags & CUTBUFFER_LINE)
+		b->buf[len++] = '\n';
+	    memcpy(b->buf + len, (char *) line + i, ct);
+	    b->len = len + ct;
+	}
+	return;
+    } else {
+	/* Save in "1, shifting "1-"8 along to "2-"9 */
+	int n;
+	zfree(vibuf[34].buf, vibuf[34].len);
+	for(n=34; n>26; n--)
+	    vibuf[n] = vibuf[n-1];
+	vibuf[26].buf = (char *)zalloc(ct);
+	memcpy(vibuf[26].buf, (char *) line + i, ct);
+	vibuf[26].len = ct;
+	vibuf[26].flags = vilinerange ? CUTBUFFER_LINE : 0;
+    }
+    if (!cutbuf.buf) {
+	cutbuf.buf = ztrdup("");
+	cutbuf.len = cutbuf.flags = 0;
+    } else if (!(lastcmd & ZLE_KILL)) {
+	kringnum = (kringnum + 1) % KRINGCT;
+	if (kring[kringnum].buf)
+	    free(kring[kringnum].buf);
+	kring[kringnum] = cutbuf;
+	cutbuf.buf = ztrdup("");
+	cutbuf.len = cutbuf.flags = 0;
+    }
+    if (dir) {
+	char *s = (char *)zalloc(cutbuf.len + ct);
+
+	memcpy(s, (char *) line + i, ct);
+	memcpy(s + ct, cutbuf.buf, cutbuf.len);
+	free(cutbuf.buf);
+	cutbuf.buf = s;
+	cutbuf.len += ct;
+    } else {
+	cutbuf.buf = realloc(cutbuf.buf, cutbuf.len + ct);
+	memcpy(cutbuf.buf + cutbuf.len, (char *) line + i, ct);
+	cutbuf.len += ct;
+    }
+    if(vilinerange)
+	cutbuf.flags |= CUTBUFFER_LINE;
+    else
+	cutbuf.flags &= ~CUTBUFFER_LINE;
+}
+
+/**/
+void
+backdel(int ct)
+{
+    shiftchars(cs -= ct, ct);
+}
+
+/**/
+void
+foredel(int ct)
+{
+    shiftchars(cs, ct);
+}
+
+/**/
+void
+setline(char const *s)
+{
+    sizeline(strlen(s));
+    strcpy((char *) line, s);
+    unmetafy((char *) line, &ll);
+    if ((cs = ll) && invicmdmode())
+	cs--;
+}
+
+/**/
+int
+findbol(void)
+{
+    int x = cs;
+
+    while (x > 0 && line[x - 1] != '\n')
+	x--;
+    return x;
+}
+
+/**/
+int
+findeol(void)
+{
+    int x = cs;
+
+    while (x != ll && line[x] != '\n')
+	x++;
+    return x;
+}
+
+/**/
+void
+findline(int *a, int *b)
+{
+    *a = findbol();
+    *b = findeol();
+}
+
+/* Search for needle in haystack.  Haystack is a metafied string while *
+ * needle is unmetafied and len-long.  Start the search at position    *
+ * pos.  Search forward if dir > 0 otherwise search backward.          */
+
+/**/
+char *
+hstrnstr(char *haystack, int pos, char *needle, int len, int dir, int sens)
+{
+    char *s = haystack + pos;
+
+    if (dir > 0) {
+	while (*s) {
+	    if (metadiffer(s, needle, len) < sens)
+		return s;
+	    s += 1 + (*s == Meta);
+	}
+    } else {
+	for (;;) {
+	    if (metadiffer(s, needle, len) < sens)
+		return s;
+	    if (s == haystack)
+		break;
+	    s -= 1 + (s != haystack+1 && s[-2] == Meta);
+	}
+    }
+    return NULL;
+}
+
+/* Query the user, and return a single character response.  The *
+ * question is assumed to have been printed already, and the    *
+ * cursor is left immediately after the response echoed.        *
+ * (Might cause a problem if this takes it onto the next line.) *
+ * <Tab> is interpreted as 'y'; any other control character is  *
+ * interpreted as 'n'.  If there are any characters in the      *
+ * buffer, this is taken as a negative response, and no         *
+ * characters are read.  Case is folded.                        */
+
+/**/
+int
+getzlequery(void)
+{
+    int c;
+#ifdef FIONREAD
+    int val;
+
+    /* check for typeahead, which is treated as a negative response */
+    ioctl(SHTTY, FIONREAD, (char *)&val);
+    if (val) {
+	putc('n', shout);
+	return 'n';
+    }
+#endif
+
+    /* get a character from the tty and interpret it */
+    c = getkey(0);
+    if (c == '\t')
+	c = 'y';
+    else if (icntrl(c) || c == EOF)
+	c = 'n';
+    else
+	c = tulower(c);
+
+    /* echo response and return */
+    putc(c, shout);
+    return c;
+}
+
+/* Format a string, keybinding style. */
+
+/**/
+char *
+bindztrdup(char *str)
+{
+    int c, len = 1;
+    char *buf, *ptr, *ret;
+
+    for(ptr = str; *ptr; ptr++) {
+	c = *ptr == Meta ? STOUC(*++ptr) ^ 32 : STOUC(*ptr);
+	if(c & 0x80) {
+	    len += 3;
+	    c &= 0x7f;
+	}
+	if(c < 32 || c == 0x7f) {
+	    len++;
+	    c ^= 64;
+	}
+	len += c == '\\' || c == '^';
+	len++;
+    }
+    ptr = buf = zalloc(len);
+    for(; *str; str++) {
+	c = *str == Meta ? STOUC(*++str) ^ 32 : STOUC(*str);
+	if(c & 0x80) {
+	    *ptr++ = '\\';
+	    *ptr++ = 'M';
+	    *ptr++ = '-';
+	    c &= 0x7f;
+	}
+	if(c < 32 || c == 0x7f) {
+	    *ptr++ = '^';
+	    c ^= 64;
+	}
+	if(c == '\\' || c == '^')
+	    *ptr++ = '\\';
+	*ptr++ = c;
+    }
+    *ptr = 0;
+    ret = dquotedztrdup(buf);
+    zsfree(buf);
+    return ret;
+}
+
+/* Display a metafied string, keybinding-style. */
+
+/**/
+int
+printbind(char *str, FILE *stream)
+{
+    char *b = bindztrdup(str);
+    int ret = zputs(b, stream);
+
+    zsfree(b);
+    return ret;
+}
+
+/* Display a message where the completion list normally goes. *
+ * The message must be metafied.                              */
+
+/**/
+void
+showmsg(char const *msg)
+{
+    char const *p;
+    int up = 0, cc = 0, c;
+
+    trashzle();
+    clearflag = isset(USEZLE) && !termflags && isset(ALWAYSLASTPROMPT);
+
+    for(p = msg; (c = *p); p++) {
+	if(c == Meta)
+	    c = *++p ^ 32;
+	if(c == '\n') {
+	    putc('\n', shout);
+	    up += 1 + cc / columns;
+	    cc = 0;
+	} else {
+	    char const *n = nicechar(c);
+	    fputs(n, shout);
+	    cc += strlen(n);
+	}
+    }
+    up += cc / columns;
+
+    if (clearflag) {
+	putc('\r', shout);
+	tcmultout(TCUP, TCMULTUP, up + nlnct);
+    } else
+	putc('\n', shout);
+    showinglist = 0;
+}
+
+/* handle the error flag */
+
+/**/
+void
+feep(void)
+{
+    feepflag = 1;
+}
+
+/**/
+void
+handlefeep(void)
+{
+    if(feepflag)
+	beep();
+    feepflag = 0;
+}
+
+/***************/
+/* undo system */
+/***************/
+
+/* head of the undo list, and the current position */
+
+static struct change *changes, *curchange;
+
+/* list of pending changes, not yet in the undo system */
+
+static struct change *nextchanges, *endnextchanges;
+
+/**/
+void
+initundo(void)
+{
+    nextchanges = NULL;
+    changes = curchange = zalloc(sizeof(*curchange));
+    curchange->prev = curchange->next = NULL;
+    curchange->del = curchange->ins = NULL;
+    lastline = zalloc(lastlinesz = linesz);
+    memcpy(lastline, line, lastll = ll);
+}
+
+/**/
+void
+freeundo(void)
+{
+    freechanges(changes);
+    freechanges(nextchanges);
+    zfree(lastline, lastlinesz);
+}
+
+/**/
+static void
+freechanges(struct change *p)
+{
+    struct change *n;
+
+    for(; p; p = n) {
+	n = p->next;
+	zsfree(p->del);
+	zsfree(p->ins);
+	zfree(p, sizeof(*p));
+    }
+}
+
+/* register pending changes in the undo system */
+
+/**/
+void
+handleundo(void)
+{
+    mkundoent();
+    if(!nextchanges)
+	return;
+    setlastline();
+    if(curchange->next) {
+	freechanges(curchange->next);
+	curchange->next = NULL;
+	zsfree(curchange->del);
+	zsfree(curchange->ins);
+	curchange->del = curchange->ins = NULL;
+    }
+    nextchanges->prev = curchange->prev;
+    if(curchange->prev)
+	curchange->prev->next = nextchanges;
+    else
+	changes = nextchanges;
+    curchange->prev = endnextchanges;
+    endnextchanges->next = curchange;
+    nextchanges = endnextchanges = NULL;
+}
+
+/* add an entry to the undo system, if anything has changed */
+
+/**/
+void
+mkundoent(void)
+{
+    int pre, suf;
+    int sh = ll < lastll ? ll : lastll;
+    struct change *ch;
+
+    if(lastll == ll && !memcmp(lastline, line, ll))
+	return;
+    for(pre = 0; pre < sh && line[pre] == lastline[pre]; )
+	pre++;
+    for(suf = 0; suf < sh - pre &&
+	line[ll - 1 - suf] == lastline[lastll - 1 - suf]; )
+	suf++;
+    ch = zalloc(sizeof(*ch));
+    ch->next = NULL;
+    ch->hist = histline;
+    ch->off = pre;
+    if(suf + pre == lastll)
+	ch->del = NULL;
+    else
+	ch->del = metafy(lastline + pre, lastll - pre - suf, META_DUP);
+    if(suf + pre == ll)
+	ch->ins = NULL;
+    else
+	ch->ins = metafy((char *)line + pre, ll - pre - suf, META_DUP);
+    if(nextchanges) {
+	ch->flags = CH_PREV;
+	ch->prev = endnextchanges;
+	endnextchanges->flags |= CH_NEXT;
+	endnextchanges->next = ch;
+    } else {
+	nextchanges = ch;
+	ch->flags = 0;
+	ch->prev = NULL;
+    }
+    endnextchanges = ch;
+}
+
+/* set lastline to match line */
+
+/**/
+void
+setlastline(void)
+{
+    if(lastlinesz != linesz)
+	lastline = realloc(lastline, lastlinesz = linesz);
+    memcpy(lastline, line, lastll = ll);
+}
+
+/* move backwards through the change list */
+
+/**/
+void
+undo(void)
+{
+    handleundo();
+    do {
+	if(!curchange->prev) {
+	    feep();
+	    return;
+	}
+	unapplychange(curchange = curchange->prev);
+    } while(curchange->flags & CH_PREV);
+    setlastline();
+}
+
+/**/
+static void
+unapplychange(struct change *ch)
+{
+    if(ch->hist != histline) {
+	remember_edits();
+	setline(zle_get_event(histline = ch->hist));
+    }
+    cs = ch->off;
+    if(ch->ins)
+	foredel(ztrlen(ch->ins));
+    if(ch->del) {
+	char *c = ch->del;
+
+	spaceinline(ztrlen(c));
+	for(; *c; c++)
+	    if(*c == Meta)
+		line[cs++] = STOUC(*++c) ^ 32;
+	    else
+		line[cs++] = STOUC(*c);
+    }
+}
+
+/* move forwards through the change list */
+
+/**/
+void
+redo(void)
+{
+    handleundo();
+    do {
+	if(!curchange->next) {
+	    feep();
+	    return;
+	}
+	applychange(curchange);
+	curchange = curchange->next;
+    } while(curchange->prev->flags & CH_NEXT);
+    setlastline();
+}
+
+/**/
+static void
+applychange(struct change *ch)
+{
+    if(ch->hist != histline) {
+	remember_edits();
+	setline(zle_get_event(histline = ch->hist));
+    }
+    cs = ch->off;
+    if(ch->del)
+	foredel(ztrlen(ch->del));
+    if(ch->ins) {
+	char *c = ch->ins;
+
+	spaceinline(ztrlen(c));
+	for(; *c; c++)
+	    if(*c == Meta)
+		line[cs++] = STOUC(*++c) ^ 32;
+	    else
+		line[cs++] = STOUC(*c);
+    }
+}
+
+/* vi undo: toggle between the end of the undo list and the preceding point */
+
+/**/
+void
+viundochange(void)
+{
+    handleundo();
+    if(curchange->next) {
+	do {
+	    applychange(curchange);
+	    curchange = curchange->next;
+	} while(curchange->next);
+	setlastline();
+    } else
+	undo();
+}
diff --git a/Src/Zle/zle_vi.c b/Src/Zle/zle_vi.c
new file mode 100644
index 000000000..a599d8091
--- /dev/null
+++ b/Src/Zle/zle_vi.c
@@ -0,0 +1,925 @@
+/*
+ * zle_vi.c - vi-specific functions
+ *
+ * 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 "zle.mdh"
+#include "zle_vi.pro"
+
+/* != 0 if we're getting a vi range */
+
+/**/
+int virangeflag;
+
+/* kludge to get cw and dw to work right */
+
+/**/
+int wordflag;
+
+/* != 0 if we're killing lines into a buffer, vi-style */
+
+/**/
+int vilinerange;
+
+/* last vi change buffer, for vi change repetition */
+
+/**/
+int vichgbufsz, vichgbufptr, vichgflag;
+
+/**/
+char *vichgbuf;
+
+/* point where vi insert mode was last entered */
+
+/**/
+int viinsbegin;
+
+static struct modifier lastmod;
+static int inrepeat, vichgrepeat;
+
+/**/
+static void
+startvichange(int im)
+{
+    if (im != -1) {
+	insmode = im;
+	vichgflag = 1;
+    }
+    if (inrepeat) {
+	zmod = lastmod;
+	inrepeat = vichgflag = 0;
+	vichgrepeat = 1;
+    } else {
+	lastmod = zmod;
+	if (vichgbuf)
+	    free(vichgbuf);
+	vichgbuf = (char *)zalloc(vichgbufsz = 16);
+	vichgbuf[0] = c;
+	vichgbufptr = 1;
+	vichgrepeat = 0;
+    }
+}
+
+/**/
+static void
+startvitext(int im)
+{
+    startvichange(im);
+    selectkeymap("main", 1);
+    undoing = 0;
+    viinsbegin = cs;
+}
+
+/**/
+int
+vigetkey(void)
+{
+    Keymap mn = openkeymap("main");
+    char m[3], *str;
+    Thingy cmd;
+
+    if((c = getkey(0)) == EOF) {
+	feep();
+	return -1;
+    }
+
+    m[0] = c;
+    metafy(m, 1, META_NOALLOC);
+    if(mn)
+	cmd = keybind(mn, m, &str);
+    else
+	cmd = t_undefinedkey;
+
+    if (!cmd || cmd == Th(z_sendbreak)) {
+	feep();
+	return -1;
+    } else if (cmd == Th(z_quotedinsert)) {
+	if ((c = getkey(0)) == EOF) {
+	    feep();
+	    return -1;
+	}
+    } else if(cmd == Th(z_viquotedinsert)) {
+	char sav = line[cs];
+
+	line[cs] = '^';
+	refresh();
+	c = getkey(0);
+	line[cs] = sav;
+	if(c == EOF) {
+	    feep();
+	    return -1;
+	}
+    } else if (cmd == Th(z_vicmdmode))
+	return -1;
+    return c;
+}
+
+/**/
+static int
+getvirange(int wf)
+{
+    int pos = cs;
+    int mult1 = zmult, hist1 = histline;
+    Thingy k2;
+
+    virangeflag = 1;
+    wordflag = wf;
+    /* Now we need to execute the movement command, to see where it *
+     * actually goes.  virangeflag here indicates to the movement   *
+     * function that it should place the cursor at the end of the   *
+     * range, rather than where the cursor would actually go if it  *
+     * were executed normally.  This makes a difference to some     *
+     * commands, but not all.  For example, if searching forward    *
+     * for a character, under normal circumstances the cursor lands *
+     * on the character.  For a range, the range must include the   *
+     * character, so the cursor gets placed after the character if  *
+     * virangeflag is set.  vi-match-bracket needs to change the    *
+     * value of virangeflag under some circumstances, meaning that  *
+     * we need to change the *starting* position.                   */
+    zmod.flags &= ~MOD_TMULT;
+    do {
+	vilinerange = 0;
+	prefixflag = 0;
+	if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) ||
+		k2 == Th(z_sendbreak)) {
+	    wordflag = 0;
+	    virangeflag = 0;
+	    feep();
+	    return -1;
+	}
+	if(k2 == bindk)
+	    /* The command key is repeated: a number of lines is used. */
+	    dovilinerange();
+	else
+	    execzlefunc(k2);
+	if(vichgrepeat)
+	    zmult = mult1;
+	else
+	    zmult = mult1 * zmod.tmult;
+    } while(prefixflag);
+    wordflag = 0;
+    virangeflag = 0;
+
+    /* It is an error to use a non-movement command to delimit the *
+     * range.  We here reject the case where the command modified  *
+     * the line, or selected a different history line.             */
+    if(histline != hist1 || ll != lastll || memcmp(line, lastline, ll)) {
+	histline = hist1;
+	memcpy(line, lastline, ll = lastll);
+	cs = pos;
+	feep();
+	return -1;
+    }
+
+    /* Can't handle an empty file.  Also, if the movement command *
+     * failed, or didn't move, it is an error.                    */
+    if (!ll || (cs == pos && virangeflag != 2)) {
+	feep();
+	return -1;
+    }
+
+    /* vi-match-bracket changes the value of virangeflag when *
+     * moving to the opening bracket, meaning that we need to *
+     * change the *starting* position.                        */
+    if(virangeflag == -1)
+	pos++;
+
+    /* Get the range the right way round.  cs is placed at the *
+     * start of the range, and pos (the return value of this   *
+     * function) is the end.                                   */
+    if (cs > pos) {
+	int tmp = cs;
+	cs = pos;
+	pos = tmp;
+    }
+
+    /* Was it a line-oriented move?  If so, the command will have set *
+     * the vilinerange flag.  In this case, entire lines are taken,   *
+     * rather than just the sequence of characters delimited by pos   *
+     * and cs.  The terminating newline is left out of the range,     *
+     * which the real command must deal with appropriately.  At this  *
+     * point we just need to make the range encompass entire lines.   */
+    if(vilinerange) {
+	int newcs = findbol();
+	cs = pos;
+	pos = findeol();
+	cs = newcs;
+    }
+    return pos;
+}
+
+/**/
+static void
+dovilinerange(void)
+{
+    int pos = cs, n = zmult;
+
+    /* A number of lines is taken as the range.  The current line *
+     * is included.  If the repeat count is positive the lines go *
+     * downward, otherwise upward.  The repeat count gives the    *
+     * number of lines.                                           */
+    vilinerange = 1;
+    if (!n) {
+	feep();
+	return;
+    }
+    if (n > 0) {
+	while(n-- && cs <= ll)
+	    cs = findeol() + 1;
+	if (n != -1) {
+	    cs = pos;
+	    feep();
+	    return;
+	}
+	cs--;
+    } else {
+	while(n++ && cs >= 0)
+	    cs = findbol() - 1;
+	if (n != 1) {
+	    cs = pos;
+	    feep();
+	    return;
+	}
+	cs++;
+    }
+    virangeflag = 2;
+}
+
+/**/
+void
+viaddnext(void)
+{
+    if (cs != findeol())
+	cs++;
+    startvitext(1);
+}
+
+/**/
+void
+viaddeol(void)
+{
+    cs = findeol();
+    startvitext(1);
+}
+
+/**/
+void
+viinsert(void)
+{
+    startvitext(1);
+}
+
+/**/
+void
+viinsertbol(void)
+{
+    vifirstnonblank();
+    startvitext(1);
+}
+
+/**/
+void
+videlete(void)
+{
+    int c2;
+
+    startvichange(1);
+    if ((c2 = getvirange(0)) != -1) {
+	forekill(c2 - cs, 0);
+	if (vilinerange && ll) {
+	    if (cs == ll)
+		cs--;
+	    foredel(1);
+	    vifirstnonblank();
+	}
+    }
+    vichgflag = 0;
+}
+
+/**/
+void
+videletechar(void)
+{
+    int n = zmult;
+
+    startvichange(-1);
+    /* handle negative argument */
+    if (n < 0) {
+	zmult = -n;
+	vibackwarddeletechar();
+	zmult = n;
+	return;
+    }
+    /* it is an error to be on the end of line */
+    if (cs == ll || line[cs] == '\n') {
+	feep();
+	return;
+    }
+    /* Put argument into the acceptable range -- it is not an error to  *
+     * specify a greater count than the number of available characters. */
+    if (n > findeol() - cs)
+	n = findeol() - cs;
+    /* do the deletion */
+    forekill(n, 0);
+}
+
+/**/
+void
+vichange(void)
+{
+    int c2;
+
+    startvichange(1);
+    if ((c2 = getvirange(1)) != -1) {
+	forekill(c2 - cs, 0);
+	selectkeymap("main", 1);
+	viinsbegin = cs;
+	undoing = 0;
+    }
+}
+
+/**/
+void
+visubstitute(void)
+{
+    int n = zmult;
+
+    startvichange(1);
+    if (n < 0) {
+	feep();
+	return;
+    }
+    /* it is an error to be on the end of line */
+    if (cs == ll || line[cs] == '\n') {
+	feep();
+	return;
+    }
+    /* Put argument into the acceptable range -- it is not an error to  *
+     * specify a greater count than the number of available characters. */
+    if (n > findeol() - cs)
+	n = findeol() - cs;
+    /* do the substitution */
+    forekill(n, 0);
+    startvitext(1);
+}
+
+/**/
+void
+vichangeeol(void)
+{
+    forekill(findeol() - cs, 0);
+    startvitext(1);
+}
+
+/**/
+void
+vichangewholeline(void)
+{
+    vifirstnonblank();
+    vichangeeol();
+}
+
+/**/
+void
+viyank(void)
+{
+    int oldcs = cs, c2;
+
+    startvichange(1);
+    if ((c2 = getvirange(0)) != -1)
+	cut(cs, c2 - cs, 0);
+    vichgflag = 0;
+    cs = oldcs;
+}
+
+/**/
+void
+viyankeol(void)
+{
+    int x = findeol();
+
+    startvichange(-1);
+    if (x == cs) {
+	feep();
+	return;
+    }
+    cut(cs, x - cs, 0);
+}
+
+/**/
+void
+viyankwholeline(void)
+{
+    int bol = findbol(), oldcs = cs;
+    int n = zmult;
+
+    startvichange(-1);
+    if (n < 1)
+	return;
+    while(n--) {
+     if (cs > ll) {
+	feep();
+	cs = oldcs;
+	return;
+     }
+     cs = findeol() + 1;
+    }
+    vilinerange = 1;
+    cut(bol, cs - bol - 1, 0);
+    cs = oldcs;
+}
+
+/**/
+void
+vireplace(void)
+{
+    startvitext(0);
+}
+
+/* vi-replace-chars has some oddities relating to vi-repeat-change.  In *
+ * the real vi, if one does 3r at the end of a line, it feeps without   *
+ * reading the argument, and won't repeat the action.  A successful rx  *
+ * followed by 3. at the end of a line (or 3rx followed by . at the end *
+ * of a line) will obviously feep after the ., even though it has the   *
+ * argument available.  Here repeating is tied very closely to argument *
+ * reading, so some trickery is needed to emulate this.  When repeating *
+ * a change, we always read the argument normally, even if the count    *
+ * was bad.  When recording a change for repeating, and a bad count is  *
+ * given, we squash the repeat buffer to avoid repeating the partial    *
+ * command; we've lost the previous change, but that can't be avoided   *
+ * without a rewrite of the repeat code.                                */
+
+/**/
+void
+vireplacechars(void)
+{
+    int ch, n = zmult;
+
+    startvichange(1);
+    /* check argument range */
+    if (n < 1 || n + cs > findeol()) {
+	if(vichgrepeat) {
+	    int ofeep = feepflag;
+	    vigetkey();
+	    feepflag = ofeep;
+	}
+	if(vichgflag) {
+	    free(vichgbuf);
+	    vichgbuf = NULL;
+	    vichgflag = 0;
+	}
+	feep();
+	return;
+    }
+    /* get key */
+    if((ch = vigetkey()) == -1) {
+	vichgflag = 0;
+	feep();
+	return;
+    }
+    /* do change */
+    if (ch == '\r' || ch == '\n') {
+	/* <return> handled specially */
+	cs += n - 1;
+	backkill(n - 1, 0);
+	line[cs++] = '\n';
+    } else {
+	while (n--)
+	    line[cs++] = ch;
+	cs--;
+    }
+    vichgflag = 0;
+}
+
+/**/
+void
+vicmdmode(void)
+{
+    if (invicmdmode() || selectkeymap("vicmd", 0))
+	feep();
+    undoing = 1;
+    vichgflag = 0;
+    if (cs != findbol())
+	cs--;
+}
+
+/**/
+void
+viopenlinebelow(void)
+{
+    cs = findeol();
+    spaceinline(1);
+    line[cs++] = '\n';
+    startvitext(1);
+}
+
+/**/
+void
+viopenlineabove(void)
+{
+    cs = findbol();
+    spaceinline(1);
+    line[cs] = '\n';
+    startvitext(1);
+}
+
+/**/
+void
+vioperswapcase(void)
+{
+    int oldcs, c2;
+
+    /* get the range */
+    startvichange(1);
+    if ((c2 = getvirange(0)) != -1) {
+	oldcs = cs;
+	/* swap the case of all letters within range */
+	while (cs < c2) {
+	    if (islower(line[cs]))
+		line[cs] = tuupper(line[cs]);
+	    else if (isupper(line[cs]))
+		line[cs] = tulower(line[cs]);
+	    cs++;
+	}
+	/* go back to the first line of the range */
+	cs = oldcs;
+	vifirstnonblank();
+    }
+    vichgflag = 0;
+}
+
+/**/
+void
+virepeatchange(void)
+{
+    /* make sure we have a change to repeat */
+    if (!vichgbuf || vichgflag) {
+	feep();
+	return;
+    }
+    /* restore or update the saved count and buffer */
+    if (zmod.flags & MOD_MULT) {
+	lastmod.mult = zmod.mult;
+	lastmod.flags |= MOD_MULT;
+    }
+    if (zmod.flags & MOD_VIBUF) {
+	lastmod.vibuf = zmod.vibuf;
+	lastmod.flags = (lastmod.flags & ~MOD_VIAPP) |
+	    MOD_VIBUF | (zmod.flags & MOD_VIAPP);
+    }
+    /* repeat the command */
+    inrepeat = 1;
+    ungetkeys(vichgbuf, vichgbufptr);
+}
+
+/**/
+void
+viindent(void)
+{
+    int oldcs = cs, c2;
+
+    /* get the range */
+    startvichange(1);
+    if ((c2 = getvirange(0)) == -1) {
+	vichgflag = 0;
+	return;
+    }
+    vichgflag = 0;
+    /* must be a line range */
+    if (!vilinerange) {
+	feep();
+	cs = oldcs;
+	return;
+    }
+    oldcs = cs;
+    /* add a tab to the beginning of each line within range */
+    while (cs < c2) {
+	spaceinline(1);
+	line[cs] = '\t';
+	cs = findeol() + 1;
+    }
+    /* go back to the first line of the range */
+    cs = oldcs;
+    vifirstnonblank();
+}
+
+/**/
+void
+viunindent(void)
+{
+    int oldcs = cs, c2;
+
+    /* get the range */
+    startvichange(1);
+    if ((c2 = getvirange(0)) == -1) {
+	vichgflag = 0;
+	return;
+    }
+    vichgflag = 0;
+    /* must be a line range */
+    if (!vilinerange) {
+	feep();
+	cs = oldcs;
+	return;
+    }
+    oldcs = cs;
+    /* remove a tab from the beginning of each line within range */
+    while (cs < c2) {
+	if (line[cs] == '\t')
+	    foredel(1);
+	cs = findeol() + 1;
+    }
+    /* go back to the first line of the range */
+    cs = oldcs;
+    vifirstnonblank();
+}
+
+/**/
+void
+vibackwarddeletechar(void)
+{
+    int n = zmult;
+
+    if (invicmdmode())
+	startvichange(-1);
+    /* handle negative argument */
+    if (n < 0) {
+	zmult = -n;
+	videletechar();
+	zmult = n;
+	return;
+    }
+    /* It is an error to be at the beginning of the line, or (in *
+     * insert mode) to delete past the beginning of insertion.   */
+    if ((!invicmdmode() && cs - n < viinsbegin) || cs == findbol()) {
+	feep();
+	return;
+    }
+    /* Put argument into the acceptable range -- it is not an error to  *
+     * specify a greater count than the number of available characters. */
+    if (n > cs - findbol())
+	n = cs - findbol();
+    /* do the deletion */
+    backkill(n, 1);
+}
+
+/**/
+void
+vikillline(void)
+{
+    if (viinsbegin > cs) {
+	feep();
+	return;
+    }
+    backdel(cs - viinsbegin);
+}
+
+/**/
+void
+viputbefore(void)
+{
+    Cutbuffer buf = &cutbuf;
+    int n = zmult;
+
+    startvichange(-1);
+    if (n < 0)
+	return;
+    if (zmod.flags & MOD_VIBUF)
+	buf = &vibuf[zmod.vibuf];
+    if (!buf->buf) {
+	feep();
+	return;
+    }
+    if(buf->flags & CUTBUFFER_LINE) {
+	cs = findbol();
+	spaceinline(buf->len + 1);
+	memcpy((char *)line + cs, buf->buf, buf->len);
+	line[cs + buf->len] = '\n';
+	vifirstnonblank();
+    } else {
+	while (n--) {
+	    spaceinline(buf->len);
+	    memcpy((char *)line + cs, buf->buf, buf->len);
+	    cs += buf->len;
+	}
+	if (cs)
+	    cs--;
+    }
+}
+
+/**/
+void
+viputafter(void)
+{
+    Cutbuffer buf = &cutbuf;
+    int n = zmult;
+
+    startvichange(-1);
+    if (n < 0)
+	return;
+    if (zmod.flags & MOD_VIBUF)
+	buf = &vibuf[zmod.vibuf];
+    if (!buf->buf) {
+	feep();
+	return;
+    }
+    if(buf->flags & CUTBUFFER_LINE) {
+	cs = findeol();
+	spaceinline(buf->len + 1);
+	line[cs++] = '\n';
+	memcpy((char *)line + cs, buf->buf, buf->len);
+	vifirstnonblank();
+    } else {
+	if (cs != findeol())
+	    cs++;
+	while (n--) {
+	    spaceinline(buf->len);
+	    memcpy((char *)line + cs, buf->buf, buf->len);
+	    cs += buf->len;
+	}
+	if (cs)
+	    cs--;
+    }
+
+}
+
+/**/
+void
+vijoin(void)
+{
+    int x;
+
+    startvichange(-1);
+    if ((x = findeol()) == ll) {
+	feep();
+	return;
+    }
+    cs = x + 1;
+    for (x = 1; cs != ll && iblank(line[cs]); cs++, x++);
+    backdel(x);
+    if (cs && iblank(line[cs-1]))
+	cs--;
+    else {
+	spaceinline(1);
+	line[cs] = ' ';
+    }
+}
+
+/**/
+void
+viswapcase(void)
+{
+    int eol, n = zmult;
+
+    startvichange(-1);
+    if (n < 1)
+	return;
+    eol = findeol();
+    while (cs < eol && n--) {
+	if (islower(line[cs]))
+	    line[cs] = tuupper(line[cs]);
+	else if (isupper(line[cs]))
+	    line[cs] = tulower(line[cs]);
+	cs++;
+    }
+    if (cs && cs == eol)
+	cs--;
+}
+
+/**/
+void
+vicapslockpanic(void)
+{
+    beep();
+    statusline = "press a lowercase key to continue";
+    statusll = strlen(statusline);
+    refresh();
+    while (!islower(getkey(0)));
+    statusline = NULL;
+}
+
+/**/
+void
+visetbuffer(void)
+{
+    int ch;
+
+    if ((zmod.flags & MOD_VIBUF) ||
+	(((ch = getkey(0)) < '1' || ch > '9') &&
+	 (ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z'))) {
+	feep();
+	return;
+    }
+    if (ch >= 'A' && ch <= 'Z')	/* needed in cut() */
+	zmod.flags |= MOD_VIAPP;
+    else
+	zmod.flags &= ~MOD_VIAPP;
+    zmod.vibuf = tulower(ch) + (idigit(ch) ? -'1' + 26 : -'a');
+    zmod.flags |= MOD_VIBUF;
+    prefixflag = 1;
+}
+
+/**/
+void
+vikilleol(void)
+{
+    int n = findeol() - cs;
+
+    startvichange(-1);
+    if (!n) {
+	/* error -- line already empty */
+	feep();
+	return;
+    }
+    /* delete to end of line */
+    forekill(findeol() - cs, 0);
+}
+
+/**/
+void
+vipoundinsert(void)
+{
+    int oldcs = cs;
+
+    startvichange(-1);
+    vifirstnonblank();
+    if(line[cs] != '#') {
+	spaceinline(1);
+	line[cs] = '#';
+	if(cs <= viinsbegin)
+	    viinsbegin++;
+	cs = oldcs + (cs <= oldcs);
+    } else {
+	foredel(1);
+	if (cs < viinsbegin)
+	    viinsbegin--;
+	cs = oldcs - (cs < oldcs);
+    }
+}
+
+/**/
+void
+viquotedinsert(void)
+{
+#ifndef HAS_TIO
+    struct sgttyb sob;
+#endif
+
+    spaceinline(1);
+    line[cs] = '^';
+    refresh();
+#ifndef HAS_TIO
+    sob = shttyinfo.sgttyb;
+    sob.sg_flags = (sob.sg_flags | RAW) & ~ECHO;
+    ioctl(SHTTY, TIOCSETN, &sob);
+#endif
+    c = getkey(0);
+#ifndef HAS_TIO
+    setterm();
+#endif
+    foredel(1);
+    if(c < 0)
+	feep();
+    else
+	selfinsert();
+}
+
+/* the 0 key in vi: continue a repeat count in the manner of      *
+ * digit-argument if possible, otherwise do vi-beginning-of-line. */
+
+/**/
+void
+vidigitorbeginningofline(void)
+{
+    if(zmod.flags & MOD_TMULT)
+	digitargument();
+    else {
+	removesuffix();
+	invalidatelist();
+	vibeginningofline();
+    }
+}
diff --git a/Src/Zle/zle_widget.sed b/Src/Zle/zle_widget.sed
new file mode 100644
index 000000000..635322b42
--- /dev/null
+++ b/Src/Zle/zle_widget.sed
@@ -0,0 +1,7 @@
+/^ *W(/{
+    s/[^,]*, *t_/    wi_/
+    s/ *,.*/,/
+    P
+    s/    wi_\(.*\),/#define w_\1 (\&widgets[wi_\1])/
+    P
+}
diff --git a/Src/Zle/zle_word.c b/Src/Zle/zle_word.c
new file mode 100644
index 000000000..923216ef8
--- /dev/null
+++ b/Src/Zle/zle_word.c
@@ -0,0 +1,477 @@
+/*
+ * zle_word.c - word-related editor functions
+ *
+ * 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 "zle.mdh"
+#include "zle_word.pro"
+
+/**/
+void
+forwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs != ll && iword(line[cs]))
+	    cs++;
+	if (wordflag && !n)
+	    return;
+	while (cs != ll && !iword(line[cs]))
+	    cs++;
+    }
+}
+
+/**/
+void
+viforwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (iident(line[cs]))
+	    while (cs != ll && iident(line[cs]))
+		cs++;
+	else
+	    while (cs != ll && !iident(line[cs]) && !iblank(line[cs]))
+		cs++;
+	if (wordflag && !n)
+	    return;
+	while (cs != ll && iblank(line[cs]))
+	    cs++;
+    }
+}
+
+/**/
+void
+viforwardblankword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	vibackwardblankword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs != ll && !iblank(line[cs]))
+	    cs++;
+	if (wordflag && !n)
+	    return;
+	while (cs != ll && iblank(line[cs]))
+	    cs++;
+    }
+}
+
+/**/
+void
+emacsforwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	emacsbackwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs != ll && !iword(line[cs]))
+	    cs++;
+	if (wordflag && !n)
+	    return;
+	while (cs != ll && iword(line[cs]))
+	    cs++;
+    }
+}
+
+/**/
+void
+viforwardblankwordend(void)
+{
+    int n = zmult;
+
+    if (n < 0)
+	return;
+    while (n--) {
+	while (cs != ll && iblank(line[cs + 1]))
+	    cs++;
+	while (cs != ll && !iblank(line[cs + 1]))
+	    cs++;
+    }
+    if (cs != ll && virangeflag)
+	cs++;
+}
+
+/**/
+void
+viforwardwordend(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	if (iblank(line[cs + 1]))
+	    while (cs != ll && iblank(line[cs + 1]))
+		cs++;
+	if (iident(line[cs + 1]))
+	    while (cs != ll && iident(line[cs + 1]))
+		cs++;
+	else
+	    while (cs != ll && !iident(line[cs + 1]) && !iblank(line[cs + 1]))
+		cs++;
+    }
+    if (cs != ll && virangeflag)
+	cs++;
+}
+
+/**/
+void
+backwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	forwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs && !iword(line[cs - 1]))
+	    cs--;
+	while (cs && iword(line[cs - 1]))
+	    cs--;
+    }
+}
+
+/**/
+void
+vibackwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs && iblank(line[cs - 1]))
+	    cs--;
+	if (iident(line[cs - 1]))
+	    while (cs && iident(line[cs - 1]))
+		cs--;
+	else
+	    while (cs && !iident(line[cs - 1]) && !iblank(line[cs - 1]))
+		cs--;
+    }
+}
+
+/**/
+void
+vibackwardblankword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	viforwardblankword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs && iblank(line[cs - 1]))
+	    cs--;
+	while (cs && !iblank(line[cs - 1]))
+	    cs--;
+    }
+}
+
+/**/
+void
+emacsbackwardword(void)
+{
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	emacsforwardword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (cs && !iword(line[cs - 1]))
+	    cs--;
+	while (cs && iword(line[cs - 1]))
+	    cs--;
+    }
+}
+
+/**/
+void
+backwarddeleteword(void)
+{
+    int x = cs, n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	deleteword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (x && !iword(line[x - 1]))
+	    x--;
+	while (x && iword(line[x - 1]))
+	    x--;
+    }
+    backdel(cs - x);
+}
+
+/**/
+void
+vibackwardkillword(void)
+{
+    int x = cs, lim = (viinsbegin > findbol()) ? viinsbegin : findbol();
+    int n = zmult;
+
+    if (n < 0) {
+	feep();
+	return;
+    }
+/* this taken from "vibackwardword" */
+    while (n--) {
+	while ((x > lim) && iblank(line[x - 1]))
+	    x--;
+	if (iident(line[x - 1]))
+	    while ((x > lim) && iident(line[x - 1]))
+		x--;
+	else
+	    while ((x > lim) && !iident(line[x - 1]) && !iblank(line[x - 1]))
+		x--;
+    }
+    backkill(cs - x, 1);
+}
+
+/**/
+void
+backwardkillword(void)
+{
+    int x = cs;
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	killword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (x && !iword(line[x - 1]))
+	    x--;
+	while (x && iword(line[x - 1]))
+	    x--;
+    }
+    backkill(cs - x, 1);
+}
+
+/**/
+void
+upcaseword(void)
+{
+    int n = zmult;
+    int neg = n < 0, ocs = cs;
+
+    if (neg)
+	n = -n;
+    while (n--) {
+	while (cs != ll && !iword(line[cs]))
+	    cs++;
+	while (cs != ll && iword(line[cs])) {
+	    line[cs] = tuupper(line[cs]);
+	    cs++;
+	}
+    }
+    if (neg)
+	cs = ocs;
+}
+
+/**/
+void
+downcaseword(void)
+{
+    int n = zmult;
+    int neg = n < 0, ocs = cs;
+
+    if (neg)
+	n = -n;
+    while (n--) {
+	while (cs != ll && !iword(line[cs]))
+	    cs++;
+	while (cs != ll && iword(line[cs])) {
+	    line[cs] = tulower(line[cs]);
+	    cs++;
+	}
+    }
+    if (neg)
+	cs = ocs;
+}
+
+/**/
+void
+capitalizeword(void)
+{
+    int first, n = zmult;
+    int neg = n < 0, ocs = cs;
+
+    if (neg)
+	n = -n;
+    while (n--) {
+	first = 1;
+	while (cs != ll && !iword(line[cs]))
+	    cs++;
+	while (cs != ll && iword(line[cs]) && !isalpha(line[cs]))
+	    cs++;
+	while (cs != ll && iword(line[cs])) {
+	    line[cs] = (first) ? tuupper(line[cs]) : tulower(line[cs]);
+	    first = 0;
+	    cs++;
+	}
+    }
+    if (neg)
+	cs = ocs;
+}
+
+/**/
+void
+deleteword(void)
+{
+    int x = cs;
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwarddeleteword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (x != ll && !iword(line[x]))
+	    x++;
+	while (x != ll && iword(line[x]))
+	    x++;
+    }
+    foredel(x - cs);
+}
+
+/**/
+void
+killword(void)
+{
+    int x = cs;
+    int n = zmult;
+
+    if (n < 0) {
+	zmult = -n;
+	backwardkillword();
+	zmult = n;
+	return;
+    }
+    while (n--) {
+	while (x != ll && !iword(line[x]))
+	    x++;
+	while (x != ll && iword(line[x]))
+	    x++;
+    }
+    forekill(x - cs, 0);
+}
+
+/**/
+void
+transposewords(void)
+{
+    int p1, p2, p3, p4, x = cs;
+    char *temp, *pp;
+    int n = zmult;
+    int neg = n < 0, ocs = cs;
+
+    if (neg)
+	n = -n;
+    while (n--) {
+	while (x != ll && line[x] != '\n' && !iword(line[x]))
+	    x++;
+	if (x == ll || line[x] == '\n') {
+	    x = cs;
+	    while (x && line[x - 1] != '\n' && !iword(line[x]))
+		x--;
+	    if (!x || line[x - 1] == '\n') {
+		feep();
+		return;
+	    }
+	}
+	for (p4 = x; p4 != ll && iword(line[p4]); p4++);
+	for (p3 = p4; p3 && iword(line[p3 - 1]); p3--);
+	if (!p3) {
+	    feep();
+	    return;
+	}
+	for (p2 = p3; p2 && !iword(line[p2 - 1]); p2--);
+	if (!p2) {
+	    feep();
+	    return;
+	}
+	for (p1 = p2; p1 && iword(line[p1 - 1]); p1--);
+	pp = temp = (char *)halloc(p4 - p1 + 1);
+	struncpy(&pp, (char *) line + p3, p4 - p3);
+	struncpy(&pp, (char *) line + p2, p3 - p2);
+	struncpy(&pp, (char *) line + p1, p2 - p1);
+	strncpy((char *)line + p1, temp, p4 - p1);
+	cs = p4;
+    }
+    if (neg)
+	cs = ocs;
+}
diff --git a/Src/ansi2knr.c b/Src/ansi2knr.c
new file mode 100644
index 000000000..e5502a7e6
--- /dev/null
+++ b/Src/ansi2knr.c
@@ -0,0 +1,413 @@
+/* Copyright (C) 1989, 1991, 1993, 1994 Aladdin Enterprises. All rights reserved. */
+
+/* ansi2knr.c */
+/* Convert ANSI function declarations to K&R syntax */
+
+/*
+ansi2knr is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
+to anyone for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.  Refer
+to the GNU General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute
+ansi2knr, but only under the conditions described in the GNU
+General Public License.  A copy of this license is supposed to have been
+given to you along with ansi2knr so you can know your rights and
+responsibilities.  It should be in a file named COPYING.  Among other
+things, the copyright notice and this notice must be preserved on all
+copies.
+*/
+
+/*
+ * Usage:
+	ansi2knr input_file [output_file]
+ * If no output_file is supplied, output goes to stdout.
+ * There are no error messages.
+ *
+ * ansi2knr recognizes function definitions by seeing a non-keyword
+ * identifier at the left margin, followed by a left parenthesis,
+ * with a right parenthesis as the last character on the line.
+ * It will recognize a multi-line header provided that the last character
+ * of the last line of the header is a right parenthesis,
+ * and no intervening line ends with a left brace or a semicolon.
+ * These algorithms ignore whitespace and comments, except that
+ * the function name must be the first thing on the line.
+ * The following constructs will confuse it:
+ *	- Any other construct that starts at the left margin and
+ *	    follows the above syntax (such as a macro or function call).
+ *	- Macros that tinker with the syntax of the function header.
+ */
+
+/*
+ * Change history:
+	lpd 89-xx-xx original version
+	lpd 94-07-16 added some conditionals to help GNU `configure',
+		suggested by Francois Pinard <pinard@iro.umontreal.ca>;
+		properly erase prototype args in function parameters,
+		contributed by Jim Avera <jima@netcom.com>;
+		correct error in writeblanks (it shouldn't erase EOLs)
+ */
+
+/* Most of the conditionals here are to make ansi2knr work with */
+/* the GNU configure machinery. */
+
+#ifdef HAVE_CONFIG_H
+# ifdef CONFIG_BROKETS
+/*
+   We use <config.h> instead of "config.h" so that a compilation
+   using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
+   (which it would do because it found this file in $srcdir).
+ */
+#  include <config.h>
+# else
+#  include "config.h"
+# endif
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+
+#ifdef HAVE_CONFIG_H
+
+/*
+   For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
+   This will define HAVE_CONFIG_H and so, activate the following lines.
+ */
+
+# if STDC_HEADERS || HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+#else /* not HAVE_CONFIG_H */
+
+/*
+   Without AC_CONFIG_HEADER, merely use <string.h> as in the original
+   Ghostscript distribution.  This loses on older BSD systems.
+ */
+
+# include <string.h>
+
+#endif /* not HAVE_CONFIG_H */
+
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+#else
+/*
+   malloc and free should be declared in stdlib.h,
+   but if you've got a K&R compiler, they probably aren't.
+ */
+char *malloc();
+void free();
+#endif
+
+/* Scanning macros */
+#define isidchar(ch) (isalnum(ch) || (ch) == '_')
+#define isidfirstchar(ch) (isalpha(ch) || (ch) == '_')
+
+/* Forward references */
+char *skipspace();
+void writeblanks();
+int test1();
+int convert1();
+
+/* The main program */
+int
+main(argc, argv)
+    int argc;
+    char *argv[];
+{	FILE *in, *out;
+#define bufsize 5000			/* arbitrary size */
+	char *buf;
+	char *line;
+	switch ( argc )
+	   {
+	default:
+		printf("Usage: ansi2knr input_file [output_file]\n");
+		exit(0);
+	case 2:
+		out = stdout; break;
+	case 3:
+		out = fopen(argv[2], "w");
+		if ( out == NULL )
+		   {	fprintf(stderr, "Cannot open %s\n", argv[2]);
+			exit(1);
+		   }
+	   }
+	in = fopen(argv[1], "r");
+	if ( in == NULL )
+	   {	fprintf(stderr, "Cannot open %s\n", argv[1]);
+		exit(1);
+	   }
+	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
+	buf = malloc(bufsize);
+	line = buf;
+	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
+	   {	switch ( test1(buf) )
+		   {
+		case 2:			/* a function header */
+			convert1(buf, out, 1);
+			break;
+		case 1:			/* a function */
+			convert1(buf, out, 0);
+			break;
+		case -1:		/* maybe the start of a function */
+			line = buf + strlen(buf);
+			if ( line != buf + (bufsize - 1) ) /* overflow check */
+				continue;
+			/* falls through */
+		default:		/* not a function */
+			fputs(buf, out);
+			break;
+		   }
+		line = buf;
+	   }
+	if ( line != buf ) fputs(buf, out);
+	free(buf);
+	fclose(out);
+	fclose(in);
+	return 0;
+}
+
+/* Skip over space and comments, in either direction. */
+char *
+skipspace(p, dir)
+    register char *p;
+    register int dir;			/* 1 for forward, -1 for backward */
+{	for ( ; ; )
+	   {	while ( isspace(*p) ) p += dir;
+		if ( !(*p == '/' && p[dir] == '*') ) break;
+		p += dir;  p += dir;
+		while ( !(*p == '*' && p[dir] == '/') )
+		   {	if ( *p == 0 ) return p;	/* multi-line comment?? */
+			p += dir;
+		   }
+		p += dir;  p += dir;
+	   }
+	return p;
+}
+
+/*
+ * Write blanks over part of a string.
+ * Don't overwrite end-of-line characters.
+ */
+void
+writeblanks(start, end)
+    char *start;
+    char *end;
+{	char *p;
+	for ( p = start; p < end; p++ )
+	  if ( *p != '\r' && *p != '\n' ) *p = ' ';
+}
+
+/*
+ * Test whether the string in buf is a function definition.
+ * The string may contain and/or end with a newline.
+ * Return as follows:
+ *	0 - definitely not a function definition;
+ *	1 - definitely a function definition;
+ *	2 - definitely a function prototype (NOT USED);
+ *	-1 - may be the beginning of a function definition,
+ *		append another line and look again.
+ * The reason we don't attempt to convert function prototypes is that
+ * Ghostscript's declaration-generating macros look too much like
+ * prototypes, and confuse the algorithms.
+ */
+int
+test1(buf)
+    char *buf;
+{	register char *p = buf;
+	char *bend;
+	char *endfn;
+	int contin;
+	if ( !isidfirstchar(*p) )
+		return 0;		/* no name at left margin */
+	bend = skipspace(buf + strlen(buf) - 1, -1);
+	switch ( *bend )
+	   {
+	case ';': contin = 0 /*2*/; break;
+	case ')': contin = 1; break;
+	case '{': return 0;		/* not a function */
+	default: contin = -1;
+	   }
+	while ( isidchar(*p) ) p++;
+	endfn = p;
+	p = skipspace(p, 1);
+	if ( *p++ != '(' )
+		return 0;		/* not a function */
+	p = skipspace(p, 1);
+	if ( *p == ')' )
+		return 0;		/* no parameters */
+	/* Check that the apparent function name isn't a keyword. */
+	/* We only need to check for keywords that could be followed */
+	/* by a left parenthesis (which, unfortunately, is most of them). */
+	   {	static char *words[] =
+		   {	"asm", "auto", "case", "char", "const", "double",
+			"extern", "float", "for", "if", "int", "long",
+			"register", "return", "short", "signed", "sizeof",
+			"static", "switch", "typedef", "unsigned",
+			"void", "volatile", "while", 0
+		   };
+		char **key = words;
+		char *kp;
+		int len = endfn - buf;
+		while ( (kp = *key) != 0 )
+		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
+				return 0;	/* name is a keyword */
+			key++;
+		   }
+	   }
+	return contin;
+}
+
+/* Convert a recognized function definition or header to K&R syntax. */
+int
+convert1(buf, out, header)
+    char *buf;
+    FILE *out;
+    int header;		/* Boolean */
+{	char *endfn;
+	register char *p;
+	char **breaks;
+	unsigned num_breaks = 2;	/* for testing */
+	char **btop;
+	char **bp;
+	char **ap;
+	/* Pre-ANSI implementations don't agree on whether strchr */
+	/* is called strchr or index, so we open-code it here. */
+	for ( endfn = buf; *(endfn++) != '('; ) ;
+top:	p = endfn;
+	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
+	if ( breaks == 0 )
+	   {	/* Couldn't allocate break table, give up */
+		fprintf(stderr, "Unable to allocate break table!\n");
+		fputs(buf, out);
+		return -1;
+	   }
+	btop = breaks + num_breaks * 2 - 2;
+	bp = breaks;
+	/* Parse the argument list */
+	do
+	   {	int level = 0;
+		char *lp = NULL;
+		char *rp;
+		char *end = NULL;
+		if ( bp >= btop )
+		   {	/* Filled up break table. */
+			/* Allocate a bigger one and start over. */
+			free((char *)breaks);
+			num_breaks <<= 1;
+			goto top;
+		   }
+		*bp++ = p;
+		/* Find the end of the argument */
+		for ( ; end == NULL; p++ )
+		   {	switch(*p)
+			   {
+			case ',':
+				if ( !level ) end = p;
+				break;
+			case '(':
+				if ( !level ) lp = p;
+				level++;
+				break;
+			case ')':
+				if ( --level < 0 ) end = p;
+				else rp = p;
+				break;
+			case '/':
+				p = skipspace(p, 1) - 1;
+				break;
+			default:
+				;
+			   }
+		   }
+		/* Erase any embedded prototype parameters. */
+		if ( lp )
+		  writeblanks(lp + 1, rp);
+		p--;			/* back up over terminator */
+		/* Find the name being declared. */
+		/* This is complicated because of procedure and */
+		/* array modifiers. */
+		for ( ; ; )
+		   {	p = skipspace(p - 1, -1);
+			switch ( *p )
+			   {
+			case ']':	/* skip array dimension(s) */
+			case ')':	/* skip procedure args OR name */
+			   {	int level = 1;
+				while ( level )
+				 switch ( *--p )
+				   {
+				case ']': case ')': level++; break;
+				case '[': case '(': level--; break;
+				case '/': p = skipspace(p, -1) + 1; break;
+				default: ;
+				   }
+			   }
+				if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
+				   {	/* We found the name being declared */
+					while ( !isidfirstchar(*p) )
+						p = skipspace(p, 1) + 1;
+					goto found;
+				   }
+				break;
+			default: goto found;
+			   }
+		   }
+found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
+		   {	p++;
+			if ( bp == breaks + 1 )	/* sole argument */
+				writeblanks(breaks[0], p);
+			else
+				writeblanks(bp[-1] - 1, p);
+			bp--;
+		   }
+		else
+		   {	while ( isidchar(*p) ) p--;
+			*bp++ = p+1;
+		   }
+		p = end;
+	   }
+	while ( *p++ == ',' );
+	*bp = p;
+	/* Make a special check for 'void' arglist */
+	if ( bp == breaks+2 )
+	   {	p = skipspace(breaks[0], 1);
+		if ( !strncmp(p, "void", 4) )
+		   {	p = skipspace(p+4, 1);
+			if ( p == breaks[2] - 1 )
+			   {	bp = breaks;	/* yup, pretend arglist is empty */
+				writeblanks(breaks[0], p + 1);
+			   }
+		   }
+	   }
+	/* Put out the function name */
+	p = buf;
+	while ( p != endfn ) putc(*p, out), p++;
+	/* Put out the declaration */
+	if ( header )
+	  {	fputs(");", out);
+		for ( p = breaks[0]; *p; p++ )
+		  if ( *p == '\n' )
+		    putc('\n', out);
+	  }
+	else
+	  {	for ( ap = breaks+1; ap < bp; ap += 2 )
+		  {	p = *ap;
+			while ( isidchar(*p) )
+			  putc(*p, out), p++;
+			if ( ap < bp - 1 )
+			  fputs(", ", out);
+		  }
+		fputs(")  ", out);
+		/* Put out the argument declarations */
+		for ( ap = breaks+2; ap <= bp; ap += 2 )
+		  (*ap)[-1] = ';';
+		fputs(breaks[0], out);
+	  }
+	free((char *)breaks);
+	return 0;
+}
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;
+}
diff --git a/Src/compat.c b/Src/compat.c
new file mode 100644
index 000000000..ca9c57aac
--- /dev/null
+++ b/Src/compat.c
@@ -0,0 +1,285 @@
+/*
+ * compat.c - compatibiltiy routines for the deprived
+ *
+ * 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 "compat.pro"
+
+/* Return pointer to first occurence of string t *
+ * in string s.  Return NULL if not present.     */
+
+#ifndef HAVE_STRSTR
+char *
+strstr(const char *s, const char *t)
+{
+    char *p1, *p2;
+ 
+    for (; *s; s++) {
+        for (p1 = s, p2 = t; *p2; p1++, p2++)
+            if (*p1 != *p2)
+                break;
+        if (!*p2)
+            return (char *)s;
+    }
+    return NULL;
+}
+#endif
+
+
+#ifndef HAVE_GETHOSTNAME
+int
+gethostname(char *name, size_t namelen)
+{
+    struct utsname uts;
+
+    uname(&uts);
+    if(strlen(uts.nodename) >= namelen) {
+	errno = EINVAL;
+	return -1;
+    }
+    strcpy(name, uts.nodename);
+    return 0;
+}
+#endif
+
+
+#ifndef HAVE_GETTIMEOFDAY
+int
+gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+    tv->tv_usec = 0;
+    tv->tv_sec = (long)time((time_t) 0);
+    return 0;
+}
+#endif
+
+
+/* compute the difference between two calendar times */
+
+#ifndef HAVE_DIFFTIME
+double
+difftime(time_t t2, time_t t1)
+{
+    return ((double)t2 - (double)t1);
+}
+#endif
+
+
+#ifndef HAVE_STRERROR
+extern char *sys_errlist[];
+
+/* Get error message string associated with a particular  *
+ * error number, and returns a pointer to that string.    *
+ * This is not a particularly robust version of strerror. */
+
+char *
+strerror(int errnum)
+{
+    return (sys_errlist[errnum]);
+}
+#endif
+
+
+/**/
+char *
+zgetdir(struct dirsav *d)
+{
+    char nbuf[PATH_MAX+3];
+    char *buf;
+    int bufsiz, pos, len;
+    struct stat sbuf;
+    struct dirent *de;
+    DIR *dir;
+    ino_t ino, pino;
+    dev_t dev, pdev;
+
+    buf = halloc(bufsiz = PATH_MAX);
+    pos = bufsiz - 1;
+    buf[pos] = '\0';
+    strcpy(nbuf, "../");
+    if (stat(".", &sbuf) < 0) {
+	if (d)
+	    return NULL;
+	buf[0] = '.';
+	buf[1] = '\0';
+	return buf;
+    }
+
+    pino = sbuf.st_ino;
+    pdev = sbuf.st_dev;
+    if (d)
+	d->ino = pino, d->dev = pdev;
+#ifdef HAVE_FCHDIR
+    else
+#endif
+	holdintr();
+
+    for (;;) {
+	if (stat("..", &sbuf) < 0)
+	    break;
+
+	ino = pino;
+	dev = pdev;
+	pino = sbuf.st_ino;
+	pdev = sbuf.st_dev;
+
+	if (ino == pino && dev == pdev) {
+	    if (!buf[pos])
+		buf[--pos] = '/';
+	    if (d) {
+#ifndef HAVE_FCHDIR
+		zchdir(buf + pos);
+		noholdintr();
+#endif
+		return d->dirname = ztrdup(buf + pos);
+	    }
+	    zchdir(buf + pos);
+	    noholdintr();
+	    return buf + pos;
+	}
+
+	if (!(dir = opendir("..")))
+	    break;
+
+	while ((de = readdir(dir))) {
+	    char *fn = de->d_name;
+	    /* Ignore `.' and `..'. */
+	    if (fn[0] == '.' &&
+		(fn[1] == '\0' ||
+		 (fn[1] == '.' && fn[2] == '\0')))
+		continue;
+#ifdef HAVE_STRUCT_DIRENT_D_STAT
+	    if(de->d_stat.st_dev == dev && de->d_stat.st_ino == ino) {
+		strncpy(nbuf + 3, fn, PATH_MAX);
+		break;
+	    }
+#else /* !HAVE_STRUCT_DIRENT_D_STAT */
+# ifdef HAVE_STRUCT_DIRENT_D_INO
+	    if (dev != pdev || (ino_t) de->d_ino == ino)
+# endif /* HAVE_STRUCT_DIRENT_D_INO */
+	    {
+		strncpy(nbuf + 3, fn, PATH_MAX);
+		lstat(nbuf, &sbuf);
+		if (sbuf.st_dev == dev && sbuf.st_ino == ino)
+		    break;
+	    }
+#endif /* !HAVE_STRUCT_DIRENT_D_STAT */
+	}
+	closedir(dir);
+	if (!de)
+	    break;
+	len = strlen(nbuf + 2);
+	pos -= len;
+	while (pos <= 1) {
+	    char *newbuf = halloc(2*bufsiz);
+	    memcpy(newbuf + bufsiz, buf, bufsiz);
+	    buf = newbuf;
+	    pos += bufsiz;
+	    bufsiz *= 2;
+	}
+	memcpy(buf + pos, nbuf + 2, len);
+#ifdef HAVE_FCHDIR
+	if (d)
+	    return d->dirname = ztrdup(buf + pos + 1);
+#endif
+	if (chdir(".."))
+	    break;
+    }
+    if (d) {
+#ifndef HAVE_FCHDIR
+	if (*buf)
+	    zchdir(buf + pos + 1);
+	noholdintr();
+#endif
+	return NULL;
+    }
+    if (*buf)
+	zchdir(buf + pos + 1);
+    noholdintr();
+    buf[0] = '.';
+    buf[1] = '\0';
+    return buf;
+}
+
+/**/
+char *
+zgetcwd(void)
+{
+    return zgetdir(NULL);
+}
+
+/* chdir with arbitrary long pathname.  Returns 0 on success, 0 on normal *
+ * faliliure and -2 when chdir failed and the current directory is lost.  */
+
+/**/
+int
+zchdir(char *dir)
+{
+    char *s;
+    int currdir = -2;
+
+    for (;;) {
+	if (!*dir)
+	    return 0;
+	if (!chdir(dir))
+	    return 0;
+	if ((errno != ENAMETOOLONG && errno != ENOMEM) ||
+	    strlen(dir) < PATH_MAX)
+	    break;
+	for (s = dir + PATH_MAX - 1; s > dir && *s != '/'; s--);
+	if (s == dir)
+	    break;
+#ifdef HAVE_FCHDIR
+	if (currdir == -2)
+	    currdir = open(".", O_RDONLY|O_NOCTTY);
+#endif
+	*s = '\0';
+	if (chdir(dir)) {
+	    *s = '/';
+	    break;
+	}
+#ifndef HAVE_FCHDIR
+	currdir = -1;
+#endif
+	*s = '/';
+	while (*++s == '/');
+	dir = s;
+    }
+#ifdef HAVE_FCHDIR
+    if (currdir == -1 || (currdir >= 0 && fchdir(currdir))) {
+	if (currdir >= 0)
+	    close(currdir);
+	return -2;
+    }
+    if (currdir >= 0)
+	close(currdir);
+    return -1;
+#else
+    return currdir == -2 ? -1 : -2;
+#endif
+}
diff --git a/Src/cond.c b/Src/cond.c
new file mode 100644
index 000000000..79886a720
--- /dev/null
+++ b/Src/cond.c
@@ -0,0 +1,226 @@
+/*
+ * cond.c - evaluate conditional expressions
+ *
+ * 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 "cond.pro"
+
+/**/
+int
+evalcond(Cond c)
+{
+    struct stat *st;
+
+    switch (c->type) {
+    case COND_NOT:
+	return !evalcond(c->left);
+    case COND_AND:
+	return evalcond(c->left) && evalcond(c->right);
+    case COND_OR:
+	return evalcond(c->left) || evalcond(c->right);
+    }
+    singsub((char **)&c->left);
+    untokenize(c->left);
+    if (c->right) {
+	singsub((char **)&c->right);
+	if (c->type != COND_STREQ && c->type != COND_STRNEQ)
+	    untokenize(c->right);
+    }
+    switch (c->type) {
+    case COND_STREQ:
+	return matchpat(c->left, c->right);
+    case COND_STRNEQ:
+	return !matchpat(c->left, c->right);
+    case COND_STRLT:
+	return strcmp(c->left, c->right) < 0;
+    case COND_STRGTR:
+	return strcmp(c->left, c->right) > 0;
+    case 'e':
+    case 'a':
+	return (doaccess(c->left, F_OK));
+    case 'b':
+	return (S_ISBLK(dostat(c->left)));
+    case 'c':
+	return (S_ISCHR(dostat(c->left)));
+    case 'd':
+	return (S_ISDIR(dostat(c->left)));
+    case 'f':
+	return (S_ISREG(dostat(c->left)));
+    case 'g':
+	return (!!(dostat(c->left) & S_ISGID));
+    case 'k':
+	return (!!(dostat(c->left) & S_ISVTX));
+    case 'n':
+	return (!!strlen(c->left));
+    case 'o':
+	return (optison(c->left));
+    case 'p':
+	return (S_ISFIFO(dostat(c->left)));
+    case 'r':
+	return (doaccess(c->left, R_OK));
+    case 's':
+	return ((st = getstat(c->left)) && !!(st->st_size));
+    case 'S':
+	return (S_ISSOCK(dostat(c->left)));
+    case 'u':
+	return (!!(dostat(c->left) & S_ISUID));
+    case 'w':
+	return (doaccess(c->left, W_OK));
+    case 'x':
+	if (privasserted()) {
+	    mode_t mode = dostat(c->left);
+	    return (mode & S_IXUGO) || S_ISDIR(mode);
+	}
+	return doaccess(c->left, X_OK);
+    case 'z':
+	return (!strlen(c->left));
+    case 'h':
+    case 'L':
+	return (S_ISLNK(dolstat(c->left)));
+    case 'O':
+	return ((st = getstat(c->left)) && st->st_uid == geteuid());
+    case 'G':
+	return ((st = getstat(c->left)) && st->st_gid == getegid());
+    case 'N':
+	return ((st = getstat(c->left)) && st->st_atime <= st->st_mtime);
+    case 't':
+	return isatty(matheval(c->left));
+    case COND_EQ:
+	return matheval(c->left) == matheval(c->right);
+    case COND_NE:
+	return matheval(c->left) != matheval(c->right);
+    case COND_LT:
+	return matheval(c->left) < matheval(c->right);
+    case COND_GT:
+	return matheval(c->left) > matheval(c->right);
+    case COND_LE:
+	return matheval(c->left) <= matheval(c->right);
+    case COND_GE:
+	return matheval(c->left) >= matheval(c->right);
+    case COND_NT:
+    case COND_OT:
+	{
+	    time_t a;
+
+	    if (!(st = getstat(c->left)))
+		return 0;
+	    a = st->st_mtime;
+	    if (!(st = getstat(c->right)))
+		return 0;
+	    return (c->type == COND_NT) ? a > st->st_mtime : a < st->st_mtime;
+	}
+    case COND_EF:
+	{
+	    dev_t d;
+	    ino_t i;
+
+	    if (!(st = getstat(c->left)))
+		return 0;
+	    d = st->st_dev;
+	    i = st->st_ino;
+	    if (!(st = getstat(c->right)))
+		return 0;
+	    return d == st->st_dev && i == st->st_ino;
+	}
+    default:
+	zerr("bad cond structure", NULL, 0);
+    }
+    return 0;
+}
+
+
+/**/
+static int
+doaccess(char *s, int c)
+{
+    return !access(unmeta(s), c);
+}
+
+
+static struct stat st;
+
+/**/
+static struct stat *
+getstat(char *s)
+{
+/* /dev/fd/n refers to the open file descriptor n.  We always use fstat *
+ * in this case since on Solaris /dev/fd/n is a device special file     */
+    if (!strncmp(s, "/dev/fd/", 8)) {
+	if (fstat(atoi(s + 8), &st))
+	    return NULL;
+        return &st;
+    }
+
+    if (stat(unmeta(s), &st))
+	return NULL;
+    return &st;
+}
+
+
+/**/
+static mode_t
+dostat(char *s)
+{
+    struct stat *statp;
+
+    if (!(statp = getstat(s)))
+	return 0;
+    return statp->st_mode;
+}
+
+
+/* pem@aaii.oz; needed since dostat now uses "stat" */
+
+/**/
+static mode_t
+dolstat(char *s)
+{
+    if (lstat(unmeta(s), &st) < 0)
+	return 0;
+    return st.st_mode;
+}
+
+
+/**/
+static int
+optison(char *s)
+{
+    int i;
+
+    if (strlen(s) == 1)
+	i = optlookupc(*s);
+    else
+	i = optlookup(s);
+    if (!i) {
+	zerr("no such option: %s", s, 0);
+	return 0;
+    } else if(i < 0)
+	return unset(-i);
+    else
+	return isset(i);
+}
diff --git a/Src/exec.c b/Src/exec.c
new file mode 100644
index 000000000..1b355d028
--- /dev/null
+++ b/Src/exec.c
@@ -0,0 +1,2965 @@
+/*
+ * exec.c - command execution
+ *
+ * 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 "exec.pro"
+
+/* used to suppress ERREXIT and trapping of SIGZERR, SIGEXIT. */
+
+/**/
+int noerrexit;
+
+/* suppress error messages */
+ 
+/**/
+int noerrs;
+ 
+/* do not save history on exec and exit */
+
+/**/
+int nohistsave;
+ 
+/* error/break flag */
+ 
+/**/
+int errflag;
+ 
+/* Status of return from a trap */
+ 
+/**/
+int trapreturn;
+ 
+/* != 0 if this is a subshell */
+ 
+/**/
+int subsh;
+ 
+/* != 0 if we have a return pending */
+ 
+/**/
+int retflag;
+
+/**/
+long lastval2;
+ 
+/* The table of file descriptors.  A table element is zero if the  *
+ * corresponding fd is not used by the shell.  It is greater than  *
+ * 1 if the fd is used by a <(...) or >(...) substitution and 1 if *
+ * it is an internal file descriptor which must be closed before   *
+ * executing an external command.  The first ten elements of the   *
+ * table is not used.  A table element is set by movefd and cleard *
+ * by zclose.                                                      */
+
+/**/
+char *fdtable;
+
+/* The allocated size of fdtable */
+
+/**/
+int fdtable_size;
+
+/* The highest fd that marked with nonzero in fdtable */
+
+/**/
+int max_zsh_fd;
+
+/* input fd from the coprocess */
+
+/**/
+int coprocin;
+
+/* output fd from the coprocess */
+
+/**/
+int coprocout;
+
+/* != 0 if the line editor is active */
+
+/**/
+int zleactive;
+
+/* pid of process undergoing 'process substitution' */
+ 
+/**/
+pid_t cmdoutpid;
+ 
+/* exit status of process undergoing 'process substitution' */
+ 
+/**/
+int cmdoutval;
+ 
+/* Stack to save some variables before executing a signal handler function */
+
+/**/
+struct execstack *exstack;
+
+#define execerr() if (!forked) { lastval = 1; return; } else _exit(1)
+
+static LinkList args;
+static int doneps4;
+
+/* parse string into a list */
+
+/**/
+List
+parse_string(char *s)
+{
+    List l;
+
+    lexsave();
+    inpush(s, 0, NULL);
+    strinbeg();
+    stophist = 2;
+    l = parse_list();
+    strinend();
+    inpop();
+    lexrestore();
+    return l;
+}
+
+#ifdef HAVE_GETRLIMIT
+
+/* the resource limits for the shell and its children */
+
+/**/
+struct rlimit current_limits[RLIM_NLIMITS], limits[RLIM_NLIMITS];
+ 
+/**/
+int
+zsetlimit(int limnum, char *nam)
+{
+    if (limits[limnum].rlim_max != current_limits[limnum].rlim_max ||
+	limits[limnum].rlim_cur != current_limits[limnum].rlim_cur) {
+	if (setrlimit(limnum, limits + limnum)) {
+	    if (nam)
+		zwarnnam(nam, "setrlimit failed: %e", NULL, errno);
+	    return -1;
+	}
+	current_limits[limnum] = limits[limnum];
+    }
+    return 0;
+}
+
+/**/
+int
+setlimits(char *nam)
+{
+    int limnum;
+    int ret = 0;
+
+    for (limnum = 0; limnum < RLIM_NLIMITS; limnum++)
+	if (zsetlimit(limnum, nam))
+	    ret++;
+    return ret;
+}
+
+#endif /* HAVE_GETRLIMIT */
+
+/* fork and set limits */
+
+/**/
+static pid_t
+zfork(void)
+{
+    pid_t pid;
+
+    if (thisjob >= MAXJOB - 1) {
+	zerr("job table full", NULL, 0);
+	return -1;
+    }
+    pid = fork();
+    if (pid == -1) {
+	zerr("fork failed: %e", NULL, errno);
+	return -1;
+    }
+#ifdef HAVE_GETRLIMIT
+    if (!pid)
+	/* set resource limits for the child process */
+	setlimits(NULL);
+#endif
+    return pid;
+}
+
+
+/**/
+int list_pipe = 0, simple_pline = 0;
+
+static pid_t list_pipe_pid;
+static int nowait, pline_level = 0;
+static int list_pipe_child = 0, list_pipe_job;
+static char list_pipe_text[JOBTEXTSIZE];
+
+/* execute a current shell command */
+
+/**/
+static int
+execcursh(Cmd cmd)
+{
+    if (!list_pipe)
+	deletejob(jobtab + thisjob);
+    execlist(cmd->u.list, 1, cmd->flags & CFLAG_EXEC);
+    cmd->u.list = NULL;
+    return lastval;
+}
+
+/* execve after handling $_ and #! */
+
+#define POUNDBANGLIMIT 64
+
+/**/
+static int
+zexecve(char *pth, char **argv)
+{
+    int eno;
+    static char buf[PATH_MAX * 2];
+    char **eep;
+
+    unmetafy(pth, NULL);
+    for (eep = argv; *eep; eep++)
+	if (*eep != pth)
+	    unmetafy(*eep, NULL);
+    for (eep = environ; *eep; eep++)
+	if (**eep == '_' && (*eep)[1] == '=')
+	    break;
+    buf[0] = '_';
+    buf[1] = '=';
+    if (*pth == '/')
+	strcpy(buf + 2, pth);
+    else
+	sprintf(buf + 2, "%s/%s", pwd, pth);
+    if (!*eep)
+	eep[1] = NULL;
+    *eep = buf;
+    execve(pth, argv, environ);
+
+    /* If the execve returns (which in general shouldn't happen),   *
+     * then check for an errno equal to ENOEXEC.  This errno is set *
+     * if the process file has the appropriate access permission,   *
+     * but has an invalid magic number in its header.               */
+    if ((eno = errno) == ENOEXEC) {
+	char execvebuf[POUNDBANGLIMIT + 1], *ptr, *ptr2, *argv0;
+	int fd, ct, t0;
+
+	if ((fd = open(pth, O_RDONLY|O_NOCTTY)) >= 0) {
+	    argv0 = *argv;
+	    *argv = pth;
+	    ct = read(fd, execvebuf, POUNDBANGLIMIT);
+	    close(fd);
+	    if (ct > 0) {
+		if (execvebuf[0] == '#') {
+		    if (execvebuf[1] == '!') {
+			for (t0 = 0; t0 != ct; t0++)
+			    if (execvebuf[t0] == '\n')
+				execvebuf[t0] = '\0';
+			execvebuf[POUNDBANGLIMIT] = '\0';
+			for (ptr = execvebuf + 2; *ptr && *ptr == ' '; ptr++);
+			for (ptr2 = ptr; *ptr && *ptr != ' '; ptr++);
+			if (*ptr) {
+			    *ptr = '\0';
+			    argv[-2] = ptr2;
+			    argv[-1] = ptr + 1;
+			    execve(ptr2, argv - 2, environ);
+			} else {
+			    argv[-1] = ptr2;
+			    execve(ptr2, argv - 1, environ);
+			}
+		    } else {
+			argv[-1] = "sh";
+			execve("/bin/sh", argv - 1, environ);
+		    }
+		} else {
+		    for (t0 = 0; t0 != ct; t0++)
+			if (!execvebuf[t0])
+			    break;
+		    if (t0 == ct) {
+			argv[-1] = "sh";
+			execve("/bin/sh", argv - 1, environ);
+		    }
+		}
+	    } else
+		eno = errno;
+	    *argv = argv0;
+	} else
+	    eno = errno;
+    }
+    /* restore the original arguments and path but do not bother with *
+     * null characters as these cannot be passed to external commands *
+     * anyway.  So the result is truncated at the first null char.    */
+    pth = metafy(pth, -1, META_NOALLOC);
+    for (eep = argv; *eep; eep++)
+	if (*eep != pth)
+	    (void) metafy(*eep, -1, META_NOALLOC);
+    return eno;
+}
+
+#define MAXCMDLEN (PATH_MAX*4)
+
+/* test whether we really want to believe the error number */
+
+/**/
+static int
+isgooderr(int e, char *dir)
+{
+    /*
+     * Maybe the directory was unreadable, or maybe it wasn't
+     * even a directory. 
+     */
+    return ((e != EACCES || !access(dir, X_OK)) &&
+	    e != ENOENT && e != ENOTDIR); 
+}
+
+/* execute an external command */
+
+/**/
+void
+execute(Cmdnam not_used_yet, int dash)
+{
+    Cmdnam cn;
+    static LinkList exargs;
+    char buf[MAXCMDLEN], buf2[MAXCMDLEN];
+    char *s, *z, *arg0;
+    char **argv, **pp;
+    int eno = 0, ee;
+
+    arg0 = (char *) peekfirst(args);
+    if (isset(RESTRICTED) && strchr(arg0, '/')) {
+	zerr("%s: restricted", arg0, 0);
+	_exit(1);
+    }
+
+    /* If the parameter STTY is set in the command's environment, *
+     * we first run the stty command with the value of this       *
+     * parameter as it arguments.                                 */
+    if (!exargs && (s = zgetenv("STTY")) && isatty(0)) {
+	char *t;
+
+	exargs = args;	/* this prevents infinite recursion */
+	args = NULL;
+	t = tricat("stty", " ", s);
+	execstring(t, 1, 0);
+	zsfree(t);
+	args = exargs;
+	exargs = NULL;
+    }
+
+    cn = (Cmdnam) cmdnamtab->getnode(cmdnamtab, arg0);
+
+    /* If ARGV0 is in the commands environment, we use *
+     * that as argv[0] for this external command       */
+    if (unset(RESTRICTED) && (z = zgetenv("ARGV0"))) {
+	setdata(firstnode(args), (void *) ztrdup(z));
+	delenv(z - 6);
+    } else if (dash) {
+    /* Else if the pre-command `-' was given, we add `-' *
+     * to the front of argv[0] for this command.         */
+	sprintf(buf2, "-%s", arg0);
+	setdata(firstnode(args), (void *) ztrdup(buf2));
+    }
+
+    argv = makecline(args);
+    child_unblock();
+    if ((int) strlen(arg0) >= PATH_MAX) {
+	zerr("command too long: %s", arg0, 0);
+	_exit(1);
+    }
+    for (s = arg0; *s; s++)
+	if (*s == '/') {
+	    errno = zexecve(arg0, argv);
+	    if (arg0 == s || unset(PATHDIRS) ||
+		(arg0[0] == '.' && (arg0 + 1 == s ||
+				    (arg0[1] == '.' && arg0 + 2 == s)))) {
+		zerr("%e: %s", arg0, errno);
+		_exit(1);
+	    }
+	    break;
+	}
+
+    if (cn) {
+	char nn[PATH_MAX], *dptr;
+
+	if (cn->flags & HASHED)
+	    strcpy(nn, cn->u.cmd);
+	else {
+	    for (pp = path; pp < cn->u.name; pp++)
+		if (!**pp || (**pp == '.' && (*pp)[1] == '\0')) {
+		    ee = zexecve(arg0, argv);
+		    if (isgooderr(ee, *pp))
+			eno = ee;
+		} else if (**pp != '/') {
+		    z = buf;
+		    strucpy(&z, *pp);
+		    *z++ = '/';
+		    strcpy(z, arg0);
+		    ee = zexecve(buf, argv);
+		    if (isgooderr(ee, *pp))
+			eno = ee;
+		}
+	    strcpy(nn, cn->u.name ? *(cn->u.name) : "");
+	    strcat(nn, "/");
+	    strcat(nn, cn->nam);
+	}
+	ee = zexecve(nn, argv);
+
+	if ((dptr = strrchr(nn, '/')))
+	    *dptr = '\0';
+	if (isgooderr(ee, *nn ? nn : "/"))
+	    eno = ee;
+    }
+    for (pp = path; *pp; pp++)
+	if (!(*pp)[0] || ((*pp)[0] == '.' && !(*pp)[1])) {
+	    ee = zexecve(arg0, argv);
+	    if (isgooderr(ee, *pp))
+		eno = ee;
+	} else {
+	    z = buf;
+	    strucpy(&z, *pp);
+	    *z++ = '/';
+	    strcpy(z, arg0);
+	    ee = zexecve(buf, argv);
+	    if (isgooderr(ee, *pp))
+		eno = ee;
+	}
+    if (eno)
+	zerr("%e: %s", arg0, eno);
+    else
+	zerr("command not found: %s", arg0, 0);
+    _exit(1);
+}
+
+#define try(X) { if (iscom(X)) return ztrdup(X); }
+
+/* get the full pathname of an external command */
+
+/**/
+char *
+findcmd(char *arg0)
+{
+    char **pp;
+    char *z, *s, buf[MAXCMDLEN];
+    Cmdnam cn;
+
+    cn = (Cmdnam) cmdnamtab->getnode(cmdnamtab, arg0);
+    if (!cn && isset(HASHCMDS))
+	cn = hashcmd(arg0, path);
+    if ((int) strlen(arg0) > PATH_MAX)
+	return NULL;
+    for (s = arg0; *s; s++)
+	if (*s == '/') {
+	    try(arg0);
+	    if (arg0 == s || unset(PATHDIRS)) {
+		return NULL;
+	    }
+	    break;
+	}
+    if (cn) {
+	char nn[PATH_MAX];
+
+	if (cn->flags & HASHED)
+	    strcpy(nn, cn->u.cmd);
+	else {
+	    for (pp = path; pp < cn->u.name; pp++)
+		if (**pp != '/') {
+		    z = buf;
+		    if (**pp) {
+			strucpy(&z, *pp);
+			*z++ = '/';
+		    }
+		    strcpy(z, arg0);
+		    try(buf);
+		}
+	    strcpy(nn, cn->u.name ? *(cn->u.name) : "");
+	    strcat(nn, "/");
+	    strcat(nn, cn->nam);
+	}
+	try(nn);
+    }
+    for (pp = path; *pp; pp++) {
+	z = buf;
+	if (**pp) {
+	    strucpy(&z, *pp);
+	    *z++ = '/';
+	}
+	strcpy(z, arg0);
+	try(buf);
+    }
+    return NULL;
+}
+
+/**/
+int
+iscom(char *s)
+{
+    struct stat statbuf;
+    char *us = unmeta(s);
+
+    return (access(us, X_OK) == 0 && stat(us, &statbuf) >= 0 &&
+	    S_ISREG(statbuf.st_mode));
+}
+
+/**/
+int
+isreallycom(Cmdnam cn)
+{
+    char fullnam[MAXCMDLEN];
+
+    strcpy(fullnam, cn->u.name ? *(cn->u.name) : "");
+    strcat(fullnam, "/");
+    strcat(fullnam, cn->nam);
+    return iscom(fullnam);
+}
+
+/**/
+int
+isrelative(char *s)
+{
+    if (*s != '/')
+	return 1;
+    for (; *s; s++)
+	if (*s == '.' && s[-1] == '/' &&
+	    (s[1] == '/' || s[1] == '\0' ||
+	     (s[1] == '.' && (s[2] == '/' || s[2] == '\0'))))
+	    return 1;
+    return 0;
+}
+
+/**/
+Cmdnam
+hashcmd(char *arg0, char **pp)
+{
+    Cmdnam cn;
+    char *s, buf[PATH_MAX];
+    char **pq;
+
+    for (; *pp; pp++)
+	if (**pp == '/') {
+	    s = buf;
+	    strucpy(&s, *pp);
+	    *s++ = '/';
+	    if ((s - buf) + strlen(arg0) >= PATH_MAX)
+		continue;
+	    strcpy(s, arg0);
+	    if (iscom(buf))
+		break;
+	}
+
+    if (!*pp)
+	return NULL;
+
+    cn = (Cmdnam) zcalloc(sizeof *cn);
+    cn->flags = 0;
+    cn->u.name = pp;
+    cmdnamtab->addnode(cmdnamtab, ztrdup(arg0), cn);
+
+    if (isset(HASHDIRS)) {
+	for (pq = pathchecked; pq <= pp; pq++)
+	    hashdir(pq);
+	pathchecked = pp + 1;
+    }
+
+    return cn;
+}
+
+/* execute a string */
+
+/**/
+void
+execstring(char *s, int dont_change_job, int exiting)
+{
+    List list;
+
+    pushheap();
+    if ((list = parse_string(s)))
+	execlist(list, dont_change_job, exiting);
+    popheap();
+}
+
+/* Main routine for executing a list.                                *
+ * exiting means that the (sub)shell we are in is a definite goner   *
+ * after the current list is finished, so we may be able to exec the *
+ * last command directly instead of forking.  If dont_change_job is  *
+ * nonzero, then restore the current job number after executing the  *
+ * list.                                                             */
+
+/**/
+void
+execlist(List list, int dont_change_job, int exiting)
+{
+    Sublist slist;
+    static int donetrap;
+    int ret, cj;
+    int old_pline_level, old_list_pipe;
+
+    cj = thisjob;
+    old_pline_level = pline_level;
+    old_list_pipe = list_pipe;
+
+    if (sourcelevel && unset(SHINSTDIN))
+	pline_level = list_pipe = 0;
+
+    /* Loop over all sets of comands separated by newline, *
+     * semi-colon or ampersand (`sublists').               */
+    while (list && list != &dummy_list && !breaks && !retflag) {
+	/* Reset donetrap:  this ensures that a trap is only *
+	 * called once for each sublist that fails.          */
+	donetrap = 0;
+	simplifyright(list);
+	slist = list->left;
+
+	/* Loop through code followed by &&, ||, or end of sublist. */
+	while (slist) {
+	    switch (slist->type) {
+	    case END:
+		/* End of sublist; just execute, ignoring status. */
+		execpline(slist, list->type, !list->right && exiting);
+		goto sublist_done;
+		break;
+	    case ANDNEXT:
+		/* If the return code is non-zero, we skip pipelines until *
+		 * we find a sublist followed by ORNEXT.                   */
+		if ((ret = execpline(slist, Z_SYNC, 0))) {
+		    while ((slist = slist->right))
+			if (slist->type == ORNEXT)
+			    break;
+		    if (!slist) {
+			/* We've skipped to the end of the list, not executing *
+			 * the final pipeline, so don't perform error handling *
+			 * for this sublist.                                   */
+			donetrap = 1;
+			goto sublist_done;
+		    }
+		}
+		break;
+	    case ORNEXT:
+		/* If the return code is zero, we skip pipelines until *
+		 * we find a sublist followed by ANDNEXT.              */
+		if (!(ret = execpline(slist, Z_SYNC, 0))) {
+		    while ((slist = slist->right))
+			if (slist->type == ANDNEXT)
+			    break;
+		    if (!slist) {
+			/* We've skipped to the end of the list, not executing *
+			 * the final pipeline, so don't perform error handling *
+			 * for this sublist.                                   */
+			donetrap = 1;
+			goto sublist_done;
+		     }
+		}
+		break;
+	    }
+	    slist = slist->right;
+	}
+sublist_done:
+
+	if (sigtrapped[SIGDEBUG])
+	    dotrap(SIGDEBUG);
+
+	/* Check whether we are suppressing traps/errexit *
+	 * (typically in init scripts) and if we haven't  *
+	 * already performed them for this sublist.       */
+	if (!noerrexit && !donetrap) {
+	    if (sigtrapped[SIGZERR] && lastval) {
+		dotrap(SIGZERR);
+		donetrap = 1;
+	    }
+	    if (lastval && isset(ERREXIT)) {
+		if (sigtrapped[SIGEXIT])
+		    dotrap(SIGEXIT);
+		if (mypid != getpid())
+		    _exit(lastval);
+		else
+		    exit(lastval);
+	    }
+	}
+
+	list = list->right;
+    }
+
+    pline_level = old_pline_level;
+    list_pipe = old_list_pipe;
+    if (dont_change_job)
+	thisjob = cj;
+}
+
+/* Execute a pipeline.                                                *
+ * last1 is a flag that this command is the last command in a shell   *
+ * that is about to exit, so we can exec instead of forking.  It gets *
+ * passed all the way down to execcmd() which actually makes the      *
+ * decision.  A 0 is always passed if the command is not the last in  *
+ * the pipeline.  This function assumes that the sublist is not NULL. *
+ * If last1 is zero but the command is at the end of a pipeline, we   *
+ * pass 2 down to execcmd().                                          *
+ */
+
+/**/
+static int
+execpline(Sublist l, int how, int last1)
+{
+    int ipipe[2], opipe[2];
+    int pj, newjob;
+    int old_simple_pline = simple_pline;
+    static int lastwj;
+
+    if (!l->left)
+	return lastval = (l->flags & PFLAG_NOT) != 0;
+
+    pj = thisjob;
+    ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = 0;
+    child_block();
+
+    /* get free entry in job table and initialize it */
+    if ((thisjob = newjob = initjob()) == -1)
+	return 1;
+    if (how & Z_TIMED)
+	jobtab[thisjob].stat |= STAT_TIMED;
+
+    if (l->flags & PFLAG_COPROC) {
+	how = Z_ASYNC;
+	if (coprocin >= 0) {
+	    zclose(coprocin);
+	    zclose(coprocout);
+	}
+	mpipe(ipipe);
+	mpipe(opipe);
+	coprocin = ipipe[0];
+	coprocout = opipe[1];
+	fdtable[coprocin] = fdtable[coprocout] = 0;
+    }
+    if (!pline_level++) {
+	list_pipe_job = newjob;
+	nowait = 0;
+    }
+    list_pipe_pid = lastwj = 0;
+    if (pline_level == 1)
+	simple_pline = (l->left->type == END);
+    execpline2(l->left, how, opipe[0], ipipe[1], last1);
+    pline_level--;
+    if (how & Z_ASYNC) {
+	lastwj = newjob;
+	jobtab[thisjob].stat |= STAT_NOSTTY;
+	if (l->flags & PFLAG_COPROC)
+	    zclose(ipipe[1]);
+	if (how & Z_DISOWN) {
+	    deletejob(jobtab + thisjob);
+	    thisjob = -1;
+	}
+	else
+	    spawnjob();
+	child_unblock();
+	return 0;
+    } else {
+	if (newjob != lastwj) {
+	    Job jn = jobtab + newjob;
+
+	    if (newjob == list_pipe_job && list_pipe_child)
+		_exit(0);
+
+	    lastwj = thisjob = newjob;
+
+	    if (list_pipe)
+		jn->stat |= STAT_NOPRINT;
+
+	    if (nowait) {
+		if(!pline_level) {
+		    struct process *pn, *qn;
+
+		    curjob = newjob;
+		    addproc(list_pipe_pid, list_pipe_text);
+
+		    for (pn = jobtab[jn->other].procs; pn; pn = pn->next)
+			if (WIFSTOPPED(pn->status))
+			    break;
+
+		    if (pn) {
+			for (qn = jn->procs; qn->next; qn = qn->next);
+			qn->status = pn->status;
+		    }
+
+		    jn->stat &= ~(STAT_DONE | STAT_NOPRINT);
+		    jn->stat |= STAT_STOPPED | STAT_CHANGED;
+		    printjob(jn, !!isset(LONGLISTJOBS), 1);
+		}
+		else
+		    deletejob(jn);
+	    }
+
+	    for (; !nowait;) {
+		if (list_pipe_child) {
+		    jn->stat |= STAT_NOPRINT;
+		    makerunning(jn);
+		}
+		if (!(jn->stat & STAT_LOCKED))
+		    waitjobs();
+
+		if (list_pipe_child &&
+		    jn->stat & STAT_DONE &&
+		    lastval2 & 0200)
+		    killpg(mypgrp, lastval2 & ~0200);
+		if ((list_pipe || last1) && !list_pipe_child &&
+		    jn->stat & STAT_STOPPED) {
+		    pid_t pid;
+		    int synch[2];
+
+		    pipe(synch);
+
+		    if ((pid = fork()) == -1) {
+			trashzle();
+			close(synch[0]);
+			close(synch[1]);
+			putc('\n', stderr);
+			fprintf(stderr, "zsh: job can't be suspended\n");
+			fflush(stderr);
+			makerunning(jn);
+			killjb(jn, SIGCONT);
+			thisjob = newjob;
+		    }
+		    else if (pid) {
+			char dummy;
+
+			list_pipe_pid = pid;
+			nowait = errflag = 1;
+			breaks = loops;
+			close(synch[1]);
+			read(synch[0], &dummy, 1);
+			close(synch[0]);
+			jobtab[list_pipe_job].other = newjob;
+			jobtab[list_pipe_job].stat |= STAT_SUPERJOB;
+			jn->stat |= STAT_SUBJOB | STAT_NOPRINT;
+			jn->other = pid;
+			killpg(jobtab[list_pipe_job].gleader, SIGSTOP);
+			break;
+		    }
+		    else {
+			close(synch[0]);
+			entersubsh(Z_ASYNC, 0, 0);
+			setpgrp(0L, mypgrp = jobtab[list_pipe_job].gleader);
+			close(synch[1]);
+			kill(getpid(), SIGSTOP);
+			list_pipe = 0;
+			list_pipe_child = 1;
+			break;
+		    }
+		}
+		else if (subsh && jn->stat & STAT_STOPPED)
+		    thisjob = newjob;
+		else
+		    break;
+	    }
+	    child_unblock();
+
+	    if (list_pipe && (lastval & 0200) && pj >= 0 &&
+		(!(jn->stat & STAT_INUSE) || (jn->stat & STAT_DONE))) {
+		jn = jobtab + pj;
+		jn->stat |= STAT_NOPRINT;
+		killjb(jobtab + pj, lastval & ~0200);
+	    }
+	    if (list_pipe_child || (list_pipe && (jn->stat & STAT_DONE)))
+		deletejob(jn);
+	    thisjob = pj;
+
+	}
+	if (l->flags & PFLAG_NOT)
+	    lastval = !lastval;
+    }
+    if (!pline_level)
+	simple_pline = old_simple_pline;
+    return lastval;
+}
+
+static int subsh_close = -1;
+
+/* execute pipeline.  This function assumes the `pline' is not NULL. */
+
+/**/
+static void
+execpline2(Pline pline, int how, int input, int output, int last1)
+{
+    pid_t pid;
+    int pipes[2];
+    int oldlineno;
+
+    if (breaks || retflag)
+	return;
+
+    oldlineno = lineno;
+    lineno = pline->left->lineno;
+
+    if (pline_level == 1)
+	strcpy(list_pipe_text, getjobtext((void *) pline->left));
+    if (pline->type == END) {
+	execcmd(pline->left, input, output, how, last1 ? 1 : 2);
+	pline->left = NULL;
+    } else {
+	int old_list_pipe = list_pipe;
+
+	mpipe(pipes);
+
+	/* if we are doing "foo | bar" where foo is a current *
+	 * shell command, do foo in a subshell and do the     *
+	 * rest of the pipeline in the current shell.         */
+	if (pline->left->type >= CURSH && (how & Z_SYNC)) {
+	    int synch[2];
+
+	    pipe(synch);
+	    if ((pid = fork()) == -1) {
+		close(synch[0]);
+		close(synch[1]);
+		zerr("fork failed: %e", NULL, errno);
+	    } else if (pid) {
+		char dummy, *text;
+
+		text = getjobtext((void *) pline->left);
+		addproc(pid, text);
+		close(synch[1]);
+		read(synch[0], &dummy, 1);
+		close(synch[0]);
+	    } else {
+		zclose(pipes[0]);
+		close(synch[0]);
+		entersubsh(how, 2, 0);
+		close(synch[1]);
+		execcmd(pline->left, input, pipes[1], how, 0);
+		_exit(lastval);
+	    }
+	} else {
+	/* otherwise just do the pipeline normally. */
+	    subsh_close = pipes[0];
+	    execcmd(pline->left, input, pipes[1], how, 0);
+	}
+	pline->left = NULL;
+	zclose(pipes[1]);
+	if (pline->right) {
+	    /* if another execpline() is invoked because the command is *
+	     * a list it must know that we're already in a pipeline     */
+	    list_pipe = 1;
+	    execpline2(pline->right, how, pipes[0], output, last1);
+	    list_pipe = old_list_pipe;
+	    zclose(pipes[0]);
+	    subsh_close = -1;
+	}
+    }
+
+    lineno = oldlineno;
+}
+
+/* make the argv array */
+
+/**/
+static char **
+makecline(LinkList list)
+{
+    LinkNode node;
+    char **argv, **ptr;
+
+    /* A bigger argv is necessary for executing scripts */
+    ptr  =
+    argv = 2 + (char **) ncalloc((countlinknodes(list) + 4) * sizeof(char *));
+    if (isset(XTRACE)) {
+	if (!doneps4)
+	    fprintf(stderr, "%s", (prompt4) ? prompt4 : "");
+
+	for (node = firstnode(list); node; incnode(node)) {
+	    *ptr++ = (char *)getdata(node);
+	    zputs(getdata(node), stderr);
+	    if (nextnode(node))
+		fputc(' ', stderr);
+	}
+	fputc('\n', stderr);
+	fflush(stderr);
+    } else {
+	for (node = firstnode(list); node; incnode(node))
+	    *ptr++ = (char *)getdata(node);
+    }
+    *ptr = NULL;
+    return (argv);
+}
+
+/**/
+void
+untokenize(char *s)
+{
+    for (; *s; s++)
+	if (itok(*s))
+	    if (*s == Nularg)
+		chuck(s--);
+	    else
+		*s = ztokens[*s - Pound];
+}
+
+/* Open a file for writing redicection */
+
+/**/
+static int
+clobber_open(struct redir *f)
+{
+    struct stat buf;
+    int fd, oerrno;
+
+    /* If clobbering, just open. */
+    if (isset(CLOBBER) || IS_CLOBBER_REDIR(f->type))
+	return open(unmeta(f->name),
+		O_WRONLY | O_CREAT | O_TRUNC | O_NOCTTY, 0666);
+
+    /* If not clobbering, attempt to create file exclusively. */
+    if ((fd = open(unmeta(f->name),
+		   O_WRONLY | O_CREAT | O_EXCL | O_NOCTTY, 0666)) >= 0)
+	return fd;
+
+    /* If that fails, we are still allowed to open non-regular files. *
+     * Try opening, and if it's a regular file then close it again    *
+     * because we weren't supposed to open it.                        */
+    oerrno = errno;
+    if ((fd = open(unmeta(f->name), O_WRONLY | O_NOCTTY)) != -1) {
+	if(!fstat(fd, &buf) && !S_ISREG(buf.st_mode))
+	    return fd;
+	close(fd);
+    }
+    errno = oerrno;
+    return -1;
+}
+
+/* size of buffer for tee and cat processes */
+#define TCBUFSIZE 4092
+
+/* close an multio (success) */
+
+/**/
+static void
+closemn(struct multio **mfds, int fd)
+{
+    struct multio *mn = mfds[fd];
+    char buf[TCBUFSIZE];
+    int len, i;
+
+    if (fd < 0 || !mfds[fd] || mfds[fd]->ct < 2)
+	return;
+    if (zfork()) {
+	for (i = 0; i < mn->ct; i++)
+	    zclose(mn->fds[i]);
+	zclose(mn->pipe);
+	mn->ct = 1;
+	mn->fds[0] = fd;
+	return;
+    }
+    /* pid == 0 */
+    closeallelse(mn);
+    if (mn->rflag) {
+	/* tee process */
+	while ((len = read(mn->pipe, buf, TCBUFSIZE)) > 0)
+	    for (i = 0; i < mn->ct; i++)
+		write(mn->fds[i], buf, len);
+    } else {
+	/* cat process */
+	for (i = 0; i < mn->ct; i++)
+	    while ((len = read(mn->fds[i], buf, TCBUFSIZE)) > 0)
+		write(mn->pipe, buf, len);
+    }
+    _exit(0);
+}
+
+/* close all the mnodes (failure) */
+
+/**/
+static void
+closemnodes(struct multio **mfds)
+{
+    int i, j;
+
+    for (i = 0; i < 10; i++)
+	if (mfds[i]) {
+	    for (j = 0; j < mfds[i]->ct; j++)
+		zclose(mfds[i]->fds[j]);
+	    mfds[i] = NULL;
+	}
+}
+
+/**/
+static void
+closeallelse(struct multio *mn)
+{
+    int i, j;
+
+    for (i = 0; i < OPEN_MAX; i++)
+	if (mn->pipe != i) {
+	    for (j = 0; j < mn->ct; j++)
+		if (mn->fds[j] == i)
+		    break;
+	    if (j == mn->ct)
+		zclose(i);
+	}
+}
+
+/* A multio is a list of fds associated with a certain fd.       *
+ * Thus if you do "foo >bar >ble", the multio for fd 1 will have *
+ * two fds, the result of open("bar",...), and the result of     *
+ * open("ble",....).                                             */
+
+/* Add a fd to an multio.  fd1 must be < 10, and may be in any state. *
+ * fd2 must be open, and is `consumed' by this function.  Note that   *
+ * fd1 == fd2 is possible, and indicates that fd1 was really closed.  *
+ * We effectively do `fd2 = movefd(fd2)' at the beginning of this     *
+ * function, but in most cases we can avoid an extra dup by delaying  *
+ * the movefd: we only >need< to move it if we're actually doing a    *
+ * multiple redirection.                                              */
+
+/**/
+static void
+addfd(int forked, int *save, struct multio **mfds, int fd1, int fd2, int rflag)
+{
+    int pipes[2];
+
+    if (!mfds[fd1] || unset(MULTIOS)) {
+	if(!mfds[fd1]) {		/* starting a new multio */
+	    mfds[fd1] = (struct multio *) alloc(sizeof(struct multio));
+	    if (!forked && save[fd1] == -2)
+		save[fd1] = (fd1 == fd2) ? -1 : movefd(fd1);
+	}
+	redup(fd2, fd1);
+	mfds[fd1]->ct = 1;
+	mfds[fd1]->fds[0] = fd1;
+	mfds[fd1]->rflag = rflag;
+    } else {
+	if (mfds[fd1]->rflag != rflag) {
+	    zerr("file mode mismatch on fd %d", NULL, fd1);
+	    return;
+	}
+	if (mfds[fd1]->ct == 1) {	/* split the stream */
+	    mfds[fd1]->fds[0] = movefd(fd1);
+	    mfds[fd1]->fds[1] = movefd(fd2);
+	    mpipe(pipes);
+	    mfds[fd1]->pipe = pipes[1 - rflag];
+	    redup(pipes[rflag], fd1);
+	    mfds[fd1]->ct = 2;
+	} else {		/* add another fd to an already split stream */
+	    if(!(mfds[fd1]->ct % MULTIOUNIT)) {
+		int new = sizeof(struct multio) + sizeof(int) * mfds[fd1]->ct;
+		int old = new - sizeof(int) * MULTIOUNIT;
+		mfds[fd1] = hrealloc((char *)mfds[fd1], old, new);
+	    }
+	    mfds[fd1]->fds[mfds[fd1]->ct++] = movefd(fd2);
+	}
+    }
+    if (subsh_close >= 0 && !fdtable[subsh_close])
+	subsh_close = -1;
+}
+
+/**/
+static void
+addvars(LinkList l, int export)
+{
+    Varasg v;
+    LinkList vl;
+    int xtr;
+    char **arr, **ptr;
+
+    xtr = isset(XTRACE);
+    if (xtr && nonempty(l)) {
+	fprintf(stderr, "%s", prompt4 ? prompt4 : "");
+	doneps4 = 1;
+    }
+
+    while (nonempty(l)) {
+	v = (Varasg) ugetnode(l);
+	singsub(&v->name);
+	if (errflag)
+	    return;
+	untokenize(v->name);
+	if (xtr)
+	    fprintf(stderr, "%s=", v->name);
+	if (v->type == PM_SCALAR) {
+	    vl = newlinklist();
+	    addlinknode(vl, v->str);
+	} else
+	    vl = v->arr;
+	prefork(vl, v->type == PM_SCALAR ? 7 : 3);
+	if (errflag)
+	    return;
+	if (isset(GLOBASSIGN) || v->type != PM_SCALAR)
+	    globlist(vl);
+	if (errflag)
+	    return;
+	if (v->type == PM_SCALAR && (empty(vl) || !nextnode(firstnode(vl)))) {
+	    Param pm;
+	    char *val;
+	    int allexp;
+
+	    if (empty(vl))
+		val = ztrdup("");
+	    else {
+		untokenize(peekfirst(vl));
+		val = ztrdup(ugetnode(vl));
+	    }
+	    if (xtr)
+		fprintf(stderr, "%s ", val);
+	    if (export) {
+		if (export < 0) {
+		    /* We are going to fork so do not bother freeing this */
+		    pm = (Param) paramtab->removenode(paramtab, v->name);
+		    if (isset(RESTRICTED) && (pm->flags & PM_RESTRICTED)) {
+			zerr("%s: restricted", pm->nam, 0);
+			zsfree(val);
+			return;
+		    }
+		}
+		allexp = opts[ALLEXPORT];
+		opts[ALLEXPORT] = 1;
+		pm = setsparam(v->name, val);
+		opts[ALLEXPORT] = allexp;
+	    } else
+		pm = setsparam(v->name, val);
+	    if (errflag)
+		return;
+	    continue;
+	}
+	ptr = arr = (char **) zalloc(sizeof(char **) * (countlinknodes(vl) + 1));
+
+	while (nonempty(vl))
+	    *ptr++ = ztrdup((char *) ugetnode(vl));
+
+	*ptr = NULL;
+	if (xtr) {
+	    fprintf(stderr, "( ");
+	    for (ptr = arr; *ptr; ptr++)
+		fprintf(stderr, "%s ", *ptr);
+	    fprintf(stderr, ") ");
+	}
+	setaparam(v->name, arr);
+	if (errflag)
+	    return;
+    }
+}
+
+/**/
+static void
+execcmd(Cmd cmd, int input, int output, int how, int last1)
+{
+    HashNode hn = NULL;
+    LinkNode node;
+    Redir fn;
+    struct multio *mfds[10];
+    char *text;
+    int save[10];
+    int fil, dfil, is_cursh, type, i;
+    int nullexec = 0, assign = 0, forked = 0;
+    int is_shfunc = 0, is_builtin = 0, is_exec = 0;
+    /* Various flags to the command. */
+    int cflags = 0, checked = 0;
+
+    doneps4 = 0;
+    args = cmd->args;
+    type = cmd->type;
+
+    for (i = 0; i < 10; i++) {
+	save[i] = -2;
+	mfds[i] = NULL;
+    }
+
+    /* If the command begins with `%', then assume it is a *
+     * reference to a job in the job table.                */
+    if (type == SIMPLE && nonempty(args) &&
+	*(char *)peekfirst(args) == '%') {
+	pushnode(args, dupstring((how & Z_DISOWN)
+				 ? "disown" : (how & Z_ASYNC) ? "bg" : "fg"));
+	how = Z_SYNC;
+    }
+
+    /* If AUTORESUME is set, the command is SIMPLE, and doesn't have *
+     * any redirections, then check if it matches as a prefix of a   *
+     * job currently in the job table.  If it does, then we treat it *
+     * as a command to resume this job.                              */
+    if (isset(AUTORESUME) && type == SIMPLE && (how & Z_SYNC) &&
+	nonempty(args) && empty(cmd->redir) && !input &&
+	!nextnode(firstnode(args))) {
+	if (unset(NOTIFY))
+	    scanjobs();
+	if (findjobnam(peekfirst(args)) != -1)
+	    pushnode(args, dupstring("fg"));
+    }
+
+    /* Check if it's a builtin needing automatic MAGIC_EQUALS_SUBST      *
+     * handling.  Things like typeset need this.  We can't detect the    *
+     * command if it contains some tokens (e.g. x=ex; ${x}port), so this *
+     * only works in simple cases.  has_token() is called to make sure   *
+     * this really is a simple case.                                     */
+    if (type == SIMPLE) {
+	while (nonempty(args)) {
+	    char *cmdarg = (char *) peekfirst(args);
+	    checked = !has_token(cmdarg);
+	    if (!checked)
+		break;
+	    if (!(cflags & (BINF_BUILTIN | BINF_COMMAND)) &&
+		(hn = shfunctab->getnode(shfunctab, cmdarg))) {
+		is_shfunc = 1;
+		break;
+	    }
+	    if (!(hn = builtintab->getnode(builtintab, cmdarg))) {
+		checked = !(cflags & BINF_BUILTIN);
+		break;
+	    }
+	    if (!(hn->flags & BINF_PREFIX)) {
+		is_builtin = 1;
+#ifdef DYNAMIC
+		/* autoload the builtin if necessary */
+		if (!((Builtin) hn)->handlerfunc) {
+		    load_module(((Builtin) hn)->optstr);
+		    hn = builtintab->getnode(builtintab, cmdarg);
+		}
+#endif
+		assign = (hn->flags & BINF_MAGICEQUALS);
+		break;
+	    }
+	    cflags &= ~BINF_BUILTIN & ~BINF_COMMAND;
+	    cflags |= hn->flags;
+	    uremnode(args, firstnode(args));
+	    hn = NULL;
+	    checked = 0;
+	    if ((cflags & BINF_COMMAND) && unset(POSIXBUILTINS))
+		break;
+	}
+    }
+
+    /* Do prefork substitutions */
+    prefork(args, assign ? 2 : isset(MAGICEQUALSUBST));
+
+    if (type == SIMPLE) {
+	int unglobbed = 0;
+
+	for (;;) {
+	    char *cmdarg;
+
+	    if (!(cflags & BINF_NOGLOB))
+		while (!checked && !errflag && nonempty(args) &&
+		       has_token((char *) peekfirst(args)))
+		    glob(args, firstnode(args));
+	    else if (!unglobbed) {
+		for (node = firstnode(args); node; incnode(node))
+		    untokenize((char *) getdata(node));
+		unglobbed = 1;
+	    }
+
+	    /* Current shell should not fork unless the *
+	     * exec occurs at the end of a pipeline.    */
+	    if ((cflags & BINF_EXEC) && last1 == 2)
+		cmd->flags |= CFLAG_EXEC;
+
+	    /* Empty command */
+	    if (empty(args)) {
+		if (nonempty(cmd->redir)) {
+		    if (cmd->flags & CFLAG_EXEC) {
+			/* Was this "exec < foobar"? */
+			nullexec = 1;
+			break;
+		    } else if (!nullcmd || !*nullcmd ||
+			       (cflags & BINF_PREFIX)) {
+			zerr("redirection with no command", NULL, 0);
+			errflag = lastval = 1;
+			return;
+		    } else if (readnullcmd && *readnullcmd &&
+			       ((Redir) peekfirst(cmd->redir))->type == READ &&
+			       !nextnode(firstnode(cmd->redir))) {
+			addlinknode(args, dupstring(readnullcmd));
+		    } else
+			addlinknode(args, dupstring(nullcmd));
+		} else if ((cflags & BINF_PREFIX) && (cflags & BINF_COMMAND)) {
+		    lastval = 0;
+		    return;
+		} else {
+		    cmdoutval = 0;
+		    addvars(cmd->vars, 0);
+		    if (errflag)
+			lastval = errflag;
+		    else
+			lastval = cmdoutval;
+		    if (isset(XTRACE)) {
+			fputc('\n', stderr);
+			fflush(stderr);
+		    }
+		    return;
+		}
+	    } else if (isset(RESTRICTED) && (cflags & BINF_EXEC) &&
+		       (cmd->flags & CFLAG_EXEC)) {
+		zerrnam("exec", "%s: restricted", (char *) getdata(firstnode(args)), 0);
+		lastval = 1;
+		return;
+	    }
+
+	    if (errflag || checked ||
+		(unset(POSIXBUILTINS) && (cflags & BINF_COMMAND)))
+		break;
+
+	    cmdarg = (char *) peekfirst(args);
+	    if (!(cflags & (BINF_BUILTIN | BINF_COMMAND)) &&
+		(hn = shfunctab->getnode(shfunctab, cmdarg))) {
+		is_shfunc = 1;
+		break;
+	    }
+	    if (!(hn = builtintab->getnode(builtintab, cmdarg))) {
+		if (cflags & BINF_BUILTIN) {
+		    zerr("no such builtin: %s", cmdarg, 0);
+		    errflag = lastval = 1;
+		    return;
+		}
+		break;
+	    }
+	    if (!(hn->flags & BINF_PREFIX)) {
+		is_builtin = 1;
+#ifdef DYNAMIC
+		/* autoload the builtin if necessary */
+		if (!((Builtin) hn)->handlerfunc)
+		    load_module(((Builtin) hn)->optstr);
+#endif
+		break;
+	    }
+	    cflags &= ~BINF_BUILTIN & ~BINF_COMMAND;
+	    cflags |= hn->flags;
+	    uremnode(args, firstnode(args));
+	    hn = NULL;
+	}
+    }
+
+    if (errflag) {
+	lastval = 1;
+	return;
+    }
+
+    /* Get the text associated with this command. */
+    if (jobbing || (how & Z_TIMED))
+	text = getjobtext((void *) cmd);
+    else
+	text = NULL;
+
+    /* Set up special parameter $_ */
+    zsfree(underscore);
+    if (nonempty(args)
+	&& (underscore = ztrdup((char *) getdata(lastnode(args)))))
+	untokenize(underscore); 
+    else
+  	underscore = ztrdup("");
+
+    /* Warn about "rm *" */
+    if (type == SIMPLE && interact && unset(RMSTARSILENT)
+	&& isset(SHINSTDIN) && nonempty(args) && nextnode(firstnode(args))
+	&& !strcmp(peekfirst(args), "rm")) {
+	LinkNode node, next;
+
+	for (node = nextnode(firstnode(args)); node && !errflag; node = next) {
+	    char *s = (char *) getdata(node);
+	    int l = strlen(s);
+
+	    next = nextnode(node);
+	    if (s[0] == Star && !s[1]) {
+		if (!checkrmall(pwd))
+		    uremnode(args, node);
+	    } else if (l > 2 && s[l - 2] == '/' && s[l - 1] == Star) {
+		char t = s[l - 2];
+
+		s[l - 2] = 0;
+		if (!checkrmall(s))
+		    uremnode(args, node);
+		s[l - 2] = t;
+	    }
+	}
+	if (!nextnode(firstnode(args)))
+	    errflag = 1;
+    }
+
+    if (errflag) {
+	lastval = 1;
+	return;
+    }
+
+    if (type == SIMPLE && !nullexec) {
+	char *s;
+	char trycd = (isset(AUTOCD) && isset(SHINSTDIN)
+		      && empty(cmd->redir) && !empty(args)
+		      && !nextnode(firstnode(args))
+		      && *(char *)peekfirst(args));
+
+	DPUTS(empty(args), "BUG: empty(args) in exec.c");
+	if (!hn) {
+	    /* Resolve external commands */
+	    char *cmdarg = (char *) peekfirst(args);
+
+	    hn = cmdnamtab->getnode(cmdnamtab, cmdarg);
+	    if (hn && trycd && !isreallycom((Cmdnam)hn)) {
+		cmdnamtab->removenode(cmdnamtab, cmdarg);
+		cmdnamtab->freenode(hn);
+		hn = NULL;
+	    }
+	    if (!hn && isset(HASHCMDS) && strcmp(cmdarg, "..")) {
+		for (s = cmdarg; *s && *s != '/'; s++);
+		if (!*s)
+		    hn = (HashNode) hashcmd(cmdarg, pathchecked);
+	    }
+	}
+
+	/* If no command found yet, see if it  *
+	 * is a directory we should AUTOCD to. */
+	if (!hn && trycd && (s = cancd(peekfirst(args)))) {
+	    peekfirst(args) = (void *) s;
+	    pushnode(args, dupstring("cd"));
+	    if ((hn = builtintab->getnode(builtintab, "cd")))
+		is_builtin = 1;
+	}
+    }
+
+    /* This is nonzero if the command is a current shell procedure? */
+    is_cursh = (is_builtin || is_shfunc || (type >= CURSH) || nullexec);
+
+    /**************************************************************************
+     * Do we need to fork?  We need to fork if:                               *
+     * 1) The command is supposed to run in the background. (or)              *
+     * 2) There is no `exec' flag, and either:                                *
+     *    a) This is a builtin or shell function with output piped somewhere. *
+     *    b) This is an external command and we can't do a `fake exec'.       *
+     *                                                                        *
+     * A `fake exec' is possible if we have all the following conditions:     *
+     * 1) last1 flag is 1.  This indicates that the current shell will not    *
+     *    be needed after the current command.  This is typically the case    *
+     *    when when the command is the last stage in a subshell, or is the    *
+     *    last command after the option `-c'.                                 *
+     * 2) We are not trapping EXIT or ZERR.                                   *
+     * 3) We don't have any files to delete.                                  *
+     *                                                                        *
+     * The condition above for a `fake exec' will also work for a current     *
+     * shell command such as a builtin, but doesn't really buy us anything    *
+     * (doesn't save us a process), since it is already running in the        *
+     * current shell.                                                         *
+     **************************************************************************/
+
+    if ((how & Z_ASYNC) || (!(cmd->flags & CFLAG_EXEC) &&
+       (((is_builtin || is_shfunc) && output) ||
+       (!is_cursh && (last1 != 1 || sigtrapped[SIGZERR] ||
+        sigtrapped[SIGEXIT] || havefiles()))))) {
+
+	pid_t pid;
+	int synch[2];
+	char dummy;
+
+	child_block();
+	pipe(synch);
+
+	if ((pid = zfork()) == -1) {
+	    close(synch[0]);
+	    close(synch[1]);
+	    return;
+	} if (pid) {
+	    close(synch[1]);
+	    read(synch[0], &dummy, 1);
+	    close(synch[0]);
+#ifdef PATH_DEV_FD
+	    closem(2);
+#endif
+	    if (how & Z_ASYNC) {
+		lastpid = (long) pid;
+	    } else if (!jobtab[thisjob].stty_in_env && nonempty(cmd->vars)) {
+		/* search for STTY=... */
+		while (nonempty(cmd->vars))
+		    if (!strcmp(((Varasg) ugetnode(cmd->vars))->name, "STTY")) {
+			jobtab[thisjob].stty_in_env = 1;
+			break;
+		    }
+	    }
+	    addproc(pid, text);
+	    return;
+	}
+	/* pid == 0 */
+	close(synch[0]);
+	entersubsh(how, type != SUBSH && !(how & Z_ASYNC) ? 2 : 1, 0);
+	close(synch[1]);
+	forked = 1;
+	if (sigtrapped[SIGINT] & ZSIG_IGNORED)
+	    holdintr();
+#ifdef HAVE_NICE
+	/* Check if we should run background jobs at a lower priority. */
+	if ((how & Z_ASYNC) && isset(BGNICE))
+	    nice(5);
+#endif /* HAVE_NICE */
+
+    } else if (is_cursh) {
+	/* This is a current shell procedure that didn't need to fork.    *
+	 * This includes current shell procedures that are being exec'ed, *
+	 * as well as null execs.                                         */
+	jobtab[thisjob].stat |= STAT_CURSH;
+    } else {
+	/* This is an exec (real or fake) for an external command.    *
+	 * Note that any form of exec means that the subshell is fake *
+	 * (but we may be in a subshell already).                     */
+	is_exec = 1;
+    }
+
+    if (!(cflags & BINF_NOGLOB))
+	globlist(args);
+    if (errflag) {
+	lastval = 1;
+	goto err;
+    }
+
+    /* Add pipeline input/output to mnodes */
+    if (input)
+	addfd(forked, save, mfds, 0, input, 0);
+    if (output)
+	addfd(forked, save, mfds, 1, output, 1);
+
+    /* Do process substitutions */
+    spawnpipes(cmd->redir);
+
+    /* Do io redirections */
+    while (nonempty(cmd->redir)) {
+	fn = (Redir) ugetnode(cmd->redir);
+	DPUTS(fn->type == HEREDOC || fn->type == HEREDOCDASH,
+	      "BUG: unexpanded here document");
+	if (fn->type == INPIPE) {
+	    if (fn->fd2 == -1) {
+		closemnodes(mfds);
+		fixfds(save);
+		execerr();
+	    }
+	    addfd(forked, save, mfds, fn->fd1, fn->fd2, 0);
+	} else if (fn->type == OUTPIPE) {
+	    if (fn->fd2 == -1) {
+		closemnodes(mfds);
+		fixfds(save);
+		execerr();
+	    }
+	    addfd(forked, save, mfds, fn->fd1, fn->fd2, 1);
+	} else {
+	    if (fn->type != HERESTR && xpandredir(fn, cmd->redir))
+		continue;
+	    if (errflag) {
+		closemnodes(mfds);
+		fixfds(save);
+		execerr();
+	    }
+	    if (isset(RESTRICTED) && IS_WRITE_FILE(fn->type)) {
+		zerr("writing redirection not allowed in restricted mode", NULL, 0);
+		execerr();
+	    }
+	    if (unset(EXECOPT))
+		continue;
+	    switch(fn->type) {
+	    case HERESTR:
+		fil = getherestr(fn);
+		if (fil == -1) {
+		    closemnodes(mfds);
+		    fixfds(save);
+		    if (errno != EINTR)
+			zerr("%e", NULL, errno);
+		    execerr();
+		}
+		addfd(forked, save, mfds, fn->fd1, fil, 0);
+		break;
+	    case READ:
+	    case READWRITE:
+		if (fn->type == READ)
+		    fil = open(unmeta(fn->name), O_RDONLY | O_NOCTTY);
+		else
+		    fil = open(unmeta(fn->name),
+			       O_RDWR | O_CREAT | O_NOCTTY, 0666);
+		if (fil == -1) {
+		    closemnodes(mfds);
+		    fixfds(save);
+		    if (errno != EINTR)
+			zerr("%e: %s", fn->name, errno);
+		    execerr();
+		}
+		addfd(forked, save, mfds, fn->fd1, fil, 0);
+		/* If this is 'exec < file', read from stdin, *
+		 * not terminal, unless `file' is a terminal. */
+		if (nullexec && fn->fd1 == 0 && isset(SHINSTDIN) && interact)
+		    init_io();
+		break;
+	    case CLOSE:
+		if (!forked && fn->fd1 < 10 && save[fn->fd1] == -2)
+		    save[fn->fd1] = movefd(fn->fd1);
+		closemn(mfds, fn->fd1);
+		zclose(fn->fd1);
+		break;
+	    case MERGEIN:
+	    case MERGEOUT:
+		if(fn->fd2 < 10)
+		    closemn(mfds, fn->fd2);
+		fil = dup(fn->fd2);
+		if (fil == -1) {
+		    char fdstr[4];
+
+		    closemnodes(mfds);
+		    fixfds(save);
+		    sprintf(fdstr, "%d", fn->fd2);
+		    zerr("%s: %e", fdstr, errno);
+		    execerr();
+		}
+		addfd(forked, save, mfds, fn->fd1, fil, fn->type == MERGEOUT);
+		break;
+	    default:
+		if (IS_APPEND_REDIR(fn->type))
+		    fil = open(unmeta(fn->name),
+			       (unset(CLOBBER) && !IS_CLOBBER_REDIR(fn->type)) ?
+			       O_WRONLY | O_APPEND | O_NOCTTY :
+			       O_WRONLY | O_APPEND | O_CREAT | O_NOCTTY, 0666);
+		else
+		    fil = clobber_open(fn);
+		if(fil != -1 && IS_ERROR_REDIR(fn->type))
+		    dfil = dup(fil);
+		else
+		    dfil = 0;
+		if (fil == -1 || dfil == -1) {
+		    if(fil != -1)
+			close(fil);
+		    closemnodes(mfds);
+		    fixfds(save);
+		    if (errno != EINTR)
+			zerr("%e: %s", fn->name, errno);
+		    execerr();
+		}
+		addfd(forked, save, mfds, fn->fd1, fil, 1);
+		if(IS_ERROR_REDIR(fn->type))
+		    addfd(forked, save, mfds, 2, dfil, 1);
+		break;
+	    }
+	}
+    }
+
+    /* We are done with redirection.  close the mnodes, *
+     * spawning tee/cat processes as necessary.         */
+    for (i = 0; i < 10; i++)
+	closemn(mfds, i);
+
+    if (nullexec) {
+	for (i = 0; i < 10; i++)
+	    if (save[i] != -2)
+		zclose(save[i]);
+	/*
+	 * Here we specifically *don't* restore the original fd's
+	 * before returning.
+	 */
+	return;
+    }
+
+    if (isset(EXECOPT) && !errflag) {
+	/*
+	 * We delay the entersubsh() to here when we are exec'ing
+	 * the current shell (including a fake exec to run a builtin then
+	 * exit) in case there is an error return.
+	 */
+	if (is_exec)
+	    entersubsh(how, type != SUBSH ? 2 : 1, 1);
+	if (type >= CURSH) {
+	    static int (*func[]) _((Cmd)) = {
+		execcursh, exectime, execfuncdef, execfor, execwhile,
+		execrepeat, execif, execcase, execselect, execcond,
+		execarith, execautofn
+	    };
+
+	    if (last1 == 1)
+		cmd->flags |= CFLAG_EXEC;
+	    lastval = (func[type - CURSH]) (cmd);
+	} else if (is_builtin || is_shfunc) {
+	    LinkList restorelist = 0, removelist = 0;
+	    /* builtin or shell function */
+
+	    if (!forked && ((cflags & BINF_COMMAND) ||
+			    (unset(POSIXBUILTINS) && !assign) ||
+			    (isset(POSIXBUILTINS) && !is_shfunc &&
+			     !(hn->flags & BINF_PSPECIAL))))
+		save_params(cmd, &restorelist, &removelist);
+
+	    if (cmd->vars) {
+		/* Export this if the command is a shell function,
+		 * but not if it's a builtin.
+		 */
+		addvars(cmd->vars, is_shfunc);
+		if (errflag) {
+		    restore_params(restorelist, removelist);
+		    lastval = 1;
+		    fixfds(save);
+		    return;
+		}
+	    }
+
+	    if (is_shfunc) {
+		/* It's a shell function */
+#ifdef PATH_DEV_FD
+		int i;
+
+		for (i = 10; i <= max_zsh_fd; i++)
+		    if (fdtable[i] > 1)
+			fdtable[i]++;
+#endif
+		if (subsh_close >= 0)
+		    zclose(subsh_close);
+		subsh_close = -1;
+		execshfunc(cmd, (Shfunc) hn);
+#ifdef PATH_DEV_FD
+		for (i = 10; i <= max_zsh_fd; i++)
+		    if (fdtable[i] > 1)
+			if (--(fdtable[i]) <= 2)
+			    zclose(i);
+#endif
+	    } else {
+		/* It's a builtin */
+		if (forked)
+		    closem(1);
+		lastval = execbuiltin(args, (Builtin) hn);
+#ifdef PATH_DEV_FD
+		closem(2);
+#endif
+		if (isset(PRINTEXITVALUE) && isset(SHINSTDIN) && lastval && !subsh) {
+		    fprintf(stderr, "zsh: exit %ld\n", (long)lastval);
+		}
+		fflush(stdout);
+		if (save[1] == -2) {
+		    if (ferror(stdout)) {
+			zerr("write error: %e", NULL, errno);
+			clearerr(stdout);
+			errflag = 0;
+		    }
+		} else
+		    clearerr(stdout);
+	    }
+
+	    if (cmd->flags & CFLAG_EXEC) {
+		if (subsh)
+		    _exit(lastval);
+
+		/* If we are exec'ing a command, and we are not in a subshell, *
+		 * then check if we should save the history file.              */
+		if (isset(RCS) && interact && !nohistsave)
+		    savehistfile(getsparam("HISTFILE"), 1, isset(APPENDHISTORY) ? 3 : 0);
+		exit(lastval);
+	    }
+
+	    restore_params(restorelist, removelist);
+
+	} else {
+	    if (cmd->flags & CFLAG_EXEC) {
+		setiparam("SHLVL", --shlvl);
+		/* If we are exec'ing a command, and we are not *
+		 * in a subshell, then save the history file.   */
+		if (!subsh && isset(RCS) && interact && !nohistsave)
+		    savehistfile(getsparam("HISTFILE"), 1, isset(APPENDHISTORY) ? 3 : 0);
+	    }
+	    if (type == SIMPLE) {
+		if (cmd->vars) {
+		    addvars(cmd->vars, -1);
+		    if (errflag)
+			_exit(1);
+		}
+		closem(1);
+		if (coprocin)
+		    zclose(coprocin);
+		if (coprocout)
+		    zclose(coprocout);
+#ifdef HAVE_GETRLIMIT
+		if (!forked)
+		    setlimits(NULL);
+#endif
+		execute((Cmdnam) hn, cflags & BINF_DASH);
+	    } else {		/* ( ... ) */
+		DPUTS(cmd->vars && nonempty(cmd->vars),
+		      "BUG: assigment before complex command");
+		list_pipe = 0;
+		if (subsh_close >= 0)
+		    zclose(subsh_close);
+                subsh_close = -1;
+		/* If we're forked (and we should be), no need to return */
+		DPUTS(last1 != 1 && !forked, "BUG: not exiting?");
+		execlist(cmd->u.list, 0, 1);
+	    }
+	}
+    }
+
+  err:
+    if (forked)
+	_exit(lastval);
+    fixfds(save);
+}
+
+/* Arrange to have variables restored. */
+
+/**/
+static void
+save_params(Cmd cmd, LinkList *restore_p, LinkList *remove_p)
+{
+    Param pm;
+    LinkNode node;
+    char *s;
+
+    MUSTUSEHEAP("save_params()");
+
+    *restore_p = newlinklist();
+    *remove_p = newlinklist();
+
+    for (node = firstnode(cmd->vars); node; incnode(node)) {
+	s = ((Varasg) getdata(node))->name;
+	if ((pm = (Param) paramtab->getnode(paramtab, s))) {
+	    if (!(pm->flags & PM_SPECIAL)) {
+		paramtab->removenode(paramtab, s);
+	    } else if (!(pm->flags & PM_READONLY) &&
+		       (unset(RESTRICTED) || !(pm->flags & PM_RESTRICTED))) {
+		Param tpm = (Param) alloc(sizeof *tpm);
+
+		tpm->nam = s;
+		tpm->flags = pm->flags;
+		switch (PM_TYPE(pm->flags)) {
+		case PM_SCALAR:
+		    tpm->u.str = ztrdup(pm->gets.cfn(pm));
+		    break;
+		case PM_INTEGER:
+		    tpm->u.val = pm->gets.ifn(pm);
+		    break;
+		case PM_ARRAY:
+		    PERMALLOC {
+			tpm->u.arr = arrdup(pm->gets.afn(pm));
+		    } LASTALLOC;
+		    break;
+		}
+		pm = tpm;
+	    }
+	    addlinknode(*remove_p, s);
+	    addlinknode(*restore_p, pm);
+	} else {
+	    addlinknode(*remove_p, s);
+	}
+    }
+}
+
+/* Restore saved parameters after executing a shfunc or builtin */
+
+/**/
+static void
+restore_params(LinkList restorelist, LinkList removelist)
+{
+    Param pm;
+    char *s;
+
+    if (removelist) {
+	/* remove temporary parameters */
+	while ((s = (char *) ugetnode(removelist))) {
+	    if ((pm = (Param) paramtab->getnode(paramtab, s)) &&
+		!(pm->flags & PM_SPECIAL)) {
+		pm->flags &= ~PM_READONLY;
+		unsetparam_pm(pm, 0, 0);
+	    }
+	}
+    }
+
+    if (restorelist) {
+	/* restore saved parameters */
+	while ((pm = (Param) ugetnode(restorelist))) {
+	    if (pm->flags & PM_SPECIAL) {
+		Param tpm = (Param) paramtab->getnode(paramtab, pm->nam);
+
+		DPUTS(!tpm || PM_TYPE(pm->flags) != PM_TYPE(tpm->flags) ||
+		      !(pm->flags & PM_SPECIAL),
+		      "BUG: in restoring special parameters");
+		tpm->flags = pm->flags;
+		switch (PM_TYPE(pm->flags)) {
+		case PM_SCALAR:
+		    tpm->sets.cfn(tpm, pm->u.str);
+		    break;
+		case PM_INTEGER:
+		    tpm->sets.ifn(tpm, pm->u.val);
+		    break;
+		case PM_ARRAY:
+		    tpm->sets.afn(tpm, pm->u.arr);
+		    break;
+		}
+	    } else
+		paramtab->addnode(paramtab, pm->nam, pm);
+	    if (pm->flags & PM_EXPORTED)
+		pm->env = addenv(pm->nam, getsparam(pm->nam));
+	}
+    }
+}
+
+/* restore fds after redirecting a builtin */
+
+/**/
+static void
+fixfds(int *save)
+{
+    int old_errno = errno;
+    int i;
+
+    for (i = 0; i != 10; i++)
+	if (save[i] != -2)
+	    redup(save[i], i);
+    errno = old_errno;
+}
+
+/**/
+static void
+entersubsh(int how, int cl, int fake)
+{
+    int sig;
+
+    if (cl != 2)
+	for (sig = 0; sig < VSIGCOUNT; sig++)
+	    if (!(sigtrapped[sig] & ZSIG_FUNC))
+		unsettrap(sig);
+    if (unset(MONITOR)) {
+	if (how & Z_ASYNC) {
+	    settrap(SIGINT, NULL);
+	    settrap(SIGQUIT, NULL);
+	    if (isatty(0)) {
+		close(0);
+		if (open("/dev/null", O_RDWR | O_NOCTTY)) {
+		    zerr("can't open /dev/null: %e", NULL, errno);
+		    _exit(1);
+		}
+	    }
+	}
+    } else if (thisjob != -1 && cl) {
+	if (jobtab[list_pipe_job].gleader && (list_pipe || list_pipe_child)) {
+	    if (kill(jobtab[list_pipe_job].gleader, 0) == -1 ||
+		setpgrp(0L, jobtab[list_pipe_job].gleader) == -1) {
+		jobtab[list_pipe_job].gleader =
+		    jobtab[thisjob].gleader = mypgrp;
+		setpgrp(0L, mypgrp);
+
+		if (how & Z_SYNC)
+		    attachtty(jobtab[thisjob].gleader);
+	    }
+	}
+	else if (!jobtab[thisjob].gleader ||
+		 (setpgrp(0L, jobtab[thisjob].gleader) == -1)) {
+	    jobtab[thisjob].gleader = getpid();
+	    if (list_pipe_job != thisjob &&
+		!jobtab[list_pipe_job].gleader)
+		jobtab[list_pipe_job].gleader = jobtab[thisjob].gleader;
+	    setpgrp(0L, jobtab[thisjob].gleader);
+	    if (how & Z_SYNC)
+		attachtty(jobtab[thisjob].gleader);
+	}
+    }
+    if (!fake)
+	subsh = 1;
+    if (SHTTY != -1) {
+	zclose(SHTTY);
+	SHTTY = -1;
+    }
+    if (isset(MONITOR)) {
+	signal_default(SIGTTOU);
+	signal_default(SIGTTIN);
+	signal_default(SIGTSTP);
+    }
+    if (interact) {
+	signal_default(SIGTERM);
+	if (!(sigtrapped[SIGINT] & ZSIG_IGNORED))
+	    signal_default(SIGINT);
+    }
+    if (!(sigtrapped[SIGQUIT] & ZSIG_IGNORED))
+	signal_default(SIGQUIT);
+    opts[MONITOR] = opts[USEZLE] = 0;
+    zleactive = 0;
+    if (cl)
+	clearjobtab();
+    times(&shtms);
+}
+
+/* close internal shell fds */
+
+/**/
+void
+closem(int how)
+{
+    int i;
+
+    for (i = 10; i <= max_zsh_fd; i++)
+	if (fdtable[i] && (!how || fdtable[i] == how))
+	    zclose(i);
+}
+
+/* convert here document into a here string */
+
+/**/
+char *
+gethere(char *str, int typ)
+{
+    char *buf;
+    int bsiz, qt = 0, strip = 0;
+    char *s, *t, *bptr, c;
+
+    for (s = str; *s; s++)
+	if (INULL(*s)) {
+	    *s = Nularg;
+	    qt = 1;
+	}
+    untokenize(str);
+    if (typ == HEREDOCDASH) {
+	strip = 1;
+	while (*str == '\t')
+	    str++;
+    }
+    bptr = buf = zalloc(bsiz = 256);
+    for (;;) {
+	t = bptr;
+
+	while ((c = hgetc()) == '\t' && strip)
+	    ;
+	for (;;) {
+	    if (bptr == buf + bsiz) {
+		buf = realloc(buf, 2 * bsiz);
+		t = buf + bsiz - (bptr - t);
+		bptr = buf + bsiz;
+		bsiz *= 2;
+	    }
+	    if (lexstop || c == '\n')
+		break;
+	    *bptr++ = c;
+	    c = hgetc();
+	}
+	*bptr = '\0';
+	if (!strcmp(t, str))
+	    break;
+	if (lexstop) {
+	    t = bptr;
+	    break;
+	}
+	*bptr++ = '\n';
+    }
+    if (t > buf && t[-1] == '\n')
+	t--;
+    *t = '\0';
+    if (!qt)
+	parsestr(buf);
+    s = dupstring(buf);
+    zfree(buf, bsiz);
+    return s;
+}
+
+/* open here string fd */
+
+/**/
+static int
+getherestr(struct redir *fn)
+{
+    char *s, *t;
+    int fd, len;
+
+    t = fn->name;
+    singsub(&t);
+    untokenize(t);
+    unmetafy(t, &len);
+    t[len++] = '\n';
+    s = gettempname();
+    if (!s || (fd = open(s, O_CREAT|O_WRONLY|O_EXCL|O_NOCTTY, 0600)) == -1)
+	return -1;
+    write(fd, t, len);
+    close(fd);
+    fd = open(s, O_RDONLY | O_NOCTTY);
+    unlink(s);
+    return fd;
+}
+
+/* $(...) */
+
+/**/
+LinkList
+getoutput(char *cmd, int qt)
+{
+    List list;
+    int pipes[2];
+    pid_t pid;
+    Cmd c;
+    Redir r;
+
+    if (!(list = parse_string(cmd)))
+	return NULL;
+    if (list != &dummy_list && !list->right && !list->left->flags &&
+	list->left->type == END && list->left->left->type == END &&
+	(c = list->left->left->left)->type == SIMPLE && empty(c->args) &&
+	empty(c->vars) && nonempty(c->redir) &&
+	!nextnode(firstnode(c->redir)) &&
+	(r = (Redir) getdata(firstnode(c->redir)))->fd1 == 0 &&
+	r->type == READ) {
+	/* $(< word) */
+	int stream;
+	char *s = r->name;
+
+	singsub(&s);
+	if (errflag)
+	    return NULL;
+	untokenize(s);
+	if ((stream = open(unmeta(s), O_RDONLY | O_NOCTTY)) == -1) {
+	    zerr("%e: %s", s, errno);
+	    return NULL;
+	}
+	return readoutput(stream, qt);
+    }
+
+    mpipe(pipes);
+    child_block();
+    cmdoutval = 0;
+    if ((cmdoutpid = pid = zfork()) == -1) {
+	/* fork error */
+	zclose(pipes[0]);
+	zclose(pipes[1]);
+	errflag = 1;
+	cmdoutpid = 0;
+	child_unblock();
+	return NULL;
+    } else if (pid) {
+	LinkList retval;
+
+	zclose(pipes[1]);
+	retval = readoutput(pipes[0], qt);
+	fdtable[pipes[0]] = 0;
+	child_suspend(0);		/* unblocks */
+	lastval = cmdoutval;
+	return retval;
+    }
+
+    /* pid == 0 */
+    child_unblock();
+    zclose(pipes[0]);
+    redup(pipes[1], 1);
+    opts[MONITOR] = 0;
+    entersubsh(Z_SYNC, 1, 0);
+    execlist(list, 0, 1);
+    close(1);
+    _exit(lastval);
+    zerr("exit returned in child!!", NULL, 0);
+    kill(getpid(), SIGKILL);
+    return NULL;
+}
+
+/* read output of command substitution */
+
+/**/
+static LinkList
+readoutput(int in, int qt)
+{
+    LinkList ret;
+    char *buf, *ptr;
+    int bsiz, c, cnt = 0;
+    FILE *fin;
+
+    fin = fdopen(in, "r");
+    ret = newlinklist();
+    ptr = buf = (char *) ncalloc(bsiz = 64);
+    while ((c = fgetc(fin)) != EOF || errno == EINTR) {
+	if (c == EOF) {
+	    errno = 0;
+	    clearerr(fin);
+	    continue;
+	}
+	if (imeta(c)) {
+	    *ptr++ = Meta;
+	    c ^= 32;
+	    cnt++;
+	}
+	if (++cnt >= bsiz) {
+	    char *pp = (char *) ncalloc(bsiz *= 2);
+
+	    memcpy(pp, buf, cnt - 1);
+	    ptr = (buf = pp) + cnt - 1;
+	}
+	*ptr++ = c;
+    }
+    fclose(fin);
+    while (cnt && ptr[-1] == '\n')
+	ptr--, cnt--;
+    *ptr = '\0';
+    if (qt) {
+	if (!cnt) {
+	    *ptr++ = Nularg;
+	    *ptr = '\0';
+	}
+	addlinknode(ret, buf);
+    } else {
+	char **words = spacesplit(buf, 0);
+
+	while (*words) {
+	    if (isset(GLOBSUBST))
+		tokenize(*words);
+	    addlinknode(ret, *words++);
+	}
+    }
+    return ret;
+}
+
+/**/
+static List
+parsecmd(char *cmd)
+{
+    char *str;
+    List list;
+
+    for (str = cmd + 2; *str && *str != Outpar; str++);
+    if (!*str || cmd[1] != Inpar) {
+	zerr("oops.", NULL, 0);
+	return NULL;
+    }
+    *str = '\0';
+    if (str[1] || !(list = parse_string(cmd + 2))) {
+	zerr("parse error in process substitution", NULL, 0);
+	return NULL;
+    }
+    return list;
+}
+
+/* =(...) */
+
+/**/
+char *
+getoutputfile(char *cmd)
+{
+    pid_t pid;
+    char *nam;
+    List list;
+    int fd;
+
+    if (thisjob == -1)
+	return NULL;
+    if (!(list = parsecmd(cmd)))
+	return NULL;
+    if (!(nam = gettempname()))
+	return NULL;
+
+    nam = ztrdup(nam);
+    PERMALLOC {
+	if (!jobtab[thisjob].filelist)
+	    jobtab[thisjob].filelist = newlinklist();
+	addlinknode(jobtab[thisjob].filelist, nam);
+    } LASTALLOC;
+    child_block();
+    fd = open(nam, O_WRONLY | O_CREAT | O_EXCL | O_NOCTTY, 0600);
+
+    if (fd < 0 || (cmdoutpid = pid = zfork()) == -1) {
+	/* fork or open error */
+	child_unblock();
+	return nam;
+    } else if (pid) {
+	int os;
+
+	close(fd);
+	os = jobtab[thisjob].stat;
+	waitforpid(pid);
+	cmdoutval = 0;
+	jobtab[thisjob].stat = os;
+	return nam;
+    }
+
+    /* pid == 0 */
+    redup(fd, 1);
+    opts[MONITOR] = 0;
+    entersubsh(Z_SYNC, 1, 0);
+    execlist(list, 0, 1);
+    close(1);
+    _exit(lastval);
+    zerr("exit returned in child!!", NULL, 0);
+    kill(getpid(), SIGKILL);
+    return NULL;
+}
+
+#if !defined(PATH_DEV_FD) && defined(HAVE_FIFOS)
+/* get a temporary named pipe */
+
+static char *
+namedpipe(void)
+{
+    char *tnam = gettempname();
+
+# ifdef HAVE_MKFIFO
+    if (mkfifo(tnam, 0600) < 0)
+# else
+    if (mknod(tnam, 0010600, 0) < 0)
+# endif
+	return NULL;
+    return tnam;
+}
+#endif /* ! PATH_DEV_FD && HAVE_FIFOS */
+
+/* <(...) or >(...) */
+
+/**/
+char *
+getproc(char *cmd)
+{
+#if !defined(HAVE_FIFOS) && !defined(PATH_DEV_FD)
+    zerr("doesn't look like your system supports FIFOs.", NULL, 0);
+    return NULL;
+#else
+    List list;
+    int out = *cmd == Inang;
+    char *pnam;
+#ifndef PATH_DEV_FD
+    int fd;
+#else
+    int pipes[2];
+#endif
+
+    if (thisjob == -1)
+	return NULL;
+#ifndef PATH_DEV_FD
+    if (!(pnam = namedpipe()))
+	return NULL;
+#else
+    pnam = ncalloc(strlen(PATH_DEV_FD) + 6);
+#endif
+    if (!(list = parsecmd(cmd)))
+	return NULL;
+#ifndef PATH_DEV_FD
+    PERMALLOC {
+	if (!jobtab[thisjob].filelist)
+	    jobtab[thisjob].filelist = newlinklist();
+	addlinknode(jobtab[thisjob].filelist, ztrdup(pnam));
+    } LASTALLOC;
+    if (zfork()) {
+#else
+    mpipe(pipes);
+    if (zfork()) {
+	sprintf(pnam, "%s/%d", PATH_DEV_FD, pipes[!out]);
+	zclose(pipes[out]);
+	fdtable[pipes[!out]] = 2;
+#endif
+	return pnam;
+    }
+#ifndef PATH_DEV_FD
+    closem(0);
+    fd = open(pnam, out ? O_WRONLY | O_NOCTTY : O_RDONLY | O_NOCTTY);
+    if (fd == -1) {
+	zerr("can't open %s: %e", pnam, errno);
+	_exit(1);
+    }
+    entersubsh(Z_ASYNC, 1, 0);
+    redup(fd, out);
+#else
+    entersubsh(Z_ASYNC, 1, 0);
+    redup(pipes[out], out);
+    closem(0);   /* this closes pipes[!out] as well */
+#endif
+    execlist(list, 0, 1);
+    zclose(out);
+    _exit(lastval);
+    return NULL;
+#endif   /* HAVE_FIFOS and PATH_DEV_FD not defined */
+}
+
+/* > >(...) or < <(...) (does not use named pipes) */
+
+/**/
+static int
+getpipe(char *cmd)
+{
+    List list;
+    int pipes[2], out = *cmd == Inang;
+
+    if (!(list = parsecmd(cmd)))
+	return -1;
+    mpipe(pipes);
+    if (zfork()) {
+	zclose(pipes[out]);
+	return pipes[!out];
+    }
+    entersubsh(Z_ASYNC, 1, 0);
+    redup(pipes[out], out);
+    closem(0);	/* this closes pipes[!out] as well */
+    execlist(list, 0, 1);
+    _exit(lastval);
+    return 0;
+}
+
+/* open pipes with fds >= 10 */
+
+/**/
+static void
+mpipe(int *pp)
+{
+    pipe(pp);
+    pp[0] = movefd(pp[0]);
+    pp[1] = movefd(pp[1]);
+}
+
+/* Do process substitution with redirection */
+
+/**/
+static void
+spawnpipes(LinkList l)
+{
+    LinkNode n;
+    Redir f;
+    char *str;
+
+    n = firstnode(l);
+    for (; n; incnode(n)) {
+	f = (Redir) getdata(n);
+	if (f->type == OUTPIPE || f->type == INPIPE) {
+	    str = f->name;
+	    f->fd2 = getpipe(str);
+	}
+    }
+}
+
+/* evaluate a [[ ... ]] */
+
+/**/
+static int
+execcond(Cmd cmd)
+{
+    return !evalcond(cmd->u.cond);
+}
+
+/* evaluate a ((...)) arithmetic command */
+
+/**/
+static int
+execarith(Cmd cmd)
+{
+    char *e;
+    long val = 0;
+
+    while ((e = (char *) ugetnode(cmd->args)))
+	val = matheval(e);
+    errflag = 0;
+    return !val;
+}
+
+/* perform time ... command */
+
+/**/
+static int
+exectime(Cmd cmd)
+{
+    int jb;
+
+    jb = thisjob;
+    if (!cmd->u.pline) {
+	shelltime();
+	return 0;
+    }
+    execpline(cmd->u.pline, Z_TIMED|Z_SYNC, 0);
+    thisjob = jb;
+    return lastval;
+}
+
+/* Define a shell function */
+
+/**/
+static int
+execfuncdef(Cmd cmd)
+{
+    Shfunc shf;
+    char *s;
+    int signum;
+
+    PERMALLOC {
+	while ((s = (char *) ugetnode(cmd->args))) {
+	    shf = (Shfunc) zalloc(sizeof *shf);
+	    shf->funcdef = (List) dupstruct(cmd->u.list);
+	    shf->flags = 0;
+
+	    /* is this shell function a signal trap? */
+	    if (!strncmp(s, "TRAP", 4) && (signum = getsignum(s + 4)) != -1) {
+		if (settrap(signum, shf->funcdef)) {
+		    freestruct(shf->funcdef);
+		    zfree(shf, sizeof *shf);
+		    LASTALLOC_RETURN 1;
+		}
+		sigtrapped[signum] |= ZSIG_FUNC;
+	    }
+	    shfunctab->addnode(shfunctab, ztrdup(s), shf);
+	}
+    } LASTALLOC;
+    if(isset(HISTNOFUNCTIONS))
+	remhist();
+    return 0;
+}
+
+/* Main entry point to execute a shell function. */
+
+/**/
+static void
+execshfunc(Cmd cmd, Shfunc shf)
+{
+    LinkList last_file_list = NULL;
+
+    if (errflag)
+	return;
+
+    if (!list_pipe) {
+	/* Without this deletejob the process table *
+	 * would be filled by a recursive function. */
+	last_file_list = jobtab[thisjob].filelist;
+	jobtab[thisjob].filelist = NULL;
+	deletejob(jobtab + thisjob);
+    }
+
+    doshfunc(shf->funcdef, cmd->args, shf->flags, 0);
+
+    if (!list_pipe)
+	deletefilelist(last_file_list);
+}
+
+/* Function to execute the special type of command that represents an *
+ * autoloaded shell function.  The command structure tells us which   *
+ * function it is.  This function is actually called as part of the   *
+ * execution of the autoloaded function itself, so when the function  *
+ * has been autoloaded, its list is just run with no frills.          */
+
+/**/
+static int
+execautofn(Cmd cmd)
+{
+    Shfunc shf = cmd->u.autofn->shf;
+    List l = getfpfunc(shf->nam);
+    if(l == &dummy_list) {
+	zerr("%s: function definition file not found", shf->nam, 0);
+	return 1;
+    }
+    if(isset(KSHAUTOLOAD)) {
+	VARARR(char, n, strlen(shf->nam) + 1);
+	strcpy(n, shf->nam);
+	execlist(l, 1, 0);
+	shf = (Shfunc) shfunctab->getnode(shfunctab, n);
+	if(!shf || (shf->flags & PM_UNDEFINED)) {
+	    zerr("%s: function not defined by file", n, 0);
+	    return 1;
+	}
+    } else {
+	freestruct(shf->funcdef);
+	PERMALLOC {
+	    shf->funcdef = dupstruct(stripkshdef(l, shf->nam));
+	} LASTALLOC;
+	shf->flags &= ~PM_UNDEFINED;
+    }
+    HEAPALLOC {
+	execlist(dupstruct(shf->funcdef), 1, 0);
+    } LASTALLOC;
+    return lastval;
+}
+
+/* execute a shell function */
+
+/**/
+void
+doshfunc(List list, LinkList doshargs, int flags, int noreturnval)
+/* If noreturnval is nonzero, then reset the current return *
+ * value (lastval) to its value before the shell function   *
+ * was executed.                                            */
+{
+    char **tab, **x, *oargv0 = NULL;
+    int xexittr, newexittr, oldzoptind, oldlastval;
+    char *ou;
+    void *xexitfn, *newexitfn;
+    char saveopts[OPT_SIZE];
+    int obreaks = breaks;
+
+    HEAPALLOC {
+	pushheap();
+	if (trapreturn < 0)
+	    trapreturn--;
+	oldlastval = lastval;
+	xexittr = sigtrapped[SIGEXIT];
+	if (xexittr & ZSIG_FUNC)
+	    xexitfn = shfunctab->removenode(shfunctab, "TRAPEXIT");
+	else
+	    xexitfn = sigfuncs[SIGEXIT];
+	sigtrapped[SIGEXIT] = 0;
+	sigfuncs[SIGEXIT] = NULL;
+	tab = pparams;
+	oldzoptind = zoptind;
+	zoptind = 1;
+
+	/* We need to save the current options even if LOCALOPTIONS is *
+	 * not currently set.  That's because if it gets set in the    *
+	 * function we need to restore the original options on exit.   */
+	memcpy(saveopts, opts, sizeof(opts));
+
+	if (flags & PM_TAGGED)
+	    opts[XTRACE] = 1;
+	opts[PRINTEXITVALUE] = 0;
+	if (doshargs) {
+	    LinkNode node;
+
+	    node = doshargs->first;
+	    pparams = x = (char **) zcalloc(((sizeof *x) * (1 + countlinknodes(doshargs))));
+	    if (isset(FUNCTIONARGZERO)) {
+		oargv0 = argzero;
+		argzero = ztrdup((char *) node->dat);
+	    }
+	    node = node->next;
+	    for (; node; node = node->next, x++)
+		*x = ztrdup((char *) node->dat);
+	} else {
+	    pparams = (char **) zcalloc(sizeof *pparams);
+	    if (isset(FUNCTIONARGZERO)) {
+		oargv0 = argzero;
+		argzero = ztrdup(argzero);
+	    }
+	}
+	startparamscope();
+	ou = underscore;
+	underscore = ztrdup(underscore);
+	execlist(dupstruct(list), 1, 0);
+	zsfree(underscore);
+	underscore = ou;
+	endparamscope();
+
+	if (retflag) {
+	    retflag = 0;
+	    breaks = obreaks;
+	}
+	freearray(pparams);
+	if (oargv0) {
+	    zsfree(argzero);
+	    argzero = oargv0;
+	}
+	zoptind = oldzoptind;
+	pparams = tab;
+
+	if (isset(LOCALOPTIONS)) {
+	    /* restore all shell options except PRIVILEGED and RESTRICTED */
+	    saveopts[PRIVILEGED] = opts[PRIVILEGED];
+	    saveopts[RESTRICTED] = opts[RESTRICTED];
+	    memcpy(opts, saveopts, sizeof(opts));
+	} else {
+	    /* just restore a couple. */
+	    opts[XTRACE] = saveopts[XTRACE];
+	    opts[PRINTEXITVALUE] = saveopts[PRINTEXITVALUE];
+	    opts[LOCALOPTIONS] = saveopts[LOCALOPTIONS];
+	}
+
+	/*
+	 * The trap '...' EXIT runs in the environment of the caller,
+	 * so remember it here but run it after resetting the
+	 * traps for the parent.
+	 */
+	newexittr = sigtrapped[SIGEXIT];
+	newexitfn = sigfuncs[SIGEXIT];
+	if (newexittr & ZSIG_FUNC)
+	    shfunctab->removenode(shfunctab, "TRAPEXIT");
+
+	sigtrapped[SIGEXIT] = xexittr;
+	if (xexittr & ZSIG_FUNC) {
+	    shfunctab->addnode(shfunctab, ztrdup("TRAPEXIT"), xexitfn);
+	    sigfuncs[SIGEXIT] = ((Shfunc) xexitfn)->funcdef;
+	} else
+	    sigfuncs[SIGEXIT] = (List) xexitfn;
+
+	if (newexitfn) {
+	    dotrapargs(SIGEXIT, &newexittr, newexitfn);
+	    freestruct(newexitfn);
+	}
+
+	if (trapreturn < -1)
+	    trapreturn++;
+	if (noreturnval)
+	    lastval = oldlastval;
+	popheap();
+    } LASTALLOC;
+}
+
+/* Search fpath for an undefined function.  Finds the file, and returns the *
+ * list of its contents.                                                    */
+
+/**/
+static List
+getfpfunc(char *s)
+{
+    char **pp, buf[PATH_MAX];
+    off_t len;
+    char *d;
+    List r;
+    int fd;
+
+    pp = fpath;
+    for (; *pp; pp++) {
+	if (strlen(*pp) + strlen(s) + 1 >= PATH_MAX)
+	    continue;
+	if (**pp)
+	    sprintf(buf, "%s/%s", *pp, s);
+	else
+	    strcpy(buf, s);
+	unmetafy(buf, NULL);
+	if (!access(buf, R_OK) && (fd = open(buf, O_RDONLY | O_NOCTTY)) != -1) {
+	    if ((len = lseek(fd, 0, 2)) != -1) {
+		lseek(fd, 0, 0);
+		d = (char *) zcalloc(len + 1);
+		if (read(fd, d, len) == len) {
+		    close(fd);
+		    d = metafy(d, len, META_REALLOC);
+		    HEAPALLOC {
+			r = parse_string(d);
+		    } LASTALLOC;
+		    zfree(d, len + 1);
+		    return r;
+		} else {
+		    zfree(d, len + 1);
+		    close(fd);
+		}
+	    } else {
+		close(fd);
+	    }
+	}
+    }
+    return &dummy_list;
+}
+
+/* Handle the most common type of ksh-style autoloading, when doing a      *
+ * zsh-style autoload.  Given the list read from an autoload file, and the *
+ * name of the function being defined, check to see if the file consists   *
+ * entirely of a single definition for that function.  If so, use the      *
+ * contents of that definition.  Otherwise, use the entire file.           */
+
+/**/
+static List
+stripkshdef(List l, char *name)
+{
+    Sublist s;
+    Pline p;
+    Cmd c;
+    if(!l)
+	return NULL;
+    if(l->type != Z_SYNC || l->right)
+	return l;
+    s = l->left;
+    if(s->flags || s->right)
+	return l;
+    p = s->left;
+    if(p->right)
+	return l;
+    c = p->left;
+    if(c->type != FUNCDEF || c->flags ||
+	nonempty(c->redir) || nonempty(c->vars) ||
+	empty(c->args) || lastnode(c->args) != firstnode(c->args) ||
+	strcmp(name, peekfirst(c->args)))
+	return l;
+    return c->u.list;
+}
+
+/* check to see if AUTOCD applies here */
+
+/**/
+static char *
+cancd(char *s)
+{
+    int nocdpath = s[0] == '.' &&
+    (s[1] == '/' || !s[1] || (s[1] == '.' && (s[2] == '/' || !s[1])));
+    char *t;
+
+    if (*s != '/') {
+	char sbuf[PATH_MAX], **cp;
+
+	if (cancd2(s))
+	    return s;
+	if (access(unmeta(s), X_OK) == 0)
+	    return NULL;
+	if (!nocdpath)
+	    for (cp = cdpath; *cp; cp++) {
+		if (strlen(*cp) + strlen(s) + 1 >= PATH_MAX)
+		    continue;
+		if (**cp)
+		    sprintf(sbuf, "%s/%s", *cp, s);
+		else
+		    strcpy(sbuf, s);
+		if (cancd2(sbuf)) {
+		    doprintdir = -1;
+		    return dupstring(sbuf);
+		}
+	    }
+	if ((t = cd_able_vars(s))) {
+	    if (cancd2(t)) {
+		doprintdir = -1;
+		return t;
+	    }
+	}
+	return NULL;
+    }
+    return cancd2(s) ? s : NULL;
+}
+
+/**/
+static int
+cancd2(char *s)
+{
+    struct stat buf;
+    char *us = unmeta(s);
+
+    return !(access(us, X_OK) || stat(us, &buf) || !S_ISDIR(buf.st_mode));
+}
+
+/**/
+void
+execsave(void)
+{
+    struct execstack *es;
+
+    es = (struct execstack *) malloc(sizeof(struct execstack));
+    es->args = args;
+    es->list_pipe_pid = list_pipe_pid;
+    es->nowait = nowait;
+    es->pline_level = pline_level;
+    es->list_pipe_child = list_pipe_child;
+    es->list_pipe_job = list_pipe_job;
+    strcpy(es->list_pipe_text, list_pipe_text);
+    es->lastval = lastval;
+    es->noeval = noeval;
+    es->badcshglob = badcshglob;
+    es->cmdoutpid = cmdoutpid;
+    es->cmdoutval = cmdoutval;
+    es->trapreturn = trapreturn;
+    es->noerrs = noerrs;
+    es->subsh_close = subsh_close;
+    es->underscore = underscore;
+    underscore = ztrdup(underscore);
+    es->next = exstack;
+    exstack = es;
+    noerrs = cmdoutpid = 0;
+}
+
+/**/
+void
+execrestore(void)
+{
+    struct execstack *en;
+
+    DPUTS(!exstack, "BUG: execrestore() without execsave()");
+    args = exstack->args;
+    list_pipe_pid = exstack->list_pipe_pid;
+    nowait = exstack->nowait;
+    pline_level = exstack->pline_level;
+    list_pipe_child = exstack->list_pipe_child;
+    list_pipe_job = exstack->list_pipe_job;
+    strcpy(list_pipe_text, exstack->list_pipe_text);
+    lastval = exstack->lastval;
+    noeval = exstack->noeval;
+    badcshglob = exstack->badcshglob;
+    cmdoutpid = exstack->cmdoutpid;
+    cmdoutval = exstack->cmdoutval;
+    trapreturn = exstack->trapreturn;
+    noerrs = exstack->noerrs;
+    subsh_close = exstack->subsh_close;
+    zsfree(underscore);
+    underscore = exstack->underscore;
+    en = exstack->next;
+    free(exstack);
+    exstack = en;
+}
diff --git a/Src/glob.c b/Src/glob.c
new file mode 100644
index 000000000..be7a04515
--- /dev/null
+++ b/Src/glob.c
@@ -0,0 +1,2800 @@
+/*
+ * glob.c - filename generation
+ *
+ * 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 "glob.pro"
+
+/* flag for CSHNULLGLOB */
+ 
+/**/
+int badcshglob;
+ 
+static int mode;		/* != 0 if we are parsing glob patterns */
+static int pathpos;		/* position in pathbuf                  */
+static int matchsz;		/* size of matchbuf                     */
+static int matchct;		/* number of matches found              */
+static char *pathbuf;		/* pathname buffer                      */
+static int pathbufsz;		/* size of pathbuf			*/
+static int pathbufcwd;		/* where did we chdir()'ed		*/
+static char **matchbuf;		/* array of matches                     */
+static char **matchptr;		/* &matchbuf[matchct]                   */
+static char *colonmod;		/* colon modifiers in qualifier list    */
+
+typedef struct stat *Statptr;	 /* This makes the Ultrix compiler happy.  Go figure. */
+
+/* modifier for unit conversions */
+
+#define TT_DAYS 0
+#define TT_HOURS 1
+#define TT_MINS 2
+#define TT_WEEKS 3
+#define TT_MONTHS 4
+
+#define TT_BYTES 0
+#define TT_POSIX_BLOCKS 1
+#define TT_KILOBYTES 2
+#define TT_MEGABYTES 3
+
+typedef int (*TestMatchFunc) _((struct stat *, long));
+
+struct qual {
+    struct qual *next;		/* Next qualifier, must match                */
+    struct qual *or;		/* Alternative set of qualifiers to match    */
+    TestMatchFunc func;		/* Function to call to test match            */
+    long data;			/* Argument passed to function               */
+    int sense;			/* Whether asserting or negating             */
+    int amc;			/* Flag for which time to test (a, m, c)     */
+    int range;			/* Whether to test <, > or = (as per signum) */
+    int units;			/* Multiplier for time or size, respectively */
+};
+
+/* Qualifiers pertaining to current pattern */
+static struct qual *quals;
+
+/* Other state values for current pattern */
+static int qualct, qualorct;
+static int range, amc, units;
+static int gf_nullglob, gf_markdirs, gf_noglobdots, gf_listtypes, gf_follow;
+
+/* Prefix, suffix for doing zle trickery */
+
+/**/
+char *glob_pre, *glob_suf;
+
+/* pathname component in filename patterns */
+
+struct complist {
+    Complist next;
+    Comp comp;
+    int closure;		/* 1 if this is a (foo/)# */
+    int follow; 		/* 1 to go thru symlinks */
+};
+struct comp {
+    Comp left, right, next, exclude;
+    char *str;
+    int stat;
+};
+
+/* Type of Comp:  a closure with one or two #'s, the end of a *
+ * pattern or path component, a piece of path to be added.    */
+#define C_ONEHASH	1
+#define C_TWOHASH	2
+#define C_OPTIONAL	4
+#define C_STAR		8    
+#define C_CLOSURE	(C_ONEHASH|C_TWOHASH|C_OPTIONAL|C_STAR)
+#define C_LAST		16
+#define C_PATHADD	32
+
+/* Test macros for the above */
+#define CLOSUREP(c)	(c->stat & C_CLOSURE)
+#define ONEHASHP(c)	(c->stat & (C_ONEHASH|C_STAR))
+#define TWOHASHP(c)	(c->stat & C_TWOHASH)
+#define OPTIONALP(c)	(c->stat & C_OPTIONAL)
+#define STARP(c)	(c->stat & C_STAR)
+#define LASTP(c)	(c->stat & C_LAST)
+#define PATHADDP(c)	(c->stat & C_PATHADD)
+
+/* Flags passed down to guts when compiling */
+#define GF_PATHADD	1	/* file glob, adding path components */
+#define GF_TOPLEV	2	/* outside (), so ~ ends main match */
+
+static char *pptr;		/* current place in string being matched */
+static Comp tail;
+static int first;		/* are leading dots special? */
+
+/* Add a component to pathbuf: This keeps track of how    *
+ * far we are into a file name, since each path component *
+ * must be matched separately.                            */
+
+/**/
+static void
+addpath(char *s)
+{
+    DPUTS(!pathbuf, "BUG: pathbuf not initialised");
+    while (pathpos + (int) strlen(s) + 1 >= pathbufsz)
+	pathbuf = realloc(pathbuf, pathbufsz *= 2);
+    while ((pathbuf[pathpos++] = *s++));
+    pathbuf[pathpos - 1] = '/';
+    pathbuf[pathpos] = '\0';
+}
+
+/* stat the filename s appended to pathbuf.  l should be true for lstat,    *
+ * false for stat.  If st is NULL, the file is only chechked for existance. *
+ * s == "" is treated as s == ".".  This is necessary since on most systems *
+ * foo/ can be used to reference a non-directory foo.  Returns nonzero if   *
+ * the file does not exists.                                                */
+
+/**/
+static int
+statfullpath(const char *s, struct stat *st, int l)
+{
+    char buf[PATH_MAX];
+
+    DPUTS(strlen(s) + !*s + pathpos - pathbufcwd >= PATH_MAX,
+	  "BUG: statfullpath(): pathname too long");
+    strcpy(buf, pathbuf + pathbufcwd);
+    strcpy(buf + pathpos - pathbufcwd, s);
+    if (!*s) {
+	buf[pathpos - pathbufcwd] = '.';
+	buf[pathpos - pathbufcwd + 1] = '\0';
+	l = 0;
+    }
+    unmetafy(buf, NULL);
+    if (!st)
+	return access(buf, F_OK) && (!l || readlink(buf, NULL, 0));
+    return l ? lstat(buf, st) : stat(buf, st);
+}
+
+/* add a match to the list */
+
+/**/
+static void
+insert(char *s, int checked)
+{
+    struct stat buf, buf2, *bp;
+    char *news = s;
+    int statted = 0;
+
+    if (gf_listtypes || gf_markdirs) {
+	/* Add the type marker to the end of the filename */
+	mode_t mode;
+	checked = statted = 1;
+	if (statfullpath(s, &buf, 1))
+	    return;
+	mode = buf.st_mode;
+	if (gf_follow) {
+	    if (!S_ISLNK(mode) || statfullpath(s, &buf2, 0))
+		memcpy(&buf2, &buf, sizeof(buf));
+	    statted = 2;
+	    mode = buf2.st_mode;
+	}
+	if (gf_listtypes || S_ISDIR(mode)) {
+	    int ll = strlen(s);
+
+	    news = (char *)ncalloc(ll + 2);
+	    strcpy(news, s);
+	    news[ll] = file_type(mode);
+	    news[ll + 1] = '\0';
+	}
+    }
+    if (qualct || qualorct) {
+	/* Go through the qualifiers, rejecting the file if appropriate */
+	struct qual *qo, *qn;
+
+	if (!statted && statfullpath(s, &buf, 1))
+	    return;
+	qo = quals;
+	for (qn = qo; qn && qn->func;) {
+	    range = qn->range;
+	    amc = qn->amc;
+	    units = qn->units;
+	    if ((qn->sense & 2) && statted != 2) {
+		/* If (sense & 2), we're following links */
+		if (!S_ISLNK(buf.st_mode) || statfullpath(s, &buf2, 0))
+		    memcpy(&buf2, &buf, sizeof(buf));
+		statted = 2;
+	    }
+	    bp = (qn->sense & 2) ? &buf2 : &buf;
+	    /* Reject the file if the function returned zero *
+	     * and the sense was positive (sense&1 == 0), or *
+	     * vice versa.                                   */
+	    if ((!((qn->func) (bp, qn->data)) ^ qn->sense) & 1) {
+		/* Try next alternative, or return if there are no more */
+		if (!(qo = qo->or))
+		    return;
+		qn = qo;
+		continue;
+	    }
+	    qn = qn->next;
+	}
+    } else if (!checked && statfullpath(s, NULL, 1))
+	return;
+
+    news = dyncat(pathbuf, news);
+    if (colonmod) {
+	/* Handle the remainder of the qualifer:  e.g. (:r:s/foo/bar/). */
+	s = colonmod;
+	modify(&news, &s);
+    }
+    *matchptr++ = news;
+    if (++matchct == matchsz) {
+	matchbuf = (char **)realloc((char *)matchbuf,
+				    sizeof(char **) * (matchsz *= 2));
+
+	matchptr = matchbuf + matchct;
+    }
+}
+
+/* Check to see if str is eligible for filename generation. */
+
+/**/
+int
+haswilds(char *str)
+{
+    /* `[' and `]' are legal even if bad patterns are usually not. */
+    if ((*str == Inbrack || *str == Outbrack) && !str[1])
+	return 0;
+
+    /* If % is immediately followed by ?, then that ? is     *
+     * not treated as a wildcard.  This is so you don't have *
+     * to escape job references such as %?foo.               */
+    if (str[0] == '%' && str[1] == Quest)
+	str[1] = '?';
+
+    for (; *str; str++) {
+	switch (*str) {
+	    case Inpar:
+	    case Bar:
+	    case Star:
+	    case Inbrack:
+	    case Inang:
+	    case Quest:
+		return 1;
+	    case Pound:
+	    case Hat:
+		if (isset(EXTENDEDGLOB))
+		    return 1;
+		break;
+	}
+    }
+    return 0;
+}
+
+/* Do the globbing:  scanner is called recursively *
+ * with successive bits of the path until we've    *
+ * tried all of it.                                */
+
+/**/
+static void
+scanner(Complist q)
+{
+    Comp c;
+    int closure;
+    int pbcwdsav = pathbufcwd;
+    struct dirsav ds;
+
+    ds.ino = ds.dev = 0;
+    ds.dirname = NULL;
+    ds.dirfd = ds.level = -1;
+    if (!q)
+	return;
+
+    if ((closure = q->closure))	/* (foo/)# - match zero or more dirs */
+	if (q->closure == 2)	/* (foo/)## - match one or more dirs */
+	    q->closure = 1;
+	else
+	    scanner(q->next);
+    c = q->comp;
+    /* Now the actual matching for the current path section. */
+    if (!(c->next || c->left) && !haswilds(c->str)) {
+	/* It's a straight string to the end of the path section. */
+	int l = strlen(c->str);
+
+	if (l + !l + pathpos - pathbufcwd >= PATH_MAX) {
+	    int err;
+
+	    if (l >= PATH_MAX)
+		return;
+	    err = lchdir(pathbuf + pathbufcwd, &ds, 0);
+	    if (err == -1)
+		return;
+	    if (err) {
+		zerr("current directory lost during glob", NULL, 0);
+		return;
+	    }
+	    pathbufcwd = pathpos;
+	}
+	if (q->next) {
+	    /* Not the last path section. Just add it to the path. */
+	    int oppos = pathpos;
+
+	    if (!errflag && !(q->closure && !strcmp(c->str, "."))) {
+		addpath(c->str);
+		if (!closure || statfullpath("", NULL, 1))
+		    scanner((q->closure) ? q : q->next);
+		pathbuf[pathpos = oppos] = '\0';
+	    }
+	} else
+	    insert(c->str, 0);
+    } else {
+	/* Do pattern matching on current path section. */
+	char *fn;
+	int dirs = !!q->next;
+	DIR *lock;
+	char *subdirs = NULL;
+	int subdirlen = 0;
+
+	fn = pathbuf[pathbufcwd] ? unmeta(pathbuf + pathbufcwd) : ".";
+	if (dirs) {
+	    struct stat st;
+	    stat(fn, &st);
+	    /* a directory with subdirectories has link count greater than 2 */
+	    if (!S_ISDIR(st.st_mode) || st.st_nlink == 2)
+		return;
+	}
+	lock = opendir(fn);
+	if (lock == NULL)
+	    return;
+	while ((fn = zreaddir(lock, 1)) && !errflag) {
+	    /* prefix and suffix are zle trickery */
+	    if (!dirs && !colonmod &&
+		((glob_pre && !strpfx(glob_pre, fn))
+		 || (glob_suf && !strsfx(glob_suf, fn))))
+		continue;
+	    if (domatch(fn, c, gf_noglobdots)) {
+		/* if this name matchs the pattern... */
+		if (pbcwdsav == pathbufcwd &&
+		    strlen(fn) + pathpos - pathbufcwd >= PATH_MAX) {
+		    int err;
+
+		    DPUTS(pathpos == pathbufcwd,
+			  "BUG: filename longer than PATH_MAX");
+		    err = lchdir(pathbuf + pathbufcwd, &ds, 0);
+		    if (err == -1)
+			break;
+		    if (err) {
+			zerr("current directory lost during glob", NULL, 0);
+			break;
+		    }
+		    pathbufcwd = pathpos;
+		}
+		if (dirs) {
+		    int l;
+
+		    /* if not the last component in the path */
+		    if (closure) {
+			/* if matching multiple directories */
+			struct stat buf;
+
+			if (statfullpath(fn, &buf, !q->follow)) {
+			    if (errno != ENOENT && errno != EINTR &&
+				errno != ENOTDIR && !errflag) {
+				zerr("%e: %s", fn, errno);
+				errflag = 0;
+			    }
+			    continue;
+			}
+			if (!S_ISDIR(buf.st_mode))
+			    continue;
+		    }
+		    l = strlen(fn) + 1;
+		    subdirs = hrealloc(subdirs, subdirlen, subdirlen + l);
+		    strcpy(subdirs + subdirlen, fn);
+		    subdirlen += l;
+		} else
+		    /* if the last filename component, just add it */
+		    insert(fn, 1);
+	    }
+	}
+	closedir(lock);
+	if (subdirs) {
+	    int oppos = pathpos;
+
+	    for (fn = subdirs; fn < subdirs+subdirlen; fn += strlen(fn) + 1) {
+		addpath(fn);
+		scanner((q->closure) ? q : q->next);  /* scan next level */
+		pathbuf[pathpos = oppos] = '\0';
+	    }
+	    hrealloc(subdirs, subdirlen, 0);
+	}
+    }
+    if (pbcwdsav < pathbufcwd) {
+	if (restoredir(&ds))
+	    zerr("current directory lost during glob", NULL, 0);
+	zsfree(ds.dirname);
+	if (ds.dirfd >= 0)
+	    close(ds.dirfd);
+	pathbufcwd = pbcwdsav;
+    }
+}
+
+/* Parse a series of path components pointed to by pptr */
+
+/* enum used with ksh-like patterns, @(...) etc. */
+
+enum { KF_NONE, KF_AT, KF_QUEST, KF_STAR, KF_PLUS, KF_NOT };
+
+/* parse lowest level pattern */
+
+/**/
+static Comp
+parsecomp(int gflag)
+{
+    int kshfunc;
+    Comp c = (Comp) alloc(sizeof *c), c1, c2;
+    char *cstr, *ls = NULL;
+
+    /* In case of alternatives, code coming up is stored in tail. */
+    c->next = tail;
+    cstr = pptr;
+
+    while (*pptr && (mode || *pptr != '/') && *pptr != Bar &&
+	   (unset(EXTENDEDGLOB) || *pptr != Tilde ||
+	    !pptr[1] || pptr[1] == Outpar || pptr[1] == Bar) &&
+	   *pptr != Outpar) {
+	/* Go through code until we find something separating alternatives,
+	 * or path components if relevant.
+	 */
+	if (*pptr == Hat && isset(EXTENDEDGLOB)) {
+	    /* negate remaining pattern */
+	    Comp stail = tail;
+	    tail = NULL;
+	    c->str = dupstrpfx(cstr, pptr - cstr);
+	    pptr++;
+
+	    c1 = (Comp) alloc(sizeof *c1);
+	    c1->stat |= C_STAR;
+
+	    c2 = (Comp) alloc(sizeof *c2);
+	    if (!(c2->exclude = parsecomp(gflag)))
+		return NULL;
+	    if (!*pptr || *pptr == '/')
+		c2->stat |= C_LAST;
+	    c2->left = c1;
+	    c2->next = stail;
+	    c->next = c2;
+	    tail = stail;
+	    return c;
+	}
+
+	/* Ksh-type globs */
+	kshfunc = KF_NONE;
+	if (isset(KSHGLOB) && *pptr && pptr[1] == Inpar) {
+	    switch (*pptr) {
+	    case '@':		/* just do paren as usual */
+		kshfunc = KF_AT;
+		break;
+
+	    case Quest:
+	    case '?':		/* matched optionally, treat as (...|) */
+		kshfunc = KF_QUEST;
+		break;
+
+	    case Star:
+	    case '*':		/* treat as (...)# */
+		kshfunc = KF_STAR;
+		break;
+
+	    case '+':		/* treat as (...)## */
+		kshfunc = KF_PLUS;
+		break;
+
+	    case '!':		/* treat as (*~...) */
+		kshfunc = KF_NOT;
+		break;
+	    }
+	    if (kshfunc != KF_NONE)
+		pptr++;
+	}
+
+	if (*pptr == Inpar) {
+	    /* Found a group (...) */
+	    char *startp = pptr, *endp;
+	    Comp stail = tail;
+	    int dpnd = 0;
+
+	    /* Need matching close parenthesis */
+	    if (skipparens(Inpar, Outpar, &pptr)) {
+		errflag = 1;
+		return NULL;
+	    }
+	    if (kshfunc == KF_STAR)
+		dpnd = 1;
+	    else if (kshfunc == KF_PLUS)
+		dpnd = 2;
+	    else if (kshfunc == KF_QUEST)
+		dpnd = 3;
+	    if (*pptr == Pound && isset(EXTENDEDGLOB)) {
+		/* Zero (or one) or more repetitions of group */
+		pptr++;
+		if(*pptr == Pound) {
+		    pptr++;
+		    if(dpnd == 0)
+			dpnd = 2;
+		    else if(dpnd == 3)
+			dpnd = 1;
+		} else
+		    dpnd = 1;
+	    }
+	    /* Parse the remaining pattern following the group... */
+	    if (!(c1 = parsecomp(gflag)))
+		return NULL;
+	    /* ...remembering what comes after it... */
+	    tail = (dpnd || kshfunc == KF_NOT) ? NULL : c1;
+	    /* ...before going back and parsing inside the group. */
+	    endp = pptr;
+	    pptr = startp;
+	    c->str = dupstrpfx(cstr, (pptr - cstr) - (kshfunc != KF_NONE));
+	    pptr++;
+	    c2 = (Comp) alloc(sizeof *c);
+	    c->next = c2;
+	    c2->next = (dpnd || kshfunc == KF_NOT) ?
+		c1 : (Comp) alloc(sizeof *c);
+	    if (!(c2->left = parsecompsw(0)))
+		return NULL;
+	    if (kshfunc == KF_NOT) {
+		/* we'd actually rather it didn't match.  Instead, match *
+		 * a star and put the parsed pattern into exclude.       */
+		Comp c3 = (Comp) alloc(sizeof *c3);
+		c3->stat |= C_STAR;
+
+		c2->exclude = c2->left;
+		c2->left = c3;
+	    }
+	    /* Remember closures for group. */
+	    if (dpnd)
+		c2->stat |= (dpnd == 3) ? C_OPTIONAL
+		    : (dpnd == 2) ? C_TWOHASH : C_ONEHASH;
+	    pptr = endp;
+	    tail = stail;
+	    return c;
+	}
+	if (*pptr == Star && pptr[1] &&
+	    (unset(EXTENDEDGLOB) || !(gflag & GF_TOPLEV) ||
+	     pptr[1] != Tilde || !pptr[2] || pptr[2] == Bar ||
+	     pptr[2] == Outpar) && (mode || pptr[1] != '/')) {
+	    /* Star followed by other patterns is now treated as a special
+	     * type of closure in doesmatch().
+	     */
+	    c->str = dupstrpfx(cstr, pptr - cstr);
+	    pptr++;
+	    c1 = (Comp) alloc(sizeof *c1);
+	    c1->stat |= C_STAR;
+	    if (!(c2 = parsecomp(gflag)))
+		return NULL;
+	    c1->next = c2;
+	    c->next = c1;
+	    return c;
+	}
+	if (*pptr == Pound && isset(EXTENDEDGLOB)) {
+	    /* repeat whatever we've just had (ls) zero or more times */
+	    if (!ls)
+		return NULL;
+	    c2 = (Comp) alloc(sizeof *c);
+	    c2->str = dupstrpfx(ls, pptr - ls);
+	    pptr++;
+	    if (*pptr == Pound) {
+		/* need one or more matches: cheat by copying previous char */
+		pptr++;
+		c->next = c1 = (Comp) alloc(sizeof *c);
+		c1->str = c2->str;
+	    } else
+		c1 = c;
+	    c1->next = c2;
+	    c2->stat |= C_ONEHASH;
+	    /* parse the rest of the pattern and return. */
+	    c2->next = parsecomp(gflag);
+	    if (!c2->next)
+		return NULL;
+	    c->str = dupstrpfx(cstr, ls - cstr);
+	    return c;
+	}
+	ls = pptr;		/* whatever we just parsed */
+	if (*pptr == Inang) {
+	    /* Numeric glob */
+	    int dshct;
+
+	    dshct = (pptr[1] == Outang);
+	    while (*++pptr && *pptr != Outang)
+		if (*pptr == '-' && !dshct)
+		    dshct = 1;
+		else if (!idigit(*pptr))
+		    break;
+	    if (*pptr != Outang)
+		return NULL;
+	} else if (*pptr == Inbrack) {
+	    /* Character set: brackets had better match */
+	    if (pptr[1] == Outbrack)
+		*++pptr = ']';
+	    else if ((pptr[1] == Hat || pptr[1] == '^' || pptr[1] == '!') &&
+		     pptr[2] == Outbrack)
+		*(pptr += 2) = ']';
+	    while (*++pptr && *pptr != Outbrack) {
+		if (itok(*pptr)) {
+		    /* POSIX classes: make sure it's a real one, *
+		     * leave the Inbrack tokenised if so.        */
+		    char *nptr;
+		    if (*pptr == Inbrack && pptr[1] == ':'
+			&& (nptr = strchr(pptr+2, ':')) && 
+			*++nptr == Outbrack)
+			pptr = nptr;
+		    *pptr = ztokens[*pptr - Pound];
+		}
+	    }
+	    if (*pptr != Outbrack)
+		return NULL;
+	} else if (itok(*pptr) && *pptr != Star && *pptr != Quest)
+	    /* something that can be tokenised which isn't otherwise special */
+	    *pptr = ztokens[*pptr - Pound];
+	pptr++;
+    }
+    /* mark if last pattern component in path component or pattern */
+    if (*pptr == '/' || !*pptr ||
+	(isset(EXTENDEDGLOB) && *pptr == Tilde && (gflag & GF_TOPLEV)))
+	c->stat |= C_LAST;
+    c->str = dupstrpfx(cstr, pptr - cstr);
+    return c;
+}
+
+/* Parse pattern possibly with different alternatives (|) */
+
+/**/
+static Comp
+parsecompsw(int gflag)
+{
+    Comp c1, c2, c3, excl = NULL, stail = tail;
+    char *sptr;
+
+    /*
+     * Check for a tilde in the expression.  We need to know this in 
+     * advance so as to be able to treat the whole a~b expression by
+     * backtracking:  see exclusion code in doesmatch().
+     */
+    if (isset(EXTENDEDGLOB)) {
+	int pct = 0;
+	for (sptr = pptr; *sptr; sptr++) {
+	    if (*sptr == Inpar)
+		pct++;
+	    else if (*sptr == Outpar && --pct < 0)
+		break;
+	    else if (*sptr == Bar && !pct)
+		break;
+	    else if (*sptr == Tilde && !pct) {
+		tail = NULL;
+		break;
+	    }
+	}
+    }
+
+    c1 = parsecomp(gflag);
+    if (!c1)
+	return NULL;
+    if (isset(EXTENDEDGLOB) && *pptr == Tilde) {
+	/* Matching remainder of pattern excludes the pattern from matching */
+	int oldmode = mode;
+
+	mode = 1;
+	pptr++;
+	excl = parsecomp(gflag);
+	mode = oldmode;
+	if (!excl)
+	    return NULL;
+    }
+    tail = stail;
+    if (*pptr == Bar || excl) {
+	/* found an alternative or something to exclude */
+	c2 = (Comp) alloc(sizeof *c2);
+	if (*pptr == Bar) {
+	    /* get the next alternative after the | */
+	    pptr++;
+	    c3 = parsecompsw(gflag);
+	    if (!c3)
+		return NULL;
+	} else
+	    c3 = NULL;
+	/* mark if end of pattern or path component */
+	if (!*pptr || *pptr == '/')
+	    c1->stat |= c2->stat = C_LAST;
+	c2->str = dupstring("");
+	c2->left = c1;
+	c2->right = c3;
+	if ((c2->exclude = excl))
+	    c2->next = stail;
+	if (gflag & GF_PATHADD)
+	    c2->stat |= C_PATHADD;
+	return c2;
+    }
+    return c1;
+}
+
+/* This function tokenizes a zsh glob pattern */
+
+/**/
+static Complist
+parsecomplist(void)
+{
+    Comp c1;
+    Complist p1;
+    char *str;
+
+    if (pptr[0] == Star && pptr[1] == Star &&
+        (pptr[2] == '/' || (pptr[2] == Star && pptr[3] == '/'))) {
+	/* Match any number of directories. */
+	int follow;
+
+	/* with three stars, follow symbolic links */
+	follow = (pptr[2] == Star);
+	pptr += (3 + follow);
+
+	/* Now get the next path component if there is one. */
+	p1 = (Complist) alloc(sizeof *p1);
+	if ((p1->next = parsecomplist()) == NULL) {
+	    errflag = 1;
+	    return NULL;
+	}
+	p1->comp = (Comp) alloc(sizeof *p1->comp);
+	p1->comp->stat |= C_LAST;	/* end of path component  */
+	p1->comp->str = dupstring("*");
+	*p1->comp->str = Star;		/* match anything...      */
+	p1->closure = 1;		/* ...zero or more times. */
+	p1->follow = follow;
+	return p1;
+    }
+
+    /* Parse repeated directories such as (dir/)# and (dir/)## */
+    if (*(str = pptr) == Inpar && !skipparens(Inpar, Outpar, &str) &&
+        *str == Pound && isset(EXTENDEDGLOB) && str[-2] == '/') {
+	pptr++;
+	if (!(c1 = parsecompsw(0)))
+	    return NULL;
+	if (pptr[0] == '/' && pptr[1] == Outpar && pptr[2] == Pound) {
+	    int pdflag = 0;
+
+	    pptr += 3;
+	    if (*pptr == Pound) {
+		pdflag = 1;
+		pptr++;
+	    }
+	    p1 = (Complist) alloc(sizeof *p1);
+	    p1->comp = c1;
+	    p1->closure = 1 + pdflag;
+	    p1->follow = 0;
+	    p1->next = parsecomplist();
+	    return (p1->comp) ? p1 : NULL;
+	}
+    } else {
+	/* parse single path component */
+	if (!(c1 = parsecompsw(GF_PATHADD|GF_TOPLEV)))
+	    return NULL;
+	/* then do the remaining path compoents */
+	if (*pptr == '/' || !*pptr) {
+	    int ef = *pptr == '/';
+
+	    p1 = (Complist) alloc(sizeof *p1);
+	    p1->comp = c1;
+	    p1->closure = 0;
+	    p1->next = ef ? (pptr++, parsecomplist()) : NULL;
+	    return (ef && !p1->next) ? NULL : p1;
+	}
+    }
+    errflag = 1;
+    return NULL;
+}
+
+/* turn a string into a Complist struct:  this has path components */
+
+/**/
+static Complist
+parsepat(char *str)
+{
+    mode = 0;			/* path components present */
+    pptr = str;
+    tail = NULL;
+    return parsecomplist();
+}
+
+/* get number after qualifier */
+
+/**/
+static long
+qgetnum(char **s)
+{
+    long v = 0;
+
+    if (!idigit(**s)) {
+	zerr("number expected", NULL, 0);
+	return 0;
+    }
+    while (idigit(**s))
+	v = v * 10 + *(*s)++ - '0';
+    return v;
+}
+
+/* get octal number after qualifier */
+
+/**/
+static long
+qgetoctnum(char **s)
+{
+    long v = 0;
+
+    if (!idigit(**s)) {
+	zerr("octal number expected", NULL, 0);
+	return 0;
+    }
+    while (**s >= '0' && **s <= '7')
+	v = v * 010 + *(*s)++ - '0';
+    return v;
+}
+
+/* Main entry point to the globbing code for filename globbing. *
+ * np points to a node in the list list which will be expanded  *
+ * into a series of nodes.                                      */
+
+/**/
+void
+glob(LinkList list, LinkNode np)
+{
+    struct qual *qo, *qn, *ql;
+    LinkNode node = prevnode(np);
+    char *str;				/* the pattern                   */
+    int sl;				/* length of the pattern         */
+    Complist q;				/* pattern after parsing         */
+    char *ostr = (char *)getdata(np);	/* the pattern before the parser */
+					/* chops it up                   */
+
+    MUSTUSEHEAP("glob");
+    if (unset(GLOBOPT) || !haswilds(ostr)) {
+	untokenize(ostr);
+	return;
+    }
+    str = dupstring(ostr);
+    sl = strlen(str);
+    uremnode(list, np);
+
+    /* Initialise state variables for current file pattern */
+    qo = qn = quals = ql = NULL;
+    qualct = qualorct = 0;
+    colonmod = NULL;
+    gf_nullglob = isset(NULLGLOB);
+    gf_markdirs = isset(MARKDIRS);
+    gf_listtypes = gf_follow = 0;
+    gf_noglobdots = unset(GLOBDOTS);
+
+    /* Check for qualifiers */
+    if (isset(BAREGLOBQUAL) && str[sl - 1] == Outpar) {
+	char *s;
+
+	/* Check these are really qualifiers, not a set of *
+	 * alternatives or exclusions                      */
+	for (s = str + sl - 2; *s != Inpar; s--)
+	    if (*s == Bar || *s == Outpar ||
+		(isset(EXTENDEDGLOB) && *s == Tilde))
+		break;
+	if (*s == Inpar) {
+	    /* Real qualifiers found. */
+	    int sense = 0;	/* bit 0 for match (0)/don't match (1)   */
+				/* bit 1 for follow links (2), don't (0) */
+	    long data = 0;	/* Any numerical argument required       */
+	    int (*func) _((Statptr, long));
+
+	    str[sl-1] = 0;
+	    *s++ = 0;
+	    while (*s && !colonmod) {
+		func = (int (*) _((Statptr, long)))0;
+		if (idigit(*s)) {
+		    /* Store numeric argument for qualifier */
+		    func = qualflags;
+		    data = 0;
+		    while (idigit(*s))
+			data = data * 010 + (*s++ - '0');
+		} else if (*s == ',') {
+		    /* A comma separates alternative sets of qualifiers */
+		    s++;
+		    sense = 0;
+		    if (qualct) {
+			qn = (struct qual *)hcalloc(sizeof *qn);
+			qo->or = qn;
+			qo = qn;
+			qualorct++;
+			qualct = 0;
+			ql = NULL;
+		    }
+		} else
+		    switch (*s++) {
+		    case ':':
+			/* Remaining arguments are history-type     *
+			 * colon substitutions, handled separately. */
+			colonmod = s - 1;
+			untokenize(colonmod);
+			break;
+		    case Hat:
+		    case '^':
+			/* Toggle sense:  go from positive to *
+			 * negative match and vice versa.     */
+			sense ^= 1;
+			break;
+		    case '-':
+			/* Toggle matching of symbolic links */
+			sense ^= 2;
+			break;
+		    case '@':
+			/* Match symbolic links */
+			func = qualislnk;
+			break;
+		    case Equals:
+		    case '=':
+			/* Match sockets */
+			func = qualissock;
+			break;
+		    case 'p':
+			/* Match named pipes */
+			func = qualisfifo;
+			break;
+		    case '/':
+			/* Match directories */
+			func = qualisdir;
+			break;
+		    case '.':
+			/* Match regular files */
+			func = qualisreg;
+			break;
+		    case '%':
+			/* Match special files: block, *
+			 * character or any device     */
+			if (*s == 'b')
+			    s++, func = qualisblk;
+			else if (*s == 'c')
+			    s++, func = qualischr;
+			else
+			    func = qualisdev;
+			break;
+		    case Star:
+			/* Match executable plain files */
+			func = qualiscom;
+			break;
+		    case 'R':
+			/* Match world-readable files */
+			func = qualflags;
+			data = 0004;
+			break;
+		    case 'W':
+			/* Match world-writeable files */
+			func = qualflags;
+			data = 0002;
+			break;
+		    case 'X':
+			/* Match world-executable files */
+			func = qualflags;
+			data = 0001;
+			break;
+		    case 'A':
+			func = qualflags;
+			data = 0040;
+			break;
+		    case 'I':
+			func = qualflags;
+			data = 0020;
+			break;
+		    case 'E':
+			func = qualflags;
+			data = 0010;
+			break;
+		    case 'r':
+			/* Match files readable by current process */
+			func = qualflags;
+			data = 0400;
+			break;
+		    case 'w':
+			/* Match files writeable by current process */
+			func = qualflags;
+			data = 0200;
+			break;
+		    case 'x':
+			/* Match files executable by current process */
+			func = qualflags;
+			data = 0100;
+			break;
+		    case 's':
+			/* Match setuid files */
+			func = qualflags;
+			data = 04000;
+			break;
+		    case 'S':
+			/* Match setgid files */
+			func = qualflags;
+			data = 02000;
+			break;
+		    case 't':
+			func = qualflags;
+			data = 01000;
+			break;
+		    case 'd':
+			/* Match device files by device number  *
+			 * (as given by stat's st_dev element). */
+			func = qualdev;
+			data = qgetnum(&s);
+			break;
+		    case 'l':
+			/* Match files with the given no. of hard links */
+			func = qualnlink;
+			amc = -1;
+			goto getrange;
+		    case 'U':
+			/* Match files owned by effective user ID */
+			func = qualuid;
+			data = geteuid();
+			break;
+		    case 'G':
+			/* Match files owned by effective group ID */
+			func = qualgid;
+			data = getegid();
+			break;
+		    case 'u':
+			/* Match files owned by given user id */
+			func = qualuid;
+			/* either the actual uid... */
+			if (idigit(*s))
+			    data = qgetnum(&s);
+			else {
+			    /* ... or a user name */
+			    char sav, *tt;
+
+			    /* Find matching delimiters */
+			    tt = get_strarg(s);
+			    if (!*tt) {
+				zerr("missing end of name",
+				     NULL, 0);
+				data = 0;
+			    } else {
+#ifdef HAVE_GETPWNAM
+				struct passwd *pw;
+				sav = *tt;
+				*tt = '\0';
+
+				if ((pw = getpwnam(s + 1)))
+				    data = pw->pw_uid;
+				else {
+				    zerr("unknown user", NULL, 0);
+				    data = 0;
+				}
+				*tt = sav;
+#else /* !HAVE_GETPWNAM */
+				sav = *tt;
+				zerr("unknown user", NULL, 0);
+				data = 0;
+#endif /* !HAVE_GETPWNAM */
+				if (sav)
+				    s = tt + 1;
+				else
+				    s = tt;
+			    }
+			}
+			break;
+		    case 'g':
+			/* Given gid or group id... works like `u' */
+			func = qualgid;
+			/* either the actual gid... */
+			if (idigit(*s))
+			    data = qgetnum(&s);
+			else {
+			    /* ...or a delimited group name. */
+			    char sav, *tt;
+
+			    tt = get_strarg(s);
+			    if (!*tt) {
+				zerr("missing end of name",
+				     NULL, 0);
+				data = 0;
+			    } else {
+#ifdef HAVE_GETGRNAM
+				struct group *gr;
+				sav = *tt;
+				*tt = '\0';
+
+				if ((gr = getgrnam(s + 1)))
+				    data = gr->gr_gid;
+				else {
+				    zerr("unknown group", NULL, 0);
+				    data = 0;
+				}
+				*tt = sav;
+#else /* !HAVE_GETGRNAM */
+				sav = *tt;
+				zerr("unknown group", NULL, 0);
+				data = 0;
+#endif /* !HAVE_GETGRNAM */
+				if (sav)
+				    s = tt + 1;
+				else
+				    s = tt;
+			    }
+			}
+			break;
+		    case 'o':
+			/* Match octal mode of file exactly. *
+			 * Currently undocumented.           */
+			func = qualeqflags;
+			data = qgetoctnum(&s);
+			break;
+		    case 'M':
+			/* Mark directories with a / */
+			if ((gf_markdirs = !(sense & 1)))
+			    gf_follow = sense & 2;
+			break;
+		    case 'T':
+			/* Mark types in a `ls -F' type fashion */
+			if ((gf_listtypes = !(sense & 1)))
+			    gf_follow = sense & 2;
+			break;
+		    case 'N':
+			/* Nullglob:  remove unmatched patterns. */
+			gf_nullglob = !(sense & 1);
+			break;
+		    case 'D':
+			/* Glob dots: match leading dots implicitly */
+			gf_noglobdots = sense & 1;
+			break;
+		    case 'a':
+			/* Access time in given range */
+			amc = 0;
+			func = qualtime;
+			goto getrange;
+		    case 'm':
+			/* Modification time in given range */
+			amc = 1;
+			func = qualtime;
+			goto getrange;
+		    case 'c':
+			/* Inode creation time in given range */
+			amc = 2;
+			func = qualtime;
+			goto getrange;
+		    case 'L':
+			/* File size (Length) in given range */
+			func = qualsize;
+			amc = -1;
+			/* Get size multiplier */
+			units = TT_BYTES;
+			if (*s == 'p' || *s == 'P')
+			    units = TT_POSIX_BLOCKS, ++s;
+			else if (*s == 'k' || *s == 'K')
+			    units = TT_KILOBYTES, ++s;
+			else if (*s == 'm' || *s == 'M')
+			    units = TT_MEGABYTES, ++s;
+		      getrange:
+			/* Get time multiplier */
+			if (amc >= 0) {
+			    units = TT_DAYS;
+			    if (*s == 'h')
+				units = TT_HOURS, ++s;
+			    else if (*s == 'm')
+				units = TT_MINS, ++s;
+			    else if (*s == 'w')
+				units = TT_WEEKS, ++s;
+			    else if (*s == 'M')
+				units = TT_MONTHS, ++s;
+			}
+			/* See if it's greater than, equal to, or less than */
+			if ((range = *s == '+' ? 1 : *s == '-' ? -1 : 0))
+			    ++s;
+			data = qgetnum(&s);
+			break;
+
+		    default:
+			zerr("unknown file attribute", NULL, 0);
+			return;
+		    }
+		if (func) {
+		    /* Requested test is performed by function func */
+		    if (!qn)
+			qn = (struct qual *)hcalloc(sizeof *qn);
+		    if (ql)
+			ql->next = qn;
+		    ql = qn;
+		    if (!quals)
+			quals = qo = qn;
+		    qn->func = func;
+		    qn->sense = sense;
+		    qn->data = data;
+		    qn->range = range;
+		    qn->units = units;
+		    qn->amc = amc;
+		    qn = NULL;
+		    qualct++;
+		}
+		if (errflag)
+		    return;
+	    }
+	}
+    }
+    if (!pathbuf)
+	pathbuf = zalloc(pathbufsz = PATH_MAX);
+    DPUTS(pathbufcwd, "BUG: glob changed directory");
+    if (*str == '/') {		/* pattern has absolute path */
+	str++;
+	pathbuf[0] = '/';
+	pathbuf[pathpos = 1] = '\0';
+    } else			/* pattern is relative to pwd */
+	pathbuf[pathpos = 0] = '\0';
+    q = parsepat(str);
+    if (!q || errflag) {	/* if parsing failed */
+	if (unset(BADPATTERN)) {
+	    untokenize(ostr);
+	    insertlinknode(list, node, ostr);
+	    return;
+	}
+	errflag = 0;
+	zerr("bad pattern: %s", ostr, 0);
+	return;
+    }
+
+    /* Initialise receptacle for matched files, *
+     * expanded by insert() where necessary.    */
+    matchptr = matchbuf = (char **)zalloc((matchsz = 16) * sizeof(char *));
+    matchct = 0;
+
+    /* The actual processing takes place here: matches go into  *
+     * matchbuf.  This is the only top-level call to scanner(). */
+    scanner(q);
+
+    /* Deal with failures to match depending on options */
+    if (matchct)
+	badcshglob |= 2;	/* at least one cmd. line expansion O.K. */
+    else if (!gf_nullglob)
+	if (isset(CSHNULLGLOB)) {
+	    badcshglob |= 1;	/* at least one cmd. line expansion failed */
+	} else if (isset(NOMATCH)) {
+	    zerr("no matches found: %s", ostr, 0);
+	    free(matchbuf);
+	    return;
+	} else {
+	    /* treat as an ordinary string */
+	    untokenize(*matchptr++ = dupstring(ostr));
+	    matchct = 1;
+	}
+    /* Sort arguments in to lexical (and possibly numeric) order. *
+     * This is reversed to facilitate insertion into the list.    */
+    qsort((void *) & matchbuf[0], matchct, sizeof(char *),
+	       (int (*) _((const void *, const void *)))notstrcmp);
+
+    matchptr = matchbuf;
+    while (matchct--)		/* insert matches in the arg list */
+	insertlinknode(list, node, *matchptr++);
+    free(matchbuf);
+}
+
+/* Return the order of two strings, taking into account *
+ * possible numeric order if NUMERICGLOBSORT is set.    *
+ * The comparison here is reversed.                     */
+
+/**/
+static int
+notstrcmp(char **a, char **b)
+{
+    char *c = *b, *d = *a;
+    int cmp;
+
+#ifdef HAVE_STRCOLL
+    cmp = strcoll(c, d);
+#endif
+    for (; *c == *d && *c; c++, d++);
+#ifndef HAVE_STRCOLL
+    cmp = (int)STOUC(*c) - (int)STOUC(*d);
+#endif
+    if (isset(NUMERICGLOBSORT) && (idigit(*c) || idigit(*d))) {
+	for (; c > *b && idigit(c[-1]); c--, d--);
+	if (idigit(*c) && idigit(*d)) {
+	    while (*c == '0')
+		c++;
+	    while (*d == '0')
+		d++;
+	    for (; idigit(*c) && *c == *d; c++, d++);
+	    if (idigit(*c) || idigit(*d)) {
+		cmp = (int)STOUC(*c) - (int)STOUC(*d);
+		while (idigit(*c) && idigit(*d))
+		    c++, d++;
+		if (idigit(*c) && !idigit(*d))
+		    return 1;
+		if (idigit(*d) && !idigit(*c))
+		    return -1;
+	    }
+	}
+    }
+    return cmp;
+}
+
+/* Return the trailing character for marking file types */
+
+/**/
+char
+file_type(mode_t filemode)
+{
+    if(S_ISBLK(filemode))
+	return '#';
+    else if(S_ISCHR(filemode))
+	return '%';
+    else if(S_ISDIR(filemode))
+	return '/';
+    else if(S_ISFIFO(filemode))
+	return '|';
+    else if(S_ISLNK(filemode))
+	return '@';
+    else if(S_ISREG(filemode))
+	return (filemode & S_IXUGO) ? '*' : ' ';
+    else if(S_ISSOCK(filemode))
+	return '=';
+    else
+	return '?';
+}
+
+/* check to see if str is eligible for brace expansion */
+
+/**/
+int
+hasbraces(char *str)
+{
+    char *lbr, *mbr, *comma;
+
+    if (isset(BRACECCL)) {
+	/* In this case, any properly formed brace expression  *
+	 * will match and expand to the characters in between. */
+	int bc;
+
+	for (bc = 0; *str; ++str)
+	    if (*str == Inbrace) {
+		if (!bc && str[1] == Outbrace)
+		    *str++ = '{', *str = '}';
+		else
+		    bc++;
+	    } else if (*str == Outbrace)
+		if (!bc)
+		    *str = '}';
+		else if (!--bc)
+		    return 1;
+	return 0;
+    }
+    /* Otherwise we need to look for... */
+    lbr = mbr = comma = NULL;
+    for (;;) {
+	switch (*str++) {
+	case Inbrace:
+	    if (!lbr) {
+		lbr = str - 1;
+		while (idigit(*str))
+		    str++;
+		if (*str == '.' && str[1] == '.') {
+		    str++;
+		    while (idigit(*++str));
+		    if (*str == Outbrace &&
+			(idigit(lbr[1]) || idigit(str[-1])))
+			return 1;
+		}
+	    } else {
+		char *s = --str;
+
+		if (skipparens(Inbrace, Outbrace, &str)) {
+		    *lbr = *s = '{';
+		    if (comma)
+			str = comma;
+		    if (mbr && mbr < str)
+			str = mbr;
+		    lbr = mbr = comma = NULL;
+		} else if (!mbr)
+		    mbr = s;
+	    }
+	    break;
+	case Outbrace:
+	    if (!lbr)
+		str[-1] = '}';
+	    else if (comma)
+		return 1;
+	    else {
+		*lbr = '{';
+		str[-1] = '}';
+		if (mbr)
+		    str = mbr;
+		mbr = lbr = NULL;
+	    }
+	    break;
+	case Comma:
+	    if (!lbr)
+		str[-1] = ',';
+	    else if (!comma)
+		comma = str - 1;
+	    break;
+	case '\0':
+	    if (lbr)
+		*lbr = '{';
+	    if (!mbr && !comma)
+		return 0;
+	    if (comma)
+		str = comma;
+	    if (mbr && mbr < str)
+		str = mbr;
+	    lbr = mbr = comma = NULL;
+	    break;
+	}
+    }
+}
+
+/* expand stuff like >>*.c */
+
+/**/
+int
+xpandredir(struct redir *fn, LinkList tab)
+{
+    LinkList fake;
+    char *nam;
+    struct redir *ff;
+    int ret = 0;
+
+    /* Stick the name in a list... */
+    fake = newlinklist();
+    addlinknode(fake, fn->name);
+    /* ...which undergoes all the usual shell expansions */
+    prefork(fake, isset(MULTIOS) ? 0 : 4);
+    /* Globbing is only done for multios. */
+    if (!errflag && isset(MULTIOS))
+	globlist(fake);
+    if (errflag)
+	return 0;
+    if (nonempty(fake) && !nextnode(firstnode(fake))) {
+	/* Just one match, the usual case. */
+	char *s = peekfirst(fake);
+	fn->name = s;
+	untokenize(s);
+	if (fn->type == MERGEIN || fn->type == MERGEOUT) {
+	    if (s[0] == '-' && !s[1])
+		fn->type = CLOSE;
+	    else if (s[0] == 'p' && !s[1]) 
+		fn->fd2 = (fn->type == MERGEOUT) ? coprocout : coprocin;
+	    else {
+		while (idigit(*s))
+		    s++;
+		if (!*s && s > fn->name)
+		    fn->fd2 = zstrtol(fn->name, NULL, 10);
+		else if (fn->type == MERGEIN)
+		    zerr("file number expected", NULL, 0);
+		else
+		    fn->type = ERRWRITE;
+	    }
+	}
+    } else if (fn->type == MERGEIN)
+	zerr("file number expected", NULL, 0);
+    else {
+	if (fn->type == MERGEOUT)
+	    fn->type = ERRWRITE;
+	while ((nam = (char *)ugetnode(fake))) {
+	    /* Loop over matches, duplicating the *
+	     * redirection for each file found.   */
+	    ff = (struct redir *)alloc(sizeof *ff);
+	    *ff = *fn;
+	    ff->name = nam;
+	    addlinknode(tab, ff);
+	    ret = 1;
+	}
+    }
+    return ret;
+}
+
+/* concatenate s1 and s2 in dynamically allocated buffer */
+
+/**/
+char *
+dyncat(char *s1, char *s2)
+{
+    /* This version always uses space from the current heap. */
+    char *ptr;
+    int l1 = strlen(s1);
+
+    ptr = (char *)ncalloc(l1 + strlen(s2) + 1);
+    strcpy(ptr, s1);
+    strcpy(ptr + l1, s2);
+    return ptr;
+}
+
+/* concatenate s1, s2, and s3 in dynamically allocated buffer */
+
+/**/
+char *
+tricat(char const *s1, char const *s2, char const *s3)
+{
+    /* This version always uses permanently-allocated space. */
+    char *ptr;
+
+    ptr = (char *)zalloc(strlen(s1) + strlen(s2) + strlen(s3) + 1);
+    strcpy(ptr, s1);
+    strcat(ptr, s2);
+    strcat(ptr, s3);
+    return ptr;
+}
+
+/* brace expansion */
+
+/**/
+void
+xpandbraces(LinkList list, LinkNode *np)
+{
+    LinkNode node = (*np), last = prevnode(node);
+    char *str = (char *)getdata(node), *str3 = str, *str2;
+    int prev, bc, comma, dotdot;
+
+    for (; *str != Inbrace; str++);
+    /* First, match up braces and see what we have. */
+    for (str2 = str, bc = comma = dotdot = 0; *str2; ++str2)
+	if (*str2 == Inbrace)
+	    ++bc;
+	else if (*str2 == Outbrace) {
+	    if (--bc == 0)
+		break;
+	} else if (bc == 1)
+	    if (*str2 == Comma)
+		++comma;	/* we have {foo,bar} */
+	    else if (*str2 == '.' && str2[1] == '.')
+		dotdot++;	/* we have {num1..num2} */
+    DPUTS(bc, "BUG: unmatched brace in xpandbraces()");
+    if (!comma && dotdot) {
+	/* Expand range like 0..10 numerically: comma or recursive
+	   brace expansion take precedence. */
+	char *dots, *p;
+	LinkNode olast = last;
+	/* Get the first number of the range */
+	int rstart = zstrtol(str+1,&dots,10), rend = 0, err = 0, rev = 0;
+	int wid1 = (dots - str) - 1, wid2 = (str2 - dots) - 2;
+	int strp = str - str3;
+      
+	if (dots == str + 1 || *dots != '.' || dots[1] != '.')
+	    err++;
+	else {
+	    /* Get the last number of the range */
+	    rend = zstrtol(dots+2,&p,10);
+	    if (p == dots+2 || p != str2)
+		err++;
+	}
+	if (!err) {
+	    /* If either no. begins with a zero, pad the output with   *
+	     * zeroes. Otherwise, choose a min width to suppress them. */
+	    int minw = (str[1] == '0') ? wid1 : (dots[2] == '0' ) ? wid2 :
+		(wid2 > wid1) ? wid1 : wid2;
+	    if (rstart > rend) {
+		/* Handle decreasing ranges correctly. */
+		int rt = rend;
+		rend = rstart;
+		rstart = rt;
+		rev = 1;
+	    }
+	    uremnode(list, node);
+	    for (; rend >= rstart; rend--) {
+		/* Node added in at end, so do highest first */
+		p = dupstring(str3);
+		sprintf(p + strp, "%0*d", minw, rend);
+		strcat(p + strp, str2 + 1);
+		insertlinknode(list, last, p);
+		if (rev)	/* decreasing:  add in reverse order. */
+		    last = nextnode(last);
+	    }
+	    *np = nextnode(olast);
+	    return;
+	}
+    }
+    if (!comma && isset(BRACECCL)) {	/* {a-mnop} */
+	/* Here we expand each character to a separate node,      *
+	 * but also ranges of characters like a-m.  ccl is a      *
+	 * set of flags saying whether each character is present; *
+	 * the final list is in lexical order.                    */
+	char ccl[256], *p;
+	unsigned char c1, c2, lastch;
+	unsigned int len, pl;
+
+	uremnode(list, node);
+	memset(ccl, 0, sizeof(ccl) / sizeof(ccl[0]));
+	for (p = str + 1, lastch = 0; p < str2;) {
+	    if (itok(c1 = *p++))
+		c1 = ztokens[c1 - STOUC(Pound)];
+	    if ((char) c1 == Meta)
+		c1 = 32 ^ *p++;
+	    if (itok(c2 = *p))
+		c2 = ztokens[c2 - STOUC(Pound)];
+	    if ((char) c2 == Meta)
+		c2 = 32 ^ p[1];
+	    if (c1 == '-' && lastch && p < str2 && (int)lastch <= (int)c2) {
+		while ((int)lastch < (int)c2)
+		    ccl[lastch++] = 1;
+		lastch = 0;
+	    } else
+		ccl[lastch = c1] = 1;
+	}
+	pl = str - str3;
+	len = pl + strlen(++str2) + 2;
+	for (p = ccl + 255; p-- > ccl;)
+	    if (*p) {
+		c1 = p - ccl;
+		if (imeta(c1)) {
+		    str = ncalloc(len + 1);
+		    str[pl] = Meta;
+		    str[pl+1] = c1 ^ 32;
+		    strcpy(str + pl + 2, str2);
+		} else {
+		    str = ncalloc(len);
+		    str[pl] = c1;
+		    strcpy(str + pl + 1, str2);
+		}
+		memcpy(str, str3, pl);
+		insertlinknode(list, last, str);
+	    }
+	*np = nextnode(last);
+	return;
+    }
+    prev = str++ - str3;
+    str2++;
+    uremnode(list, node);
+    node = last;
+    /* Finally, normal comma expansion               *
+     * str1{foo,bar}str2 -> str1foostr2 str1barstr2. *
+     * Any number of intervening commas is allowed.  */
+    for (;;) {
+	char *zz, *str4;
+	int cnt;
+
+	for (str4 = str, cnt = 0; cnt || (*str != Comma && *str !=
+					  Outbrace); str++) {
+	    if (*str == Inbrace)
+		cnt++;
+	    else if (*str == Outbrace)
+		cnt--;
+	    DPUTS(!*str, "BUG: illegal brace expansion");
+	}
+	/* Concatenate the string before the braces (str3), the section *
+	 * just found (str4) and the text after the braces (str2)       */
+	zz = (char *)ncalloc(prev + (str - str4) + strlen(str2) + 1);
+	ztrncpy(zz, str3, prev);
+	strncat(zz, str4, str - str4);
+	strcat(zz, str2);
+	/* and add this text to the argument list. */
+	insertlinknode(list, node, zz);
+	incnode(node);
+	if (*str != Outbrace)
+	    str++;
+	else
+	    break;
+    }
+    *np = nextnode(last);
+}
+
+/* check to see if a matches b (b is not a filename pattern) */
+
+/**/
+int
+matchpat(char *a, char *b)
+{
+    Comp c = parsereg(b);
+
+    if (!c) {
+	zerr("bad pattern: %s", b, 0);
+	return 0;
+    }
+    return domatch(a, c, 0);
+}
+
+/* do the ${foo%%bar}, ${foo#bar} stuff */
+/* please do not laugh at this code. */
+
+/* Having found a match in getmatch, decide what part of string
+ * to return.  The matched part starts b characters into string s
+ * and finishes e characters in: 0 <= b <= e <= strlen(s)
+ * (yes, empty matches should work).
+ * Bits 3 and higher in fl are used: the flags are
+ *   8:		Result is matched portion.
+ *  16:		Result is unmatched portion.
+ *		(N.B. this should be set for standard ${foo#bar} etc. matches.)
+ *  32:		Result is numeric position of start of matched portion.
+ *  64:		Result is numeric position of end of matched portion.
+ * 128:		Result is length of matched portion.
+ */
+
+/**/
+static char *
+get_match_ret(char *s, int b, int e, int fl)
+{
+    char buf[80], *r, *p, *rr;
+    int ll = 0, l = strlen(s), bl = 0, t = 0, i;
+
+    if (fl & 8)			/* matched portion */
+	ll += 1 + (e - b);
+    if (fl & 16)		/* unmatched portion */
+	ll += 1 + (l - (e - b));
+    if (fl & 32) {
+	/* position of start of matched portion */
+	sprintf(buf, "%d ", b + 1);
+	ll += (bl = strlen(buf));
+    }
+    if (fl & 64) {
+	/* position of end of matched portion */
+	sprintf(buf + bl, "%d ", e + 1);
+	ll += (bl = strlen(buf));
+    }
+    if (fl & 128) {
+	/* length of matched portion */
+	sprintf(buf + bl, "%d ", e - b);
+	ll += (bl = strlen(buf));
+    }
+    if (bl)
+	buf[bl - 1] = '\0';
+
+    rr = r = (char *)ncalloc(ll);
+
+    if (fl & 8) {
+	/* copy matched portion to new buffer */
+	for (i = b, p = s + b; i < e; i++)
+	    *rr++ = *p++;
+	t = 1;
+    }
+    if (fl & 16) {
+	/* Copy unmatched portion to buffer.  If both portions *
+	 * requested, put a space in between (why?)            */
+	if (t)
+	    *rr++ = ' ';
+	/* there may be unmatched bits at both beginning and end of string */
+	for (i = 0, p = s; i < b; i++)
+	    *rr++ = *p++;
+	for (i = e, p = s + e; i < l; i++)
+	    *rr++ = *p++;
+	t = 1;
+    }
+    *rr = '\0';
+    if (bl) {
+	/* if there was a buffer (with a numeric result), add it; *
+	 * if there was other stuff too, stick in a space first.  */
+	if (t)
+	    *rr++ = ' ';
+	strcpy(rr, buf);
+    }
+    return r;
+}
+
+/* It is called from paramsubst to get the match for ${foo#bar} etc.
+ * Bits of fl determines the required action:
+ *   bit 0: match the end instead of the beginning (% or %%)
+ *   bit 1: % or # was doubled so get the longest match
+ *   bit 2: substring match
+ *   bit 3: include the matched portion
+ *   bit 4: include the unmatched portion
+ *   bit 5: the index of the beginning
+ *   bit 6: the index of the end
+ *   bit 7: the length of the match
+ *   bit 8: match the complete string
+ * *sp points to the string we have to modify. The n'th match will be
+ * returned in *sp. ncalloc is used to get memory for the result string.
+ */
+
+/**/
+int
+getmatch(char **sp, char *pat, int fl, int n)
+{
+    Comp c;
+    char *s = *sp, *t, sav;
+    int i, j, l = strlen(*sp);
+
+    c = parsereg(pat);
+    if (!c) {
+	zerr("bad pattern: %s", pat, 0);
+	return 1;
+    }
+    if (fl & 256) {
+	i = domatch(s, c, 0);
+	*sp = get_match_ret(*sp, 0, domatch(s, c, 0) ? l : 0, fl);
+	if (! **sp && (((fl & 8) && !i) || ((fl & 16) && i)))
+	    return 0;
+	return 1;
+    }
+    switch (fl & 7) {
+    case 0:
+	/* Smallest possible match at head of string:    *
+	 * start adding characters until we get a match. */
+	for (i = 0, t = s; i <= l; i++, t++) {
+	    sav = *t;
+	    *t = '\0';
+	    if (domatch(s, c, 0) && !--n) {
+		*t = sav;
+		*sp = get_match_ret(*sp, 0, i, fl);
+		return 1;
+	    }
+	    if ((*t = sav) == Meta)
+		i++, t++;
+	}
+	break;
+
+    case 1:
+	/* Smallest possible match at tail of string:  *
+	 * move back down string until we get a match. */
+	for (t = s + l; t >= s; t--) {
+	    if (domatch(t, c, 0) && !--n) {
+		*sp = get_match_ret(*sp, t - s, l, fl);
+		return 1;
+	    }
+	    if (t > s+1 && t[-2] == Meta)
+		t--;
+	}
+	break;
+
+    case 2:
+	/* Largest possible match at head of string:        *
+	 * delete characters from end until we get a match. */
+	for (t = s + l; t > s; t--) {
+	    sav = *t;
+	    *t = '\0';
+	    if (domatch(s, c, 0) && !--n) {
+		*t = sav;
+		*sp = get_match_ret(*sp, 0, t - s, fl);
+		return 1;
+	    }
+	    *t = sav;
+	    if (t >= s+2 && t[-2] == Meta)
+		t--;
+	}
+	break;
+
+    case 3:
+	/* Largest possible match at tail of string:       *
+	 * move forward along string until we get a match. */
+	for (i = 0, t = s; i < l; i++, t++) {
+	    if (domatch(t, c, 0) && !--n) {
+		*sp = get_match_ret(*sp, i, l, fl);
+		return 1;
+	    }
+	    if (*t == Meta)
+		i++, t++;
+	}
+	break;
+
+    case 4:
+	/* Smallest at start, but matching substrings. */
+	if (domatch(s + l, c, 0) && !--n) {
+	    *sp = get_match_ret(*sp, 0, 0, fl);
+	    return 1;
+	}
+	for (i = 1; i <= l; i++) {
+	    for (t = s, j = i; j <= l; j++, t++) {
+		sav = s[j];
+		s[j] = '\0';
+		if (domatch(t, c, 0) && !--n) {
+		    s[j] = sav;
+		    *sp = get_match_ret(*sp, t - s, j, fl);
+		    return 1;
+		}
+		if ((s[j] = sav) == Meta)
+		    j++;
+		if (*t == Meta)
+		    t++;
+	    }
+	    if (s[i] == Meta)
+		i++;
+	}
+	break;
+
+    case 5:
+	/* Smallest at end, matching substrings */
+	if (domatch(s + l, c, 0) && !--n) {
+	    *sp = get_match_ret(*sp, l, l, fl);
+	    return 1;
+	}
+	for (i = l; i--;) {
+	    if (i && s[i-1] == Meta)
+		i--;
+	    for (t = s + l, j = i; j >= 0; j--, t--) {
+		sav = *t;
+		*t = '\0';
+		if (domatch(s + j, c, 0) && !--n) {
+		    *t = sav;
+		    *sp = get_match_ret(*sp, j, t - s, fl);
+		    return 1;
+		}
+		*t = sav;
+		if (t >= s+2 && t[-2] == Meta)
+		    t--;
+		if (j >= 2 && s[j-2] == Meta)
+		    j--;
+	    }
+	}
+	break;
+
+    case 6:
+	/* Largest at start, matching substrings. */
+	for (i = l; i; i--) {
+	    for (t = s, j = i; j <= l; j++, t++) {
+		sav = s[j];
+		s[j] = '\0';
+		if (domatch(t, c, 0) && !--n) {
+		    s[j] = sav;
+		    *sp = get_match_ret(*sp, t - s, j, fl);
+		    return 1;
+		}
+		if ((s[j] = sav) == Meta)
+		    j++;
+		if (*t == Meta)
+		    t++;
+	    }
+	    if (i >= 2 && s[i-2] == Meta)
+		i--;
+	}
+	if (domatch(s + l, c, 0) && !--n) {
+	    *sp = get_match_ret(*sp, 0, 0, fl);
+	    return 1;
+	}
+	break;
+
+    case 7:
+	/* Largest at end, matching substrings. */
+	for (i = 0; i < l; i++) {
+	    for (t = s + l, j = i; j >= 0; j--, t--) {
+		sav = *t;
+		*t = '\0';
+		if (domatch(s + j, c, 0) && !--n) {
+		    *t = sav;
+		    *sp = get_match_ret(*sp, j, t - s, fl);
+		    return 1;
+		}
+		*t = sav;
+		if (t >= s+2 && t[-2] == Meta)
+		    t--;
+		if (j >= 2 && s[j-2] == Meta)
+		    j--;
+	    }
+	    if (s[i] == Meta)
+		i++;
+	}
+	if (domatch(s + l, c, 0) && !--n) {
+	    *sp = get_match_ret(*sp, l, l, fl);
+	    return 1;
+	}
+	break;
+    }
+    /* munge the whole string */
+    *sp = get_match_ret(*sp, 0, 0, fl);
+    return 1;
+}
+
+/* The main entry point for matching a string str against  *
+ * a compiled pattern c.  `fist' indicates whether leading *
+ * dots are special.                                       */
+
+/**/
+int
+domatch(char *str, Comp c, int fist)
+{
+    int ret;
+    pptr = str;
+    first = fist;
+    if (*pptr == Nularg)
+	pptr++;
+    PERMALLOC {
+	ret = doesmatch(c);
+    } LASTALLOC;
+    return ret;
+}
+
+#define untok(C)  (itok(C) ? ztokens[(C) - Pound] : (C))
+
+/* See if pattern has a matching exclusion (~...) part */
+
+/**/
+static int
+excluded(Comp c, char *eptr)
+{
+    char *saves = pptr;
+    int savei = first, ret;
+
+    first = 0;
+    if (PATHADDP(c) && pathpos) {
+	VARARR(char, buf, pathpos + strlen(eptr) + 1);
+
+	strcpy(buf, pathbuf);
+	strcpy(buf + pathpos, eptr);
+	pptr = buf;
+	ret = doesmatch(c->exclude);
+    } else {
+	pptr = eptr;
+	ret = doesmatch(c->exclude);
+    }
+    if (*pptr)
+	ret = 0;
+
+    pptr = saves;
+    first = savei;
+
+    return ret;
+}
+
+struct gclose {
+    char *start;
+    char *end;
+};
+typedef struct gclose *Gclose;
+
+static int inclosure;		/* see comment in doesmatch() */
+
+/* Add a list of matches that fit the closure.  trystring is a string of
+ * the same length as the target string; a non-zero in that string
+ * indicates that we have already tried to match the patterns following
+ * the closure (c->next) at that point and failed.  This means that not
+ * only should we not bother using the corresponding match, we should
+ * also not bother going any further, since the first time we got to
+ * that position (when it was marked), we must already have failed on
+ * and backtracked over any further closure matches beyond that point.
+ */
+
+/**/
+static void
+addclosures(Comp c, LinkList closlist, int *pdone, char *trystring)
+{
+    Gclose gcnode;
+    char *opptr = pptr;
+
+    while (*pptr) {
+	if (STARP(c)) {
+	    if (trystring[(pptr+1)-opptr])
+		break;
+	    gcnode = (Gclose)zalloc(sizeof(struct gclose));
+	    gcnode->start = pptr;
+	    gcnode->end = ++pptr;
+	} else {
+	    char *saves = pptr;
+	    if (OPTIONALP(c) && *pdone >= 1)
+		return;
+	    if (!matchonce(c) || saves == pptr ||
+		trystring[pptr-opptr]) {
+		pptr = saves;
+		break;
+	    }
+	    gcnode = (Gclose)zalloc(sizeof(struct gclose));
+	    gcnode->start = saves;
+	    gcnode->end = pptr;
+	}
+	pushnode(closlist, gcnode);
+	(*pdone)++;
+    }
+}
+
+/* see if current string in pptr matches c */
+
+/**/
+static int
+doesmatch(Comp c)
+{
+    if (CLOSUREP(c)) {
+	int done, retflag = 0;
+	char *saves, *trystring, *opptr;
+	LinkList closlist;
+	Gclose gcnode;
+
+	if (first && *pptr == '.')
+	    return 0;
+
+	if (!inclosure && !c->left) {
+	    /* We are not inside another closure, and the current
+	     * pattern is a simple string.  We handle this very common
+	     * case specially: otherwise, matches like *foo* are
+	     * extremely slow.  Here, instead of backtracking, we track
+	     * forward until we get a match.  At top level, we are bound
+	     * to get there eventually, so this is OK.
+	     */
+	    char looka;
+
+	    if (STARP(c) && c->next &&
+		!c->next->left && (looka = *c->next->str) &&
+		!itok(looka)) {
+		/* Another simple optimisation for a very common case:
+		 * we are processing a * and there is
+		 * an ordinary character match next.  We look ahead for
+		 * that character, taking care of Meta bytes.
+		 */
+		while (*pptr) {
+		    for (; *pptr; pptr++) {
+			if (*pptr == Meta)
+			    pptr++;
+			else if (*pptr == looka)
+			    break;
+		    }
+		    if (!*(saves = pptr))
+			break;
+		    if (doesmatch(c->next))
+			return 1;
+		    pptr = saves+1;
+		}
+	    } else {
+		/* Standard track-forward code */
+		for (done = 0; ; done++) {
+		    saves = pptr;
+		    if ((done || ONEHASHP(c) || OPTIONALP(c)) &&
+			((!c->next && (!LASTP(c) || !*pptr)) ||
+			 (c->next && doesmatch(c->next))))
+			return 1;
+		    if (done && OPTIONALP(c))
+			return 0;
+		    pptr = saves;
+		    first = 0;
+		    if (STARP(c)) {
+			if (!*pptr)
+			    return 0;
+			pptr++;
+		    } else if (!matchonce(c) || pptr == saves)
+			return 0;
+		}
+	    }
+	    return 0;
+	}
+	/* The full, gory backtracking code is now necessary. */
+	inclosure++;
+	closlist = newlinklist();
+	trystring = zcalloc(strlen(pptr)+1);
+	opptr = pptr;
+
+	/* Start by making a list where each match is as long
+	 * as possible.  We later have to take account of the
+	 * fact that earlier matches may be too long.
+	 */
+	done = 0;
+	addclosures(c, closlist, &done, trystring);
+	for (;;) {
+	    if (TWOHASHP(c) && !done)
+		break;
+	    saves = pptr;
+	    /* do we really want this LASTP here?? */
+	    if ((!c->next && (!LASTP(c) || !*pptr)) ||
+		(c->next && doesmatch(c->next))) {
+		retflag = 1;
+		break;
+	    }
+	    trystring[saves-opptr] = 1;
+	    /*
+	     * If we failed, the first thing to try is whether we can
+	     * shorten the match using the last pattern in the closure.
+	     */
+	    gcnode = firstnode(closlist) ? peekfirst(closlist) : NULL;
+	    if (gcnode && --gcnode->end > gcnode->start
+		&& (gcnode->end[-1] != Meta ||
+		    --gcnode->end > gcnode->start)) {
+		char savec = *gcnode->end;
+		*gcnode->end = '\0';
+		pptr = gcnode->start;
+		if (matchonce(c) && pptr != gcnode->start
+		    && !trystring[pptr-opptr]) {
+		    *gcnode->end = savec;
+		    gcnode->end = pptr;
+		    /* Try again to construct a list based on
+		     * this new position
+		     */
+		    addclosures(c, closlist, &done, trystring+(pptr-opptr));
+		    continue;
+		}
+		*gcnode->end = savec;
+	    }
+	    /* We've now exhausted the possibilities with that match,
+	     * backtrack to the previous.
+	     */
+	    if ((gcnode = (Gclose)getlinknode(closlist))) {
+		pptr = gcnode->start;
+		zfree(gcnode, sizeof(struct gclose));
+		done--;
+	    } else
+		break;
+	}
+	freelinklist(closlist, free);
+	zfree(trystring, strlen(opptr)+1);
+	inclosure--;
+
+	return retflag;
+    } else
+	return matchonce(c);
+}
+
+/**/
+static int
+posix_range(char **patptr, int ch)
+{
+    /* Match POSIX ranges, which correspond to ctype macros,  *
+     * e.g. [:alpha:] -> isalpha.  It just doesn't seem worth * 
+     * the palaver of creating a hash table for this.         */
+    char *start = *patptr;
+    int len;
+
+    /* we made sure in parsecomp() there was a ':' to search for */
+    *patptr = strchr(start, ':');
+    len = (*patptr)++ - start;
+
+    if (!strncmp(start, "alpha", len))
+	return isalpha(ch);
+    if (!strncmp(start, "alnum", len))
+	return isalnum(ch);
+    if (!strncmp(start, "blank", len))
+	return ch == ' ' || ch == '\t';
+    if (!strncmp(start, "cntrl", len))
+	return iscntrl(ch);
+    if (!strncmp(start, "digit", len))
+	return isdigit(ch);
+    if (!strncmp(start, "graph", len))
+	return isgraph(ch);
+    if (!strncmp(start, "lower", len))
+	return islower(ch);
+    if (!strncmp(start, "print", len))
+	return isprint(ch);
+    if (!strncmp(start, "punct", len))
+	return ispunct(ch);
+    if (!strncmp(start, "space", len))
+	return isspace(ch);
+    if (!strncmp(start, "upper", len))
+	return isupper(ch);
+    if (!strncmp(start, "xdigit", len))
+	return isxdigit(ch);
+    return 0;
+}
+
+/**/
+static void
+rangematch(char **patptr, int ch, int rchar)
+{
+    /* Check for a character in a [...] or [^...].  The [ *
+     * and optional ^ have already been skipped.          */
+
+    char *pat = *patptr;
+#ifdef HAVE_STRCOLL
+    char l_buf[2], r_buf[2], ch_buf[2];
+
+    ch_buf[0] = ch;
+    l_buf[1] = r_buf[1] = ch_buf[1] = '\0';
+#endif
+
+#define PAT(X) (pat[X] == Meta ? pat[(X)+1] ^ 32 : untok(pat[X]))
+#define PPAT(X) (pat[(X)-1] == Meta ? pat[X] ^ 32 : untok(pat[X]))
+
+    for (pat++; *pat != Outbrack && *pat;
+	 *pat == Meta ? pat += 2 : pat++) {
+	if (*pat == Inbrack) {
+	    /* Inbrack can only occur inside a range if we found [:...:]. */
+	    pat += 2;
+	    if (posix_range(&pat, ch))
+		break;
+	} else if (*pat == '-' && pat[-1] != rchar &&
+		   pat[1] != Outbrack) {
+#ifdef HAVE_STRCOLL
+	    l_buf[0] = PPAT(-1);
+	    r_buf[0] = PAT(1);
+	    if (strcoll(l_buf, ch_buf) <= 0 &&
+		strcoll(ch_buf, r_buf) <= 0)
+#else
+		if (PPAT(-1) <= ch && PAT(1) >= ch)
+#endif
+		    break;
+	} else if (ch == PAT(0))
+	    break;
+    }
+
+    *patptr = pat;
+}
+
+/**/
+static int
+matchonce(Comp c)
+{
+    char *pat = c->str;
+    for (;;) {
+	/* loop until success or failure of pattern */
+	if (!pat || !*pat) {
+	    /* No current pattern (c->str). */
+	    char *saves;
+	    int savei;
+
+	    if (errflag)
+		return 0;
+	    /* Remember state in case we need to go back and   *
+	     * check for exclusion of pattern or alternatives. */
+	    saves = pptr;
+	    savei = first;
+	    /* Loop over alternatives with exclusions: (foo~bar|...). *
+	     * Exclusions apply to the pattern in c->left.            */
+	    if (c->left || c->right) {
+		int ret = 0, ret2 = 0;
+		if (c->exclude) {
+		    char *exclend = 0;
+
+		    /* We may need to back up on things like `(*~foo)'
+		     * if the `*' matched `foo' but needs to match `fo'.
+		     * exclend marks the end of the shortened text.  We
+		     * need to restore it to match the tail.
+		     * We set `inclosure' because we need the more
+		     * sophisticated code in doesmatch() for any nested
+		     * closures.
+		     */
+		    inclosure++;
+
+		    while (!exclend || exclend >= pptr) {
+			char exclsav = 0;
+			if (exclend) {
+			     exclsav = *exclend;
+			    *exclend = '\0';
+			 }
+			if ((ret = doesmatch(c->left))) {
+			    if (exclend)
+				*exclend = exclsav;
+			    exclsav = *(exclend = pptr);
+			    *exclend = '\0';
+			    ret2 = !excluded(c, saves);
+			}
+			if (exclend)
+			    *exclend = exclsav;
+
+			if (!ret)
+			    break;
+			if ((ret = ret2 &&
+			     ((!c->next && (!LASTP(c) || !*pptr))
+			      || (c->next && doesmatch(c->next)))) ||
+			    (!c->next && LASTP(c)))
+			    break;
+			/* Back up if necessary: exclend gives the position
+			 * of the end of the match we are excluding,
+			 * so only try to match to there.
+			 */
+			exclend--;
+			pptr = saves;
+		    }
+		    inclosure--;
+		    if (ret)
+			return 1;
+		} else
+		    ret = doesmatch(c->left);
+		ret2 = 0;
+		if (c->right && (!ret || inclosure)) {
+		    /* If in a closure, we always want the longest match. */
+		    char *newpptr = pptr;
+		    pptr = saves;
+		    first = savei;
+		    ret2 = doesmatch(c->right);
+		    if (ret && (!ret2 || pptr < newpptr))
+			pptr = newpptr;
+		}
+		if (!ret && !ret2)
+		    return 0;
+	    }
+	    if (CLOSUREP(c))
+		return 1;
+	    if (!c->next)	/* no more patterns left */
+		return (!LASTP(c) || !*pptr);
+	    /* optimisation when next pattern is not a closure */
+	    if (!CLOSUREP(c->next)) {
+		c = c->next;
+		pat = c->str;
+		continue;
+	    }
+	    return doesmatch(c->next);
+	}
+	/* Don't match leading dot if first is set */
+	if (first && *pptr == '.' && *pat != '.')
+	    return 0;
+	if (*pat == Star) {	/* final * is not expanded to ?#; returns success */
+	    while (*pptr)
+		pptr++;
+	    return 1;
+	}
+	first = 0;		/* finished checking start of pattern */
+	if (*pat == Quest && *pptr) {
+	    /* match exactly one character */
+	    if (*pptr == Meta)
+		pptr++;
+	    pptr++;
+	    pat++;
+	    continue;
+	}
+	if (*pat == Inbrack) {
+	    /* Match groups of characters */
+	    char ch;
+
+	    if (!*pptr)
+		break;
+	    ch = *pptr == Meta ? pptr[1] ^ 32 : *pptr;
+	    if (pat[1] == Hat || pat[1] == '^' || pat[1] == '!') {
+		/* group is negated */
+		*++pat = Hat;
+		rangematch(&pat, ch, Hat);
+		DPUTS(!*pat, "BUG: something is very wrong in doesmatch()");
+		if (*pat != Outbrack)
+		    break;
+		pat++;
+		*pptr == Meta ? pptr += 2 : pptr++;
+		continue;
+	    } else {
+		/* pattern is not negated (affirmed? asserted?) */
+		rangematch(&pat, ch, Inbrack);
+		DPUTS(!pat || !*pat, "BUG: something is very wrong in doesmatch()");
+		if (*pat == Outbrack)
+		    break;
+		for (*pptr == Meta ? pptr += 2 : pptr++;
+		     *pat != Outbrack; pat++);
+		pat++;
+		continue;
+	    }
+	}
+	if (*pat == Inang) {
+	    /* Numeric globbing. */
+	    unsigned long t1, t2, t3;
+	    char *ptr;
+
+	    if (!idigit(*pptr))
+		break;
+	    if (*++pat == Outang || 
+		(*pat == '-' && pat[1] == Outang && ++pat)) {
+		/* <> or <->:  any number matches */
+		while (idigit(*++pptr));
+		pat++;
+	    } else {
+		/* Flag that there is no upper limit */
+		int not3 = 0;
+		char *opptr = pptr;
+		/*
+		 * Form is <a-b>, where a or b are numbers or blank.
+		 * t1 = number supplied:  must be positive, so use
+		 * unsigned arithmetic.
+		 */
+		t1 = (unsigned long)zstrtol(pptr, &ptr, 10);
+		pptr = ptr;
+		/* t2 = lower limit */
+		if (idigit(*pat))
+		    t2 = (unsigned long)zstrtol(pat, &ptr, 10);
+		else
+		    t2 = 0, ptr = pat;
+		if (*ptr != '-' || (not3 = (ptr[1] == Outang)))
+				/* exact match or no upper limit */
+		    t3 = t2, pat = ptr + not3;
+		else		/* t3 = upper limit */
+		    t3 = (unsigned long)zstrtol(ptr + 1, &pat, 10);
+		DPUTS(*pat != Outang, "BUG: wrong internal range pattern");
+		pat++;
+		/*
+		 * If the number found is too large for the pattern,
+		 * try matching just the first part.  This way
+		 * we always get the longest possible match.
+		 */
+		while (!not3 && t1 > t3 && pptr > opptr+1) {
+		  pptr--;
+		  t1 /= 10;
+		}
+		if (t1 < t2 || (!not3 && t1 > t3))
+		    break;
+	    }
+	    continue;
+	}
+	if (*pptr == *pat) {
+	    /* just plain old characters */
+	    pptr++;
+	    pat++;
+	    continue;
+	}
+	break;
+    }
+    return 0;
+}
+
+/* turn a string into a Comp struct:  this doesn't treat / specially */
+
+/**/
+Comp
+parsereg(char *str)
+{
+    remnulargs(str);
+    mode = 1;			/* no path components */
+    pptr = str;
+    tail = NULL;
+    return parsecompsw(GF_TOPLEV);
+}
+
+/* blindly turn a string into a tokenised expression without lexing */
+
+/**/
+void
+tokenize(char *s)
+{
+    char *t;
+    int bslash = 0;
+
+    for (; *s; s++) {
+      cont:
+	switch (*s) {
+	case Bnull:
+	case '\\':
+	    if (bslash) {
+		s[-1] = Bnull;
+		break;
+	    }
+	    bslash = 1;
+	    continue;
+	case '<':
+	    if (isset(SHGLOB))
+		break;
+	    if (bslash) {
+		s[-1] = Bnull;
+		break;
+	    }
+	    t = s;
+	    while (idigit(*++s));
+	    if (*s != '-')
+		goto cont;
+	    while (idigit(*++s));
+	    if (*s != '>')
+		goto cont;
+	    *t = Inang;
+	    *s = Outang;
+	    break;
+	case '^':
+	case '#':
+	case '~':
+	    if (unset(EXTENDEDGLOB))
+		break;
+	case '(':
+	case '|':
+	case ')':
+	    if (isset(SHGLOB))
+		break;
+	case '[':
+	case ']':
+	case '*':
+	case '?':
+	    for (t = ztokens; *t; t++)
+		if (*t == *s) {
+		    if (bslash)
+			s[-1] = Bnull;
+		    else
+			*s = (t - ztokens) + Pound;
+		    break;
+		}
+	}
+	bslash = 0;
+    }
+}
+
+/* remove unnecessary Nulargs */
+
+/**/
+void
+remnulargs(char *s)
+{
+    int nl = *s;
+    char *t = s;
+
+    while (*s)
+	if (INULL(*s))
+	    chuck(s);
+	else
+	    s++;
+    if (!*t && nl) {
+	t[0] = Nularg;
+	t[1] = '\0';
+    }
+}
+
+/* qualifier functions:  mostly self-explanatory, see glob(). */
+
+/* device number */
+
+/**/
+static int
+qualdev(struct stat *buf, long dv)
+{
+    return buf->st_dev == dv;
+}
+
+/* number of hard links to file */
+
+/**/
+static int
+qualnlink(struct stat *buf, long ct)
+{
+    return (range < 0 ? buf->st_nlink < ct :
+	    range > 0 ? buf->st_nlink > ct :
+	    buf->st_nlink == ct);
+}
+
+/* user ID */
+
+/**/
+static int
+qualuid(struct stat *buf, long uid)
+{
+    return buf->st_uid == uid;
+}
+
+/* group ID */
+
+/**/
+static int
+qualgid(struct stat *buf, long gid)
+{
+    return buf->st_gid == gid;
+}
+
+/* device special file? */
+
+/**/
+static int
+qualisdev(struct stat *buf, long junk)
+{
+    return S_ISBLK(buf->st_mode) || S_ISCHR(buf->st_mode);
+}
+
+/* block special file? */
+
+/**/
+static int
+qualisblk(struct stat *buf, long junk)
+{
+    return S_ISBLK(buf->st_mode);
+}
+
+/* character special file? */
+
+/**/
+static int
+qualischr(struct stat *buf, long junk)
+{
+    return S_ISCHR(buf->st_mode);
+}
+
+/* directory? */
+
+/**/
+static int
+qualisdir(struct stat *buf, long junk)
+{
+    return S_ISDIR(buf->st_mode);
+}
+
+/* FIFO? */
+
+/**/
+static int
+qualisfifo(struct stat *buf, long junk)
+{
+    return S_ISFIFO(buf->st_mode);
+}
+
+/* symbolic link? */
+
+/**/
+static int
+qualislnk(struct stat *buf, long junk)
+{
+    return S_ISLNK(buf->st_mode);
+}
+
+/* regular file? */
+
+/**/
+static int
+qualisreg(struct stat *buf, long junk)
+{
+    return S_ISREG(buf->st_mode);
+}
+
+/* socket? */
+
+/**/
+static int
+qualissock(struct stat *buf, long junk)
+{
+    return S_ISSOCK(buf->st_mode);
+}
+
+/* given flag is set in mode */
+
+/**/
+static int
+qualflags(struct stat *buf, long mod)
+{
+    return mode_to_octal(buf->st_mode) & mod;
+}
+
+/* mode matches number supplied exactly  */
+
+/**/
+static int
+qualeqflags(struct stat *buf, long mod)
+{
+    return mode_to_octal(buf->st_mode) == mod;
+}
+
+/* regular executable file? */
+
+/**/
+static int
+qualiscom(struct stat *buf, long mod)
+{
+    return S_ISREG(buf->st_mode) && (buf->st_mode & S_IXUGO);
+}
+
+/* size in required range? */
+
+/**/
+static int
+qualsize(struct stat *buf, long size)
+{
+    unsigned long scaled = buf->st_size;
+
+    switch (units) {
+    case TT_POSIX_BLOCKS:
+	scaled += 511l;
+	scaled /= 512l;
+	break;
+    case TT_KILOBYTES:
+	scaled += 1023l;
+	scaled /= 1024l;
+	break;
+    case TT_MEGABYTES:
+	scaled += 1048575l;
+	scaled /= 1048576l;
+	break;
+    }
+
+    return (range < 0 ? scaled < (unsigned long) size :
+	    range > 0 ? scaled > (unsigned long) size :
+	    scaled == (unsigned long) size);
+}
+
+/* time in required range? */
+
+/**/
+static int
+qualtime(struct stat *buf, long days)
+{
+    time_t now, diff;
+
+    time(&now);
+    diff = now - (amc == 0 ? buf->st_atime : amc == 1 ? buf->st_mtime :
+		  buf->st_ctime);
+    /* handle multipliers indicating units */
+    switch (units) {
+    case TT_DAYS:
+	diff /= 86400l;
+	break;
+    case TT_HOURS:
+	diff /= 3600l;
+	break;
+    case TT_MINS:
+	diff /= 60l;
+	break;
+    case TT_WEEKS:
+	diff /= 604800l;
+	break;
+    case TT_MONTHS:
+	diff /= 2592000l;
+	break;
+    }
+
+    return (range < 0 ? diff < days :
+	    range > 0 ? diff > days :
+	    diff == days);
+}
diff --git a/Src/hashtable.c b/Src/hashtable.c
new file mode 100644
index 000000000..4adf3904d
--- /dev/null
+++ b/Src/hashtable.c
@@ -0,0 +1,1285 @@
+/*
+ * hashtable.c - hash tables
+ *
+ * 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 "../config.h"
+
+#ifdef ZSH_HASH_DEBUG
+# define HASHTABLE_DEBUG_MEMBERS \
+    /* Members of struct hashtable used for debugging hash tables */ \
+    HashTable next, last;	/* linked list of all hash tables           */ \
+    char *tablename;		/* string containing name of the hash table */ \
+    PrintTableStats printinfo;	/* pointer to function to print table stats */
+#else /* !ZSH_HASH_DEBUG */
+# define HASHTABLE_DEBUG_MEMBERS
+#endif /* !ZSH_HASH_DEBUG */
+
+#define HASHTABLE_INTERNAL_MEMBERS \
+    ScanStatus scan;		/* status of a scan over this hashtable     */ \
+    HASHTABLE_DEBUG_MEMBERS
+
+typedef struct scanstatus *ScanStatus;
+
+#include "zsh.mdh"
+#include "hashtable.pro"
+
+/* Structure for recording status of a hashtable scan in progress.  When a *
+ * scan starts, the .scan member of the hashtable structure points to one  *
+ * of these.  That member being non-NULL disables resizing of the          *
+ * hashtable (when adding elements).  When elements are deleted, the       *
+ * contents of this structure is used to make sure the scan won't stumble  *
+ * into the deleted element.                                               */
+
+struct scanstatus {
+    int sorted;
+    union {
+	struct {
+	    HashNode *tab;
+	    int ct;
+	} s;
+	HashNode u;
+    } u;
+};
+
+/********************************/
+/* Generic Hash Table functions */
+/********************************/
+
+#ifdef ZSH_HASH_DEBUG
+static HashTable firstht, lastht;
+#endif /* ZSH_HASH_DEBUG */
+
+/* Generic hash function */
+
+/**/
+unsigned
+hasher(char *str)
+{
+    unsigned hashval = 0;
+
+    while (*str)
+	hashval += (hashval << 5) + ((unsigned) *str++);
+
+    return hashval;
+}
+
+/* Get a new hash table */
+
+/**/
+HashTable
+newhashtable(int size, char const *name, PrintTableStats printinfo)
+{
+    HashTable ht;
+
+    ht = (HashTable) zcalloc(sizeof *ht);
+#ifdef ZSH_HASH_DEBUG
+    ht->next = NULL;
+    if(!firstht)
+	firstht = ht;
+    ht->last = lastht;
+    if(lastht)
+	lastht->next = ht;
+    lastht = ht;
+    ht->printinfo = printinfo ? printinfo : printhashtabinfo;
+    ht->tablename = ztrdup(name);
+#endif /* ZSH_HASH_DEBUG */
+    ht->nodes = (HashNode *) zcalloc(size * sizeof(HashNode));
+    ht->hsize = size;
+    ht->ct = 0;
+    ht->scan = NULL;
+    return ht;
+}
+
+/* Delete a hash table.  After this function has been used, any *
+ * existing pointers to the hash table are invalid.             */
+
+/**/
+void
+deletehashtable(HashTable ht)
+{
+    ht->emptytable(ht);
+#ifdef ZSH_HASH_DEBUG
+    if(ht->next)
+	ht->next->last = ht->last;
+    else
+	lastht = ht->last;
+    if(ht->last)
+	ht->last->next = ht->next;
+    else
+	firstht = ht->next;
+#endif /* ZSH_HASH_DEBUG */
+    zfree(ht->nodes, ht->hsize * sizeof(HashNode));
+    zfree(ht, sizeof(*ht));
+}
+
+/* Add a node to a hash table.                          *
+ * nam is the key to use in hashing.  dat is a pointer  *
+ * to the node to add.  If there is already a node in   *
+ * the table with the same key, it is first freed, and  *
+ * then the new node is added.  If the number of nodes  *
+ * is now greater than twice the number of hash values, *
+ * the table is then expanded.                          */
+
+/**/
+void
+addhashnode(HashTable ht, char *nam, void *nodeptr)
+{
+    unsigned hashval;
+    HashNode hn, hp, hq;
+
+    hn = (HashNode) nodeptr;
+    hn->nam = nam;
+
+    hashval = ht->hash(hn->nam) % ht->hsize;
+    hp = ht->nodes[hashval];
+
+    /* check if this is the first node for this hash value */
+    if (!hp) {
+	hn->next = NULL;
+	ht->nodes[hashval] = hn;
+	if (++ht->ct >= ht->hsize * 2 && !ht->scan)
+	    expandhashtable(ht);
+	return;
+    }
+
+    /* else check if the first node contains the same key */
+    if (!strcmp(hp->nam, hn->nam)) {
+	ht->nodes[hashval] = hn;
+	replacing:
+	hn->next = hp->next;
+	if(ht->scan)
+	    if(ht->scan->sorted) {
+		HashNode *tab = ht->scan->u.s.tab;
+		int i;
+		for(i = ht->scan->u.s.ct; i--; )
+		    if(tab[i] == hp)
+			tab[i] = hn;
+	    } else if(ht->scan->u.u == hp)
+		ht->scan->u.u = hn;
+	ht->freenode(hp);
+	return;
+    }
+
+    /* else run through the list and check all the keys */
+    hq = hp;
+    hp = hp->next;
+    for (; hp; hq = hp, hp = hp->next) {
+	if (!strcmp(hp->nam, hn->nam)) {
+	    hq->next = hn;
+	    goto replacing;
+	}
+    }
+
+    /* else just add it at the front of the list */
+    hn->next = ht->nodes[hashval];
+    ht->nodes[hashval] = hn;
+    if (++ht->ct >= ht->hsize * 2 && !ht->scan)
+        expandhashtable(ht);
+}
+
+/* Get an enabled entry in a hash table.  *
+ * If successful, it returns a pointer to *
+ * the hashnode.  If the node is DISABLED *
+ * or isn't found, it returns NULL        */
+
+/**/
+HashNode
+gethashnode(HashTable ht, char *nam)
+{
+    unsigned hashval;
+    HashNode hp;
+
+    hashval = ht->hash(nam) % ht->hsize;
+    for (hp = ht->nodes[hashval]; hp; hp = hp->next) {
+	if (!strcmp(hp->nam, nam)) {
+	    if (hp->flags & DISABLED)
+		return NULL;
+	    else
+		return hp;
+	}
+    }
+    return NULL;
+}
+
+/* Get an entry in a hash table.  It will *
+ * ignore the DISABLED flag and return a  *
+ * pointer to the hashnode if found, else *
+ * it returns NULL.                       */
+
+/**/
+HashNode
+gethashnode2(HashTable ht, char *nam)
+{
+    unsigned hashval;
+    HashNode hp;
+
+    hashval = ht->hash(nam) % ht->hsize;
+    for (hp = ht->nodes[hashval]; hp; hp = hp->next) {
+	if (!strcmp(hp->nam, nam))
+	    return hp;
+    }
+    return NULL;
+}
+
+/* Remove an entry from a hash table.           *
+ * If successful, it removes the node from the  *
+ * table and returns a pointer to it.  If there *
+ * is no such node, then it returns NULL        */
+
+/**/
+HashNode
+removehashnode(HashTable ht, char *nam)
+{
+    unsigned hashval;
+    HashNode hp, hq;
+
+    hashval = ht->hash(nam) % ht->hsize;
+    hp = ht->nodes[hashval];
+
+    /* if no nodes at this hash value, return NULL */
+    if (!hp)
+	return NULL;
+
+    /* else check if the key in the first one matches */
+    if (!strcmp(hp->nam, nam)) {
+	ht->nodes[hashval] = hp->next;
+	gotit:
+	ht->ct--;
+	if(ht->scan)
+	    if(ht->scan->sorted) {
+		HashNode *tab = ht->scan->u.s.tab;
+		int i;
+		for(i = ht->scan->u.s.ct; i--; )
+		    if(tab[i] == hp)
+			tab[i] = NULL;
+	    } else if(ht->scan->u.u == hp)
+		ht->scan->u.u = hp->next;
+	return hp;
+    }
+
+    /* else run through the list and check the rest of the keys */
+    hq = hp;
+    hp = hp->next;
+    for (; hp; hq = hp, hp = hp->next) {
+	if (!strcmp(hp->nam, nam)) {
+	    hq->next = hp->next;
+	    goto gotit;
+	}
+    }
+
+    /* else it is not in the list, so return NULL */
+    return NULL;
+}
+
+/* Disable a node in a hash table */
+
+/**/
+void
+disablehashnode(HashNode hn, int flags)
+{
+    hn->flags |= DISABLED;
+}
+
+/* Enable a node in a hash table */
+
+/**/
+void
+enablehashnode(HashNode hn, int flags)
+{
+    hn->flags &= ~DISABLED;
+}
+
+/* Compare two hash table entries */
+
+/**/
+static int
+hnamcmp(const void *ap, const void *bp)
+{
+    HashNode a = *(HashNode *)ap;
+    HashNode b = *(HashNode *)bp;
+    return ztrcmp((unsigned char *) a->nam, (unsigned char *) b->nam);
+}
+
+/* Scan the nodes in a hash table and execute scanfunc on nodes based on
+ * the flags that are set/unset.  scanflags is passed unchanged to
+ * scanfunc (if executed).
+ *
+ * If sorted != 0, then sort entries of hash table before scanning.
+ * If flags1 > 0, then execute scanfunc on a node only if at least one of
+ *                these flags is set.
+ * If flags2 > 0, then execute scanfunc on a node only if all of
+ *                these flags are NOT set.
+ * The conditions above for flags1/flags2 must both be true.
+ *
+ * It is safe to add, remove or replace hash table elements from within
+ * the scanfunc.  Replaced elements will appear in the scan exactly once,
+ * the new version if it was not scanned before the replacement was made.
+ * Added elements might or might not appear in the scan.
+ */
+
+/**/
+void
+scanhashtable(HashTable ht, int sorted, int flags1, int flags2, ScanFunc scanfunc, int scanflags)
+{
+    struct scanstatus st;
+
+    if (sorted) {
+	int i, ct = ht->ct;
+	VARARR(HashNode, hnsorttab, ct);
+	HashNode *htp, hn;
+
+	for (htp = hnsorttab, i = 0; i < ht->hsize; i++)
+	    for (hn = ht->nodes[i]; hn; hn = hn->next)
+		*htp++ = hn;
+	qsort((void *)hnsorttab, ct, sizeof(HashNode), hnamcmp);
+
+	st.sorted = 1;
+	st.u.s.tab = hnsorttab;
+	st.u.s.ct = ct;
+	ht->scan = &st;
+
+	for (htp = hnsorttab, i = 0; i < ct; i++, htp++)
+	    if (*htp && ((*htp)->flags & flags1) + !flags1 &&
+		!((*htp)->flags & flags2))
+		scanfunc(*htp, scanflags);
+
+	ht->scan = NULL;
+    } else {
+	int i, hsize = ht->hsize;
+	HashNode *nodes = ht->nodes;
+
+	st.sorted = 0;
+	ht->scan = &st;
+
+	for (i = 0; i < hsize; i++)
+	    for (st.u.u = nodes[i]; st.u.u; ) {
+		HashNode hn = st.u.u;
+		st.u.u = st.u.u->next;
+		if ((hn->flags & flags1) + !flags1 && !(hn->flags & flags2))
+		    scanfunc(hn, scanflags);
+	    }
+
+	ht->scan = NULL;
+    }
+}
+
+/* Scan all nodes in a hash table and executes scanfunc on the *
+ * nodes which meet all the following criteria:                *
+ * The hash key must match the glob pattern given by `com'.    *
+ * If (flags1 > 0), then any flag in flags1 must be set.       *
+ * If (flags2 > 0), then all flags in flags2 must NOT be set.  *
+ *                                                             *
+ * scanflags is passed unchanged to scanfunc (if executed).    *
+ * The return value is the number of matches.                  */
+
+/**/
+int
+scanmatchtable(HashTable ht, Comp com, int flags1, int flags2, ScanFunc scanfunc, int scanflags)
+{
+    int i, hsize = ht->hsize;
+    HashNode *nodes = ht->nodes;
+    int match = 0;
+    struct scanstatus st;
+
+    st.sorted = 0;
+    ht->scan = &st;
+
+    for (i = 0; i < hsize; i++)
+	for (st.u.u = nodes[i]; st.u.u; ) {
+	    HashNode hn = st.u.u;
+	    st.u.u = st.u.u->next;
+	    if ((hn->flags & flags1) + !flags1 && !(hn->flags & flags2) &&
+		domatch(hn->nam, com, 0))
+		scanfunc(hn, scanflags);
+		match++;
+	}
+
+    ht->scan = NULL;
+
+    return match;
+}
+
+/* Expand hash tables when they get too many entries. *
+ * The new size is 4 times the previous size.         */
+
+/**/
+static void
+expandhashtable(HashTable ht)
+{
+    struct hashnode **onodes, **ha, *hn, *hp;
+    int i, osize;
+
+    osize = ht->hsize;
+    onodes = ht->nodes;
+
+    ht->hsize = osize * 4;
+    ht->nodes = (HashNode *) zcalloc(ht->hsize * sizeof(HashNode));
+    ht->ct = 0;
+
+    /* scan through the old list of nodes, and *
+     * rehash them into the new list of nodes  */
+    for (i = 0, ha = onodes; i < osize; i++, ha++) {
+	for (hn = *ha; hn;) {
+	    hp = hn->next;
+	    ht->addnode(ht, hn->nam, hn);
+	    hn = hp;
+	}
+    }
+    zfree(onodes, osize * sizeof(HashNode));
+}
+
+/* Empty the hash table and resize it if necessary */
+
+/**/
+static void
+resizehashtable(HashTable ht, int newsize)
+{
+    struct hashnode **ha, *hn, *hp;
+    int i;
+
+    /* free all the hash nodes */
+    ha = ht->nodes;
+    for (i = 0; i < ht->hsize; i++, ha++) {
+	for (hn = *ha; hn;) {
+	    hp = hn->next;
+	    ht->freenode(hn);
+	    hn = hp;
+	}
+    }
+
+    /* If new size desired is different from current size, *
+     * we free it and allocate a new nodes array.          */
+    if (ht->hsize != newsize) {
+	zfree(ht->nodes, ht->hsize * sizeof(HashNode));
+	ht->nodes = (HashNode *) zcalloc(newsize * sizeof(HashNode));
+	ht->hsize = newsize;
+    } else {
+	/* else we just re-zero the current nodes array */
+	memset(ht->nodes, 0, newsize * sizeof(HashNode));
+    }
+
+    ht->ct = 0;
+}
+
+/* Generic method to empty a hash table */
+
+/**/
+void
+emptyhashtable(HashTable ht)
+{
+    resizehashtable(ht, ht->hsize);
+}
+
+#ifdef ZSH_HASH_DEBUG
+
+/* Print info about hash table */
+
+#define MAXDEPTH 7
+
+/**/
+static void
+printhashtabinfo(HashTable ht)
+{
+    HashNode hn;
+    int chainlen[MAXDEPTH + 1];
+    int i, tmpcount, total;
+
+    printf("name of table   : %s\n",   ht->tablename);
+    printf("size of nodes[] : %d\n",   ht->hsize);
+    printf("number of nodes : %d\n\n", ht->ct);
+
+    memset(chainlen, 0, sizeof(chainlen));
+
+    /* count the number of nodes just to be sure */
+    total = 0;
+    for (i = 0; i < ht->hsize; i++) {
+	tmpcount = 0;
+	for (hn = ht->nodes[i]; hn; hn = hn->next)
+	    tmpcount++;
+	if (tmpcount >= MAXDEPTH)
+	    chainlen[MAXDEPTH]++;
+	else
+	    chainlen[tmpcount]++;
+	total += tmpcount;
+    }
+
+    for (i = 0; i < MAXDEPTH; i++)
+	printf("number of hash values with chain of length %d  : %4d\n", i, chainlen[i]);
+    printf("number of hash values with chain of length %d+ : %4d\n", MAXDEPTH, chainlen[MAXDEPTH]);
+    printf("total number of nodes                         : %4d\n", total);
+}
+
+/**/
+int
+bin_hashinfo(char *nam, char **args, char *ops, int func)
+{
+    HashTable ht;
+    printf("----------------------------------------------------\n");
+    for(ht = firstht; ht; ht = ht->next) {
+	ht->printinfo(ht);
+	printf("----------------------------------------------------\n");
+    }
+    return 0;
+}
+
+#endif /* ZSH_HASH_DEBUG */
+
+/********************************/
+/* Command Hash Table Functions */
+/********************************/
+
+/* hash table containing external commands */
+ 
+/**/
+HashTable cmdnamtab;
+ 
+/* how far we've hashed the PATH so far */
+ 
+/**/
+char **pathchecked;
+ 
+/* Create a new command hash table */
+ 
+/**/
+void
+createcmdnamtable(void)
+{
+    cmdnamtab = newhashtable(201, "cmdnamtab", NULL);
+
+    cmdnamtab->hash        = hasher;
+    cmdnamtab->emptytable  = emptycmdnamtable;
+    cmdnamtab->filltable   = fillcmdnamtable;
+    cmdnamtab->addnode     = addhashnode;
+    cmdnamtab->getnode     = gethashnode2;
+    cmdnamtab->getnode2    = gethashnode2;
+    cmdnamtab->removenode  = removehashnode;
+    cmdnamtab->disablenode = NULL;
+    cmdnamtab->enablenode  = NULL;
+    cmdnamtab->freenode    = freecmdnamnode;
+    cmdnamtab->printnode   = printcmdnamnode;
+
+    pathchecked = path;
+}
+
+/**/
+static void
+emptycmdnamtable(HashTable ht)
+{
+    emptyhashtable(ht);
+    pathchecked = path;
+}
+
+/* Add all commands in a given directory *
+ * to the command hashtable.             */
+
+/**/
+void
+hashdir(char **dirp)
+{
+    Cmdnam cn;
+    DIR *dir;
+    char *fn;
+
+    if (isrelative(*dirp) || !(dir = opendir(unmeta(*dirp))))
+	return;
+
+    while ((fn = zreaddir(dir, 1))) {
+	if (!cmdnamtab->getnode(cmdnamtab, fn)) {
+	    cn = (Cmdnam) zcalloc(sizeof *cn);
+	    cn->flags = 0;
+	    cn->u.name = dirp;
+	    cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
+	}
+    }
+    closedir(dir);
+}
+
+/* Go through user's PATH and add everything to *
+ * the command hashtable.                       */
+
+/**/
+static void
+fillcmdnamtable(HashTable ht)
+{
+    char **pq;
+ 
+    for (pq = pathchecked; *pq; pq++)
+	hashdir(pq);
+
+    pathchecked = pq;
+}
+
+/**/
+static void
+freecmdnamnode(HashNode hn)
+{
+    Cmdnam cn = (Cmdnam) hn;
+ 
+    zsfree(cn->nam);
+    if (cn->flags & HASHED)
+	zsfree(cn->u.cmd);
+ 
+    zfree(cn, sizeof(struct cmdnam));
+}
+
+/* Print an element of the cmdnamtab hash table (external command) */
+ 
+/**/
+static void
+printcmdnamnode(HashNode hn, int printflags)
+{
+    Cmdnam cn = (Cmdnam) hn;
+
+    if (printflags & PRINT_WHENCE_WORD) {
+	printf("%s: %s\n", cn->nam, (cn->flags & HASHED) ? 
+	       "hashed" : "command");
+	return;
+    }
+
+    if ((printflags & PRINT_WHENCE_CSH) || (printflags & PRINT_WHENCE_SIMPLE)) {
+	if (cn->flags & HASHED) {
+	    zputs(cn->u.cmd, stdout);
+	    putchar('\n');
+	} else {
+	    zputs(*(cn->u.name), stdout);
+	    putchar('/');
+	    zputs(cn->nam, stdout);
+	    putchar('\n');
+	}
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_VERBOSE) {
+	if (cn->flags & HASHED) {
+	    nicezputs(cn->nam, stdout);
+	    printf(" is hashed to ");
+	    nicezputs(cn->u.cmd, stdout);
+	    putchar('\n');
+	} else {
+	    nicezputs(cn->nam, stdout);
+	    printf(" is ");
+	    nicezputs(*(cn->u.name), stdout);
+	    putchar('/');
+	    nicezputs(cn->nam, stdout);
+	    putchar('\n');
+	}
+	return;
+    }
+
+    if (cn->flags & HASHED) {
+	quotedzputs(cn->nam, stdout);
+	putchar('=');
+	quotedzputs(cn->u.cmd, stdout);
+	putchar('\n');
+    } else {
+	quotedzputs(cn->nam, stdout);
+	putchar('=');
+	quotedzputs(*(cn->u.name), stdout);
+	putchar('/');
+	quotedzputs(cn->nam, stdout);
+	putchar('\n');
+    }
+}
+
+/***************************************/
+/* Shell Function Hash Table Functions */
+/***************************************/
+
+/* hash table containing the shell functions */
+
+/**/
+HashTable shfunctab;
+
+/**/
+void
+createshfunctable(void)
+{
+    shfunctab = newhashtable(7, "shfunctab", NULL);
+
+    shfunctab->hash        = hasher;
+    shfunctab->emptytable  = NULL;
+    shfunctab->filltable   = NULL;
+    shfunctab->addnode     = addhashnode;
+    shfunctab->getnode     = gethashnode;
+    shfunctab->getnode2    = gethashnode2;
+    shfunctab->removenode  = removeshfuncnode;
+    shfunctab->disablenode = disableshfuncnode;
+    shfunctab->enablenode  = enableshfuncnode;
+    shfunctab->freenode    = freeshfuncnode;
+    shfunctab->printnode   = printshfuncnode;
+}
+
+/* Remove an entry from the shell function hash table.   *
+ * It checks if the function is a signal trap and if so, *
+ * it will disable the trapping of that signal.          */
+
+/**/
+static HashNode
+removeshfuncnode(HashTable ht, char *nam)
+{
+    HashNode hn;
+
+    if ((hn = removehashnode(shfunctab, nam))) {
+	if (!strncmp(hn->nam, "TRAP", 4))
+	    unsettrap(getsignum(hn->nam + 4));
+	return hn;
+    } else
+	return NULL;
+}
+
+/* Disable an entry in the shell function hash table.    *
+ * It checks if the function is a signal trap and if so, *
+ * it will disable the trapping of that signal.          */
+
+/**/
+static void
+disableshfuncnode(HashNode hn, int flags)
+{
+    hn->flags |= DISABLED;
+    if (!strncmp(hn->nam, "TRAP", 4)) {
+	int signum = getsignum(hn->nam + 4);
+	sigtrapped[signum] &= ~ZSIG_FUNC;
+	sigfuncs[signum] = NULL;
+	unsettrap(signum);
+    }
+}
+
+/* Re-enable an entry in the shell function hash table.  *
+ * It checks if the function is a signal trap and if so, *
+ * it will re-enable the trapping of that signal.        */
+
+/**/
+static void
+enableshfuncnode(HashNode hn, int flags)
+{
+    Shfunc shf = (Shfunc) hn;
+    int signum;
+
+    shf->flags &= ~DISABLED;
+    if (!strncmp(shf->nam, "TRAP", 4)) {
+	signum = getsignum(shf->nam + 4);
+	if (signum != -1) {
+	    settrap(signum, shf->funcdef);
+	    sigtrapped[signum] |= ZSIG_FUNC;
+	}
+    }
+}
+
+/**/
+static void
+freeshfuncnode(HashNode hn)
+{
+    Shfunc shf = (Shfunc) hn;
+
+    zsfree(shf->nam);
+    if (shf->funcdef)
+	freestruct(shf->funcdef);
+    zfree(shf, sizeof(struct shfunc));
+}
+
+/* Print a shell function */
+ 
+/**/
+static void
+printshfuncnode(HashNode hn, int printflags)
+{
+    Shfunc f = (Shfunc) hn;
+    char *t;
+ 
+    if ((printflags & PRINT_NAMEONLY) ||
+	((printflags & PRINT_WHENCE_SIMPLE) &&
+	!(printflags & PRINT_WHENCE_FUNCDEF))) {
+	zputs(f->nam, stdout);
+	putchar('\n');
+	return;
+    }
+ 
+    if ((printflags & (PRINT_WHENCE_VERBOSE|PRINT_WHENCE_WORD)) &&
+	!(printflags & PRINT_WHENCE_FUNCDEF)) {
+	nicezputs(f->nam, stdout);
+	printf((printflags & PRINT_WHENCE_WORD) ? ": function\n" :
+	       " is a shell function\n");
+	return;
+    }
+ 
+    if (f->flags & PM_UNDEFINED)
+	printf("undefined ");
+    if (f->flags & PM_TAGGED)
+	printf("traced ");
+    if ((f->flags & PM_UNDEFINED) || !f->funcdef) {
+	nicezputs(f->nam, stdout);
+	printf(" () { }\n");
+	return;
+    }
+ 
+    t = getpermtext((void *) dupstruct((void *) f->funcdef));
+    quotedzputs(f->nam, stdout);
+    printf(" () {\n\t");
+    zputs(t, stdout);
+    printf("\n}\n");
+    zsfree(t);
+}
+
+/**************************************/
+/* Reserved Word Hash Table Functions */
+/**************************************/
+
+/* Nodes for reserved word hash table */
+
+static struct reswd reswds[] = {
+    {NULL, "!", 0, BANG},
+    {NULL, "[[", 0, DINBRACK},
+    {NULL, "{", 0, INBRACE},
+    {NULL, "}", 0, OUTBRACE},
+    {NULL, "case", 0, CASE},
+    {NULL, "coproc", 0, COPROC},
+    {NULL, "do", 0, DO},
+    {NULL, "done", 0, DONE},
+    {NULL, "elif", 0, ELIF},
+    {NULL, "else", 0, ELSE},
+    {NULL, "end", 0, ZEND},
+    {NULL, "esac", 0, ESAC},
+    {NULL, "fi", 0, FI},
+    {NULL, "for", 0, FOR},
+    {NULL, "foreach", 0, FOREACH},
+    {NULL, "function", 0, FUNC},
+    {NULL, "if", 0, IF},
+    {NULL, "nocorrect", 0, NOCORRECT},
+    {NULL, "repeat", 0, REPEAT},
+    {NULL, "select", 0, SELECT},
+    {NULL, "then", 0, THEN},
+    {NULL, "time", 0, TIME},
+    {NULL, "until", 0, UNTIL},
+    {NULL, "while", 0, WHILE},
+    {NULL, NULL}
+};
+
+/* hash table containing the reserved words */
+
+/**/
+HashTable reswdtab;
+
+/* Build the hash table containing zsh's reserved words. */
+
+/**/
+void
+createreswdtable(void)
+{
+    Reswd rw;
+
+    reswdtab = newhashtable(23, "reswdtab", NULL);
+
+    reswdtab->hash        = hasher;
+    reswdtab->emptytable  = NULL;
+    reswdtab->filltable   = NULL;
+    reswdtab->addnode     = addhashnode;
+    reswdtab->getnode     = gethashnode;
+    reswdtab->getnode2    = gethashnode2;
+    reswdtab->removenode  = NULL;
+    reswdtab->disablenode = disablehashnode;
+    reswdtab->enablenode  = enablehashnode;
+    reswdtab->freenode    = NULL;
+    reswdtab->printnode   = printreswdnode;
+
+    for (rw = reswds; rw->nam; rw++)
+	reswdtab->addnode(reswdtab, rw->nam, rw);
+}
+
+/* Print a reserved word */
+
+/**/
+static void
+printreswdnode(HashNode hn, int printflags)
+{
+    Reswd rw = (Reswd) hn;
+
+    if (printflags & PRINT_WHENCE_WORD) {
+	printf("%s: reserved\n", rw->nam);
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_CSH) {
+	printf("%s: shell reserved word\n", rw->nam);
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_VERBOSE) {
+	printf("%s is a reserved word\n", rw->nam);
+	return;
+    }
+
+    /* default is name only */
+    printf("%s\n", rw->nam);
+}
+
+/********************************/
+/* Aliases Hash Table Functions */
+/********************************/
+
+/* hash table containing the aliases */
+ 
+/**/
+HashTable aliastab;
+ 
+/* Create new hash table for aliases */
+
+/**/
+void
+createaliastable(void)
+{
+    aliastab = newhashtable(23, "aliastab", NULL);
+
+    aliastab->hash        = hasher;
+    aliastab->emptytable  = NULL;
+    aliastab->filltable   = NULL;
+    aliastab->addnode     = addhashnode;
+    aliastab->getnode     = gethashnode;
+    aliastab->getnode2    = gethashnode2;
+    aliastab->removenode  = removehashnode;
+    aliastab->disablenode = disablehashnode;
+    aliastab->enablenode  = enablehashnode;
+    aliastab->freenode    = freealiasnode;
+    aliastab->printnode   = printaliasnode;
+
+    /* add the default aliases */
+    aliastab->addnode(aliastab, ztrdup("run-help"), createaliasnode(ztrdup("man"), 0));
+    aliastab->addnode(aliastab, ztrdup("which-command"), createaliasnode(ztrdup("whence"), 0));
+}
+
+/* Create a new alias node */
+
+/**/
+Alias
+createaliasnode(char *txt, int flags)
+{
+    Alias al;
+
+    al = (Alias) zcalloc(sizeof *al);
+    al->flags = flags;
+    al->text = txt;
+    al->inuse = 0;
+    return al;
+}
+
+/**/
+static void
+freealiasnode(HashNode hn)
+{
+    Alias al = (Alias) hn;
+ 
+    zsfree(al->nam);
+    zsfree(al->text);
+    zfree(al, sizeof(struct alias));
+}
+
+/* Print an alias */
+
+/**/
+static void
+printaliasnode(HashNode hn, int printflags)
+{
+    Alias a = (Alias) hn;
+
+    if (printflags & PRINT_NAMEONLY) {
+	zputs(a->nam, stdout);
+	putchar('\n');
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_WORD) {
+	printf("%s: alias\n", a->nam);
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_SIMPLE) {
+	zputs(a->text, stdout);
+	putchar('\n');
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_CSH) {
+	nicezputs(a->nam, stdout);
+	if (a->flags & ALIAS_GLOBAL)
+	    printf(": globally aliased to ");
+	else
+	    printf(": aliased to ");
+	nicezputs(a->text, stdout);
+	putchar('\n');
+	return;
+    }
+
+    if (printflags & PRINT_WHENCE_VERBOSE) {
+	nicezputs(a->nam, stdout);
+	if (a->flags & ALIAS_GLOBAL)
+	    printf(" is a global alias for ");
+	else
+	    printf(" is an alias for ");
+	nicezputs(a->text, stdout);
+	putchar('\n');
+	return;
+    }
+
+    if (printflags & PRINT_LIST) {
+	printf("alias ");
+	if (a->flags & ALIAS_GLOBAL)
+	    printf("-g ");
+
+	/* If an alias begins with `-', then we must output `-- ' *
+	 * first, so that it is not interpreted as an option.     */
+	if(a->nam[0] == '-')
+	    printf("-- ");
+    }
+
+    quotedzputs(a->nam, stdout);
+    putchar('=');
+    quotedzputs(a->text, stdout);
+    putchar('\n');
+}
+
+/**********************************/
+/* Parameter Hash Table Functions */
+/**********************************/
+
+/**/
+void
+freeparamnode(HashNode hn)
+{
+    Param pm = (Param) hn;
+ 
+    zsfree(pm->nam);
+    zfree(pm, sizeof(struct param));
+}
+
+/* Print a parameter */
+
+/**/
+void
+printparamnode(HashNode hn, int printflags)
+{
+    Param p = (Param) hn;
+    char *t, **u;
+
+    if (p->flags & PM_UNSET)
+	return;
+
+    /* Print the attributes of the parameter */
+    if (printflags & PRINT_TYPE) {
+	if (p->flags & PM_INTEGER)
+	    printf("integer ");
+	if (p->flags & PM_ARRAY)
+	    printf("array ");
+	if (p->flags & PM_LEFT)
+	    printf("left justified %d ", p->ct);
+	if (p->flags & PM_RIGHT_B)
+	    printf("right justified %d ", p->ct);
+	if (p->flags & PM_RIGHT_Z)
+	    printf("zero filled %d ", p->ct);
+	if (p->flags & PM_LOWER)
+	    printf("lowercase ");
+	if (p->flags & PM_UPPER)
+	    printf("uppercase ");
+	if (p->flags & PM_READONLY)
+	    printf("readonly ");
+	if (p->flags & PM_TAGGED)
+	    printf("tagged ");
+	if (p->flags & PM_EXPORTED)
+	    printf("exported ");
+    }
+
+    if (printflags & PRINT_NAMEONLY) {
+	zputs(p->nam, stdout);
+	putchar('\n');
+	return;
+    }
+
+    /* How the value is displayed depends *
+     * on the type of the parameter       */
+    quotedzputs(p->nam, stdout);
+    putchar('=');
+    switch (PM_TYPE(p->flags)) {
+    case PM_SCALAR:
+	/* string: simple output */
+	if (p->gets.cfn && (t = p->gets.cfn(p)))
+	    quotedzputs(t, stdout);
+	putchar('\n');
+	break;
+    case PM_INTEGER:
+	/* integer */
+	printf("%ld\n", p->gets.ifn(p));
+	break;
+    case PM_ARRAY:
+	/* array */
+	putchar('(');
+	u = p->gets.afn(p);
+	if(*u) {
+	    quotedzputs(*u++, stdout);
+	    while (*u) {
+		putchar(' ');
+		quotedzputs(*u++, stdout);
+	    }
+	}
+	printf(")\n");
+	break;
+    }
+}
+
+/****************************************/
+/* Named Directory Hash Table Functions */
+/****************************************/
+
+/* hash table containing named directories */
+
+/**/
+HashTable nameddirtab;
+ 
+/* != 0 if all the usernames have already been *
+ * added to the named directory hash table.    */
+
+static int allusersadded;
+
+/* Create new hash table for named directories */
+
+/**/
+void
+createnameddirtable(void)
+{
+    nameddirtab = newhashtable(201, "nameddirtab", NULL);
+
+    nameddirtab->hash        = hasher;
+    nameddirtab->emptytable  = emptynameddirtable;
+    nameddirtab->filltable   = fillnameddirtable;
+    nameddirtab->addnode     = addnameddirnode;
+    nameddirtab->getnode     = gethashnode;
+    nameddirtab->getnode2    = gethashnode2;
+    nameddirtab->removenode  = removenameddirnode;
+    nameddirtab->disablenode = NULL;
+    nameddirtab->enablenode  = NULL;
+    nameddirtab->freenode    = freenameddirnode;
+    nameddirtab->printnode   = printnameddirnode;
+
+    allusersadded = 0;
+    finddir(NULL);		/* clear the finddir cache */
+}
+
+/* Empty the named directories table */
+
+/**/
+static void
+emptynameddirtable(HashTable ht)
+{
+    emptyhashtable(ht);
+    allusersadded = 0;
+    finddir(NULL);		/* clear the finddir cache */
+}
+
+/* Add all the usernames in the password file/database *
+ * to the named directories table.                     */
+
+/**/
+static void
+fillnameddirtable(HashTable ht)
+{
+#ifdef HAVE_GETPWENT
+    if (!allusersadded) {
+	struct passwd *pw;
+ 
+	setpwent();
+ 
+	/* loop through the password file/database *
+	 * and add all entries returned.           */
+	while ((pw = getpwent()) && !errflag)
+	    adduserdir(ztrdup(pw->pw_name), pw->pw_dir, ND_USERNAME, 1);
+ 
+	endpwent();
+	allusersadded = 1;
+    }
+    return;
+#endif /* HAVE_GETPWENT */
+}
+
+/* Add an entry to the named directory hash *
+ * table, clearing the finddir() cache and  *
+ * initialising the `diff' member.          */
+
+/**/
+static void
+addnameddirnode(HashTable ht, char *nam, void *nodeptr)
+{
+    Nameddir nd = (Nameddir) nodeptr;
+
+    nd->diff = strlen(nd->dir) - strlen(nam);
+    finddir(NULL);		/* clear the finddir cache */
+    addhashnode(ht, nam, nodeptr);
+}
+
+/* Remove an entry from the named directory  *
+ * hash table, clearing the finddir() cache. */
+
+/**/
+static HashNode
+removenameddirnode(HashTable ht, char *nam)
+{
+    HashNode hn = removehashnode(ht, nam);
+
+    if(hn)
+	finddir(NULL);		/* clear the finddir cache */
+    return hn;
+}
+
+/* Free up the memory used by a named directory hash node. */
+
+/**/
+static void
+freenameddirnode(HashNode hn)
+{
+    Nameddir nd = (Nameddir) hn;
+ 
+    zsfree(nd->nam);
+    zsfree(nd->dir);
+    zfree(nd, sizeof(struct nameddir));
+}
+
+/* Print a named directory */
+
+/**/
+static void
+printnameddirnode(HashNode hn, int printflags)
+{
+    Nameddir nd = (Nameddir) hn;
+
+    if (printflags & PRINT_NAMEONLY) {
+	zputs(nd->nam, stdout);
+	putchar('\n');
+	return;
+    }
+
+    quotedzputs(nd->nam, stdout);
+    putchar('=');
+    quotedzputs(nd->dir, stdout);
+    putchar('\n');
+}
diff --git a/Src/hashtable.h b/Src/hashtable.h
new file mode 100644
index 000000000..5b78c9c18
--- /dev/null
+++ b/Src/hashtable.h
@@ -0,0 +1,62 @@
+/*
+ * hashtable.h - header file for hash table handling code
+ *
+ * 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.
+ *
+ */
+
+/* Builtin function numbers; used by handler functions that handle more *
+ * than one builtin.  Note that builtins such as compctl, that are not  *
+ * overloaded, don't get a number.                                      */
+
+#define BIN_TYPESET   0
+#define BIN_BG        1
+#define BIN_FG        2
+#define BIN_JOBS      3
+#define BIN_WAIT      4
+#define BIN_DISOWN    5
+#define BIN_BREAK     6
+#define BIN_CONTINUE  7
+#define BIN_EXIT      8
+#define BIN_RETURN    9
+#define BIN_CD       10
+#define BIN_POPD     11
+#define BIN_PUSHD    12
+#define BIN_PRINT    13
+#define BIN_EVAL     14
+#define BIN_SCHED    15
+#define BIN_FC       16
+#define BIN_PUSHLINE 17
+#define BIN_LOGOUT   18
+#define BIN_TEST     19
+#define BIN_BRACKET  20
+#define BIN_EXPORT   21
+#define BIN_ECHO     22
+#define BIN_DISABLE  23
+#define BIN_ENABLE   24
+
+/* These currently depend on being 0 and 1. */
+#define BIN_SETOPT    0
+#define BIN_UNSETOPT  1
diff --git a/Src/hist.c b/Src/hist.c
new file mode 100644
index 000000000..a4c5735c1
--- /dev/null
+++ b/Src/hist.c
@@ -0,0 +1,1670 @@
+/*
+ * hist.c - history expansion
+ *
+ * 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 "hist.pro"
+
+/* != 0 means history substitution is turned off */
+ 
+/**/
+int stophist;
+ 
+/* this line began with a space, so junk it if HISTIGNORESPACE is on */
+ 
+/**/
+int spaceflag;
+ 
+/* if != 0, we are expanding the current line */
+
+/**/
+int expanding;
+
+/* these are used to modify the cursor position during expansion */
+
+/**/
+int excs, exlast;
+
+/*
+ * Current history event number
+ *
+ * Note on curhist: with history inactive, this points to the
+ * last line actually added to the history list.  With history active,
+ * the line does not get added to the list until hend(), if at all.
+ * However, curhist is incremented to reflect the current line anyway.
+ * Thus if the line is not added to the list, curhist must be
+ * decremented in hend().
+ */
+ 
+/**/
+int curhist;
+
+/* number of history entries */
+ 
+/**/
+int histentct;
+ 
+/* array of history entries */
+ 
+/**/
+Histent histentarr;
+ 
+/* capacity of history lists */
+ 
+/**/
+int histsiz;
+ 
+/* if = 1, we have performed history substitution on the current line *
+ * if = 2, we have used the 'p' modifier                              */
+ 
+/**/
+int histdone;
+ 
+/* state of the history mechanism */
+ 
+/**/
+int histactive;
+
+/* Bits of histactive variable */
+#define HA_ACTIVE	(1<<0)	/* History mechanism is active */
+#define HA_NOSTORE	(1<<1)	/* Don't store the line when finished */
+#define HA_JUNKED	(1<<2)	/* Last history line was already junked */
+#define HA_NOINC	(1<<3)	/* Don't store, curhist not incremented */
+
+/* Array of word beginnings and endings in current history line. */
+
+/**/
+short *chwords;
+
+/* Max, actual position in chwords.
+ * nwords = chwordpos/2 because we record beginning and end of words.
+ */
+
+/**/
+int chwordlen, chwordpos;
+
+/* the last l for s/l/r/ history substitution */
+ 
+/**/
+char *hsubl;
+
+/* the last r for s/l/r/ history substitution */
+ 
+/**/
+char *hsubr;
+ 
+/* pointer into the history line */
+ 
+/**/
+char *hptr;
+ 
+/* the current history line */
+ 
+/**/
+char *chline;
+
+/* true if the last character returned by hgetc was an escaped bangchar *
+ * if it is set and NOBANGHIST is unset hwaddc escapes bangchars        */
+
+/**/
+int qbang;
+ 
+/* max size of histline */
+ 
+/**/
+int hlinesz;
+ 
+/* default event (usually curhist-1, that is, "!!") */
+ 
+static int defev;
+ 
+/* add a character to the current history word */
+
+/**/
+void
+hwaddc(int c)
+{
+    /* Only if history line exists and lexing has not finished. */
+    if (chline && !(errflag || lexstop)) {
+	/* Quote un-expanded bangs in the history line. */
+	if (c == bangchar && stophist < 2 && qbang)
+	    /* If qbang is not set, we do not escape this bangchar as it's *
+	     * not mecessary (e.g. it's a bang in !=, or it is followed    *
+	     * by a space). Roughly speaking, qbang is zero only if the    *
+	     * history interpreter has already digested this bang and      *
+	     * found that it is not necessary to escape it.                */
+	    hwaddc('\\');
+	*hptr++ = c;
+
+	/* Resize history line if necessary */
+	if (hptr - chline >= hlinesz) {
+	    int oldsiz = hlinesz;
+
+	    chline = realloc(chline, hlinesz = oldsiz + 16);
+	    hptr = chline + oldsiz;
+	}
+    }
+}
+
+/* This function adds a character to the zle input line. It is used when *
+ * zsh expands history (see doexpandhist() in zle_tricky.c). It also     *
+ * calculates the new cursor position after the expansion. It is called  *
+ * from hgetc() and from gettok() in lex.c for characters in comments.   */
+ 
+/**/
+void
+addtoline(int c)
+{
+    if (! expanding || lexstop)
+	return;
+    if (qbang && c == bangchar && stophist < 2) {
+	exlast--;
+	spaceinline(1);
+	line[cs++] = '\\';
+    }
+    if (excs > cs) {
+	excs += 1 + inbufct - exlast;
+	if (excs < cs)
+	    /* this case could be handled better but it is    *
+	     * so rare that it does not worth it              */
+	    excs = cs;
+    }
+    exlast = inbufct;
+    spaceinline(1);
+    line[cs++] = itok(c) ? ztokens[c - Pound] : c;
+}
+
+/**/
+int
+hgetc(void)
+{
+    int c = ingetc();
+
+    qbang = 0;
+    if (!stophist && !(inbufflags & INP_ALIAS)) {
+	/* If necessary, expand history characters. */
+	c = histsubchar(c);
+	if (c < 0) {
+	    /* bad expansion */
+	    errflag = lexstop = 1;
+	    return ' ';
+	}
+    }
+    if ((inbufflags & INP_HIST) && !stophist) {
+	/* the current character c came from a history expansion          *
+	 * (inbufflags && INP_HIST) and history is not disabled           *
+	 * (e.g. we are not inside single quotes). In that case, \!       *
+	 * should be treated as ! (since this \! came from a previous     *
+	 * history line where \ was used to escape the bang). So if       *
+	 * c == '\\' we fetch one more character to see if it's a bang,   *
+	 * and if it is not, we unget it and reset c back to '\\'         */
+	qbang = 0;
+	if (c == '\\' && !(qbang = (c = ingetc()) == bangchar))
+	    safeinungetc(c), c = '\\';
+    } else if (stophist || (inbufflags & INP_ALIAS))
+	/* If the result is a bangchar which came from history or alias  *
+	 * expansion, we treat it as an escaped bangchar, unless history *
+	 * is disabled. If stophist == 1 it only means that history is   *
+	 * temporarily disabled by a !" which won't appear in in the     *
+	 * history, so we still have an escaped bang. stophist > 1 if    *
+	 * history is disabled with NOBANGHIST or by someone else (e.g.  *
+	 * when the lexer scans single quoted text).                     */
+	qbang = c == bangchar && (stophist < 2);
+    hwaddc(c);
+    addtoline(c);
+
+    return c;
+}
+
+/**/
+static void
+safeinungetc(int c)
+{
+    if (lexstop)
+	lexstop = 0;
+    else
+	inungetc(c);
+}
+
+/**/
+void
+herrflush(void)
+{
+    while (!lexstop && inbufct)
+	hwaddc(ingetc());
+}
+
+/* extract :s/foo/bar/ delimiters and arguments */
+
+/**/
+static int
+getsubsargs(char *subline)
+{
+    int del;
+    char *ptr1, *ptr2;
+
+    del = ingetc();
+    ptr1 = hdynread2(del);
+    if (!ptr1)
+	return 1;
+    ptr2 = hdynread2(del);
+    if (strlen(ptr1)) {
+	zsfree(hsubl);
+	hsubl = ptr1;
+    }
+    zsfree(hsubr);
+    hsubr = ptr2;
+    if (hsubl && !strstr(subline, hsubl)) {
+	herrflush();
+	zerr("substitution failed", NULL, 0);
+	return 1;
+    }
+    return 0;
+}
+
+/* Get the maximum no. of words for a history entry. */
+
+/**/
+static int
+getargc(Histent ehist)
+{
+    return ehist->nwords ? ehist->nwords-1 : 0;
+}
+
+/* Perform history substitution, returning the next character afterwards. */
+
+/**/
+static int
+histsubchar(int c)
+{
+    int ev, farg, evset = -1, larg, argc, cflag = 0, bflag = 0;
+    static int mev = -1, marg = -1;
+    char buf[256], *ptr;
+    char *sline;
+    Histent ehist;
+
+    /* look, no goto's */
+    if (isfirstch && c == hatchar) {
+	/* Line begins ^foo^bar */
+	isfirstch = 0;
+	inungetc(hatchar);
+	if (!(ehist = gethist(defev))
+	    || !(sline = getargs(ehist, 0, getargc(ehist)))
+	    || getsubsargs(sline) || !hsubl)
+	    return -1;
+	subst(&sline, hsubl, hsubr, 0);
+    } else {
+	/* Line doesn't begin ^foo^bar */
+	if (c != ' ')
+	    isfirstch = 0;
+	if (c == '\\') {
+	    int g = ingetc();
+
+	    if (g != bangchar)
+		safeinungetc(g);
+	    else {
+		qbang = 1;
+		return bangchar;
+	    }
+	}
+	if (c != bangchar)
+	    return c;
+	*hptr = '\0';
+	if ((c = ingetc()) == '{') {
+	    bflag = cflag = 1;
+	    c = ingetc();
+	}
+	if (c == '\"') {
+	    stophist = 1;
+	    return ingetc();
+	}
+	if ((!cflag && inblank(c)) || c == '=' || c == '(' || lexstop) {
+	    safeinungetc(c);
+	    return bangchar;
+	}
+	cflag = 0;
+	ptr = buf;
+
+	/* get event number */
+
+	if (c == '?') {
+	    for (;;) {
+		c = ingetc();
+		if (c == '?' || c == '\n' || lexstop)
+		    break;
+		else
+		    *ptr++ = c;
+	    }
+	    if (c != '\n' && !lexstop)
+		c = ingetc();
+	    *ptr = '\0';
+	    mev = ev = hconsearch(hsubl = ztrdup(buf), &marg);
+	    evset = 0;
+	    if (ev == -1) {
+		herrflush();
+		zerr("no such event: %s", buf, 0);
+		return -1;
+	    }
+	} else {
+	    int t0;
+
+	    for (;;) {
+		if (inblank(c) || c == ';' || c == ':' || c == '^' ||
+		    c == '$' || c == '*' || c == '%' || c == '}' ||
+		    c == '\'' || c == '"' || c == '`' || lexstop)
+		    break;
+		if (ptr != buf) {
+		    if (c == '-')
+			break;
+		    if ((idigit(buf[0]) || buf[0] == '-') && !idigit(c))
+			break;
+		}
+		*ptr++ = c;
+		if (c == '#' || c == bangchar) {
+		    c = ingetc();
+		    break;
+		}
+		c = ingetc();
+	    }
+	    *ptr = 0;
+	    if (!*buf)
+		if (c != '%') {
+		    if (isset(CSHJUNKIEHISTORY))
+			ev = curhist - 1;
+		    else
+			ev = defev;
+		    if (c == ':' && evset == -1)
+			evset = 0;
+		    else
+			evset = 1;
+		} else {
+		    if (marg != -1)
+			ev = mev;
+		    else
+			ev = defev;
+		    evset = 0;
+	    } else if ((t0 = atoi(buf))) {
+		ev = (t0 < 0) ? curhist + t0 : t0;
+		evset = 1;
+	    } else if ((unsigned)*buf == bangchar) {
+		ev = curhist - 1;
+		evset = 1;
+	    } else if (*buf == '#') {
+		ev = curhist;
+		evset = 1;
+	    } else if ((ev = hcomsearch(buf)) == -1) {
+		herrflush();
+		zerr("event not found: %s", buf, 0);
+		return -1;
+	    } else
+		evset = 1;
+	}
+
+	/* get the event */
+
+	if (!(ehist = gethist(defev = ev)))
+	    return -1;
+
+	/* extract the relevant arguments */
+
+	argc = getargc(ehist);
+	if (c == ':') {
+	    cflag = 1;
+	    c = ingetc();
+	    if (c == '%' && marg != -1) {
+		if (!evset) {
+		    ehist = gethist(defev = mev);
+		    argc = getargc(ehist);
+		} else {
+		    herrflush();
+		    zerr("Ambiguous history reference", NULL, 0);
+		    return -1;
+		}
+
+	    }
+	}
+	if (c == '*') {
+	    farg = 1;
+	    larg = argc;
+	    cflag = 0;
+	} else {
+	    inungetc(c);
+	    larg = farg = getargspec(argc, marg, evset);
+	    if (larg == -2)
+		return -1;
+	    if (farg != -1)
+		cflag = 0;
+	    c = ingetc();
+	    if (c == '*') {
+		cflag = 0;
+		larg = argc;
+	    } else if (c == '-') {
+		cflag = 0;
+		larg = getargspec(argc, marg, evset);
+		if (larg == -2)
+		    return -1;
+		if (larg == -1)
+		    larg = argc - 1;
+	    } else
+		inungetc(c);
+	}
+	if (farg == -1)
+	    farg = 0;
+	if (larg == -1)
+	    larg = argc;
+	if (!(sline = getargs(ehist, farg, larg)))
+	    return -1;
+    }
+
+    /* do the modifiers */
+
+    for (;;) {
+	c = (cflag) ? ':' : ingetc();
+	cflag = 0;
+	if (c == ':') {
+	    int gbal = 0;
+
+	    if ((c = ingetc()) == 'g') {
+		gbal = 1;
+		c = ingetc();
+	    }
+	    switch (c) {
+	    case 'p':
+		histdone = HISTFLAG_DONE | HISTFLAG_NOEXEC;
+		break;
+	    case 'h':
+		if (!remtpath(&sline)) {
+		    herrflush();
+		    zerr("modifier failed: h", NULL, 0);
+		    return -1;
+		}
+		break;
+	    case 'e':
+		if (!rembutext(&sline)) {
+		    herrflush();
+		    zerr("modifier failed: e", NULL, 0);
+		    return -1;
+		}
+		break;
+	    case 'r':
+		if (!remtext(&sline)) {
+		    herrflush();
+		    zerr("modifier failed: r", NULL, 0);
+		    return -1;
+		}
+		break;
+	    case 't':
+		if (!remlpaths(&sline)) {
+		    herrflush();
+		    zerr("modifier failed: t", NULL, 0);
+		    return -1;
+		}
+		break;
+	    case 's':
+		if (getsubsargs(sline))
+		    return -1; /* fall through */
+	    case '&':
+		if (hsubl && hsubr)
+		    subst(&sline, hsubl, hsubr, gbal);
+		else {
+		    herrflush();
+		    zerr("no previous substitution", NULL, 0);
+		    return -1;
+		}
+		break;
+	    case 'q':
+		quote(&sline);
+		break;
+	    case 'x':
+		quotebreak(&sline);
+		break;
+	    case 'l':
+		downcase(&sline);
+		break;
+	    case 'u':
+		upcase(&sline);
+		break;
+	    default:
+		herrflush();
+		zerr("illegal modifier: %c", NULL, c);
+		return -1;
+	    }
+	} else {
+	    if (c != '}' || !bflag)
+		inungetc(c);
+	    if (c != '}' && bflag) {
+		zerr("'}' expected", NULL, 0);
+		return -1;
+	    }
+	    break;
+	}
+    }
+
+    /*
+     * Push the expanded value onto the input stack,
+     * marking this as a history word for purposes of the alias stack.
+     */
+
+    lexstop = 0;
+    /* this function is called only called from hgetc and only if      *
+     * !(inbufflags & INP_ALIAS). History expansion should never be    *
+     * done with INP_ALIAS (to prevent recursive history expansion and *
+     * histoty expansion of aliases). Escapes are not removed here.    *
+     * This is now handled in hgetc.                                   */
+    inpush(sline, INP_HIST, NULL); /* sline from heap, don't free */
+    histdone |= HISTFLAG_DONE;
+    if (isset(HISTVERIFY))
+	histdone |= HISTFLAG_NOEXEC | HISTFLAG_RECALL;
+
+    /* Don't try and re-expand line. */
+    return ingetc();
+}
+
+/* unget a char and remove it from chline. It can only be used *
+ * to unget a character returned by hgetc.                     */
+
+/**/
+void
+hungetc(int c)
+{
+    int doit = 1;
+
+    while (!lexstop) {
+	if (hptr[-1] != (char) c && stophist < 4 &&
+	    hptr > chline + 1 && hptr[-1] == '\n' && hptr[-2] == '\\')
+	    hungetc('\n'), hungetc('\\');
+
+	if (expanding) {
+	    cs--;
+	    ll--;
+	    exlast++;
+	}
+	DPUTS(hptr <= chline, "BUG: hungetc attempted at buffer start");
+	hptr--;
+	DPUTS(*hptr != (char) c, "BUG: wrong character in hungetc() ");
+	qbang = (c == bangchar && stophist < 2 &&
+		 hptr > chline && hptr[-1] == '\\');
+	if (doit)
+	    inungetc(c);
+	if (!qbang)
+	    return;
+	doit = !stophist && ((inbufflags & INP_HIST) ||
+				 !(inbufflags & INP_ALIAS));
+	c = '\\';
+    }
+}
+
+/* begin reading a string */
+
+/**/
+void
+strinbeg(void)
+{
+    strin++;
+    hbegin();
+    lexinit();
+}
+
+/* done reading a string */
+
+/**/
+void
+strinend(void)
+{
+    hend();
+    DPUTS(!strin, "BUG: strinend() called without strinbeg()");
+    strin--;
+    isfirstch = 1;
+    histdone = 0;
+}
+
+/* initialize the history mechanism */
+
+/**/
+void
+hbegin(void)
+{
+    Histent curhistent;
+
+    isfirstln = isfirstch = 1;
+    errflag = histdone = spaceflag = 0;
+    stophist = (!interact || unset(BANGHIST) || unset(SHINSTDIN)) << 1;
+    chline = hptr = zcalloc(hlinesz = 16);
+    chwords = zalloc((chwordlen = 16)*sizeof(short));
+    chwordpos = 0;
+
+    if (histactive & HA_JUNKED)
+	curhist--;
+    curhistent = gethistent(curhist);
+    if (!curhistent->ftim)
+	curhistent->ftim = time(NULL);
+    histactive = HA_ACTIVE;
+    if (interact && isset(SHINSTDIN) && !strin) {
+	attachtty(mypgrp);
+	defev = curhist;
+	curhist++;
+    } else
+	histactive |= HA_NOINC;
+}
+
+/* compare current line with history entry using only text in words */
+
+/**/
+static int
+histcmp(Histent he)
+{
+    int kword, lword;
+    int nwords = chwordpos/2;
+
+    /* If the history entry came from a file, the words were not
+     * divided by the lexer so we have to resort to strcmp.
+     */
+    if (he->flags & HIST_READ)
+	return strcmp(he->text, chline);
+
+    if (nwords != he->nwords)
+	return 1;
+
+    for (kword = 0; kword < 2*nwords; kword += 2)
+	if ((lword = chwords[kword+1]-chwords[kword])
+	    != he->words[kword+1]-he->words[kword] ||
+	    memcmp(he->text+he->words[kword], chline+chwords[kword], lword))
+	    return 1;
+
+    return 0;
+}
+
+/**/
+void
+histreduceblanks(void)
+{
+    int i, len, pos, needblank;
+
+    for (i = 0, len = 0; i < chwordpos; i += 2) {
+	len += chwords[i+1] - chwords[i]
+	     + (i > 0 && chwords[i] > chwords[i-1]);
+    }
+    if (chline[len] == '\0')
+	return;
+
+    for (i = 0, pos = 0; i < chwordpos; i += 2) {
+	len = chwords[i+1] - chwords[i];
+	needblank = (i < chwordpos-2 && chwords[i+2] > chwords[i+1]);
+	if (pos != chwords[i]) {
+	    memcpy(chline + pos, chline + chwords[i], len + needblank);
+	    chwords[i] = pos;
+	    chwords[i+1] = chwords[i] + len;
+	}
+	pos += len + needblank;
+    }
+    chline[pos] = '\0';
+}
+
+/* say we're done using the history mechanism */
+
+/**/
+int
+hend(void)
+{
+    int flag, save = 1;
+
+    DPUTS(!chline, "BUG: chline is NULL in hend()");
+    if (histactive & (HA_NOSTORE|HA_NOINC)) {
+	zfree(chline, hlinesz);
+	zfree(chwords, chwordlen*sizeof(short));
+	chline = NULL;
+	if (!(histactive & HA_NOINC))
+	    curhist--;
+	histactive = 0;
+	return 1;
+    }
+    flag = histdone;
+    histdone = 0;
+    if (hptr < chline + 1)
+	save = 0;
+    else {
+	*hptr = '\0';
+	if (hptr[-1] == '\n')
+	    if (chline[1]) {
+		*--hptr = '\0';
+	    } else
+		save = 0;
+	if (!*chline || !strcmp(chline, "\n") ||
+	    (isset(HISTIGNORESPACE) && spaceflag))
+	    save = 0;
+    }
+    if (flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) {
+	char *ptr;
+
+	ptr = ztrdup(chline);
+	if ((flag & (HISTFLAG_DONE | HISTFLAG_RECALL)) == HISTFLAG_DONE) {
+	    zputs(ptr, shout);
+	    fputc('\n', shout);
+	    fflush(shout);
+	}
+	if (flag & HISTFLAG_RECALL) {
+	    PERMALLOC {
+		pushnode(bufstack, ptr);
+	    } LASTALLOC;
+	    save = 0;
+	} else
+	    zsfree(ptr);
+    }
+    if (save) {
+	Histent he;
+	int keepflags = 0;
+
+#ifdef DEBUG
+	/* debugging only */
+	if (chwordpos%2) {
+	    hwend();
+	    DPUTS(1, "BUG: uncompleted line in history");
+	}
+#endif
+	/* get rid of pesky \n which we've already nulled out */
+	if (!chline[chwords[chwordpos-2]])
+	    chwordpos -= 2;
+	/* strip superfluous blanks, if desired */
+	if (isset(HISTREDUCEBLANKS))
+	    histreduceblanks();
+
+	if (isset(HISTIGNOREDUPS) && (he = gethistent(curhist - 1))
+	 && he->text && !histcmp(he)) {
+	    /* This history entry compares the same as the previous.
+	     * In case minor changes were made, we overwrite the
+	     * previous one with the current one.  This also gets
+	     * the timestamp right.  However, keep the old flags.
+	     */
+	    keepflags = he->flags;
+	    curhist--;
+	}
+
+	he =  gethistent(curhist);
+	zsfree(he->text);
+	he->text = ztrdup(chline);
+	if (he->nwords)
+	    zfree(he->words, he->nwords*2*sizeof(short));
+	he->stim = time(NULL);
+	he->ftim = 0L;
+	he->flags = keepflags;
+
+	if ((he->nwords = chwordpos/2)) {
+	    he->words = (short *)zalloc(chwordpos * sizeof(short));
+	    memcpy(he->words, chwords, chwordpos * sizeof(short));
+	}
+    } else
+	curhist--;
+    zfree(chline, hlinesz);
+    zfree(chwords, chwordlen*sizeof(short));
+    chline = NULL;
+    histactive = 0;
+    return !(flag & HISTFLAG_NOEXEC || errflag);
+}
+
+/* remove the current line from the history List */
+
+/**/
+void
+remhist(void)
+{
+    if (!(histactive & HA_ACTIVE)) {
+	if (!(histactive & HA_JUNKED)) {
+	    /* make sure this doesn't show up when we do firsthist() */
+	    Histent he = gethistent(curhist);
+	    zsfree(he->text);
+	    he->text = NULL;
+	    histactive |= HA_JUNKED;
+	    /* curhist-- is delayed until the next hbegin() */
+	}
+    } else
+	histactive |= HA_NOSTORE;
+}
+
+/* Gives current expansion word if not last word before chwordpos. */
+
+/**/
+int hwgetword = -1;
+
+/* begin a word */
+
+/**/
+void
+hwbegin(int offset)
+{
+    if (chwordpos%2)
+	chwordpos--;	/* make sure we're on a word start, not end */
+    /* If we're expanding an alias, we should overwrite the expansion
+     * in the history.
+     */
+    if ((inbufflags & INP_ALIAS) && !(inbufflags & INP_HIST))
+	hwgetword = chwordpos;
+    else
+	hwgetword = -1;
+    chwords[chwordpos++] = hptr - chline + offset;
+}
+
+/* add a word to the history List */
+
+/**/
+void
+hwend(void)
+{
+    if (chwordpos%2 && chline) {
+	/* end of word reached and we've already begun a word */
+	if (hptr > chline + chwords[chwordpos-1]) {
+	    chwords[chwordpos++] = hptr - chline;
+	    if (chwordpos >= chwordlen) {
+		chwords = (short *) realloc(chwords,
+					    (chwordlen += 16)*sizeof(short));
+	    }
+	    if (hwgetword > -1) {
+		/* We want to reuse the current word position */
+		chwordpos = hwgetword;
+		/* Start from where previous word ended, if possible */
+		hptr = chline + chwords[chwordpos ? chwordpos - 1 : 0];
+	    }
+	} else {
+	    /* scrub that last word, it doesn't exist */
+	    chwordpos--;
+	}
+    }
+}
+
+/* Go back to immediately after the last word, skipping space. */
+
+/**/
+void
+histbackword(void)
+{
+    if (!(chwordpos%2) && chwordpos)
+	hptr = chline + chwords[chwordpos-1];
+}
+
+/* Get the start and end point of the current history word */
+
+/**/
+static void
+hwget(char **startptr)
+{
+    int pos = hwgetword > -1 ? hwgetword : chwordpos - 2;
+
+#ifdef DEBUG
+    /* debugging only */
+    if (hwgetword == -1 && !chwordpos) {
+	/* no words available */
+	DPUTS(1, "BUG: hwget() called with no words");
+	*startptr = "";
+	return;
+    } 
+    else if (hwgetword == -1 && chwordpos%2) {
+	DPUTS(1, "BUG: hwget() called in middle of word");
+	*startptr = "";
+	return;
+    }
+#endif
+
+    *startptr = chline + chwords[pos];
+    chline[chwords[++pos]] = '\0';
+}
+
+/* Replace the current history word with rep, if different */
+
+/**/
+void
+hwrep(char *rep)
+{
+    char *start;
+    hwget(&start);
+
+    if (!strcmp(rep, start))
+	return;
+    
+    hptr = start;
+    chwordpos = (hwgetword > -1) ? hwgetword : chwordpos - 2;
+    hwbegin(0);
+    qbang = 1;
+    while (*rep)
+	hwaddc(*rep++);
+    hwend();
+}
+
+/* Get the entire current line, deleting it in the history. */
+
+/**/
+char *
+hgetline(void)
+{
+    /* Currently only used by pushlineoredit().
+     * It's necessary to prevent that from getting too pally with
+     * the history code.
+     */
+    char *ret;
+
+    if (!chline || hptr == chline)
+	return NULL;
+    *hptr = '\0';
+    ret = dupstring(chline);
+
+    /* reset line */
+    hptr = chline;
+    chwordpos = 0;
+    hwgetword = -1;
+
+    return ret;
+}
+
+/* get an argument specification */
+
+/**/
+static int
+getargspec(int argc, int marg, int evset)
+{
+    int c, ret = -1;
+
+    if ((c = ingetc()) == '0')
+	return 0;
+    if (idigit(c)) {
+	ret = 0;
+	while (idigit(c)) {
+	    ret = ret * 10 + c - '0';
+	    c = ingetc();
+	}
+	inungetc(c);
+    } else if (c == '^')
+	ret = 1;
+    else if (c == '$')
+	ret = argc;
+    else if (c == '%') {
+	if (evset) {
+	    herrflush();
+	    zerr("Ambiguous history reference", NULL, 0);
+	    return -2;
+	}
+	if (marg == -1) {
+	    herrflush();
+	    zerr("%% with no previous word matched", NULL, 0);
+	    return -2;
+	}
+	ret = marg;
+    } else
+	inungetc(c);
+    return ret;
+}
+
+/* do ?foo? search */
+
+/**/
+static int
+hconsearch(char *str, int *marg)
+{
+    int t0, t1 = 0;
+    char *s;
+    Histent he;
+
+    for (t0 = curhist - 1; (he = quietgethist(t0)); t0--)
+	if ((s = strstr(he->text, str))) {
+	    int pos = s - he->text;
+	    while (t1 < he->nwords && he->words[2*t1] <= pos)
+		t1++;
+	    *marg = t1 - 1;
+	    return t0;
+	}
+    return -1;
+}
+
+/* do !foo search */
+
+/**/
+int
+hcomsearch(char *str)
+{
+    int t0;
+    char *hs;
+
+    for (t0 = curhist - 1; (hs = quietgetevent(t0)); t0--)
+	if (!strncmp(hs, str, strlen(str)))
+	    return t0;
+    return -1;
+}
+
+/* various utilities for : modifiers */
+
+/**/
+int
+remtpath(char **junkptr)
+{
+    char *str = *junkptr, *remcut;
+
+    if ((remcut = strrchr(str, '/'))) {
+	if (str != remcut)
+	    *remcut = '\0';
+	else
+	    str[1] = '\0';
+	return 1;
+    }
+    return 0;
+}
+
+/**/
+int
+remtext(char **junkptr)
+{
+    char *str = *junkptr, *remcut;
+
+    if ((remcut = strrchr(str, '.')) && remcut != str) {
+	*remcut = '\0';
+	return 1;
+    }
+    return 0;
+}
+
+/**/
+int
+rembutext(char **junkptr)
+{
+    char *str = *junkptr, *remcut;
+
+    if ((remcut = strrchr(str, '.')) && remcut != str) {
+	*junkptr = dupstring(remcut + 1);	/* .xx or xx? */
+	return 1;
+    }
+    return 0;
+}
+
+/**/
+int
+remlpaths(char **junkptr)
+{
+    char *str = *junkptr, *remcut;
+
+    if ((remcut = strrchr(str, '/'))) {
+	*remcut = '\0';
+	*junkptr = dupstring(remcut + 1);
+	return 1;
+    }
+    return 0;
+}
+
+/**/
+int
+makeuppercase(char **junkptr)
+{
+    char *str = *junkptr;
+
+    for (; *str; str++)
+	*str = tuupper(*str);
+    return 1;
+}
+
+/**/
+int
+makelowercase(char **junkptr)
+{
+    char *str = *junkptr;
+
+    for (; *str; str++)
+	*str = tulower(*str);
+    return 1;
+}
+
+/**/
+int
+makecapitals(char **junkptr)
+{
+    char *str = *junkptr;
+
+    for (; *str;) {
+	for (; *str && !ialnum(*str); str++);
+	if (*str)
+	    *str = tuupper(*str), str++;
+	for (; *str && ialnum(*str); str++)
+	    *str = tulower(*str);
+    }
+    return 1;
+}
+
+/**/
+void
+subst(char **strptr, char *in, char *out, int gbal)
+{
+    char *str = *strptr, *instr = *strptr, *substcut, *sptr, *oldstr;
+    int off, inlen, outlen;
+
+    if (!*in)
+	in = str, gbal = 0;
+    if (!(substcut = (char *)strstr(str, in)))
+	return;
+    inlen = strlen(in);
+    sptr = convamps(out, in, inlen);
+    outlen = strlen(sptr);
+
+    do {
+	*substcut = '\0';
+	off = substcut - *strptr + outlen;
+	substcut += inlen;
+	*strptr = tricat(oldstr = *strptr, sptr, substcut);
+	if (oldstr != instr)
+	    zsfree(oldstr);
+	str = (char *)*strptr + off;
+    } while (gbal && (substcut = (char *)strstr(str, in)));
+}
+
+/**/
+static char *
+convamps(char *out, char *in, int inlen)
+{
+    char *ptr, *ret, *pp;
+    int slen, sdup = 0;
+
+    for (ptr = out, slen = 0; *ptr; ptr++, slen++)
+	if (*ptr == '\\')
+	    ptr++, sdup = 1;
+	else if (*ptr == '&')
+	    slen += inlen - 1, sdup = 1;
+    if (!sdup)
+	return out;
+    ret = pp = (char *)alloc(slen + 1);
+    for (ptr = out; *ptr; ptr++)
+	if (*ptr == '\\')
+	    *pp++ = *++ptr;
+	else if (*ptr == '&') {
+	    strcpy(pp, in);
+	    pp += inlen;
+	} else
+	    *pp++ = *ptr;
+    *pp = '\0';
+    return ret;
+}
+
+/**/
+struct histent *
+quietgethist(int ev)
+{
+    static struct histent storehist;
+
+    if (ev < firsthist() || ev > curhist)
+	return NULL;
+    if (ev == curhist && (histactive & HA_ACTIVE)) {
+	/* The current history line has not been stored.  Build it up
+	 * from other variables.
+	 */
+	storehist.text = chline;
+	storehist.nwords = chwordpos/2;
+	storehist.words = chwords;
+
+	return &storehist;
+    } else
+	return gethistent(ev);
+}
+
+/**/
+char *
+quietgetevent(int ev)
+{
+    Histent ent = quietgethist(ev);
+
+    return ent ? ent->text : NULL;
+}
+
+/**/
+static Histent
+gethist(int ev)
+{
+    Histent ret;
+
+    ret = quietgethist(ev);
+    if (!ret) {
+	herrflush();
+	zerr("no such event: %d", NULL, ev);
+    }
+    return ret;
+}
+
+/**/
+static char *
+getargs(Histent elist, int arg1, int arg2)
+{
+    short *words = elist->words;
+    int pos1, nwords = elist->nwords;
+
+    if (arg2 < arg1 || arg1 >= nwords || arg2 >= nwords) {
+	/* remember, argN is indexed from 0, nwords is total no. of words */
+	herrflush();
+	zerr("no such word in event", NULL, 0);
+	return NULL;
+    }
+
+    pos1 = words[2*arg1];
+    return dupstrpfx(elist->text + pos1, words[2*arg2+1] - pos1);
+}
+
+/**/
+void
+upcase(char **x)
+{
+    char *pp = *(char **)x;
+
+    for (; *pp; pp++)
+	*pp = tuupper(*pp);
+}
+
+/**/
+void
+downcase(char **x)
+{
+    char *pp = *(char **)x;
+
+    for (; *pp; pp++)
+	*pp = tulower(*pp);
+}
+
+/**/
+int
+quote(char **tr)
+{
+    char *ptr, *rptr, **str = (char **)tr;
+    int len = 3;
+    int inquotes = 0;
+
+    for (ptr = *str; *ptr; ptr++, len++)
+	if (*ptr == '\'') {
+	    len += 3;
+	    if (!inquotes)
+		inquotes = 1;
+	    else
+		inquotes = 0;
+	} else if (inblank(*ptr) && !inquotes && ptr[-1] != '\\')
+	    len += 2;
+    ptr = *str;
+    *str = rptr = (char *)alloc(len);
+    *rptr++ = '\'';
+    for (; *ptr; ptr++)
+	if (*ptr == '\'') {
+	    if (!inquotes)
+		inquotes = 1;
+	    else
+		inquotes = 0;
+	    *rptr++ = '\'';
+	    *rptr++ = '\\';
+	    *rptr++ = '\'';
+	    *rptr++ = '\'';
+	} else if (inblank(*ptr) && !inquotes && ptr[-1] != '\\') {
+	    *rptr++ = '\'';
+	    *rptr++ = *ptr;
+	    *rptr++ = '\'';
+	} else
+	    *rptr++ = *ptr;
+    *rptr++ = '\'';
+    *rptr++ = 0;
+    str[1] = NULL;
+    return 0;
+}
+
+/**/
+static int
+quotebreak(char **tr)
+{
+    char *ptr, *rptr, **str = (char **)tr;
+    int len = 3;
+
+    for (ptr = *str; *ptr; ptr++, len++)
+	if (*ptr == '\'')
+	    len += 3;
+	else if (inblank(*ptr))
+	    len += 2;
+    ptr = *str;
+    *str = rptr = (char *)alloc(len);
+    *rptr++ = '\'';
+    for (; *ptr;)
+	if (*ptr == '\'') {
+	    *rptr++ = '\'';
+	    *rptr++ = '\\';
+	    *rptr++ = '\'';
+	    *rptr++ = '\'';
+	    ptr++;
+	} else if (inblank(*ptr)) {
+	    *rptr++ = '\'';
+	    *rptr++ = *ptr++;
+	    *rptr++ = '\'';
+	} else
+	    *rptr++ = *ptr++;
+    *rptr++ = '\'';
+    *rptr++ = '\0';
+    return 0;
+}
+
+#if 0
+/* read an arbitrary amount of data into a buffer until stop is found */
+
+/**/
+char *
+hdynread(int stop)
+{
+    int bsiz = 256, ct = 0, c;
+    char *buf = (char *)zalloc(bsiz), *ptr;
+
+    ptr = buf;
+    while ((c = ingetc()) != stop && c != '\n' && !lexstop) {
+	if (c == '\\')
+	    c = ingetc();
+	*ptr++ = c;
+	if (++ct == bsiz) {
+	    buf = realloc(buf, bsiz *= 2);
+	    ptr = buf + ct;
+	}
+    }
+    *ptr = 0;
+    if (c == '\n') {
+	inungetc('\n');
+	zerr("delimiter expected", NULL, 0);
+	zfree(buf, bsiz);
+	return NULL;
+    }
+    return buf;
+}
+#endif
+
+/**/
+static char *
+hdynread2(int stop)
+{
+    int bsiz = 256, ct = 0, c;
+    char *buf = (char *)zalloc(bsiz), *ptr;
+
+    ptr = buf;
+    while ((c = ingetc()) != stop && c != '\n' && !lexstop) {
+	if (c == '\n') {
+	    inungetc(c);
+	    break;
+	}
+	if (c == '\\')
+	    c = ingetc();
+	*ptr++ = c;
+	if (++ct == bsiz) {
+	    buf = realloc(buf, bsiz *= 2);
+	    ptr = buf + ct;
+	}
+    }
+    *ptr = 0;
+    if (c == '\n')
+	inungetc('\n');
+    return buf;
+}
+
+/**/
+void
+inithist(void)
+{
+    histentct = histsiz;
+    histentarr = (Histent) zcalloc(histentct * sizeof *histentarr);
+}
+
+/**/
+void
+resizehistents(void)
+{
+    int newentct, t0, t1, firstlex;
+    Histent newarr;
+
+    newentct = histsiz;
+    newarr = (Histent) zcalloc(newentct * sizeof *newarr);
+    firstlex = curhist - histsiz + 1;
+    t0 = firsthist();
+    if (t0 < curhist - newentct)
+	t0 = curhist - newentct;
+    t1 = t0 % newentct;
+    for (; t0 <= curhist; t0++) {
+	newarr[t1] = *gethistent(t0);
+	if (t0 < firstlex) {
+	    zsfree(newarr[t1].text);
+	    newarr[t1].text = NULL;
+	}
+	t1++;
+	if (t1 == newentct)
+	    t1 = 0;
+    }
+    free(histentarr);
+    histentarr = newarr;
+    histentct = newentct;
+}
+
+/**/
+void
+readhistfile(char *s, int err)
+{
+    char *buf;
+    FILE *in;
+    Histent ent;
+    time_t tim = time(NULL);
+    short *wordlist;
+    int nwordpos, nwordlist, bufsiz;
+
+    if (!s)
+	return;
+    if ((in = fopen(unmeta(s), "r"))) {
+	nwordlist = 16;
+	wordlist = (short *)zalloc(nwordlist*sizeof(short));
+	bufsiz = 1024;
+	buf = zalloc(bufsiz);
+
+	while (fgets(buf, bufsiz, in)) {
+	    int l = strlen(buf);
+	    char *pt, *start;
+
+	    while (l) {
+		while (buf[l - 1] != '\n') {
+		    buf = zrealloc(buf, 2 * bufsiz);
+		    bufsiz = 2 * bufsiz;
+		    if (!fgets(buf + l, bufsiz - l, in)) {
+			l++;
+			break;
+		    }
+		    l = strlen(buf);
+		}
+		buf[l - 1] = '\0';
+		if (l > 1 && buf[l - 2] == '\\') {
+		    buf[l - 2] = '\n';
+		    fgets(buf + l - 1, bufsiz - (l - 1), in);
+		    l = strlen(buf);
+		} else
+		    break;
+	    }
+
+	    ent = gethistent(++curhist);
+	    pt = buf;
+	    if (*pt == ':') {
+		pt++;
+		ent->stim = zstrtol(pt, NULL, 0);
+		for (; *pt != ':' && *pt; pt++);
+		if (*pt) {
+		    pt++;
+		    ent->ftim = zstrtol(pt, NULL, 0);
+		    for (; *pt != ';' && *pt; pt++);
+		    if (*pt)
+			pt++;
+		} else {
+		    ent->ftim = tim;
+		}
+		if (ent->stim == 0)
+		    ent->stim = tim;
+		if (ent->ftim == 0)
+		    ent->ftim = tim;
+	    } else {
+		ent->ftim = ent->stim = tim;
+	    }
+
+	    zsfree(ent->text);
+	    ent->text = ztrdup(pt);
+	    ent->flags = HIST_OLD|HIST_READ;
+	    if (ent->nwords)
+		zfree(ent->words, ent->nwords*2*sizeof(short));
+
+	    /* Divide up the words.  We don't know how it lexes,
+	       so just look for spaces.
+	       */
+	    nwordpos = 0;
+	    start = pt;
+	    do {
+		while (*pt == ' ')
+		    pt++;
+		if (*pt) {
+		    if (nwordpos >= nwordlist)
+			wordlist = (short *) realloc(wordlist,
+					(nwordlist += 16)*sizeof(short));
+		    wordlist[nwordpos++] = pt - start;
+		    while (*pt && *pt != ' ')
+			pt++;
+		    wordlist[nwordpos++] = pt - start;
+		}
+	    } while (*pt);
+
+	    ent->nwords = nwordpos/2;
+	    if (ent->nwords) {
+		ent->words = (short *)zalloc(nwordpos*sizeof(short));
+		memcpy(ent->words, wordlist, nwordpos*sizeof(short));
+	    } else
+		ent->words = (short *)NULL;
+	}
+	fclose(in);
+
+	zfree(wordlist, nwordlist*sizeof(short));
+	zfree(buf, bufsiz);
+    } else if (err)
+	zerr("can't read history file", s, 0);
+}
+
+/**/
+void
+savehistfile(char *s, int err, int app)
+{
+    char *t;
+    FILE *out;
+    int ev;
+    Histent ent;
+    int savehist = getiparam("SAVEHIST");
+
+    if (!s || !interact || savehist <= 0)
+	return;
+    ev = curhist - savehist + 1;
+    if (ev < firsthist())
+	ev = firsthist();
+    if (app & 1)
+	out = fdopen(open(unmeta(s),
+		     O_CREAT | O_WRONLY | O_APPEND | O_NOCTTY, 0600), "a");
+    else
+	out = fdopen(open(unmeta(s),
+		     O_CREAT | O_WRONLY | O_TRUNC | O_NOCTTY, 0600), "w");
+    if (out) {
+	for (; ev <= curhist - !!(histactive & HA_ACTIVE); ev++) {
+	    ent = gethistent(ev);
+	    if (app & 2) {
+		if (ent->flags & HIST_OLD)
+		    continue;
+		ent->flags |= HIST_OLD;
+	    }
+	    t = ent->text;
+	    if (isset(EXTENDEDHISTORY)) {
+		fprintf(out, ": %ld:%ld;",
+			(long)ent->stim,
+			(long)ent->ftim);
+	    } else if (*t == ':')
+		fputc('\\', out);
+
+	    for (; *t; t++) {
+		if (*t == '\n')
+		    fputc('\\', out);
+		fputc(*t, out);
+	    }
+	    fputc('\n', out);
+	}
+	fclose(out);
+
+	if (app & 2 && (out = fopen(unmeta(s), "r"))) {
+	    char **store, buf[1024], **ptr;
+	    int i, l, histnum = 0;
+
+	    store = (char **)zcalloc((savehist + 1) * sizeof *store);
+	    while (fgets(buf, sizeof(buf), out)) {
+		char *t;
+
+		if (store[i = histnum % savehist])
+		    free(store[i]);
+		store[i] = ztrdup(buf);
+		l = strlen(buf);
+		if (l > 1) {
+		    t = store[i] + l;
+		    while ((t[-1] != '\n' ||
+			    (t[-1] == '\n' && t[-2] == '\\')) &&
+			   fgets(buf, sizeof(buf), out)) {
+			l += strlen(buf);
+			store[i] = zrealloc(store[i], l + 1);
+			t = store[i] + l;
+			strcat(store[i], buf);
+		    }
+		}
+		histnum++;
+	    }
+	    fclose(out);
+	    if ((out = fdopen(open(unmeta(s),
+			    O_WRONLY | O_TRUNC | O_NOCTTY, 0600), "w"))) {
+		if (histnum < savehist)
+		    for (i = 0; i < histnum; i++)
+			fprintf(out, "%s", store[i]);
+		else
+		    for (i = histnum; i < histnum + savehist; i++)
+			fprintf(out, "%s", store[i % savehist]);
+		fclose(out);
+	    }
+	    for (ptr = store; *ptr; ptr++)
+		zsfree(*ptr);
+	    free(store);
+	}
+    } else if (err)
+	zerr("can't write history file %s", s, 0);
+}
+
+/**/
+int
+firsthist(void)
+{
+    int ev;
+    Histent ent;
+
+    ev = curhist - histentct + 1;
+    if (ev < 1)
+	ev = 1;
+    do {
+	ent = gethistent(ev);
+	if (ent->text)
+	    break;
+	ev++;
+    }
+    while (ev < curhist);
+    return ev;
+}
+
diff --git a/Src/init.c b/Src/init.c
new file mode 100644
index 000000000..33496adc6
--- /dev/null
+++ b/Src/init.c
@@ -0,0 +1,936 @@
+/*
+ * init.c - main loop and initialization routines
+ *
+ * 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 "init.pro"
+
+#include "zshpaths.h"
+#include "zshxmods.h"
+
+/**/
+int noexitct = 0;
+
+/* what level of sourcing we are at */
+ 
+/**/
+int sourcelevel;
+
+/* the shell tty fd */
+
+/**/
+int SHTTY;
+
+/* the FILE attached to the shell tty */
+
+/**/
+FILE *shout;
+
+/* termcap strings */
+ 
+/**/
+char *tcstr[TC_COUNT];
+
+/* lengths of each termcap string */
+ 
+/**/
+int tclen[TC_COUNT];
+
+/* Values of the li, co and am entries */
+
+/**/
+int tclines, tccolumns, hasam;
+
+#ifdef DEBUG
+/* depth of allocation type stack */
+
+/**/
+int alloc_stackp;
+#endif
+
+/* keep executing lists until EOF found */
+
+/**/
+void
+loop(int toplevel, int justonce)
+{
+    List list;
+#ifdef DEBUG
+    int oasp = toplevel ? 0 : alloc_stackp;
+#endif
+
+    pushheap();
+    for (;;) {
+	freeheap();
+	errflag = 0;
+	if (isset(SHINSTDIN)) {
+	    setblock_stdin();
+	    if (interact)
+		preprompt();
+	}
+	hbegin();		/* init history mech        */
+	intr();			/* interrupts on            */
+	lexinit();              /* initialize lexical state */
+	if (!(list = parse_event())) {	/* if we couldn't parse a list */
+	    hend();
+	    if ((tok == ENDINPUT && !errflag) ||
+		(tok == LEXERR && (!isset(SHINSTDIN) || !toplevel)) ||
+		justonce)
+		break;
+	    continue;
+	}
+	if (hend()) {
+	    int toksav = tok;
+	    List prelist;
+
+	    if (toplevel && (prelist = getshfunc("preexec")) != &dummy_list) {
+		Histent he = gethistent(curhist);
+		LinkList args;
+		PERMALLOC {
+		    args = newlinklist();
+		    addlinknode(args, "preexec");
+		    if (he && he->text)
+			addlinknode(args, he->text);
+		} LASTALLOC;
+		doshfunc(prelist, args, 0, 1);
+		freelinklist(args, (FreeFunc) NULL);
+		errflag = 0;
+	    }
+	    if (stopmsg)	/* unset 'you have stopped jobs' flag */
+		stopmsg--;
+	    execlist(list, 0, 0);
+	    tok = toksav;
+	    if (toplevel)
+		noexitct = 0;
+	}
+	DPUTS(alloc_stackp != oasp, "BUG: alloc_stackp changed in loop()");
+	if (ferror(stderr)) {
+	    zerr("write error", NULL, 0);
+	    clearerr(stderr);
+	}
+	if (subsh)		/* how'd we get this far in a subshell? */
+	    exit(lastval);
+	if (((!interact || sourcelevel) && errflag) || retflag)
+	    break;
+	if (trapreturn) {
+	    lastval = trapreturn;
+	    trapreturn = 0;
+	}
+	if (isset(SINGLECOMMAND) && toplevel) {
+	    if (sigtrapped[SIGEXIT])
+		dotrap(SIGEXIT);
+	    exit(lastval);
+	}
+	if (justonce)
+	    break;
+    }
+    popheap();
+}
+
+static char *cmd;
+static int restricted;
+
+/**/
+void
+parseargs(char **argv)
+{
+    char **x;
+    int action, optno;
+    LinkList paramlist;
+    int bourne = (emulation == EMULATE_KSH || emulation == EMULATE_SH);
+
+    argzero = *argv++;
+    SHIN = 0;
+
+    /* There's a bit of trickery with opts[INTERACTIVE] here.  It starts *
+     * at a value of 2 (instead of 1) or 0.  If it is explicitly set on  *
+     * the command line, it goes to 1 or 0.  If input is coming from     *
+     * somewhere that normally makes the shell non-interactive, we do    *
+     * "opts[INTERACTIVE] &= 1", so that only a *default* on state will  *
+     * be changed.  At the end of the function, a value of 2 gets        *
+     * changed to 1.                                                     */
+    opts[INTERACTIVE] = isatty(0) ? 2 : 0;
+    opts[SHINSTDIN] = 0;
+    opts[SINGLECOMMAND] = 0;
+
+    /* loop through command line options (begins with "-" or "+") */
+    while (*argv && (**argv == '-' || **argv == '+')) {
+	action = (**argv == '-');
+	if(!argv[0][1])
+	    *argv = "--";
+	while (*++*argv) {
+	    /* The pseudo-option `--' signifies the end of options. *
+	     * `-b' does too, csh-style, unless we're emulating a   *
+	     * Bourne style shell.                                  */
+	    if (**argv == '-' || (!bourne && **argv == 'b')) {
+		argv++;
+		goto doneoptions;
+	    }
+
+	    if (**argv == 'c') {         /* -c command */
+		if (!*++argv) {
+		    zerr("string expected after -c", NULL, 0);
+		    exit(1);
+		}
+		cmd = *argv++;
+		opts[INTERACTIVE] &= 1;
+		opts[SHINSTDIN] = 0;
+		goto doneoptions;
+	    } else if (**argv == 'o') {
+		if (!*++*argv)
+		    argv++;
+		if (!*argv) {
+		    zerr("string expected after -o", NULL, 0);
+		    exit(1);
+		}
+		if(!(optno = optlookup(*argv)))
+		    zerr("no such option: %s", *argv, 0);
+		else if (optno == RESTRICTED)
+		    restricted = action;
+		else
+		    dosetopt(optno, action, 1);
+		break;
+	    } else {
+	    	if (!(optno = optlookupc(**argv))) {
+		    zerr("bad option: -%c", NULL, **argv);
+		    exit(1);
+		} else if (optno == RESTRICTED)
+		    restricted = action;
+		else
+		    dosetopt(optno, action, 1);
+	    }
+	}
+	argv++;
+    }
+    doneoptions:
+    paramlist = newlinklist();
+    if (*argv) {
+	if (unset(SHINSTDIN)) {
+	    argzero = *argv;
+	    if (!cmd)
+		SHIN = movefd(open(unmeta(argzero), O_RDONLY | O_NOCTTY));
+	    if (SHIN == -1) {
+		zerr("can't open input file: %s", argzero, 0);
+		exit(1);
+	    }
+	    opts[INTERACTIVE] &= 1;
+	    argv++;
+	}
+	while (*argv)
+	    addlinknode(paramlist, ztrdup(*argv++));
+    } else
+	opts[SHINSTDIN] = 1;
+    if(isset(SINGLECOMMAND))
+	opts[INTERACTIVE] &= 1;
+    opts[INTERACTIVE] = !!opts[INTERACTIVE];
+    pparams = x = (char **) zcalloc((countlinknodes(paramlist) + 1) * sizeof(char *));
+
+    while ((*x++ = (char *)getlinknode(paramlist)));
+    free(paramlist);
+    argzero = ztrdup(argzero);
+}
+
+
+/**/
+void
+init_io(void)
+{
+    long ttpgrp;
+    static char outbuf[BUFSIZ], errbuf[BUFSIZ];
+
+#ifdef RSH_BUG_WORKAROUND
+    int i;
+#endif
+
+/* stdout, stderr fully buffered */
+#ifdef _IOFBF
+    setvbuf(stdout, outbuf, _IOFBF, BUFSIZ);
+    setvbuf(stderr, errbuf, _IOFBF, BUFSIZ);
+#else
+    setbuffer(stdout, outbuf, BUFSIZ);
+    setbuffer(stderr, errbuf, BUFSIZ);
+#endif
+
+/* This works around a bug in some versions of in.rshd. *
+ * Currently this is not defined by default.            */
+#ifdef RSH_BUG_WORKAROUND
+    if (cmd) {
+	for (i = 3; i < 10; i++)
+	    close(i);
+    }
+#endif
+
+    if (shout) {
+	fclose(shout);
+	shout = 0;
+    }
+    if (SHTTY != -1) {
+	zclose(SHTTY);
+	SHTTY = -1;
+    }
+
+    /* Make sure the tty is opened read/write. */
+    if (isatty(0)) {
+	zsfree(ttystrname);
+	if ((ttystrname = ztrdup(ttyname(0))))
+	    SHTTY = movefd(open(ttystrname, O_RDWR | O_NOCTTY));
+    }
+    if (SHTTY == -1 &&
+	(SHTTY = movefd(open("/dev/tty", O_RDWR | O_NOCTTY))) != -1) {
+	zsfree(ttystrname);
+	ttystrname = ztrdup("/dev/tty");
+    }
+    if (SHTTY == -1) {
+	zsfree(ttystrname);
+	ttystrname = ztrdup("");
+    }
+
+    /* We will only use zle if shell is interactive, *
+     * SHTTY != -1, and shout != 0                   */
+    if (interact && SHTTY != -1) {
+	init_shout();
+	if(!shout)
+	    opts[USEZLE] = 0;
+    } else
+	opts[USEZLE] = 0;
+
+#ifdef JOB_CONTROL
+    /* If interactive, make the shell the foreground process */
+    if (opts[MONITOR] && interact && (SHTTY != -1)) {
+	attachtty(GETPGRP());
+	if ((mypgrp = GETPGRP()) > 0) {
+	    while ((ttpgrp = gettygrp()) != -1 && ttpgrp != mypgrp) {
+		sleep(1);
+		mypgrp = GETPGRP();
+		if (mypgrp == gettygrp())
+		    break;
+		killpg(mypgrp, SIGTTIN);
+		mypgrp = GETPGRP();
+	    }
+	} else
+	    opts[MONITOR] = 0;
+    } else
+	opts[MONITOR] = 0;
+#else
+    opts[MONITOR] = 0;
+#endif
+}
+
+/**/
+void
+init_shout(void)
+{
+    static char shoutbuf[BUFSIZ];
+#if defined(JOB_CONTROL) && defined(TIOCSETD) && defined(NTTYDISC)
+    int ldisc = NTTYDISC;
+
+    ioctl(SHTTY, TIOCSETD, (char *)&ldisc);
+#endif
+
+    /* Associate terminal file descriptor with a FILE pointer */
+    shout = fdopen(SHTTY, "w");
+#ifdef _IOFBF
+    setvbuf(shout, shoutbuf, _IOFBF, BUFSIZ);
+#endif
+  
+    gettyinfo(&shttyinfo);	/* get tty state */
+#if defined(__sgi)
+    if (shttyinfo.tio.c_cc[VSWTCH] <= 0)	/* hack for irises */
+	shttyinfo.tio.c_cc[VSWTCH] = CSWTCH;
+#endif
+}
+
+/* names of the termcap strings we want */
+
+static char *tccapnams[TC_COUNT] = {
+    "cl", "le", "LE", "nd", "RI", "up", "UP", "do",
+    "DO", "dc", "DC", "ic", "IC", "cd", "ce", "al", "dl", "ta",
+    "md", "so", "us", "me", "se", "ue"
+};
+
+/* Initialise termcap */
+
+/**/
+int
+init_term(void)
+{
+#ifndef TGETENT_ACCEPTS_NULL
+    static char termbuf[2048];	/* the termcap buffer */
+#endif
+
+    if (!*term) {
+	termflags |= TERM_UNKNOWN;
+	return 0;
+    }
+
+    /* unset zle if using zsh under emacs */
+    if (!strcmp(term, "emacs"))
+	opts[USEZLE] = 0;
+
+#ifdef TGETENT_ACCEPTS_NULL
+    /* If possible, we let tgetent allocate its own termcap buffer */
+    if (tgetent(NULL, term) != 1) {
+#else
+    if (tgetent(termbuf, term) != 1) {
+#endif
+
+	if (isset(INTERACTIVE))
+	    zerr("can't find termcap info for %s", term, 0);
+	errflag = 0;
+	termflags |= TERM_BAD;
+	return 0;
+    } else {
+	char tbuf[1024], *pp;
+	int t0;
+
+	termflags &= ~TERM_BAD;
+	termflags &= ~TERM_UNKNOWN;
+	for (t0 = 0; t0 != TC_COUNT; t0++) {
+	    pp = tbuf;
+	    zsfree(tcstr[t0]);
+	/* AIX tgetstr() ignores second argument */
+	    if (!(pp = tgetstr(tccapnams[t0], &pp)))
+		tcstr[t0] = NULL, tclen[t0] = 0;
+	    else {
+		tclen[t0] = strlen(pp);
+		tcstr[t0] = (char *) zalloc(tclen[t0] + 1);
+		memcpy(tcstr[t0], pp, tclen[t0] + 1);
+	    }
+	}
+
+	/* check whether terminal has automargin (wraparound) capability */
+	hasam = tgetflag("am");
+
+	tclines = tgetnum("li");
+	tccolumns = tgetnum("co");
+
+	/* if there's no termcap entry for cursor up, use single line mode: *
+	 * this is flagged by termflags which is examined in zle_refresh.c  *
+	 */
+	if (tccan(TCUP))
+	    termflags &= ~TERM_NOUP;
+	else {
+	    tcstr[TCUP] = NULL;
+	    termflags |= TERM_NOUP;
+	}
+
+	/* if there's no termcap entry for cursor left, use \b. */
+	if (!tccan(TCLEFT)) {
+	    tcstr[TCLEFT] = ztrdup("\b");
+	    tclen[TCLEFT] = 1;
+	}
+
+	/* if the termcap entry for down is \n, don't use it. */
+	if (tccan(TCDOWN) && tcstr[TCDOWN][0] == '\n') {
+	    tclen[TCDOWN] = 0;
+	    zsfree(tcstr[TCDOWN]);
+	    tcstr[TCDOWN] = NULL;
+	}
+
+	/* if there's no termcap entry for clear, use ^L. */
+	if (!tccan(TCCLEARSCREEN)) {
+	    tcstr[TCCLEARSCREEN] = ztrdup("\14");
+	    tclen[TCCLEARSCREEN] = 1;
+	}
+    }
+    return 1;
+}
+
+/* Initialize lots of global variables and hash tables */
+
+/**/
+void
+setupvals(void)
+{
+#ifdef HAVE_GETPWUID
+    struct passwd *pswd;
+#endif
+    struct timezone dummy_tz;
+    char *ptr;
+#ifdef HAVE_GETRLIMIT
+    int i;
+#endif
+
+    noeval = 0;
+    curhist = 0;
+    histsiz = DEFAULT_HISTSIZE;
+    inithist();
+
+    cmdstack = (unsigned char *) zalloc(256);
+    cmdsp = 0;
+
+    bangchar = '!';
+    hashchar = '#';
+    hatchar = '^';
+    termflags = TERM_UNKNOWN;
+    curjob = prevjob = coprocin = coprocout = -1;
+    gettimeofday(&shtimer, &dummy_tz);	/* init $SECONDS */
+    srand((unsigned int)(shtimer.tv_sec + shtimer.tv_usec)); /* seed $RANDOM */
+
+    hostnam     = (char *) zalloc(256);
+    gethostname(hostnam, 256);
+
+    /* Set default path */
+    path    = (char **) zalloc(sizeof(*path) * 5);
+    path[0] = ztrdup("/bin");
+    path[1] = ztrdup("/usr/bin");
+    path[2] = ztrdup("/usr/ucb");
+    path[3] = ztrdup("/usr/local/bin");
+    path[4] = NULL;
+
+    cdpath   = mkarray(NULL);
+    manpath  = mkarray(NULL);
+    fignore  = mkarray(NULL);
+    fpath    = mkarray(NULL);
+    mailpath = mkarray(NULL);
+    watch    = mkarray(NULL);
+    psvar    = mkarray(NULL);
+#ifdef DYNAMIC
+    module_path = mkarray(ztrdup(MODULE_DIR));
+    modules = newlinklist();
+#endif
+
+    /* Set default prompts */
+    if(unset(INTERACTIVE)) {
+	prompt = ztrdup("");
+	prompt2 = ztrdup("");
+    } else if (emulation == EMULATE_KSH || emulation == EMULATE_SH) {
+	prompt  = ztrdup(privasserted() ? "# " : "$ ");
+	prompt2 = ztrdup("> ");
+    } else {
+	prompt  = ztrdup("%m%# ");
+	prompt2 = ztrdup("%_> ");
+    }
+    prompt3 = ztrdup("?# ");
+    prompt4 = ztrdup("+ ");
+    sprompt = ztrdup("zsh: correct '%R' to '%r' [nyae]? ");
+
+    ifs         = ztrdup(DEFAULT_IFS);
+    wordchars   = ztrdup(DEFAULT_WORDCHARS);
+    postedit    = ztrdup("");
+    underscore  = ztrdup("");
+
+    zoptarg = ztrdup("");
+    zoptind = 1;
+
+    ppid  = (long) getppid();
+    mypid = (long) getpid();
+    term  = ztrdup("");
+
+    /* The following variable assignments cause zsh to behave more *
+     * like Bourne and Korn shells when invoked as "sh" or "ksh".  *
+     * NULLCMD=":" and READNULLCMD=":"                             */
+
+    if (emulation == EMULATE_KSH || emulation == EMULATE_SH) {
+	nullcmd     = ztrdup(":");
+	readnullcmd = ztrdup(":");
+    } else {
+	nullcmd     = ztrdup("cat");
+	readnullcmd = ztrdup("more");
+    }
+
+    /* We cache the uid so we know when to *
+     * recheck the info for `USERNAME'     */
+    cached_uid = getuid();
+
+    /* Get password entry and set info for `HOME' and `USERNAME' */
+#ifdef HAVE_GETPWUID
+    if ((pswd = getpwuid(cached_uid))) {
+	home = metafy(pswd->pw_dir, -1, META_DUP);
+	cached_username = ztrdup(pswd->pw_name);
+    } else
+#endif /* HAVE_GETPWUID */
+	   {
+	home = ztrdup("/");
+	cached_username = ztrdup("");
+    }
+
+    /* Try a cheap test to see if we can *
+     * initialize `PWD' from `HOME'      */
+    if (ispwd(home))
+	pwd = ztrdup(home);
+    else if ((ptr = zgetenv("PWD")) && ispwd(ptr))
+	pwd = ztrdup(ptr);
+    else
+	pwd = metafy(zgetcwd(), -1, META_DUP);
+
+    oldpwd = ztrdup(pwd);  /* initialize `OLDPWD' = `PWD' */
+
+    inittyptab();     /* initialize the ztypes table */
+    initlextabs();    /* initialize lexing tables    */
+
+    createreswdtable();     /* create hash table for reserved words    */
+    createaliastable();     /* create hash table for aliases           */
+    createcmdnamtable();    /* create hash table for external commands */
+    createshfunctable();    /* create hash table for shell functions   */
+    createbuiltintable();   /* create hash table for builtin commands  */
+    createnameddirtable();  /* create hash table for named directories */
+    createparamtable();     /* create paramater hash table             */
+
+#ifdef TIOCGWINSZ
+    adjustwinsize();
+#else
+    /* Using zero below sets the defaults from termcap */
+    setiparam("COLUMNS", 0);
+    setiparam("LINES", 0);
+#endif
+
+#ifdef HAVE_GETRLIMIT
+    for (i = 0; i != RLIM_NLIMITS; i++) {
+	getrlimit(i, current_limits + i);
+	limits[i] = current_limits[i];
+    }
+#endif
+
+    breaks = loops = 0;
+    lastmailcheck = time(NULL);
+    locallevel = sourcelevel = 0;
+    trapreturn = 0;
+    noerrexit = -1;
+    nohistsave = 1;
+    dirstack = newlinklist();
+    bufstack = newlinklist();
+    prepromptfns = newlinklist();
+    hsubl = hsubr = NULL;
+    lastpid = 0;
+    bshin = SHIN ? fdopen(SHIN, "r") : stdin;
+    if (isset(SHINSTDIN) && !SHIN && unset(INTERACTIVE)) {
+#ifdef _IONBF
+	setvbuf(stdin, NULL, _IONBF, 0);
+#else
+	setlinebuf(stdin);
+#endif
+    }
+
+    times(&shtms);
+}
+
+/* Initialize signal handling */
+
+/**/
+void
+init_signals(void)
+{
+    intr();
+
+#ifndef QDEBUG
+    signal_ignore(SIGQUIT);
+#endif
+
+    install_handler(SIGHUP);
+    install_handler(SIGCHLD);
+#ifdef SIGWINCH
+    install_handler(SIGWINCH);
+#endif
+    if (interact) {
+	install_handler(SIGALRM);
+	signal_ignore(SIGTERM);
+    }
+    if (jobbing) {
+	long ttypgrp;
+
+	while ((ttypgrp = gettygrp()) != -1 && ttypgrp != mypgrp)
+	    kill(0, SIGTTIN);
+	if (ttypgrp == -1) {
+	    opts[MONITOR] = 0;
+	} else {
+	    signal_ignore(SIGTTOU);
+	    signal_ignore(SIGTSTP);
+	    signal_ignore(SIGTTIN);
+	    attachtty(mypgrp);
+	}
+    }
+    if (islogin) {
+	signal_setmask(signal_mask(0));
+    } else if (interact) {
+	sigset_t set;
+
+	sigemptyset(&set);
+	sigaddset(&set, SIGINT);
+	sigaddset(&set, SIGQUIT);
+	signal_unblock(set);
+    }
+}
+
+/* Source the init scripts.  If called as "ksh" or "sh"  *
+ * then we source the standard sh/ksh scripts instead of *
+ * the standard zsh scripts                              */
+
+/**/
+void
+run_init_scripts(void)
+{
+    noerrexit = -1;
+
+    if (emulation == EMULATE_KSH || emulation == EMULATE_SH) {
+	if (islogin)
+	    source("/etc/profile");
+	if (unset(PRIVILEGED)) {
+	    char *s = getsparam("ENV");
+	    if (islogin)
+		sourcehome(".profile");
+	    noerrs = 1;
+	    if (s && !parsestr(s)) {
+		singsub(&s);
+		noerrs = 0;
+		source(s);
+	    }
+	    noerrs = 0;
+	} else
+	    source("/etc/suid_profile");
+    } else {
+#ifdef GLOBAL_ZSHENV
+	source(GLOBAL_ZSHENV);
+#endif
+	if (isset(RCS)) {
+	    if (unset(PRIVILEGED))
+		sourcehome(".zshenv");
+	    if (islogin) {
+#ifdef GLOBAL_ZPROFILE
+		source(GLOBAL_ZPROFILE);
+#endif
+		if (unset(PRIVILEGED))
+		    sourcehome(".zprofile");
+	    }
+	    if (interact) {
+#ifdef GLOBAL_ZSHRC
+		source(GLOBAL_ZSHRC);
+#endif
+		if (unset(PRIVILEGED))
+		    sourcehome(".zshrc");
+	    }
+	    if (islogin) {
+#ifdef GLOBAL_ZLOGIN
+		source(GLOBAL_ZLOGIN);
+#endif
+		if (unset(PRIVILEGED))
+		    sourcehome(".zlogin");
+	    }
+	}
+    }
+    noerrexit = 0;
+    nohistsave = 0;
+}
+
+/* Miscellaneous initializations that happen after init scripts are run */
+
+/**/
+void
+init_misc(void)
+{
+    if (*zsh_name == 'r' || restricted)
+	dosetopt(RESTRICTED, 1, 0);
+    if (cmd) {
+	if (SHIN >= 10)
+	    fclose(bshin);
+	SHIN = movefd(open("/dev/null", O_RDONLY | O_NOCTTY));
+	bshin = fdopen(SHIN, "r");
+	execstring(cmd, 0, 1);
+	stopmsg = 1;
+	zexit(lastval, 0);
+    }
+
+    if (interact && isset(RCS))
+	readhistfile(getsparam("HISTFILE"), 0);
+}
+
+/* source a file */
+
+/**/
+int
+source(char *s)
+{
+    int tempfd, fd, cj, oldlineno;
+    int oldshst, osubsh, oloops;
+    FILE *obshin;
+    char *old_scriptname = scriptname;
+
+    if (!s || (tempfd = movefd(open(unmeta(s), O_RDONLY | O_NOCTTY))) == -1) {
+	return 1;
+    }
+
+    /* save the current shell state */
+    fd        = SHIN;            /* store the shell input fd                  */
+    obshin    = bshin;          /* store file handle for buffered shell input */
+    osubsh    = subsh;           /* store whether we are in a subshell        */
+    cj        = thisjob;         /* store our current job number              */
+    oldlineno = lineno;          /* store our current lineno                  */
+    oloops    = loops;           /* stored the # of nested loops we are in    */
+    oldshst   = opts[SHINSTDIN]; /* store current value of this option        */
+
+    SHIN = tempfd;
+    bshin = fdopen(SHIN, "r");
+    subsh  = 0;
+    lineno = 0;
+    loops  = 0;
+    dosetopt(SHINSTDIN, 0, 1);
+    scriptname = s;
+
+    sourcelevel++;
+    loop(0, 0);			/* loop through the file to be sourced        */
+    sourcelevel--;
+    fclose(bshin);
+    fdtable[SHIN] = 0;
+
+    /* restore the current shell state */
+    SHIN = fd;                       /* the shell input fd                   */
+    bshin = obshin;                  /* file handle for buffered shell input */
+    subsh = osubsh;                  /* whether we are in a subshell         */
+    thisjob = cj;                    /* current job number                   */
+    lineno = oldlineno;              /* our current lineno                   */
+    loops = oloops;                  /* the # of nested loops we are in      */
+    dosetopt(SHINSTDIN, oldshst, 1); /* SHINSTDIN option                     */
+    errflag = 0;
+    retflag = 0;
+    scriptname = old_scriptname;
+
+    return 0;
+}
+
+/* Try to source a file in the home directory */
+
+/**/
+void
+sourcehome(char *s)
+{
+    char buf[PATH_MAX];
+    char *h;
+
+    if (emulation == EMULATE_SH || emulation == EMULATE_KSH ||
+	!(h = getsparam("ZDOTDIR")))
+	h = home;
+    if (strlen(h) + strlen(s) + 1 >= PATH_MAX) {
+	zerr("path too long: %s", s, 0);
+	return;
+    }
+    sprintf(buf, "%s/%s", h, s);
+    source(buf);
+}
+
+/**/
+void
+init_bltinmods(void)
+{
+    static struct module mod = { NULL, 0, NULL, NULL };
+#include "bltinmods.list"
+    mod.nam = NULL;
+}
+
+/* ZLE entry point pointers.  They are defined here because the initial *
+ * values depend on whether ZLE is linked in or not -- if it is, we     *
+ * avoid wasting space with the fallback functions.  No other source    *
+ * file needs to know which modules are linked in.                      */
+
+#ifdef LINKED_XMOD_zle
+
+/**/
+ZleVoidFn trashzleptr;
+/**/
+ZleVoidFn gotwordptr;
+/**/
+ZleVoidFn refreshptr;
+/**/
+ZleVoidIntFn spaceinlineptr;
+/**/
+ZleReadFn zlereadptr;
+
+#else /* !LINKED_XMOD_zle */
+
+ZleVoidFn trashzleptr = noop_function;
+ZleVoidFn gotwordptr = noop_function;
+ZleVoidFn refreshptr = noop_function;
+ZleVoidIntFn spaceinlineptr = noop_function_int;
+# ifdef UNLINKED_XMOD_zle
+ZleReadFn zlereadptr = autoload_zleread;
+# else /* !UNLINKED_XMOD_zle */
+ZleReadFn zlereadptr = fallback_zleread;
+# endif /* !UNLINKED_XMOD_zle */
+
+/**/
+void
+noop_function(void)
+{
+    /* do nothing */
+}
+
+/**/
+void
+noop_function_int(int nothing)
+{
+    /* do nothing */
+}
+
+# ifdef UNLINKED_XMOD_zle
+
+/**/
+static unsigned char *
+autoload_zleread(char *lp, char *rp, int ha)
+{
+    zlereadptr = fallback_zleread;
+    load_module("zle");
+    return zleread(lp, rp, ha);
+}
+
+# endif /* UNLINKED_XMOD_zle */
+
+/**/
+unsigned char *
+fallback_zleread(char *lp, char *rp, int ha)
+{
+    char *pptbuf;
+    int pptlen;
+
+    pptbuf = unmetafy(promptexpand(lp, 0, NULL, NULL), &pptlen);
+    write(2, (WRITE_ARG_2_T)pptbuf, pptlen);
+    free(pptbuf);
+    return (unsigned char *)shingetline();
+}
+
+#endif /* !LINKED_XMOD_zle */
+
+/* compctl entry point pointers.  Similar to the ZLE ones. */
+
+#ifdef LINKED_XMOD_comp1
+
+/**/
+CompctlReadFn compctlreadptr;
+
+#else /* !LINKED_XMOD_comp1 */
+
+CompctlReadFn compctlreadptr = fallback_compctlread;
+
+/**/
+int
+fallback_compctlread(char *name, char **args, char *ops, char *reply)
+{
+    zwarnnam(name, "option valid only in functions called from completion",
+	    NULL, 0);
+    return 1;
+}
+
+#endif /* !LINKED_XMOD_comp1 */
diff --git a/Src/input.c b/Src/input.c
new file mode 100644
index 000000000..576341a7c
--- /dev/null
+++ b/Src/input.c
@@ -0,0 +1,530 @@
+/*
+ * input.c - read and store lines of input
+ *
+ * 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.
+ *
+ */
+
+
+/*
+ * This file deals with input buffering, supplying characters to the
+ * history expansion code a character at a time.  Input is stored on a
+ * stack, which allows insertion of strings into the input, possibly with
+ * flags marking the end of alias expansion, with minimal copying of
+ * strings.  The same stack is used to record the fact that the input
+ * is a history or alias expansion and to store the alias while it is in use.
+ * 
+ * Input is taken either from zle, if appropriate, or read directly from
+ * the input file, or may be supplied by some other part of the shell (such
+ * as `eval' or $(...) substitution).  In the last case, it should be
+ * supplied by pushing a new level onto the stack, via inpush(input_string,
+ * flag, alias); if the current input really needs to be altered, use
+ * inputsetline(input_string, flag).  `Flag' can include or's of INP_FREE
+ * (if the input string is to be freed when used), INP_CONT (if the input
+ * is to continue onto what's already in the input queue), INP_ALIAS
+ * (push supplied alias onto stack) or INP_HIST (ditto, but used to
+ * mark history expansion).  `alias' is ignored unless INP_ALIAS or
+ * INP_HIST is supplied.  INP_ALIAS is always set if INP_HIST is.
+ * 
+ * Note that the input string is itself used as the input buffer: it is not
+ * copied, nor is it every written back to, so using a constant string
+ * should work.  Consequently, when passing areas of memory from the heap
+ * it is necessary that that heap last as long as the operation of reading
+ * the string.  After the string is read, the stack should be popped with
+ * inpop(), which effectively flushes any unread input as well as restoring
+ * the previous input state.
+ *
+ * The internal flag INP_ALCONT shows that the stack element was pushed
+ * by an alias expansion; it should not be needed elsewhere.
+ *
+ * The global variable inalmore is set to indicate aliases should
+ * continue to be expanded because the last alias expansion ended
+ * in a space.  It is only reset after a complete word was read
+ * without expanding a new alias, in exalias().
+ *
+ * PWS 1996/12/10
+ */
+
+#include "zsh.mdh"
+#include "input.pro"
+
+/* the shell input fd */
+
+/**/
+int SHIN;
+
+/* buffered shell input for non-interactive shells */
+
+/**/
+FILE *bshin;
+
+/* != 0 means we are reading input from a string */
+ 
+/**/
+int strin;
+ 
+/* total # of characters waiting to be read. */
+
+/**/
+int inbufct;
+
+/* the flags controlling the input routines in input.c: see INP_* in zsh.h */
+
+/**/
+int inbufflags;
+
+static char *inbuf;		/* Current input buffer */
+static char *inbufptr;		/* Pointer into input buffer */
+static char *inbufpush;		/* Character at which to re-push alias */
+static int inbufleft;		/* Characters left in current input
+				   stack element */
+
+
+ /* Input must be stacked since the input queue is used by
+  * various different parts of the shell.
+  */
+
+struct instacks {
+    char *buf, *bufptr;
+    Alias alias;
+    int bufleft, bufct, flags;
+};
+static struct instacks *instack, *instacktop;
+/*
+ * Input stack size.  We need to push the stack for aliases, history
+ * expansion, and reading from internal strings: only if these operations
+ * are nested do we need more than one extra level.  Thus we shouldn't need
+ * too much space as a rule.  Initially, INSTACK_INITIAL is allocated; if
+ * more is required, an extra INSTACK_EXPAND is added each time.
+ */
+#define INSTACK_INITIAL	4
+#define INSTACK_EXPAND	4
+
+static int instacksz = INSTACK_INITIAL;
+
+/* Read a line from bshin.  Convert tokens and   *
+ * null characters to Meta c^32 character pairs. */
+
+/**/
+char *
+shingetline(void)
+{
+    char *line = NULL;
+    int ll = 0;
+    int c;
+    char buf[BUFSIZ];
+    char *p;
+
+    p = buf;
+    for (;;) {
+	do {
+	    errno = 0;
+	    c = fgetc(bshin);
+	} while (c < 0 && errno == EINTR);
+	if (c < 0 || c == '\n') {
+	    if (c == '\n')
+		*p++ = '\n';
+	    if (p > buf) {
+		*p++ = '\0';
+		line = zrealloc(line, ll + (p - buf));
+		memcpy(line + ll, buf, p - buf);
+	    }
+	    return line;
+	}
+	if (imeta(c)) {
+	    *p++ = Meta;
+	    *p++ = c ^ 32;
+	} else
+	    *p++ = c;
+	if (p >= buf + BUFSIZ - 1) {
+	    line = zrealloc(line, ll + (p - buf) + 1);
+	    memcpy(line + ll, buf, p - buf);
+	    ll += p - buf;
+	    line[ll] = '\0';
+	    p = buf;
+	}
+    }
+}
+
+/* Get the next character from the input.
+ * Will call inputline() to get a new line where necessary.
+ */
+  
+/**/
+int
+ingetc(void)
+{
+    char lastc;
+
+    if (lexstop)
+	return ' ';
+    for (;;) {
+	if (inbufleft) {
+	    inbufleft--;
+	    inbufct--;
+	    if (itok(lastc = STOUC(*inbufptr++)))
+		continue;
+	    return lastc;
+	}
+
+	/* If the next element down the input stack is a continuation of
+	 * this, use it.
+	 */ 
+	if (inbufflags & INP_CONT) {
+	    inpoptop();
+	    continue;
+	}
+	/*
+	 * Otherwise, see if we have reached the end of input
+	 * (due to an error, or to reading from a single string).
+	 */
+	if (strin || errflag) {
+	    lexstop = 1;
+	    return ' ';
+	}
+	/* As a last resort, get some more input */
+	if (inputline())
+	    return ' ';
+    }
+}
+
+/* Read a line from the current command stream and store it as input */
+
+/**/
+static int
+inputline(void)
+{
+    char *ingetcline, *ingetcpmptl = NULL, *ingetcpmptr = NULL;
+
+    /* If reading code interactively, work out the prompts. */
+    if (interact && isset(SHINSTDIN))
+	if (!isfirstln)
+	    ingetcpmptl = prompt2;
+	else {
+	    ingetcpmptl = prompt;
+	    if (rprompt)
+		ingetcpmptr = rprompt;
+	}
+    if (!(interact && isset(SHINSTDIN) && SHTTY != -1 && isset(USEZLE))) {
+	/*
+	 * If not using zle, read the line straight from the input file.
+	 * Possibly we don't get the whole line at once:  in that case,
+	 * we get another chunk with the next call to inputline().
+	 */
+
+	if (interact && isset(SHINSTDIN)) {
+	    /*
+	     * We may still be interactive (e.g. running under emacs),
+	     * so output a prompt if necessary.  We don't know enough
+	     * about the input device to be able to handle an rprompt,
+	     * though.
+	     */
+	    char *pptbuf;
+	    int pptlen;
+	    pptbuf = unmetafy(promptexpand(ingetcpmptl, 0, NULL, NULL), &pptlen);
+	    write(2, (WRITE_ARG_2_T)pptbuf, pptlen);
+	    free(pptbuf);
+	}
+	ingetcline = shingetline();
+    } else
+	ingetcline = (char *)zleread(ingetcpmptl, ingetcpmptr, 1);
+    if (!ingetcline) {
+	return lexstop = 1;
+    }
+    if (errflag) {
+	free(ingetcline);
+	return lexstop = errflag = 1;
+    }
+    /* Look for a space, to see if this shouldn't be put into history */
+    if (isfirstln)
+	spaceflag = *ingetcline == ' ';
+    if (isset(VERBOSE)) {
+	/* Output the whole line read so far. */
+	zputs(ingetcline, stderr);
+	fflush(stderr);
+    }
+    if (*ingetcline && ingetcline[strlen(ingetcline) - 1] == '\n') {
+	/* We've now read a complete line. */
+	lineno++;
+	if (interact && isset(SUNKEYBOARDHACK) && isset(SHINSTDIN) &&
+	    SHTTY != -1 && *ingetcline && ingetcline[1] &&
+	    ingetcline[strlen(ingetcline) - 2] == '`') {
+	    /* Junk an unmatched "`" at the end of the line. */
+	    int ct;
+	    char *ptr;
+
+	    for (ct = 0, ptr = ingetcline; *ptr; ptr++)
+		if (*ptr == '`')
+		    ct++;
+	    if (ct & 1) {
+		ptr[-2] = '\n';
+		ptr[-1] = '\0';
+	    }
+	}
+    }
+    isfirstch = 1;
+    /* Put this into the input channel. */
+    inputsetline(ingetcline, INP_FREE);
+
+    return 0;
+}
+
+/*
+ * Put a string in the input queue:
+ * inbuf is only freeable if the flags include INP_FREE.
+ */
+
+/**/
+static void
+inputsetline(char *str, int flags)
+{
+    if ((inbufflags & INP_FREE) && inbuf) {
+	free(inbuf);
+    }
+    inbuf = inbufptr = str;
+    inbufleft = strlen(inbuf);
+
+    /*
+     * inbufct must reflect the total number of characters left,
+     * as it used by other parts of the shell, so we need to take account
+     * of whether the input stack continues, and whether there
+     * is an extra space to add on at the end.
+     */
+    if (flags & INP_CONT)
+	inbufct += inbufleft;
+    else
+	inbufct = inbufleft;
+    inbufflags = flags;
+}
+
+/*
+ * Backup one character of the input.
+ * The last character can always be backed up, provided we didn't just
+ * expand an alias or a history reference.
+ * In fact, the character is ignored and the previous character is used.
+ * (If that's wrong, the bug is in the calling code.  Use the #ifdef DEBUG
+ * code to check.) 
+ */
+
+/**/
+void
+inungetc(int c)
+{
+    if (!lexstop) {
+	if (inbufptr != inbuf) {
+#ifdef DEBUG
+	    /* Just for debugging: enable only if foul play suspected. */
+	    if (inbufptr[-1] != (char) c)
+		fprintf(stderr, "Warning: backing up wrong character.\n");
+#endif
+	    /* Just decrement the pointer:  if it's not the same
+	     * character being pushed back, we're in trouble anyway.
+	     */
+	    inbufptr--;
+	    inbufct++;
+	    inbufleft++;
+	}
+#ifdef DEBUG
+        else if (!(inbufflags & INP_CONT)) {
+	    /* Just for debugging */
+	    fprintf(stderr, "Attempt to inungetc() at start of input.\n");
+	}
+#endif
+	else {
+	    /*
+	     * The character is being backed up from a previous input stack
+	     * layer.  However, there was an expansion in the middle, so we
+	     * can't back up where we want to.  Instead, we just push it
+	     * onto the input stack as an extra character.
+	     */
+	    char *cback = (char *)zcalloc(2);
+	    cback[0] = (char) c;
+	    inpush(cback, INP_FREE|INP_CONT, NULL);
+	}
+	/* If we are back at the start of a segment,
+	 * we may need to restore an alias popped from the stack.
+	 * Note this may be a dummy (history expansion) entry.
+	 */
+	if (inbufptr == inbufpush && inbufflags & INP_ALCONT) {
+	    /*
+	     * Go back up the stack over all entries which were alias
+	     * expansions and were pushed with nothing remaining to read.
+	     */
+	    do {
+		if (instacktop->alias)
+		    instacktop->alias->inuse = 1;
+		instacktop++;
+	    } while ((instacktop->flags & INP_ALCONT) && !instacktop->bufleft);
+	    inbufflags = INP_CONT|INP_ALIAS;
+	    inbufleft = 0;
+	    inbuf = inbufptr = "";
+	}
+    }
+}
+
+/* stuff a whole file into the input queue and print it */
+
+/**/
+int
+stuff(char *fn)
+{
+    FILE *in;
+    char *buf;
+    int len;
+
+    if (!(in = fopen(unmeta(fn), "r"))) {
+	zerr("can't open %s", fn, 0);
+	return 1;
+    }
+    fseek(in, 0, 2);
+    len = ftell(in);
+    fseek(in, 0, 0);
+    buf = (char *)zalloc(len + 1);
+    if (!(fread(buf, len, 1, in))) {
+	zerr("read error on %s", fn, 0);
+	fclose(in);
+	zfree(buf, len + 1);
+	return 1;
+    }
+    fclose(in);
+    buf[len] = '\0';
+    fwrite(buf, len, 1, stderr);
+    fflush(stderr);
+    inputsetline(metafy(buf, len, META_REALLOC), INP_FREE);
+    return 0;
+}
+
+/* flush input queue */
+
+/**/
+void
+inerrflush(void)
+{
+    while (!lexstop && inbufct)
+	ingetc();
+}
+
+/* Set some new input onto a new element of the input stack */
+
+/**/
+void
+inpush(char *str, int flags, Alias inalias)
+{
+    if (!instack) {
+	/* Initial stack allocation */
+	instack = (struct instacks *)zalloc(instacksz*sizeof(struct instacks));
+	instacktop = instack;
+    }
+
+    instacktop->buf = inbuf;
+    instacktop->bufptr = inbufptr;
+    instacktop->bufleft = inbufleft;
+    instacktop->bufct = inbufct;
+    inbufflags &= ~INP_ALCONT;
+    if (flags & (INP_ALIAS|INP_HIST)) {
+	/*
+	 * Text is expansion for history or alias, so continue
+	 * back to old level when done.  Also mark stack top
+	 * as alias continuation so as to back up if necessary,
+	 * and mark alias as in use.
+	 */
+	flags |= INP_CONT|INP_ALIAS;
+	instacktop->flags = inbufflags | INP_ALCONT;
+	if ((instacktop->alias = inalias))
+	    inalias->inuse = 1;
+    } else {
+	/* If we are continuing an alias expansion, record the alias
+	 * expansion in new set of flags (do we need this?)
+	 */
+	if (((instacktop->flags = inbufflags) & INP_ALIAS) &&
+	    (flags & INP_CONT))
+	    flags |= INP_ALIAS;
+    }
+
+    instacktop++;
+    if (instacktop == instack + instacksz) {
+	/* Expand the stack */
+	instack = (struct instacks *)
+	    realloc(instack,
+		    (instacksz + INSTACK_EXPAND)*sizeof(struct instacks));
+	instacktop = instack + instacksz;
+	instacksz += INSTACK_EXPAND;
+    }
+    /*
+     * We maintain the entry above the highest one with real
+     * text as a flag to inungetc() that it can stop re-pushing the stack.
+     */
+    instacktop->flags = 0;
+
+    inbufpush = inbuf = NULL;
+
+    inputsetline(str, flags);
+}
+
+/* Remove the top element of the stack */
+
+/**/
+static void
+inpoptop(void)
+{
+    if (inbuf && (inbufflags & INP_FREE))
+	free(inbuf);
+
+    instacktop--;
+
+    inbuf = instacktop->buf;
+    inbufptr = inbufpush = instacktop->bufptr;
+    inbufleft = instacktop->bufleft;
+    inbufct = instacktop->bufct;
+    inbufflags = instacktop->flags;
+
+    if (!(inbufflags & INP_ALCONT))
+	return;
+
+    if (instacktop->alias) {
+	char *t = instacktop->alias->text;
+	/* a real alias:  mark it as unused. */
+	instacktop->alias->inuse = 0;
+	if (*t && t[strlen(t) - 1] == ' ') {
+	    inalmore = 1;
+	    histbackword();
+	}
+    }
+}
+
+/* Remove the top element of the stack and all its continuations. */
+
+/**/
+void
+inpop(void)
+{
+    int remcont;
+
+    do {
+	remcont = inbufflags & INP_CONT;
+
+	inpoptop();
+    } while (remcont);
+}
diff --git a/Src/jobs.c b/Src/jobs.c
new file mode 100644
index 000000000..331902d9f
--- /dev/null
+++ b/Src/jobs.c
@@ -0,0 +1,1361 @@
+/*
+ * jobs.c - job control
+ *
+ * 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 "jobs.pro"
+
+/* the process group of the shell */
+
+/**/
+pid_t mypgrp;
+ 
+/* the job we are working on */
+ 
+/**/
+int thisjob;
+
+/* the current job (+) */
+ 
+/**/
+int curjob;
+ 
+/* the previous job (-) */
+ 
+/**/
+int prevjob;
+ 
+/* the job table */
+ 
+/**/
+struct job jobtab[MAXJOB];
+ 
+/* shell timings */
+ 
+/**/
+struct tms shtms;
+ 
+/* 1 if ttyctl -f has been executed */
+ 
+/**/
+int ttyfrozen;
+ 
+/* empty job structure for quick clearing of jobtab entries */
+
+static struct job zero;		/* static variables are initialized to zero */
+
+static struct timeval dtimeval, now;
+
+/* Diff two timevals for elapsed-time computations */
+
+/**/
+static struct timeval *
+dtime(struct timeval *dt, struct timeval *t1, struct timeval *t2)
+{
+    dt->tv_sec = t2->tv_sec - t1->tv_sec;
+    dt->tv_usec = t2->tv_usec - t1->tv_usec;
+    if (dt->tv_usec < 0) {
+	dt->tv_usec += 1000000.0;
+	dt->tv_sec -= 1.0;
+    }
+    return dt;
+}
+
+/* change job table entry from stopped to running */
+
+/**/
+void
+makerunning(Job jn)
+{
+    Process pn;
+
+    jn->stat &= ~STAT_STOPPED;
+    for (pn = jn->procs; pn; pn = pn->next)
+	if (WIFSTOPPED(pn->status) && 
+	    (!(jn->stat & STAT_SUPERJOB) || pn->next))
+	    pn->status = SP_RUNNING;
+
+    if (jn->stat & STAT_SUPERJOB)
+	makerunning(jobtab + jn->other);
+}
+
+/* Find process and job associated with pid.         *
+ * Return 1 if search was successful, else return 0. */
+
+/**/
+int
+findproc(pid_t pid, Job *jptr, Process *pptr)
+{
+    Process pn;
+    int i;
+
+    for (i = 1; i < MAXJOB; i++)
+	for (pn = jobtab[i].procs; pn; pn = pn->next)
+	    if (pn->pid == pid) {
+		*pptr = pn;
+		*jptr = jobtab + i;
+		return 1;
+	    }
+
+    return 0;
+}
+
+/* Update status of process that we have just WAIT'ed for */
+
+/**/
+void
+update_process(Process pn, int status)
+{
+    struct timezone dummy_tz;
+    long childs, childu;
+
+    childs = shtms.tms_cstime;
+    childu = shtms.tms_cutime;
+    times(&shtms);                          /* get time-accounting info          */
+
+    pn->status = status;                    /* save the status returned by WAIT  */
+    pn->ti.st  = shtms.tms_cstime - childs; /* compute process system space time */
+    pn->ti.ut  = shtms.tms_cutime - childu; /* compute process user space time   */
+
+    gettimeofday(&pn->endtime, &dummy_tz);  /* record time process exited        */
+}
+
+/* Update status of job, possibly printing it */
+
+/**/
+void
+update_job(Job jn)
+{
+    Process pn;
+    int job;
+    int val = 0, status = 0;
+    int somestopped = 0, inforeground = 0;
+
+    for (pn = jn->procs; pn; pn = pn->next) {
+	if (pn->status == SP_RUNNING)      /* some processes in this job are running       */
+	    return;                        /* so no need to update job table entry         */
+	if (WIFSTOPPED(pn->status))        /* some processes are stopped                   */
+	    somestopped = 1;               /* so job is not done, but entry needs updating */
+	if (!pn->next)                     /* last job in pipeline determines exit status  */
+	    val = (WIFSIGNALED(pn->status)) ? 0200 | WTERMSIG(pn->status) :
+		WEXITSTATUS(pn->status);
+	if (pn->pid == jn->gleader)        /* if this process is process group leader      */
+	    status = pn->status;
+    }
+
+    job = jn - jobtab;   /* compute job number */
+
+    if (somestopped) {
+	if (jn->stty_in_env && !jn->ty) {
+	    jn->ty = (struct ttyinfo *) zalloc(sizeof(struct ttyinfo));
+	    gettyinfo(jn->ty);
+	}
+	if (jn->stat & STAT_STOPPED)
+	    return;
+    } else {                   /* job is done, so remember return value */
+	lastval2 = val;
+	/* If last process was run in the current shell, keep old status
+	 * and let it handle its own traps
+	 */
+	if (job == thisjob && !(jn->stat & STAT_CURSH)) {
+	  lastval = val;
+	  inforeground = 1;
+	}
+    }
+
+    if (shout && !ttyfrozen && !jn->stty_in_env && !zleactive &&
+	job == thisjob && !somestopped && !(jn->stat & STAT_NOSTTY))
+	gettyinfo(&shttyinfo);
+
+    if (isset(MONITOR)) {
+	pid_t pgrp = gettygrp();           /* get process group of tty      */
+
+	/* is this job in the foreground of an interactive shell? */
+	if (mypgrp != pgrp && inforeground &&
+	    (jn->gleader == pgrp || (pgrp > 1 && kill(-pgrp, 0) == -1))) {
+	    attachtty(mypgrp);
+	    adjustwinsize();   /* check window size and adjust if necessary */
+	}
+    }
+
+    if (somestopped && jn->stat & STAT_SUPERJOB)
+	return;
+    jn->stat |= (somestopped) ? STAT_CHANGED | STAT_STOPPED :
+	STAT_CHANGED | STAT_DONE;
+    if ((jn->stat & (STAT_DONE | STAT_STOPPED)) == STAT_STOPPED) {
+	prevjob = curjob;
+	curjob = job;
+    }
+    if ((isset(NOTIFY) || job == thisjob) && (jn->stat & STAT_LOCKED)) {
+	printjob(jn, !!isset(LONGLISTJOBS), 0);
+	if (zleactive)
+	    refresh();
+    }
+    if (sigtrapped[SIGCHLD] && job != thisjob)
+	dotrap(SIGCHLD);
+
+    /* When MONITOR is set, the foreground process runs in a different *
+     * process group from the shell, so the shell will not receive     *
+     * terminal signals, therefore we we pretend that the shell got    *
+     * the signal too.                                                 */
+    if (inforeground && isset(MONITOR) && WIFSIGNALED(status)) {
+	int sig = WTERMSIG(status);
+
+	if (sig == SIGINT || sig == SIGQUIT) {
+	    if (sigtrapped[sig]) {
+		dotrap(sig);
+		/* We keep the errflag as set or not by dotrap.
+		 * This is to fulfil the promise to carry on
+		 * with the jobs if trap returns zero.
+		 * Setting breaks = loops ensures a consistent return
+		 * status if inside a loop.  Maybe the code in loops
+		 * should be changed.
+		 */
+		if (errflag)
+		    breaks = loops;
+	    } else {
+		breaks = loops;
+		errflag = 1;
+	    }
+	}
+    }
+}
+
+/* set the previous job to something reasonable */
+
+/**/
+static void
+setprevjob(void)
+{
+    int i;
+
+    for (i = MAXJOB - 1; i; i--)
+	if ((jobtab[i].stat & STAT_INUSE) && (jobtab[i].stat & STAT_STOPPED) &&
+	    i != curjob && i != thisjob) {
+	    prevjob = i;
+	    return;
+	}
+
+    for (i = MAXJOB - 1; i; i--)
+	if ((jobtab[i].stat & STAT_INUSE) && i != curjob && i != thisjob) {
+	    prevjob = i;
+	    return;
+	}
+
+    prevjob = -1;
+}
+
+static long clktck = 0;
+
+/**/
+static void
+set_clktck(void)
+{
+#ifdef _SC_CLK_TCK
+    if (!clktck)
+	/* fetch clock ticks per second from *
+	 * sysconf only the first time       */
+	clktck = sysconf(_SC_CLK_TCK);
+#else
+# ifdef __NeXT__
+    /* NeXTStep 3.3 defines CLK_TCK wrongly */
+    clktck = 60;
+# else
+#  ifdef CLK_TCK
+    clktck = CLK_TCK;
+#  else
+#   ifdef HZ
+     clktck = HZ;
+#   else
+     clktck = 60;
+#   endif
+#  endif
+# endif
+#endif
+}
+
+/**/
+static void
+printhhmmss(double secs)
+{
+    int mins = (int) secs / 60;
+    int hours = mins / 60;
+
+    secs -= 60 * mins;
+    mins -= 60 * hours;
+    if (hours)
+	fprintf(stderr, "%d:%02d:%05.2f", hours, mins, secs);
+    else if (mins)
+	fprintf(stderr,      "%d:%05.2f",        mins, secs);
+    else
+	fprintf(stderr,           "%.3f",              secs);
+}
+
+/**/
+static void
+printtime(struct timeval *real, struct timeinfo *ti, char *desc)
+{
+    char *s;
+    double elapsed_time, user_time, system_time;
+    int percent;
+
+    if (!desc)
+	desc = "";
+
+    set_clktck();
+    /* go ahead and compute these, since almost every TIMEFMT will have them */
+    elapsed_time = real->tv_sec + real->tv_usec / 1000000.0;
+    user_time    = ti->ut / (double) clktck;
+    system_time  = ti->st / (double) clktck;
+    percent      =  100.0 * (ti->ut + ti->st)
+	/ (clktck * real->tv_sec + clktck * real->tv_usec / 1000000.0);
+
+    if (!(s = getsparam("TIMEFMT")))
+	s = DEFAULT_TIMEFMT;
+
+    for (; *s; s++)
+	if (*s == '%')
+	    switch (*++s) {
+	    case 'E':
+		fprintf(stderr, "%4.2fs", elapsed_time);
+		break;
+	    case 'U':
+		fprintf(stderr, "%4.2fs", user_time);
+		break;
+	    case 'S':
+		fprintf(stderr, "%4.2fs", system_time);
+		break;
+	    case '*':
+		switch (*++s) {
+		case 'E':
+		    printhhmmss(elapsed_time);
+		    break;
+		case 'U':
+		    printhhmmss(user_time);
+		    break;
+		case 'S':
+		    printhhmmss(system_time);
+		    break;
+		default:
+		    fprintf(stderr, "%%*");
+		    s--;
+		    break;
+		}
+		break;
+	    case 'P':
+		fprintf(stderr, "%d%%", percent);
+		break;
+	    case 'J':
+		fprintf(stderr, "%s", desc);
+		break;
+	    case '%':
+		putc('%', stderr);
+		break;
+	    case '\0':
+		s--;
+		break;
+	    default:
+		fprintf(stderr, "%%%c", *s);
+		break;
+	} else
+	    putc(*s, stderr);
+    putc('\n', stderr);
+    fflush(stderr);
+}
+
+/**/
+static void
+dumptime(Job jn)
+{
+    Process pn;
+
+    if (!jn->procs)
+	return;
+    for (pn = jn->procs; pn; pn = pn->next)
+	printtime(dtime(&dtimeval, &pn->bgtime, &pn->endtime), &pn->ti, pn->text);
+}
+
+/* Check whether shell should report the amount of time consumed   *
+ * by job.  This will be the case if we have preceded the command  *
+ * with the keyword time, or if REPORTTIME is non-negative and the *
+ * amount of time consumed by the job is greater than REPORTTIME   */
+
+/**/
+static int
+should_report_time(Job j)
+{
+    Value v;
+    char *s = "REPORTTIME";
+    int reporttime;
+
+    /* if the time keyword was used */
+    if (j->stat & STAT_TIMED)
+	return 1;
+
+    if (!(v = getvalue(&s, 0)) || (reporttime = getintvalue(v)) < 0)
+	return 0;
+
+    /* can this ever happen? */
+    if (!j->procs)
+	return 0;
+
+    set_clktck();
+    return ((j->procs->ti.ut + j->procs->ti.st) / clktck >= reporttime);
+}
+
+/* !(lng & 3) means jobs    *
+ *  (lng & 1) means jobs -l *
+ *  (lng & 2) means jobs -p
+ *  (lng & 4) means jobs -d
+ *
+ * synch = 0 means asynchronous
+ * synch = 1 means synchronous
+ * synch = 2 means called synchronously from jobs
+*/
+
+/**/
+void
+printjob(Job jn, int lng, int synch)
+{
+    Process pn;
+    int job = jn - jobtab, len = 9, sig, sflag = 0, llen;
+    int conted = 0, lineleng = columns, skip = 0, doputnl = 0;
+    FILE *fout = (synch == 2) ? stdout : shout;
+
+    if (jn->stat & STAT_NOPRINT)
+	return;
+
+    if (lng < 0) {
+	conted = 1;
+	lng = 0;
+    }
+
+/* find length of longest signame, check to see */
+/* if we really need to print this job          */
+
+    for (pn = jn->procs; pn; pn = pn->next) {
+	if (jn->stat & STAT_SUPERJOB &&
+	    jn->procs->status == SP_RUNNING && !pn->next)
+	    pn->status = SP_RUNNING;
+	if (pn->status != SP_RUNNING)
+	    if (WIFSIGNALED(pn->status)) {
+		sig = WTERMSIG(pn->status);
+		llen = strlen(sigmsg[sig]);
+		if (WCOREDUMP(pn->status))
+		    llen += 14;
+		if (llen > len)
+		    len = llen;
+		if (sig != SIGINT && sig != SIGPIPE)
+		    sflag = 1;
+		if (job == thisjob && sig == SIGINT)
+		    doputnl = 1;
+	    } else if (WIFSTOPPED(pn->status)) {
+		sig = WSTOPSIG(pn->status);
+		if ((int)strlen(sigmsg[sig]) > len)
+		    len = strlen(sigmsg[sig]);
+		if (job == thisjob && sig == SIGTSTP)
+		    doputnl = 1;
+	    } else if (isset(PRINTEXITVALUE) && isset(SHINSTDIN) &&
+		       WEXITSTATUS(pn->status))
+		sflag = 1;
+    }
+
+/* print if necessary */
+
+    if (interact && jobbing && ((jn->stat & STAT_STOPPED) || sflag ||
+				job != thisjob)) {
+	int len2, fline = 1;
+	Process qn;
+
+	if (!synch)
+	    trashzle();
+	if (doputnl && !synch)
+	    putc('\n', fout);
+	for (pn = jn->procs; pn;) {
+	    len2 = ((job == thisjob) ? 5 : 10) + len;	/* 2 spaces */
+	    if (lng & 3)
+		qn = pn->next;
+	    else
+		for (qn = pn->next; qn; qn = qn->next) {
+		    if (qn->status != pn->status)
+			break;
+		    if ((int)strlen(qn->text) + len2 + ((qn->next) ? 3 : 0) > lineleng)
+			break;
+		    len2 += strlen(qn->text) + 2;
+		}
+	    if (job != thisjob)
+		if (fline)
+		    fprintf(fout, "[%ld]  %c ",
+			    (long)(jn - jobtab),
+			    (job == curjob) ? '+'
+			    : (job == prevjob) ? '-' : ' ');
+		else
+		    fprintf(fout, (job > 9) ? "        " : "       ");
+	    else
+		fprintf(fout, "zsh: ");
+	    if (lng & 1)
+		fprintf(fout, "%ld ", (long) pn->pid);
+	    else if (lng & 2) {
+		pid_t x = jn->gleader;
+
+		fprintf(fout, "%ld ", (long) x);
+		do
+		    skip++;
+		while ((x /= 10));
+		skip++;
+		lng &= ~3;
+	    } else
+		fprintf(fout, "%*s", skip, "");
+	    if (pn->status == SP_RUNNING)
+		if (!conted)
+		    fprintf(fout, "running%*s", len - 7 + 2, "");
+		else
+		    fprintf(fout, "continued%*s", len - 9 + 2, "");
+	    else if (WIFEXITED(pn->status))
+		if (WEXITSTATUS(pn->status))
+		    fprintf(fout, "exit %-4d%*s", WEXITSTATUS(pn->status),
+			    len - 9 + 2, "");
+		else
+		    fprintf(fout, "done%*s", len - 4 + 2, "");
+	    else if (WIFSTOPPED(pn->status))
+		fprintf(fout, "%-*s", len + 2, sigmsg[WSTOPSIG(pn->status)]);
+	    else if (WCOREDUMP(pn->status))
+		fprintf(fout, "%s (core dumped)%*s",
+			sigmsg[WTERMSIG(pn->status)],
+			(int)(len - 14 + 2 - strlen(sigmsg[WTERMSIG(pn->status)])), "");
+	    else
+		fprintf(fout, "%-*s", len + 2, sigmsg[WTERMSIG(pn->status)]);
+	    for (; pn != qn; pn = pn->next)
+		fprintf(fout, (pn->next) ? "%s | " : "%s", pn->text);
+	    putc('\n', fout);
+	    fline = 0;
+	}
+	fflush(fout);
+    } else if (doputnl && interact && !synch) {
+	putc('\n', fout);
+	fflush(fout);
+    }
+
+/* print "(pwd now: foo)" messages: with (lng & 4) we are printing
+ * the directory where the job is running, otherwise the current directory
+ */
+
+    if ((lng & 4) || (interact && job == thisjob && strcmp(jn->pwd, pwd))) {
+	fprintf(shout, "(pwd %s: ", (lng & 4) ? "" : "now");
+	fprintdir((lng & 4) ? jn->pwd : pwd, shout);
+	fprintf(shout, ")\n");
+	fflush(shout);
+    }
+/* delete job if done */
+
+    if (jn->stat & STAT_DONE) {
+	if (should_report_time(jn))
+	    dumptime(jn);
+	deletejob(jn);
+	if (job == curjob) {
+	    curjob = prevjob;
+	    prevjob = job;
+	}
+	if (job == prevjob)
+	    setprevjob();
+    } else
+	jn->stat &= ~STAT_CHANGED;
+}
+
+/**/
+void
+deletefilelist(LinkList file_list)
+{
+    char *s;
+    if (file_list) {
+	while ((s = (char *)getlinknode(file_list))) {
+	    unlink(s);
+	    zsfree(s);
+	}
+	zfree(file_list, sizeof(struct linklist));
+    }
+}
+
+/**/
+void
+deletejob(Job jn)
+{
+    struct process *pn, *nx;
+
+    pn = jn->procs;
+    jn->procs = NULL;
+    for (; pn; pn = nx) {
+	nx = pn->next;
+	zfree(pn, sizeof(struct process));
+    }
+    zsfree(jn->pwd);
+
+    deletefilelist(jn->filelist);
+
+    if (jn->ty)
+	zfree(jn->ty, sizeof(struct ttyinfo));
+
+    *jn = zero;
+}
+
+/* add a process to the current job */
+
+/**/
+void
+addproc(pid_t pid, char *text)
+{
+    Process pn;
+    struct timezone dummy_tz;
+
+    pn = (Process) zcalloc(sizeof *pn);
+    pn->pid = pid;
+    if (text)
+	strcpy(pn->text, text);
+    else
+	*pn->text = '\0';
+    gettimeofday(&pn->bgtime, &dummy_tz);
+    pn->status = SP_RUNNING;
+    pn->next = NULL;
+
+    /* if this is the first process we are adding to *
+     * the job, then it's the group leader.          */
+    if (!jobtab[thisjob].gleader)
+	jobtab[thisjob].gleader = pid;
+
+    /* attach this process to end of process list of current job */
+    if (jobtab[thisjob].procs) {
+	Process n;
+
+	for (n = jobtab[thisjob].procs; n->next; n = n->next);
+	pn->next = NULL;
+	n->next = pn;
+    } else {
+	/* first process for this job */
+	jobtab[thisjob].procs = pn;
+    }
+    /* If the first process in the job finished before any others were *
+     * added, maybe STAT_DONE got set incorrectly.  This can happen if *
+     * a $(...) was waited for and the last existing job in the        *
+     * pipeline was already finished.  We need to be very careful that *
+     * there was no call to printjob() between then and now, else      *
+     * the job will already have been deleted from the table.          */
+    jobtab[thisjob].stat &= ~STAT_DONE;
+}
+
+/* Check if we have files to delete.  We need to check this to see *
+ * if it's all right to exec a command without forking in the last *
+ * component of subshells or after the `-c' option.                */
+
+/**/
+int
+havefiles(void)
+{
+    int i;
+
+    for (i = 1; i < MAXJOB; i++)
+	if (jobtab[i].stat && jobtab[i].filelist)
+	    return 1;
+    return 0;
+
+}
+
+/* wait for a particular process */
+
+/**/
+void
+waitforpid(pid_t pid)
+{
+    int first = 1;
+
+    /* child_block() around this loop in case #ifndef WNOHANG */
+    child_block();		/* unblocked in child_suspend() */
+    while (!errflag && (kill(pid, 0) >= 0 || errno != ESRCH)) {
+	if (first)
+	    first = 0;
+	else
+	    kill(pid, SIGCONT);
+
+	child_suspend(SIGINT);
+	child_block();
+    }
+    child_unblock();
+}
+
+/* wait for a job to finish */
+
+/**/
+static void
+waitjob(int job, int sig)
+{
+    Job jn = jobtab + job;
+
+    child_block();		 /* unblocked during child_suspend() */
+    if (jn->procs) {		 /* if any forks were done         */
+	jn->stat |= STAT_LOCKED;
+	if (jn->stat & STAT_CHANGED)
+	    printjob(jn, !!isset(LONGLISTJOBS), 1);
+	while (!errflag && jn->stat &&
+	       !(jn->stat & STAT_DONE) &&
+	       !(interact && (jn->stat & STAT_STOPPED))) {
+	    child_suspend(sig);
+	    /* Commenting this out makes ^C-ing a job started by a function
+	       stop the whole function again.  But I guess it will stop
+	       something else from working properly, we have to find out
+	       what this might be.  --oberon
+
+	    errflag = 0; */
+	    if (jn->stat & STAT_SUPERJOB) {
+		Job sj = jobtab + jn->other;
+		if (sj->stat & STAT_DONE) {
+		    struct process *p;
+		    
+		    for (p = sj->procs; p; p = p->next)
+			if (WIFSIGNALED(p->status)) {
+			    killpg(jn->gleader, WTERMSIG(p->status));
+			    kill(sj->other, SIGCONT);
+			    kill(sj->other, WTERMSIG(p->status));
+			    break;
+			}
+		    if (!p) {
+			jn->stat &= ~STAT_SUPERJOB;
+			kill(sj->other, SIGCONT);
+			deletejob(sj);
+		    }
+		    curjob = jn - jobtab;
+		}
+		else if (sj->stat & STAT_STOPPED) {
+		    struct process *p;
+
+		    jn->stat |= STAT_STOPPED;
+		    for (p = jn->procs; p; p = p->next)
+			p->status = sj->procs->status;
+		    curjob = jn - jobtab;
+		    printjob(jn, !!isset(LONGLISTJOBS), 1);
+		    break;
+		}
+	    }
+	    child_block();
+	}
+    } else
+	deletejob(jn);
+    child_unblock();
+}
+
+/* wait for running job to finish */
+
+/**/
+void
+waitjobs(void)
+{
+    waitjob(thisjob, 0);
+    thisjob = -1;
+}
+
+/* clear job table when entering subshells */
+
+/**/
+void
+clearjobtab(void)
+{
+    int i;
+
+    for (i = 1; i < MAXJOB; i++) {
+	if (jobtab[i].pwd)
+	    zsfree(jobtab[i].pwd);
+	if (jobtab[i].ty)
+	    zfree(jobtab[i].ty, sizeof(struct ttyinfo));
+    }
+
+    memset(jobtab, 0, sizeof(jobtab)); /* zero out table */
+}
+
+/* Get a free entry in the job table and initialize it. */
+
+/**/
+int
+initjob(void)
+{
+    int i;
+
+    for (i = 1; i < MAXJOB; i++)
+	if (!jobtab[i].stat) {
+	    jobtab[i].stat = STAT_INUSE;
+	    jobtab[i].pwd = ztrdup(pwd);
+	    jobtab[i].gleader = 0;
+	    return i;
+	}
+
+    zerr("job table full or recursion limit exceeded", NULL, 0);
+    return -1;
+}
+
+/* print pids for & */
+
+/**/
+void
+spawnjob(void)
+{
+    Process pn;
+
+    /* if we are not in a subshell */
+    if (!subsh) {
+	if (curjob == -1 || !(jobtab[curjob].stat & STAT_STOPPED)) {
+	    curjob = thisjob;
+	    setprevjob();
+	} else if (prevjob == -1 || !(jobtab[prevjob].stat & STAT_STOPPED))
+	    prevjob = thisjob;
+	if (interact && jobbing && jobtab[thisjob].procs) {
+	    fprintf(stderr, "[%d]", thisjob);
+	    for (pn = jobtab[thisjob].procs; pn; pn = pn->next)
+		fprintf(stderr, " %ld", (long) pn->pid);
+	    fprintf(stderr, "\n");
+	    fflush(stderr);
+	}
+    }
+    if (!jobtab[thisjob].procs)
+	deletejob(jobtab + thisjob);
+    else
+	jobtab[thisjob].stat |= STAT_LOCKED;
+    thisjob = -1;
+}
+
+/**/
+void
+shelltime(void)
+{
+    struct timeinfo ti;
+    struct timezone dummy_tz;
+    struct tms buf;
+
+    times(&buf);
+    ti.ut = buf.tms_utime;
+    ti.st = buf.tms_stime;
+    gettimeofday(&now, &dummy_tz);
+    printtime(dtime(&dtimeval, &shtimer, &now), &ti, "shell");
+    ti.ut = buf.tms_cutime;
+    ti.st = buf.tms_cstime;
+    printtime(dtime(&dtimeval, &shtimer, &now), &ti, "children");
+}
+
+/* see if jobs need printing */
+ 
+/**/
+void
+scanjobs(void)
+{
+    int i;
+ 
+    for (i = 1; i < MAXJOB; i++)
+        if (jobtab[i].stat & STAT_CHANGED)
+            printjob(jobtab + i, 0, 1);
+}
+
+/**** job control builtins ****/
+
+/* This simple function indicates whether or not s may represent      *
+ * a number.  It returns true iff s consists purely of digits and     *
+ * minuses.  Note that minus may appear more than once, and the empty *
+ * string will produce a `true' response.                             */
+
+/**/
+static int
+isanum(char *s)
+{
+    while (*s == '-' || idigit(*s))
+	s++;
+    return *s == '\0';
+}
+
+/* Make sure we have a suitable current and previous job set. */
+
+/**/
+static void
+setcurjob(void)
+{
+    if (curjob == thisjob ||
+	(curjob != -1 && !(jobtab[curjob].stat & STAT_INUSE))) {
+	curjob = prevjob;
+	setprevjob();
+	if (curjob == thisjob ||
+	    (curjob != -1 && !((jobtab[curjob].stat & STAT_INUSE) &&
+			       curjob != thisjob))) {
+	    curjob = prevjob;
+	    setprevjob();
+	}
+    }
+}
+
+/* Convert a job specifier ("%%", "%1", "%foo", "%?bar?", etc.) *
+ * to a job number.                                             */
+
+/**/
+static int
+getjob(char *s, char *prog)
+{
+    int jobnum, returnval;
+
+    /* if there is no %, treat as a name */
+    if (*s != '%')
+	goto jump;
+    s++;
+    /* "%%", "%+" and "%" all represent the current job */
+    if (*s == '%' || *s == '+' || !*s) {
+	if (curjob == -1) {
+	    zwarnnam(prog, "no current job", NULL, 0);
+	    returnval = -1;
+	    goto done;
+	}
+	returnval = curjob;
+	goto done;
+    }
+    /* "%-" represents the previous job */
+    if (*s == '-') {
+	if (prevjob == -1) {
+	    zwarnnam(prog, "no previous job", NULL, 0);
+	    returnval = -1;
+	    goto done;
+	}
+	returnval = prevjob;
+	goto done;
+    }
+    /* a digit here means we have a job number */
+    if (idigit(*s)) {
+	jobnum = atoi(s);
+	if (jobnum && jobnum < MAXJOB && jobtab[jobnum].stat &&
+	    !(jobtab[jobnum].stat & STAT_SUBJOB) && jobnum != thisjob) {
+	    returnval = jobnum;
+	    goto done;
+	}
+	zwarnnam(prog, "%%%s: no such job", s, 0);
+	returnval = -1;
+	goto done;
+    }
+    /* "%?" introduces a search string */
+    if (*s == '?') {
+	struct process *pn;
+
+	for (jobnum = MAXJOB - 1; jobnum >= 0; jobnum--)
+	    if (jobtab[jobnum].stat && !(jobtab[jobnum].stat & STAT_SUBJOB) &&
+		jobnum != thisjob)
+		for (pn = jobtab[jobnum].procs; pn; pn = pn->next)
+		    if (strstr(pn->text, s + 1)) {
+			returnval = jobnum;
+			goto done;
+		    }
+	zwarnnam(prog, "job not found: %s", s, 0);
+	returnval = -1;
+	goto done;
+    }
+  jump:
+    /* anything else is a job name, specified as a string that begins the
+    job's command */
+    if ((jobnum = findjobnam(s)) != -1) {
+	returnval = jobnum;
+	goto done;
+    }
+    /* if we get here, it is because none of the above succeeded and went
+    to done */
+    zwarnnam(prog, "job not found: %s", s, 0);
+    returnval = -1;
+  done:
+    return returnval;
+}
+
+/* For jobs -Z (which modifies the shell's name as seen in ps listings).  *
+ * hackzero is the start of the safely writable space, and hackspace is   *
+ * its length, excluding a final NUL terminator that will always be left. */
+
+static char *hackzero;
+static int hackspace;
+
+/* Initialise the jobs -Z system.  The technique is borrowed from perl: *
+ * check through the argument and environment space, to see how many of *
+ * the strings are in contiguous space.  This determines the value of   *
+ * hackspace.                                                           */
+
+/**/
+void
+init_hackzero(char **argv, char **envp)
+{
+    char *p, *q;
+
+    hackzero = *argv;
+    p = strchr(hackzero, 0);
+    while(*++argv) {
+	q = *argv;
+	if(q != p+1)
+	    goto done;
+	p = strchr(q, 0);
+    }
+    for(; *envp; envp++) {
+	q = *envp;
+	if(q != p+1)
+	    goto done;
+	p = strchr(q, 0);
+    }
+    done:
+    hackspace = p - hackzero;
+}
+
+/* bg, disown, fg, jobs, wait: most of the job control commands are     *
+ * here.  They all take the same type of argument.  Exception: wait can *
+ * take a pid or a job specifier, whereas the others only work on jobs. */
+
+/**/
+int
+bin_fg(char *name, char **argv, char *ops, int func)
+{
+    int job, lng, firstjob = -1, retval = 0;
+
+    if (ops['Z']) {
+	int len;
+
+	if(isset(RESTRICTED)) {
+	    zwarnnam(name, "-Z is restricted", NULL, 0);
+	    return 1;
+	}
+	if(!argv[0] || argv[1]) {
+	    zwarnnam(name, "-Z requires one argument", NULL, 0);
+	    return 1;
+	}
+	unmetafy(*argv, &len);
+	if(len > hackspace)
+	    len = hackspace;
+	memcpy(hackzero, *argv, len);
+	memset(hackzero + len, 0, hackspace - len);
+	return 0;
+    }
+
+    lng = (ops['l']) ? 1 : (ops['p']) ? 2 : 0;
+    if (ops['d'])
+	lng |= 4;
+    
+    if ((func == BIN_FG || func == BIN_BG) && !jobbing) {
+	/* oops... maybe bg and fg should have been disabled? */
+	zwarnnam(name, "no job control in this shell.", NULL, 0);
+	return 1;
+    }
+
+    /* If necessary, update job table. */
+    if (unset(NOTIFY))
+	scanjobs();
+
+    setcurjob();
+
+    if (func == BIN_JOBS)
+        /* If you immediately type "exit" after "jobs", this      *
+         * will prevent zexit from complaining about stopped jobs */
+	stopmsg = 2;
+    if (!*argv)
+	/* This block handles all of the default cases (no arguments).  bg,
+	fg and disown act on the current job, and jobs and wait act on all the
+	jobs. */
+ 	if (func == BIN_FG || func == BIN_BG || func == BIN_DISOWN) {
+	    /* W.r.t. the above comment, we'd better have a current job at this
+	    point or else. */
+	    if (curjob == -1 || (jobtab[curjob].stat & STAT_NOPRINT)) {
+		zwarnnam(name, "no current job", NULL, 0);
+		return 1;
+	    }
+	    firstjob = curjob;
+	} else if (func == BIN_JOBS) {
+	    /* List jobs. */
+	    for (job = 0; job != MAXJOB; job++)
+		if (job != thisjob && jobtab[job].stat) {
+		    if ((!ops['r'] && !ops['s']) ||
+			(ops['r'] && ops['s']) ||
+			(ops['r'] && !(jobtab[job].stat & STAT_STOPPED)) ||
+			(ops['s'] && jobtab[job].stat & STAT_STOPPED))
+			printjob(job + jobtab, lng, 2);
+		}
+	    return 0;
+	} else {   /* Must be BIN_WAIT, so wait for all jobs */
+	    for (job = 0; job != MAXJOB; job++)
+		if (job != thisjob && jobtab[job].stat)
+		    waitjob(job, SIGINT);
+	    return 0;
+	}
+
+    /* Defaults have been handled.  We now have an argument or two, or three...
+    In the default case for bg, fg and disown, the argument will be provided by
+    the above routine.  We now loop over the arguments. */
+    for (; (firstjob != -1) || *argv; (void)(*argv && argv++)) {
+	int stopped, ocj = thisjob;
+
+	if (func == BIN_WAIT && isanum(*argv)) {
+	    /* wait can take a pid; the others can't. */
+	    waitforpid((long)atoi(*argv));
+	    retval = lastval2;
+	    thisjob = ocj;
+	    continue;
+	}
+	/* The only type of argument allowed now is a job spec.  Check it. */
+	job = (*argv) ? getjob(*argv, name) : firstjob;
+	firstjob = -1;
+	if (job == -1) {
+	    retval = 1;
+	    break;
+	}
+	if (!(jobtab[job].stat & STAT_INUSE) ||
+	    (jobtab[job].stat & STAT_NOPRINT)) {
+	    zwarnnam(name, "no such job: %d", 0, job);
+	    return 1;
+	}
+	/* We have a job number.  Now decide what to do with it. */
+	switch (func) {
+	case BIN_FG:
+	case BIN_BG:
+	case BIN_WAIT:
+	    if (func == BIN_BG)
+		jobtab[job].stat |= STAT_NOSTTY;
+	    if ((stopped = (jobtab[job].stat & STAT_STOPPED)))
+		makerunning(jobtab + job);
+	    else if (func == BIN_BG) {
+		/* Silly to bg a job already running. */
+		zwarnnam(name, "job already in background", NULL, 0);
+		thisjob = ocj;
+		return 1;
+	    }
+	    /* It's time to shuffle the jobs around!  Reset the current job,
+	    and pick a sensible secondary job. */
+	    if (curjob == job) {
+		curjob = prevjob;
+		prevjob = (func == BIN_BG) ? -1 : job;
+	    }
+	    if (prevjob == job || prevjob == -1)
+		setprevjob();
+	    if (curjob == -1) {
+		curjob = prevjob;
+		setprevjob();
+	    }
+	    if (func != BIN_WAIT)
+		/* for bg and fg -- show the job we are operating on */
+		printjob(jobtab + job, (stopped) ? -1 : 0, 1);
+	    if (func != BIN_BG) {		/* fg or wait */
+		if (strcmp(jobtab[job].pwd, pwd)) {
+		    fprintf(shout, "(pwd : ");
+		    fprintdir(jobtab[job].pwd, shout);
+		    fprintf(shout, ")\n");
+		}
+		fflush(shout);
+		if (func != BIN_WAIT) {		/* fg */
+		    thisjob = job;
+		    attachtty(jobtab[job].gleader);
+		}
+	    }
+	    if (stopped) {
+		if (func != BIN_BG && jobtab[job].ty)
+		    settyinfo(jobtab[job].ty);
+		killjb(jobtab + job, SIGCONT);
+	    }
+	    if (func == BIN_WAIT)
+	        waitjob(job, SIGINT);
+	    if (func != BIN_BG) {
+		waitjobs();
+		retval = lastval2;
+	    }
+	    break;
+	case BIN_JOBS:
+	    printjob(job + jobtab, lng, 2);
+	    break;
+	case BIN_DISOWN:
+	    deletejob(jobtab + job);
+	    break;
+	}
+	thisjob = ocj;
+    }
+    return retval;
+}
+
+/* kill: send a signal to a process.  The process(es) may be specified *
+ * by job specifier (see above) or pid.  A signal, defaulting to       *
+ * SIGTERM, may be specified by name or number, preceded by a dash.    */
+
+/**/
+int
+bin_kill(char *nam, char **argv, char *ops, int func)
+{
+    int sig = SIGTERM;
+    int returnval = 0;
+
+    /* check for, and interpret, a signal specifier */
+    if (*argv && **argv == '-') {
+	if (idigit((*argv)[1]))
+	    /* signal specified by number */
+	    sig = atoi(*argv + 1);
+	else if ((*argv)[1] != '-' || (*argv)[2]) {
+	    char *signame;
+
+	    /* with argument "-l" display the list of signal names */
+	    if ((*argv)[1] == 'l' && (*argv)[2] == '\0') {
+		if (argv[1]) {
+		    while (*++argv) {
+			sig = zstrtol(*argv, &signame, 10);
+			if (signame == *argv) {
+			    for (sig = 1; sig <= SIGCOUNT; sig++)
+				if (!cstrpcmp(sigs + sig, &signame))
+				    break;
+			    if (sig > SIGCOUNT) {
+				zwarnnam(nam, "unknown signal: SIG%s",
+					 signame, 0);
+				returnval++;
+			    } else
+				printf("%d\n", sig);
+			} else {
+			    if (*signame) {
+				zwarnnam(nam, "unknown signal: SIG%s",
+					 signame, 0);
+				returnval++;
+			    } else {
+				if (WIFSIGNALED(sig))
+				    sig = WTERMSIG(sig);
+				else if (WIFSTOPPED(sig))
+				    sig = WSTOPSIG(sig);
+				if (1 <= sig && sig <= SIGCOUNT)
+				    printf("%s\n", sigs[sig]);
+				else
+				    printf("%d\n", sig);
+			    }
+			}
+		    }
+		    return returnval;
+		}
+		printf("%s", sigs[1]);
+		for (sig = 2; sig <= SIGCOUNT; sig++)
+		    printf(" %s", sigs[sig]);
+		putchar('\n');
+		return 0;
+	    }
+	    if ((*argv)[1] == 's' && (*argv)[2] == '\0')
+		signame = *++argv;
+	    else
+		signame = *argv + 1;
+
+	    /* check for signal matching specified name */
+	    for (sig = 1; sig <= SIGCOUNT; sig++)
+		if (!cstrpcmp(sigs + sig, &signame))
+		    break;
+	    if (*signame == '0' && !signame[1])
+		sig = 0;
+	    if (sig > SIGCOUNT) {
+		zwarnnam(nam, "unknown signal: SIG%s", signame, 0);
+		zwarnnam(nam, "type kill -l for a List of signals", NULL, 0);
+		return 1;
+	    }
+	}
+	argv++;
+    }
+
+    setcurjob();
+
+    /* Remaining arguments specify processes.  Loop over them, and send the
+    signal (number sig) to each process. */
+    for (; *argv; argv++) {
+	if (**argv == '%') {
+	    /* job specifier introduced by '%' */
+	    int p;
+
+	    if ((p = getjob(*argv, nam)) == -1) {
+		returnval++;
+		continue;
+	    }
+	    if (killjb(jobtab + p, sig) == -1) {
+		zwarnnam("kill", "kill %s failed: %e", *argv, errno);
+		returnval++;
+		continue;
+	    }
+	    /* automatically update the job table if sending a SIGCONT to a
+	    job, and send the job a SIGCONT if sending it a non-stopping
+	    signal. */
+	    if (jobtab[p].stat & STAT_STOPPED) {
+		if (sig == SIGCONT)
+		    jobtab[p].stat &= ~STAT_STOPPED;
+		if (sig != SIGKILL && sig != SIGCONT && sig != SIGTSTP
+		    && sig != SIGTTOU && sig != SIGTTIN && sig != SIGSTOP)
+		    killjb(jobtab + p, SIGCONT);
+	    }
+	} else if (!isanum(*argv)) {
+	    zwarnnam("kill", "illegal pid: %s", *argv, 0);
+	    returnval++;
+	} else if (kill(atoi(*argv), sig) == -1) {
+	    zwarnnam("kill", "kill %s failed: %e", *argv, errno);
+	    returnval++;
+	}
+    }
+    return returnval < 126 ? returnval : 1;
+}
+
+/* Suspend this shell */
+
+/**/
+int
+bin_suspend(char *name, char **argv, char *ops, int func)
+{
+    /* won't suspend a login shell, unless forced */
+    if (islogin && !ops['f']) {
+	zwarnnam(name, "can't suspend login shell", NULL, 0);
+	return 1;
+    }
+    if (jobbing) {
+	/* stop ignoring signals */
+	signal_default(SIGTTIN);
+	signal_default(SIGTSTP);
+	signal_default(SIGTTOU);
+    }
+    /* suspend ourselves with a SIGTSTP */
+    kill(0, SIGTSTP);
+    if (jobbing) {
+	/* stay suspended */
+	while (gettygrp() != mypgrp) {
+	    sleep(1);
+	    if (gettygrp() != mypgrp)
+		kill(0, SIGTTIN);
+	}
+	/* restore signal handling */
+	signal_ignore(SIGTTOU);
+	signal_ignore(SIGTSTP);
+	signal_ignore(SIGTTIN);
+    }
+    return 0;
+}
+
+/* find a job named s */
+
+/**/
+int
+findjobnam(char *s)
+{
+    int jobnum;
+
+    for (jobnum = MAXJOB - 1; jobnum >= 0; jobnum--)
+	if (!(jobtab[jobnum].stat & (STAT_SUBJOB | STAT_NOPRINT)) &&
+	    jobtab[jobnum].stat && jobtab[jobnum].procs && jobnum != thisjob &&
+	    jobtab[jobnum].procs->text && strpfx(s, jobtab[jobnum].procs->text))
+	    return jobnum;
+    return -1;
+}
diff --git a/Src/lex.c b/Src/lex.c
new file mode 100644
index 000000000..6f4f2dd20
--- /dev/null
+++ b/Src/lex.c
@@ -0,0 +1,1489 @@
+/*
+ * lex.c - lexical analysis
+ *
+ * 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 "lex.pro"
+
+/* tokens */
+
+/**/
+char ztokens[] = "#$^*()$=|{}[]`<>?~`,'\"\\";
+
+/* parts of the current token */
+
+/**/
+char *yytext, *tokstr;
+/**/
+int tok, tokfd;
+
+/* lexical analyzer error flag */
+ 
+/**/
+int lexstop;
+
+/* if != 0, this is the first line of the command */
+ 
+/**/
+int isfirstln;
+ 
+/* if != 0, this is the first char of the command (not including white space) */
+ 
+/**/
+int isfirstch;
+
+/* flag that an alias should be expanded after expansion ending in space */
+
+/**/
+int inalmore;
+
+/* don't do spelling correction */
+ 
+/**/
+int nocorrect;
+
+/* the line buffer */
+
+/**/
+unsigned char *line;
+
+/* cursor position and line length */
+
+/**/
+int cs, ll;
+
+/* inwhat says what exactly we are in     *
+ * (its value is one of the IN_* things). */
+
+/**/
+int inwhat;
+
+/* 1 if x added to complete in a blank between words */
+
+/**/
+int addedx;
+
+/* 1 if aliases should not be expanded */
+ 
+/**/
+int noaliases;
+
+/* we are parsing a line sent to use by the editor */
+ 
+/**/
+int zleparse;
+ 
+/**/
+int wordbeg;
+ 
+/**/
+int parbegin;
+
+/**/
+int parend;
+ 
+/* text of puctuation tokens */
+
+static char *tokstrings[WHILE + 1] = {
+    NULL,	/* NULLTOK	  0  */
+    ";",	/* SEPER	     */
+    "\\n",	/* NEWLIN	     */
+    ";",	/* SEMI		     */
+    ";;",	/* DSEMI	     */
+    "&",	/* AMPER	  5  */
+    "(",	/* INPAR	     */
+    ")",	/* OUTPAR	     */
+    "||",	/* DBAR		     */
+    "&&",	/* DAMPER	     */
+    ")",	/* OUTANG	  10 */
+    ">|",	/* OUTANGBANG	     */
+    ">>",	/* DOUTANG	     */
+    ">>|",	/* DOUTANGBANG	     */
+    "<",	/* INANG	     */
+    "<>",	/* INOUTANG	  15 */
+    "<<",	/* DINANG	     */
+    "<<-",	/* DINANGDASH	     */
+    "<&",	/* INANGAMP	     */
+    ">&",	/* OUTANGAMP	     */
+    "&>",	/* AMPOUTANG	  20 */
+    "&>|",	/* OUTANGAMPBANG     */
+    ">>&",	/* DOUTANGAMP	     */
+    ">>&|",	/* DOUTANGAMPBANG    */
+    "<<<",	/* TRINANG	     */
+    "|",	/* BAR		  25 */
+    "|&",	/* BARAMP	     */
+    "()",	/* INOUTPAR	     */
+    "((",	/* DINPAR	     */
+    "))",	/* DOUTPAR	     */
+    "&|",	/* AMPERBANG	  30 */
+    ";&",	/* SEMIAMP	     */
+};
+
+/* lexical state */
+
+static int dbparens;
+static int len = 0, bsiz = 256;
+static char *bptr;
+
+struct lexstack {
+    struct lexstack *next;
+
+    int incmdpos;
+    int incond;
+    int incasepat;
+    int dbparens;
+    int isfirstln;
+    int isfirstch;
+    int histactive;
+    int histdone;
+    int spaceflag;
+    int stophist;
+    int hlinesz;
+    char *hline;
+    char *hptr;
+    int tok;
+    int isnewlin;
+    char *tokstr;
+    char *yytext;
+    char *bptr;
+    int bsiz;
+    short *chwords;
+    int chwordlen;
+    int chwordpos;
+    int hwgetword;
+    int lexstop;
+    struct heredocs *hdocs;
+
+    unsigned char *cstack;
+    int csp;
+};
+
+static struct lexstack *lstack = NULL;
+
+/* save the lexical state */
+
+/* is this a hack or what? */
+
+/**/
+void
+lexsave(void)
+{
+    struct lexstack *ls;
+
+    ls = (struct lexstack *)malloc(sizeof(struct lexstack));
+
+    ls->incmdpos = incmdpos;
+    ls->incond = incond;
+    ls->incasepat = incasepat;
+    ls->dbparens = dbparens;
+    ls->isfirstln = isfirstln;
+    ls->isfirstch = isfirstch;
+    ls->histactive = histactive;
+    ls->histdone = histdone;
+    ls->spaceflag = spaceflag;
+    ls->stophist = stophist;
+    ls->hline = chline;
+    ls->hptr = hptr;
+    ls->hlinesz = hlinesz;
+    ls->cstack = cmdstack;
+    ls->csp = cmdsp;
+    cmdstack = (unsigned char *)zalloc(256);
+    ls->tok = tok;
+    ls->isnewlin = isnewlin;
+    ls->tokstr = tokstr;
+    ls->yytext = yytext;
+    ls->bptr = bptr;
+    ls->bsiz = bsiz;
+    ls->chwords = chwords;
+    ls->chwordlen = chwordlen;
+    ls->chwordpos = chwordpos;
+    ls->hwgetword = hwgetword;
+    ls->lexstop = lexstop;
+    ls->hdocs = hdocs;
+    cmdsp = 0;
+    inredir = 0;
+    hdocs = NULL;
+
+    ls->next = lstack;
+    lstack = ls;
+}
+
+/* restore lexical state */
+
+/**/
+void
+lexrestore(void)
+{
+    struct lexstack *ln;
+
+    DPUTS(!lstack, "BUG: lexrestore() without lexsave()");
+    incmdpos = lstack->incmdpos;
+    incond = lstack->incond;
+    incasepat = lstack->incasepat;
+    dbparens = lstack->dbparens;
+    isfirstln = lstack->isfirstln;
+    isfirstch = lstack->isfirstch;
+    histactive = lstack->histactive;
+    histdone = lstack->histdone;
+    spaceflag = lstack->spaceflag;
+    stophist = lstack->stophist;
+    chline = lstack->hline;
+    hptr = lstack->hptr;
+    if (cmdstack)
+	free(cmdstack);
+    cmdstack = lstack->cstack;
+    cmdsp = lstack->csp;
+    tok = lstack->tok;
+    isnewlin = lstack->isnewlin;
+    tokstr = lstack->tokstr;
+    yytext = lstack->yytext;
+    bptr = lstack->bptr;
+    bsiz = lstack->bsiz;
+    chwords = lstack->chwords;
+    chwordlen = lstack->chwordlen;
+    chwordpos = lstack->chwordpos;
+    hwgetword = lstack->hwgetword;
+    lexstop = lstack->lexstop;
+    hdocs = lstack->hdocs;
+    hlinesz = lstack->hlinesz;
+    errflag = 0;
+
+    ln = lstack->next;
+    free(lstack);
+    lstack = ln;
+}
+
+/**/
+void
+yylex(void)
+{
+    if (tok == LEXERR)
+	return;
+    do
+	tok = gettok();
+    while (tok != ENDINPUT && exalias());
+    if (tok == NEWLIN || tok == ENDINPUT) {
+	while (hdocs) {
+	    struct heredocs *next = hdocs->next;
+
+	    hwbegin(0);
+	    cmdpush(hdocs->rd->type == HEREDOC ? CS_HEREDOC : CS_HEREDOCD);
+	    STOPHIST
+	    hdocs->rd->name = gethere(hdocs->rd->name, hdocs->rd->type);
+	    ALLOWHIST
+	    cmdpop();
+	    hwend();
+	    hdocs->rd->type = HERESTR;
+	    zfree(hdocs, sizeof(struct heredocs));
+	    hdocs = next;
+	}
+    }
+    if (tok != NEWLIN)
+	isnewlin = 0;
+    else
+	isnewlin = (inbufct) ? -1 : 1;
+    if (tok == SEMI || tok == NEWLIN)
+	tok = SEPER;
+}
+
+/**/
+void
+ctxtlex(void)
+{
+    static int oldpos;
+
+    yylex();
+    switch (tok) {
+    case SEPER:
+    case NEWLIN:
+    case SEMI:
+    case DSEMI:
+    case SEMIAMP:
+    case AMPER:
+    case AMPERBANG:
+    case INPAR:
+    case INBRACE:
+    case DBAR:
+    case DAMPER:
+    case BAR:
+    case BARAMP:
+    case INOUTPAR:
+    case DO:
+    case THEN:
+    case ELIF:
+    case ELSE:
+    case DOUTBRACK:
+	incmdpos = 1;
+	break;
+    case STRING:
+ /* case ENVSTRING: */
+    case ENVARRAY:
+    case OUTPAR:
+    case CASE:
+    case DINBRACK:
+	incmdpos = 0;
+	break;
+    }
+    if (tok != DINPAR)
+	infor = tok == FOR ? 2 : 0;
+    if (IS_REDIROP(tok) || tok == FOR || tok == FOREACH || tok == SELECT) {
+	inredir = 1;
+	oldpos = incmdpos;
+	incmdpos = 0;
+    } else if (inredir) {
+	incmdpos = oldpos;
+	inredir = 0;
+    }
+}
+
+#define LX1_BKSLASH 0
+#define LX1_COMMENT 1
+#define LX1_NEWLIN 2
+#define LX1_SEMI 3
+#define LX1_AMPER 5
+#define LX1_BAR 6
+#define LX1_INPAR 7
+#define LX1_OUTPAR 8
+#define LX1_INANG 13
+#define LX1_OUTANG 14
+#define LX1_OTHER 15
+
+#define LX2_BREAK 0
+#define LX2_OUTPAR 1
+#define LX2_BAR 2
+#define LX2_STRING 3
+#define LX2_INBRACK 4
+#define LX2_OUTBRACK 5
+#define LX2_TILDE 6
+#define LX2_INPAR 7
+#define LX2_INBRACE 8
+#define LX2_OUTBRACE 9
+#define LX2_OUTANG 10
+#define LX2_INANG 11
+#define LX2_EQUALS 12
+#define LX2_BKSLASH 13
+#define LX2_QUOTE 14
+#define LX2_DQUOTE 15
+#define LX2_BQUOTE 16
+#define LX2_COMMA 17
+#define LX2_OTHER 18
+#define LX2_META 19
+
+static unsigned char lexact1[256], lexact2[256], lextok2[256];
+
+/**/
+void
+initlextabs(void)
+{
+    int t0;
+    static char *lx1 = "\\q\n;!&|(){}[]<>";
+    static char *lx2 = ";)|$[]~({}><=\\\'\"`,";
+
+    for (t0 = 0; t0 != 256; t0++) {
+	lexact1[t0] = LX1_OTHER;
+	lexact2[t0] = LX2_OTHER;
+	lextok2[t0] = t0;
+    }
+    for (t0 = 0; lx1[t0]; t0++)
+	lexact1[(int)lx1[t0]] = t0;
+    for (t0 = 0; lx2[t0]; t0++)
+	lexact2[(int)lx2[t0]] = t0;
+    lexact2['&'] = LX2_BREAK;
+    lexact2[STOUC(Meta)] = LX2_META;
+    lextok2['*'] = Star;
+    lextok2['?'] = Quest;
+    lextok2['{'] = Inbrace;
+    lextok2['['] = Inbrack;
+    lextok2['$'] = String;
+    lextok2['~'] = Tilde;
+    lextok2['#'] = Pound;
+    lextok2['^'] = Hat;
+}
+
+/* initialize lexical state */
+
+/**/
+void
+lexinit(void)
+{
+    incond = incasepat = nocorrect =
+    infor = dbparens = lexstop = 0;
+    incmdpos = 1;
+    tok = ENDINPUT;
+}
+
+/* add a char to the string buffer */
+
+/**/
+void
+add(int c)
+{
+    *bptr++ = c;
+    if (bsiz == ++len) {
+	int newbsiz;
+
+	newbsiz = bsiz * 8;
+	while (newbsiz < inbufct)
+	    newbsiz *= 2;
+	bptr = len + (tokstr = (char *)hrealloc(tokstr, bsiz, newbsiz));
+	bsiz = newbsiz;
+    }
+}
+
+#define SETPARBEGIN {if (zleparse && !(inbufflags & INP_ALIAS) && cs >= ll+1-inbufct) parbegin = inbufct;}
+#define SETPAREND {\
+	    if (zleparse && !(inbufflags & INP_ALIAS) && parbegin != -1 && parend == -1)\
+		if (cs >= ll + 1 - inbufct)\
+		    parbegin = -1;\
+		else\
+		    parend = inbufct;}
+
+static int
+cmd_or_math(int cs_type)
+{
+    int oldlen = len;
+    int c;
+
+    cmdpush(cs_type);
+    c = dquote_parse(')', 0);
+    cmdpop();
+    *bptr = '\0';
+    if (!c) {
+	c = hgetc();
+	if (c == ')')
+	    return 1;
+	hungetc(c);
+	lexstop = 0;
+	c = ')';
+    }
+    hungetc(c);
+    lexstop = 0;
+    while (len > oldlen) {
+	len--;
+	hungetc(itok(*--bptr) ? ztokens[*bptr - Pound] : *bptr);
+    }
+    hungetc('(');
+    return 0;
+}
+
+static int
+cmd_or_math_sub(void)
+{
+    int c = hgetc();
+
+    if (c == '(') {
+	add(Inpar);
+	add('(');
+	if (cmd_or_math(CS_MATHSUBST)) {
+	    add(')');
+	    return 0;
+	}
+	bptr -= 2;
+	len -= 2;
+    } else {
+	hungetc(c);
+	lexstop = 0;
+    }
+    return skipcomm();
+}
+
+/**/
+int
+gettok(void)
+{
+    int c, d;
+    int peekfd = -1, peek;
+
+    MUSTUSEHEAP("gettok");
+  beginning:
+    tokstr = NULL;
+    while (iblank(c = hgetc()) && !lexstop);
+    if (lexstop)
+	return (errflag) ? LEXERR : ENDINPUT;
+    isfirstln = 0;
+    wordbeg = inbufct - (qbang && c == bangchar);
+    hwbegin(-1-(qbang && c == bangchar));
+    /* word includes the last character read and possibly \ before ! */
+    if (dbparens) {
+	len = 0;
+	bptr = tokstr = (char *)ncalloc(bsiz = 256);
+	hungetc(c);
+	cmdpush(CS_MATH);
+	c = dquote_parse(infor ? ';' : ')', 0);
+	cmdpop();
+	*bptr = '\0';
+	if (!c && infor) {
+	    infor--;
+	    return DINPAR;
+	}
+	if (c || (c = hgetc()) != ')') {
+	    hungetc(c);
+	    return LEXERR;
+	}
+	dbparens = 0;
+	return DOUTPAR;
+    } else if (idigit(c)) {	/* handle 1< foo */
+	d = hgetc();
+	if (d == '>' || d == '<') {
+	    peekfd = c - '0';
+	    c = d;
+	} else {
+	    hungetc(d);
+	    lexstop = 0;
+	}
+    }
+
+    /* chars in initial position in word */
+
+    if (c == hashchar &&
+	(isset(INTERACTIVECOMMENTS) ||
+	 (!zleparse && !expanding &&
+	  (!interact || unset(SHINSTDIN) || strin)))) {
+	/* History is handled here to prevent extra  *
+	 * newlines being inserted into the history. */
+
+	while ((c = ingetc()) != '\n' && !lexstop) {
+	    hwaddc(c);
+	    addtoline(c);
+	}
+
+	if (errflag)
+	    peek = LEXERR;
+	else {
+	    hwend();
+	    hwbegin(0);
+	    hwaddc('\n');
+	    addtoline('\n');
+	    peek = NEWLIN;
+	}
+	return peek;
+    }
+    switch (lexact1[STOUC(c)]) {
+    case LX1_BKSLASH:
+	d = hgetc();
+	if (d == '\n')
+	    goto beginning;
+	hungetc(d);
+	lexstop = 0;
+	break;
+    case LX1_NEWLIN:
+	return NEWLIN;
+    case LX1_SEMI:
+	d = hgetc();
+	if(d == ';')
+	    return DSEMI;
+	else if(d == '&')
+	    return SEMIAMP;
+	hungetc(d);
+	lexstop = 0;
+	return SEMI;
+    case LX1_AMPER:
+	d = hgetc();
+	if (d == '&')
+	    return DAMPER;
+	else if (d == '!' || d == '|')
+	    return AMPERBANG;
+	else if (d == '>') {
+	    d = hgetc();
+	    if (d == '!' || d == '|')
+		return OUTANGAMPBANG;
+	    else if (d == '>') {
+		d = hgetc();
+		if (d == '!' || d == '|')
+		    return DOUTANGAMPBANG;
+		hungetc(d);
+		lexstop = 0;
+		return DOUTANGAMP;
+	    }
+	    hungetc(d);
+	    lexstop = 0;
+	    return AMPOUTANG;
+	}
+	hungetc(d);
+	lexstop = 0;
+	return AMPER;
+    case LX1_BAR:
+	d = hgetc();
+	if (d == '|')
+	    return DBAR;
+	else if (d == '&')
+	    return BARAMP;
+	hungetc(d);
+	lexstop = 0;
+	return BAR;
+    case LX1_INPAR:
+	d = hgetc();
+	if (d == '(') {
+	    if (infor) {
+		dbparens = 1;
+		return DINPAR;
+	    }
+	    if (incmdpos) {
+		len = 0;
+		bptr = tokstr = (char *)ncalloc(bsiz = 256);
+		return cmd_or_math(CS_MATH) ? DINPAR : INPAR;
+	    }
+	} else if (d == ')')
+	    return INOUTPAR;
+	hungetc(d);
+	lexstop = 0;
+	if (!(incond == 1 || incmdpos))
+	    break;
+	return INPAR;
+    case LX1_OUTPAR:
+	return OUTPAR;
+    case LX1_INANG:
+	d = hgetc();
+	if (!incmdpos && d == '(') {
+	    hungetc(d);
+	    lexstop = 0;
+	    break;
+	}
+	if (d == '>')
+	    peek = INOUTANG;
+	else if (idigit(d) || d == '-') {
+	    int tbs = 256, n = 0, nc;
+	    char *tbuf, *tbp, *ntb;
+
+	    tbuf = tbp = (char *)zalloc(tbs);
+	    hungetc(d);
+
+	    while ((nc = hgetc()) && !lexstop) {
+		if (!idigit(nc) && nc != '-')
+		    break;
+		*tbp++ = (char)nc;
+		if (++n == tbs) {
+		    ntb = (char *)realloc(tbuf, tbs *= 2);
+		    tbp += ntb - tbuf;
+		    tbuf = ntb;
+		}
+	    }
+	    if (nc == '>' && !lexstop) {
+		hungetc(nc);
+		while (n--)
+		    hungetc(*--tbp);
+		zfree(tbuf, tbs);
+		break;
+	    }
+	    if (nc && !lexstop)
+		hungetc(nc);
+	    lexstop = 0;
+	    while (n--)
+		hungetc(*--tbp);
+	    zfree(tbuf, tbs);
+	    peek = INANG;
+	} else if (d == '<') {
+	    int e = hgetc();
+
+	    if (e == '(') {
+		hungetc(e);
+		hungetc(d);
+		peek = INANG;
+	    } else if (e == '<')
+		peek = TRINANG;
+	    else if (e == '-')
+		peek = DINANGDASH;
+	    else {
+		hungetc(e);
+		lexstop = 0;
+		peek = DINANG;
+	    }
+	} else if (d == '&')
+	    peek = INANGAMP;
+	else {
+	    peek = INANG;
+	    hungetc(d);
+	    lexstop = 0;
+	}
+	tokfd = peekfd;
+	return peek;
+    case LX1_OUTANG:
+	d = hgetc();
+	if (d == '(') {
+	    hungetc(d);
+	    break;
+	} else if (d == '&') {
+	    d = hgetc();
+	    if (d == '!' || d == '|')
+		peek = OUTANGAMPBANG;
+	    else {
+		hungetc(d);
+		lexstop = 0;
+		peek = OUTANGAMP;
+	    }
+	} else if (d == '!' || d == '|')
+	    peek = OUTANGBANG;
+	else if (d == '>') {
+	    d = hgetc();
+	    if (d == '&') {
+		d = hgetc();
+		if (d == '!' || d == '|')
+		    peek = DOUTANGAMPBANG;
+		else {
+		    hungetc(d);
+		    lexstop = 0;
+		    peek = DOUTANGAMP;
+		}
+	    } else if (d == '!' || d == '|')
+		peek = DOUTANGBANG;
+	    else if (d == '(') {
+		hungetc(d);
+		hungetc('>');
+		peek = OUTANG;
+	    } else {
+		hungetc(d);
+		lexstop = 0;
+		peek = DOUTANG;
+		if (isset(HISTALLOWCLOBBER))
+		    hwaddc('|');
+	    }
+	} else {
+	    hungetc(d);
+	    lexstop = 0;
+	    peek = OUTANG;
+	    if (!incond && isset(HISTALLOWCLOBBER))
+		hwaddc('|');
+	}
+	tokfd = peekfd;
+	return peek;
+    }
+
+    /* we've started a string, now get the *
+     * rest of it, performing tokenization */
+    return gettokstr(c, 0);
+}
+
+/**/
+static int
+gettokstr(int c, int sub)
+{
+    int bct = 0, pct = 0, brct = 0;
+    int intpos = 1, in_brace_param = 0;
+    int peek, inquote;
+#ifdef DEBUG
+    int ocmdsp = cmdsp;
+#endif
+
+    peek = STRING;
+    if (!sub) {
+	len = 0;
+	bptr = tokstr = (char *)ncalloc(bsiz = 256);
+    }
+    for (;;) {
+	int act;
+	int e;
+
+	if (inblank(c) && !in_brace_param && !pct)
+	    act = LX2_BREAK;
+	else {
+	    act = lexact2[STOUC(c)];
+	    c = lextok2[STOUC(c)];
+	}
+	switch (act) {
+	case LX2_BREAK:
+	    if (!in_brace_param && !sub)
+		goto brk;
+	    break;
+	case LX2_META:
+	    c = hgetc();
+#ifdef DEBUG
+	    if (lexstop) {
+		fputs("BUG: input terminated by Meta\n", stderr);
+		fflush(stderr);
+		goto brk;
+	    }
+#endif
+	    add(Meta);
+	    break;
+	case LX2_OUTPAR:
+	    if ((sub || in_brace_param) && isset(SHGLOB))
+		break;
+	    if (!in_brace_param && !pct--)
+		if (sub) {
+		    pct = 0;
+		    break;
+		} else
+		    goto brk;
+	    c = Outpar;
+	    break;
+	case LX2_BAR:
+	    if (!pct && !in_brace_param)
+		if (sub)
+		    break;
+		else
+		    goto brk;
+	    if (unset(SHGLOB) || (!sub && !in_brace_param))
+		c = Bar;
+	    break;
+	case LX2_STRING:
+	    e = hgetc();
+	    if (e == '[') {
+		cmdpush(CS_MATHSUBST);
+		add(String);
+		add(Inbrack);
+		c = dquote_parse(']', sub);
+		cmdpop();
+		if (c) {
+		    peek = LEXERR;
+		    goto brk;
+		}
+		c = Outbrack;
+	    } else if (e == '(') {
+		add(String);
+		c = cmd_or_math_sub();
+		if (c) {
+		    peek = LEXERR;
+		    goto brk;
+		}
+		c = Outpar;
+	    } else {
+		if (e == '{') {
+		    add(c);
+		    c = Inbrace;
+		    ++bct;
+		    cmdpush(CS_BRACEPAR);
+		    if (!in_brace_param)
+			in_brace_param = bct;
+		} else {
+		    hungetc(e);
+		    lexstop = 0;
+		}
+	    }
+	    break;
+	case LX2_INBRACK:
+	    if (!in_brace_param)
+		brct++;
+	    c = Inbrack;
+	    break;
+	case LX2_OUTBRACK:
+	    if (!in_brace_param)
+		brct--;
+	    if (brct < 0)
+		brct = 0;
+	    c = Outbrack;
+	    break;
+	case LX2_INPAR:
+	    if ((sub || in_brace_param) && isset(SHGLOB))
+		break;
+	    if (!in_brace_param) {
+		if (!sub) {
+		    e = hgetc();
+		    hungetc(e);
+		    lexstop = 0;
+		    if (e == ')' ||
+			(incmdpos && !brct && peek != ENVSTRING))
+			goto brk;
+		}
+		pct++;
+	    }
+	    c = Inpar;
+	    break;
+	case LX2_INBRACE:
+	    if (isset(IGNOREBRACES) || sub)
+		c = '{';
+	    else {
+		if (!len && incmdpos) {
+		    add('{');
+		    *bptr = '\0';
+		    return STRING;
+		}
+		if (in_brace_param)
+		    cmdpush(CS_BRACE);
+		bct++;
+	    }
+	    break;
+	case LX2_OUTBRACE:
+	    if ((isset(IGNOREBRACES) || sub) && !in_brace_param)
+		break;
+	    if (!bct)
+		break;
+	    if (in_brace_param)
+		cmdpop();
+	    if (bct-- == in_brace_param)
+		in_brace_param = 0;
+	    c = Outbrace;
+	    break;
+	case LX2_COMMA:
+	    if (unset(IGNOREBRACES) && !sub && bct > in_brace_param)
+		c = Comma;
+	    break;
+	case LX2_OUTANG:
+	    if (!intpos)
+		if (in_brace_param || sub)
+		    break;
+		else
+		    goto brk;
+	    e = hgetc();
+	    if (e != '(') {
+		hungetc(e);
+		lexstop = 0;
+		goto brk;
+	    }
+	    add(Outang);
+	    if (skipcomm()) {
+		peek = LEXERR;
+		goto brk;
+	    }
+	    c = Outpar;
+	    break;
+	case LX2_INANG:
+	    if (isset(SHGLOB) && sub)
+		break;
+	    e = hgetc();
+	    if (!(idigit(e) || e == '-' || (e == '(' && intpos))) {
+		hungetc(e);
+		lexstop = 0;
+		if (in_brace_param || sub)
+		    break;
+		goto brk;
+	    }
+	    c = Inang;
+	    if (e == '(') {
+		add(c);
+		if (skipcomm()) {
+		    peek = LEXERR;
+		    goto brk;
+		}
+		c = Outpar;
+	    } else {
+		add(c);
+		c = e;
+		while (c != '>' && !lexstop)
+		    add(c), c = hgetc();
+		c = Outang;
+	    }
+	    break;
+	case LX2_EQUALS:
+	    if (intpos) {
+		e = hgetc();
+		if (e != '(') {
+		    hungetc(e);
+		    lexstop = 0;
+		    c = Equals;
+		} else {
+		    add(Equals);
+		    if (skipcomm()) {
+			peek = LEXERR;
+			goto brk;
+		    }
+		    c = Outpar;
+		}
+	    } else if (!sub && peek != ENVSTRING &&
+		       incmdpos && !bct && !brct) {
+		char *t = tokstr;
+		if (idigit(*t))
+		    while (++t < bptr && idigit(*t));
+		else {
+		    while (iident(*t) && ++t < bptr);
+		    if (t < bptr) {
+			*bptr = '\0';
+			skipparens(Inbrack, Outbrack, &t);
+		    }
+		}
+		if (t == bptr) {
+		    e = hgetc();
+		    if (e == '(' && incmdpos) {
+			*bptr = '\0';
+			return ENVARRAY;
+		    }
+		    hungetc(e);
+		    lexstop = 0;
+		    peek = ENVSTRING;
+		    intpos = 2;
+		} else
+		    c = Equals;
+	    } else
+		c = Equals;
+	    break;
+	case LX2_BKSLASH:
+	    c = hgetc();
+	    if (c == '\n') {
+		c = hgetc();
+		if (!lexstop)
+		    continue;
+	    } else
+		add(Bnull);
+	    if (lexstop)
+		goto brk;
+	    break;
+	case LX2_QUOTE: {
+	    int strquote = (len && bptr[-1] == String);
+
+	    add(Snull);
+	    cmdpush(CS_QUOTE);
+	    for (;;) {
+		STOPHIST
+		while ((c = hgetc()) != '\'' && !lexstop) {
+		    if (strquote && c == '\\') {
+			add(c);
+			c = hgetc();
+			if (lexstop)
+			    break;
+		    } else if (!sub && isset(CSHJUNKIEQUOTES) && c == '\n') {
+			if (bptr[-1] == '\\')
+			    bptr--, len--;
+			else
+			    break;
+		    }
+		    add(c);
+		}
+		ALLOWHIST
+		if (c != '\'') {
+		    zerr("unmatched \'", NULL, 0);
+		    peek = LEXERR;
+		    cmdpop();
+		    goto brk;
+		}
+		e = hgetc();
+		if (e != '\'' || unset(RCQUOTES))
+		    break;
+		add(c);
+	    }
+	    cmdpop();
+	    hungetc(e);
+	    lexstop = 0;
+	    c = Snull;
+	    break;
+	}
+	case LX2_DQUOTE:
+	    add(Dnull);
+	    cmdpush(CS_DQUOTE);
+	    c = dquote_parse('"', sub);
+	    cmdpop();
+	    if (c) {
+		zerr("unmatched \"", NULL, 0);
+		peek = LEXERR;
+		goto brk;
+	    }
+	    c = Dnull;
+	    break;
+	case LX2_BQUOTE:
+	    add(Tick);
+	    cmdpush(CS_BQUOTE);
+	    SETPARBEGIN
+	    inquote = 0;
+	    while ((c = hgetc()) != '`' && !lexstop)
+		if (c == '\\') {
+		    c = hgetc();
+		    if (c != '\n') {
+			add(c == '`' || c == '\\' || c == '$' ? Bnull : '\\');
+			add(c);
+		    }
+		    else if (!sub && isset(CSHJUNKIEQUOTES))
+			add(c);
+		} else {
+		    if (!sub && isset(CSHJUNKIEQUOTES) && c == '\n') {
+			break;
+		    }
+		    add(c);
+		    if (c == '\'')
+			if ((inquote = !inquote))
+			    STOPHIST
+			else
+			    ALLOWHIST
+		}
+	    if (inquote)
+		ALLOWHIST
+	    cmdpop();
+	    if (c != '`') {
+		zerr("unmatched `", NULL, 0);
+		peek = LEXERR;
+		goto brk;
+	    }
+	    c = Tick;
+	    SETPAREND
+	    break;
+	}
+	add(c);
+	c = hgetc();
+	if (intpos)
+	    intpos--;
+	if (lexstop)
+	    break;
+    }
+  brk:
+    hungetc(c);
+    if (in_brace_param) {
+	while(bct-- >= in_brace_param)
+	    cmdpop();
+	zerr("closing brace expected", NULL, 0);
+    } else if (unset(IGNOREBRACES) && !sub && len > 1 &&
+	       peek == STRING && bptr[-1] == '}' && bptr[-2] != Bnull) {
+	/* hack to get {foo} command syntax work */
+	bptr--;
+	len--;
+	lexstop = 0;
+	hungetc('}');
+    }
+    *bptr = '\0';
+    DPUTS(cmdsp != ocmdsp, "BUG: gettok: cmdstack changed.");
+    return peek;
+}
+
+/**/
+static int
+dquote_parse(char endchar, int sub)
+{
+    int pct = 0, brct = 0, bct = 0, intick = 0, err = 0;
+    int c;
+    int math = endchar == ')' || endchar == ']';
+    int zlemath = math && cs > ll + addedx - inbufct;
+
+    while (((c = hgetc()) != endchar || bct ||
+	    (math && ((pct > 0) || (brct > 0))) ||
+	    intick) && !lexstop) {
+      cont:
+	switch (c) {
+	case '\\':
+	    c = hgetc();
+	    if (c != '\n') {
+		if (c == '$' || c == '\\' || (c == '}' && !intick && bct) ||
+		    c == endchar || c == '`')
+		    add(Bnull);
+		else {
+		    /* lexstop is implicitely handled here */
+		    add('\\');
+		    goto cont;
+		}
+	    } else if (sub || unset(CSHJUNKIEQUOTES) || endchar != '"')
+		continue;
+	    break;
+	case '\n':
+	    err = !sub && isset(CSHJUNKIEQUOTES) && endchar == '"';
+	    break;
+	case '$':
+	    if (intick)
+		break;
+	    c = hgetc();
+	    if (c == '(') {
+		add(Qstring);
+		err = cmd_or_math_sub();
+		c = Outpar;
+	    } else if (c == '[') {
+		add(String);
+		add(Inbrack);
+		cmdpush(CS_MATHSUBST);
+		err = dquote_parse(']', sub);
+		cmdpop();
+		c = Outbrack;
+	    } else if (c == '{') {
+		add(Qstring);
+		c = Inbrace;
+		cmdpush(CS_BRACEPAR);
+		bct++;
+	    } else if (c == '$')
+		add(Qstring);
+	    else {
+		hungetc(c);
+		lexstop = 0;
+		c = Qstring;
+	    }
+	    break;
+	case '}':
+	    if (intick || !bct)
+		break;
+	    c = Outbrace;
+	    bct--;
+	    cmdpop();
+	    break;
+	case '`':
+	    c = Qtick;
+	    if (intick == 2)
+		ALLOWHIST
+	    if ((intick = !intick)) {
+		SETPARBEGIN
+		cmdpush(CS_BQUOTE);
+	    } else {
+		SETPAREND
+	        cmdpop();
+	    }
+	    break;
+	case '\'':
+	    if (!intick)
+		break;
+	    if (intick == 1)
+		intick = 2, STOPHIST
+	    else
+		intick = 1, ALLOWHIST
+	    break;
+	case '(':
+	    pct++;
+	    break;
+	case ')':
+	    err = (!pct-- && math);
+	    break;
+	case '[':
+	    brct++;
+	    break;
+	case ']':
+	    err = (!brct-- && math);
+	    break;
+	case '"':
+	    if (intick || (!endchar && !bct))
+		break;
+	    if (bct) {
+		add(Dnull);
+		err = dquote_parse('"', sub);
+		c = Dnull;
+	    } else
+		err = 1;
+	    break;
+	}
+	if (err || lexstop)
+	    break;
+	add(c);
+    }
+    if (intick == 2)
+	ALLOWHIST
+    if (intick)
+	cmdpop();
+    while (bct--)
+	cmdpop();
+    if (lexstop)
+	err = intick || endchar || err;
+    else if (err == 1)
+	err = c;
+    if (zlemath && cs <= ll + 1 - inbufct)
+	inwhat = IN_MATH;
+    return err;
+}
+
+/* Tokenize a string given in s. Parsing is done as in double *
+ * quotes.  This is usually called before singsub().          */
+
+/**/
+int
+parsestr(char *s)
+{
+    int l = strlen(s), err;
+
+    HEAPALLOC {
+	lexsave();
+	untokenize(s);
+	inpush(dupstring(s), 0, NULL);
+	strinbeg();
+	stophist = 2;
+	len = 0;
+	bptr = tokstr = s;
+	bsiz = l + 1;
+	err = dquote_parse('\0', 1);
+	*bptr = '\0';
+	strinend();
+	inpop();
+	DPUTS(cmdsp, "BUG: parsestr: cmdstack not empty.");
+	lexrestore();
+	if (err) {
+	    untokenize(s);
+	    if (err > 32 && err < 127)
+		zerr("parse error near `%c'", NULL, err);
+	    else
+		zerr("parse error", NULL, 0);
+	}
+    } LASTALLOC;
+    return err;
+}
+
+/* Tokenize a string given in s. Parsing is done as if s were a normal *
+ * command-line argument but it may contain separators.  This is used  *
+ * to parse the right-hand side of ${...%...} substitutions.           */
+
+/**/
+int
+parse_subst_string(char *s)
+{
+    int c, l = strlen(s), err;
+
+    if (! *s)
+	return 0;
+    lexsave();
+    untokenize(s);
+    inpush(dupstring(s), 0, NULL);
+    strinbeg();
+    stophist = 2;
+    len = 0;
+    bptr = tokstr = s;
+    bsiz = l + 1;
+    c = hgetc();
+    c = gettokstr(c, 1);
+    err = errflag;
+    strinend();
+    inpop();
+    DPUTS(cmdsp, "BUG: parse_subst_string: cmdstack not empty.");
+    lexrestore();
+    errflag = err;
+    if (c == LEXERR) {
+	untokenize(s);
+	return 1;
+    }
+#ifdef DEBUG
+    if (c != STRING || len != l || errflag) {
+	fprintf(stderr, "Oops. Bug in parse_subst_string: %s\n",
+		len < l ? "len < l" : errflag ? "errflag" : "c != STRING");
+	fflush(stderr);
+	untokenize(s);
+	return 1;
+    }
+#endif
+    return 0;
+}
+
+/* expand aliases and reserved words */
+
+/**/
+int
+exalias(void)
+{
+    Alias an;
+    Reswd rw;
+
+    hwend();
+    if (interact && isset(SHINSTDIN) && !strin && !incasepat &&
+	tok == STRING && !nocorrect && !(inbufflags & INP_ALIAS) &&
+	(isset(CORRECTALL) || (isset(CORRECT) && incmdpos)))
+	spckword(&tokstr, 1, incmdpos, 1);
+
+    if (!tokstr) {
+	yytext = tokstrings[tok];
+	if (yytext)
+	    yytext = dupstring(yytext);
+	return 0;
+    }
+
+    if (has_token(tokstr)) {
+	char *p, *t;
+
+	yytext = p = ncalloc(strlen(tokstr) + 1);
+	for (t = tokstr; (*p++ = itok(*t) ? ztokens[*t++ - Pound] : *t++););
+    } else
+	yytext = tokstr;
+
+    if (zleparse && !(inbufflags & INP_ALIAS)) {
+	int zp = zleparse;
+
+	gotword();
+	if (zp == 1 && !zleparse) {
+	    return 0;
+	}
+    }
+
+    if (tok == STRING) {
+	/* Check for an alias */
+	an = noaliases ? NULL : (Alias) aliastab->getnode(aliastab, yytext);
+	if (an && !an->inuse && ((an->flags & ALIAS_GLOBAL) || incmdpos ||
+	     inalmore)) {
+	    inpush(an->text, INP_ALIAS, an);
+	    /* remove from history if it begins with space */
+	    if (isset(HISTIGNORESPACE) && an->text[0] == ' ')
+		remhist();
+	    lexstop = 0;
+	    return 1;
+	}
+
+	/* Then check for a reserved word */
+	if ((incmdpos ||
+	     (unset(IGNOREBRACES) && yytext[0] == '}' && !yytext[1])) &&
+	    (rw = (Reswd) reswdtab->getnode(reswdtab, yytext))) {
+	    tok = rw->token;
+	    if (tok == DINBRACK)
+		incond = 1;
+	} else if (incond && !strcmp(yytext, "]]")) {
+	    tok = DOUTBRACK;
+	    incond = 0;
+	} else if (incond && yytext[0] == '!' && !yytext[1])
+	    tok = BANG;
+    }
+    inalmore = 0;
+    return 0;
+}
+
+/* skip (...) */
+
+/**/
+static int
+skipcomm(void)
+{
+    int pct = 1, c;
+
+    cmdpush(CS_CMDSUBST);
+    SETPARBEGIN
+    c = Inpar;
+    do {
+	add(c);
+	c = hgetc();
+	if (itok(c) || lexstop)
+	    break;
+	switch (c) {
+	case '(':
+	    pct++;
+	    break;
+	case ')':
+	    pct--;
+	    break;
+	case '\\':
+	    add(c);
+	    c = hgetc();
+	    break;
+	case '\'': {
+	    int strquote = bptr[-1] == '$';
+	    add(c);
+	    STOPHIST
+	    while ((c = hgetc()) != '\'' && !lexstop) {
+		if (c == '\\' && strquote) {
+		    add(c);
+		    c = hgetc();
+		}
+		add(c);
+	    }
+	    ALLOWHIST
+	    break;
+	}
+	case '\"':
+	    add(c);
+	    while ((c = hgetc()) != '\"' && !lexstop)
+		if (c == '\\') {
+		    add(c);
+		    add(hgetc());
+		} else
+		    add(c);
+	    break;
+	case '`':
+	    add(c);
+	    while ((c = hgetc()) != '`' && !lexstop)
+		if (c == '\\')
+		    add(c), add(hgetc());
+		else
+		    add(c);
+	    break;
+	}
+    }
+    while (pct);
+    if (!lexstop)
+	SETPAREND
+    cmdpop();
+    return lexstop;
+}
diff --git a/Src/linklist.c b/Src/linklist.c
new file mode 100644
index 000000000..62a962595
--- /dev/null
+++ b/Src/linklist.c
@@ -0,0 +1,222 @@
+/*
+ * linklist.c - linked lists
+ *
+ * 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 "linklist.pro"
+
+/* Get an empty linked list header */
+
+/**/
+LinkList
+newlinklist(void)
+{
+    LinkList list;
+
+    list = (LinkList) alloc(sizeof *list);
+    list->first = NULL;
+    list->last = (LinkNode) list;
+    return list;
+}
+
+/* Insert a node in a linked list after a given node */
+
+/**/
+LinkNode
+insertlinknode(LinkList list, LinkNode node, void *dat)
+{
+    LinkNode tmp, new;
+
+    tmp = node->next;
+    node->next = new = (LinkNode) alloc(sizeof *tmp);
+    new->last = node;
+    new->dat = dat;
+    new->next = tmp;
+    if (tmp)
+	tmp->last = new;
+    else
+	list->last = new;
+    return new;
+}
+
+/* Insert an already-existing node into a linked list after a given node */
+
+/**/
+LinkNode
+uinsertlinknode(LinkList list, LinkNode node, LinkNode new)
+{
+    LinkNode tmp = node->next;
+    node->next = new;
+    new->last = node;
+    new->next = tmp;
+    if (tmp)
+	tmp->last = new;
+    else
+	list->last = new;
+    return new;
+}
+
+/* Insert a list in another list */
+
+/**/
+void
+insertlinklist(LinkList l, LinkNode where, LinkList x)
+{
+    LinkNode nx;
+
+    nx = where->next;
+    if (!l->first)
+	return;
+    where->next = l->first;
+    l->last->next = nx;
+    l->first->last = where;
+    if (nx)
+	nx->last = l->last;
+    else
+	x->last = l->last;
+}
+
+/* Get top node in a linked list */
+
+/**/
+void *
+getlinknode(LinkList list)
+{
+    void *dat;
+    LinkNode node;
+
+    if (!(node = list->first))
+	return NULL;
+    dat = node->dat;
+    list->first = node->next;
+    if (node->next)
+	node->next->last = (LinkNode) list;
+    else
+	list->last = (LinkNode) list;
+    zfree(node, sizeof(struct linknode));
+    return dat;
+}
+
+/* Get top node in a linked list without freeing */
+
+/**/
+void *
+ugetnode(LinkList list)
+{
+    void *dat;
+    LinkNode node;
+
+    if (!(node = list->first))
+	return NULL;
+    dat = node->dat;
+    list->first = node->next;
+    if (node->next)
+	node->next->last = (LinkNode) list;
+    else
+	list->last = (LinkNode) list;
+    return dat;
+}
+
+/* Remove a node from a linked list */
+
+/**/
+void *
+remnode(LinkList list, LinkNode nd)
+{
+    void *dat;
+
+    nd->last->next = nd->next;
+    if (nd->next)
+	nd->next->last = nd->last;
+    else
+	list->last = nd->last;
+    dat = nd->dat;
+    zfree(nd, sizeof(struct linknode));
+
+    return dat;
+}
+
+/* Remove a node from a linked list without freeing */
+
+/**/
+void *
+uremnode(LinkList list, LinkNode nd)
+{
+    void *dat;
+
+    nd->last->next = nd->next;
+    if (nd->next)
+	nd->next->last = nd->last;
+    else
+	list->last = nd->last;
+    dat = nd->dat;
+    return dat;
+}
+
+/* Free a linked list */
+
+/**/
+void
+freelinklist(LinkList list, FreeFunc freefunc)
+{
+    LinkNode node, next;
+
+    for (node = list->first; node; node = next) {
+	next = node->next;
+	if (freefunc)
+	    freefunc(node->dat);
+	zfree(node, sizeof(struct linknode));
+    }
+    zfree(list, sizeof(struct linklist));
+}
+
+/* Count the number of nodes in a linked list */
+
+/**/
+int
+countlinknodes(LinkList list)
+{
+    LinkNode nd;
+    int ct = 0;
+
+    for (nd = firstnode(list); nd; incnode(nd), ct++);
+    return ct;
+}
+
+/**/
+void
+rolllist(LinkList l, LinkNode nd)
+{
+    l->last->next = l->first;
+    l->first->last = l->last;
+    l->first = nd;
+    l->last = nd->last;
+    nd->last = (LinkNode) l;
+    l->last->next = 0;
+}
+
diff --git a/Src/loop.c b/Src/loop.c
new file mode 100644
index 000000000..5fbf2b841
--- /dev/null
+++ b/Src/loop.c
@@ -0,0 +1,421 @@
+/*
+ * loop.c - loop execution
+ *
+ * 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 "loop.pro"
+
+/* # of nested loops we are in */
+ 
+/**/
+int loops;
+ 
+/* # of continue levels */
+ 
+/**/
+int contflag;
+ 
+/* # of break levels */
+ 
+/**/
+int breaks;
+ 
+/**/
+int
+execfor(Cmd cmd)
+{
+    List list;
+    Forcmd node;
+    char *str;
+    int val;
+    LinkList args;
+
+    node = cmd->u.forcmd;
+    args = cmd->args;
+    if (node->condition) {
+	str = node->name;
+	singsub(&str);
+	if (!errflag)
+	    matheval(str);
+	if (errflag)
+	    return lastval = errflag;
+    } else if (!node->inflag) {
+	char **x;
+
+	args = newlinklist();
+	for (x = pparams; *x; x++)
+	    addlinknode(args, ztrdup(*x));
+    }
+    lastval = 0;
+    loops++;
+    pushheap();
+    for (;;) {
+	if (node->condition) {
+	    str = dupstring(node->condition);
+	    singsub(&str);
+	    if (!errflag) {
+		while (iblank(*str))
+		    str++;
+		if (*str)
+		    val = matheval(str);
+		else
+		    val = 1;
+	    }
+	    if (errflag) {
+		if (breaks)
+		    breaks--;
+		lastval = 1;
+		break;
+	    }
+	    if (!val)
+		break;
+	} else {
+	    str = (char *) ugetnode(args);
+	    if (!str)
+		break;
+	    setsparam(node->name, ztrdup(str));
+	}
+	list = (List) dupstruct(node->list);
+	execlist(list, 1, (cmd->flags & CFLAG_EXEC) && empty(args));
+	if (breaks) {
+	    breaks--;
+	    if (breaks || !contflag)
+		break;
+	    contflag = 0;
+	}
+	if (node->condition && !errflag) {
+	    str = dupstring(node->advance);
+	    singsub(&str);
+	    if (!errflag)
+		matheval(str);
+	}
+	if (errflag) {
+	    if (breaks)
+		breaks--;
+	    lastval = 1;
+	    break;
+	}
+	freeheap();
+    }
+    popheap();
+    loops--;
+    return lastval;
+}
+
+/**/
+int
+execselect(Cmd cmd)
+{
+    List list;
+    Forcmd node;
+    char *str, *s;
+    LinkList args;
+    LinkNode n;
+    int i;
+    FILE *inp;
+
+    node = cmd->u.forcmd;
+    args = cmd->args;
+    if (!node->inflag) {
+	char **x;
+
+	args = newlinklist();
+	for (x = pparams; *x; x++)
+	    addlinknode(args, ztrdup(*x));
+    }
+    if (empty(args))
+	return 1;
+    loops++;
+    lastval = 0;
+    pushheap();
+    inp = fdopen(dup((SHTTY == -1) ? 0 : SHTTY), "r");
+    selectlist(args);
+    for (;;) {
+	for (;;) {
+	    if (empty(bufstack)) {
+	    	if (interact && SHTTY != -1 && isset(USEZLE)) {
+		    isfirstln = 1;
+		    str = (char *)zleread(prompt3, NULL, 0);
+	    	} else {
+		    str = promptexpand(prompt3, 0, NULL, NULL);
+		    zputs(str, stderr);
+		    free(str);
+		    fflush(stderr);
+		    str = fgets(zalloc(256), 256, inp);
+	    	}
+	    } else
+		str = (char *)getlinknode(bufstack);
+	    if (!str || errflag) {
+		if (breaks)
+		    breaks--;
+		fprintf(stderr, "\n");
+		fflush(stderr);
+		goto done;
+	    }
+	    if ((s = strchr(str, '\n')))
+		*s = '\0';
+	    if (*str)
+	      break;
+	    selectlist(args);
+	}
+	setsparam("REPLY", ztrdup(str));
+	i = atoi(str);
+	if (!i)
+	    str = "";
+	else {
+	    for (i--, n = firstnode(args); n && i; incnode(n), i--);
+	    if (n)
+		str = (char *) getdata(n);
+	    else
+		str = "";
+	}
+	setsparam(node->name, ztrdup(str));
+	list = (List) dupstruct(node->list);
+	execlist(list, 1, 0);
+	freeheap();
+	if (breaks) {
+	    breaks--;
+	    if (breaks || !contflag)
+		break;
+	    contflag = 0;
+	}
+	if (errflag)
+	    break;
+    }
+  done:
+    popheap();
+    fclose(inp);
+    loops--;
+    return lastval;
+}
+
+/* And this is used to print select lists. */
+
+/**/
+static void
+selectlist(LinkList l)
+{
+    size_t longest = 1, fct, fw = 0, colsz, t0, t1, ct;
+    LinkNode n;
+    char **arr, **ap;
+
+    trashzle();
+    ct = countlinknodes(l);
+    ap = arr = (char **)alloc((countlinknodes(l) + 1) * sizeof(char **));
+
+    for (n = (LinkNode) firstnode(l); n; incnode(n))
+	*ap++ = (char *)getdata(n);
+    *ap = NULL;
+    for (ap = arr; *ap; ap++)
+	if (strlen(*ap) > longest)
+	    longest = strlen(*ap);
+    t0 = ct;
+    longest++;
+    while (t0)
+	t0 /= 10, longest++;
+    /* to compensate for added ')' */
+    fct = (columns - 1) / (longest + 3);
+    if (fct == 0)
+	fct = 1;
+    else
+	fw = (columns - 1) / fct;
+    colsz = (ct + fct - 1) / fct;
+    for (t1 = 0; t1 != colsz; t1++) {
+	ap = arr + t1;
+	do {
+	    int t2 = strlen(*ap) + 2, t3;
+
+	    fprintf(stderr, "%d) %s", t3 = ap - arr + 1, *ap);
+	    while (t3)
+		t2++, t3 /= 10;
+	    for (; t2 < fw; t2++)
+		fputc(' ', stderr);
+	    for (t0 = colsz; t0 && *ap; t0--, ap++);
+	}
+	while (*ap);
+	fputc('\n', stderr);
+    }
+
+ /* Below is a simple attempt at doing it the Korn Way..
+       ap = arr;
+       t0 = 0;
+       do {
+           t0++;
+           fprintf(stderr,"%d) %s\n",t0,*ap);
+           ap++;
+       }
+       while (*ap);*/
+    fflush(stderr);
+}
+
+/**/
+int
+execwhile(Cmd cmd)
+{
+    List list;
+    struct whilecmd *node;
+    int olderrexit, oldval;
+
+    olderrexit = noerrexit;
+    node = cmd->u.whilecmd;
+    oldval = 0;
+    pushheap();
+    loops++;
+    for (;;) {
+	list = (List) dupstruct(node->cont);
+	noerrexit = 1;
+	execlist(list, 1, 0);
+	noerrexit = olderrexit;
+	if (!((lastval == 0) ^ node->cond)) {
+	    if (breaks)
+		breaks--;
+	    lastval = oldval;
+	    break;
+	}
+	list = (List) dupstruct(node->loop);
+	execlist(list, 1, 0);
+	if (breaks) {
+	    breaks--;
+	    if (breaks || !contflag)
+		break;
+	    contflag = 0;
+	}
+	freeheap();
+	if (errflag) {
+	    lastval = 1;
+	    break;
+	}
+	oldval = lastval;
+    }
+    popheap();
+    loops--;
+    return lastval;
+}
+
+/**/
+int
+execrepeat(Cmd cmd)
+{
+    List list;
+    int count;
+
+    lastval = 0;
+    if (empty(cmd->args) || nextnode(firstnode(cmd->args))) {
+	zerr("bad argument for repeat", NULL, 0);
+	return 1;
+    }
+    count = atoi(peekfirst(cmd->args));
+    pushheap();
+    loops++;
+    while (count--) {
+	list = (List) dupstruct(cmd->u.list);
+	execlist(list, 1, 0);
+	freeheap();
+	if (breaks) {
+	    breaks--;
+	    if (breaks || !contflag)
+		break;
+	    contflag = 0;
+	}
+	if (errflag) {
+	    lastval = 1;
+	    break;
+	}
+    }
+    popheap();
+    loops--;
+    return lastval;
+}
+
+/**/
+int
+execif(Cmd cmd)
+{
+    struct ifcmd *node;
+    int olderrexit;
+    List *i, *t;
+
+    olderrexit = noerrexit;
+    node = cmd->u.ifcmd;
+    i = node->ifls;
+    t = node->thenls;
+
+    if (!noerrexit)
+	noerrexit = 1;
+    while (*i) {
+	execlist(*i, 1, 0);
+	if (!lastval)
+	    break;
+	i++;
+	t++;
+    }
+    noerrexit = olderrexit;
+
+    if (*t)
+	execlist(*t, 1, cmd->flags & CFLAG_EXEC);
+    else
+	lastval = 0;
+
+    return lastval;
+}
+
+/**/
+int
+execcase(Cmd cmd)
+{
+    struct casecmd *node;
+    char *word;
+    List *l;
+    char **p;
+
+    node = cmd->u.casecmd;
+    l = node->lists;
+    p = node->pats;
+
+    word = *p++;
+    singsub(&word);
+    untokenize(word);
+    lastval = 0;
+
+    if (node) {
+	while (*p) {
+	    char *pat = *p + 1;
+	    singsub(&pat);
+	    if (matchpat(word, pat)) {
+		do {
+		    execlist(*l++, 1, **p == ';' && (cmd->flags & CFLAG_EXEC));
+		} while(**p++ == '&' && *p);
+		break;
+	    }
+	    p++;
+	    l++;
+	}
+    }
+    return lastval;
+}
+
diff --git a/Src/main.c b/Src/main.c
new file mode 100644
index 000000000..7ec8f07bd
--- /dev/null
+++ b/Src/main.c
@@ -0,0 +1,99 @@
+/*
+ * main.c - the main() function
+ *
+ * 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 "main.pro"
+
+/**/
+int
+main(int argc, char **argv)
+{
+    char **t;
+#ifdef LC_ALL
+    setlocale(LC_ALL, "");
+#endif
+
+    global_permalloc();
+
+    init_hackzero(argv, environ);
+
+    for (t = argv; *t; *t = metafy(*t, -1, META_ALLOC), t++);
+
+    if (!(zsh_name = strrchr(argv[0], '/')))
+	zsh_name = argv[0];
+    else
+	zsh_name++;
+    if (*zsh_name == '-')
+	zsh_name++;
+
+    fdtable_size = OPEN_MAX;
+    fdtable = zcalloc(fdtable_size);
+
+    createoptiontable();
+    emulate(zsh_name, 1);   /* initialises most options */
+    opts[LOGINSHELL] = (**argv == '-');
+    opts[MONITOR] = 1;   /* may be unset in init_io() */
+    opts[PRIVILEGED] = (getuid() != geteuid() || getgid() != getegid());
+    opts[USEZLE] = 1;   /* may be unset in init_io() */
+    parseargs(argv);   /* sets INTERACTIVE, SHINSTDIN and SINGLECOMMAND */
+
+    SHTTY = -1;
+    init_io();
+    setupvals();
+    init_signals();
+    global_heapalloc();
+    init_bltinmods();
+    run_init_scripts();
+    init_misc();
+
+    for (;;) {
+	do
+	    loop(1,0);
+	while (tok != ENDINPUT && (tok != LEXERR || isset(SHINSTDIN)));
+	if (tok == LEXERR) {
+	    stopmsg = 1;
+	    zexit(lastval, 0);
+	}
+	if (!(isset(IGNOREEOF) && interact)) {
+#if 0
+	    if (interact)
+		fputs(islogin ? "logout\n" : "exit\n", shout);
+#endif
+	    zexit(lastval, 0);
+	    continue;
+	}
+	noexitct++;
+	if (noexitct >= 10) {
+	    stopmsg = 1;
+	    zexit(lastval, 0);
+	}
+	zerrnam("zsh", (!islogin) ? "use 'exit' to exit."
+		: "use 'logout' to logout.", NULL, 0);
+    }
+}
diff --git a/Src/makepro.awk b/Src/makepro.awk
new file mode 100644
index 000000000..b5d2f3dc4
--- /dev/null
+++ b/Src/makepro.awk
@@ -0,0 +1,146 @@
+#
+# makepro.awk - generate prototype lists
+#
+
+BEGIN {
+    aborting = 0
+
+    # arg 1 is the name of the file to process
+    # arg 2 is the name of the subdirectory it is in
+    if(ARGC != 3) {
+	aborting = 1
+	exit 1
+    }
+    name = ARGV[1]
+    gsub(/^.*\//, "", name)
+    gsub(/\.c$/, "", name)
+    name = ARGV[2] "_" name
+    gsub(/\//, "_", name)
+    ARGC--
+
+    # `locals' is a list of local declarations, built up while global
+    # declarations are output.
+    locals = ""
+
+    printf "#ifndef have_%s_globals\n", name
+    printf "#define have_%s_globals\n", name
+    printf "\n"
+}
+
+# all relevant declarations are preceded by "/**/" on a line by itself
+
+/^\/\*\*\/$/ {
+    # The declaration is on following lines.  The interesting part might
+    # be terminated by a `{' (`int foo(void) { }' or `int bar[] = {')
+    # or `;' (`int x;').
+    line = ""
+    isfunc = 0
+    while(1) {
+	if(getline <= 0) {
+	    aborting = 1
+	    exit 1
+	}
+	gsub(/\t/, " ")
+	line = line " " $0
+	gsub(/\/\*([^*]|\*+[^*\/])*\*+\//, " ", line)
+	if(line ~ /\/\*/)
+	    continue
+	# If it is a function definition, note so.
+	if(line ~ /\) *[{].*$/) #}
+	    isfunc = 1
+	if(sub(/ *[{;].*$/, "", line)) #}
+	    break
+    }
+    # Put spaces around each identifier.
+    while(match(line, /[^_0-9A-Za-z ][_0-9A-Za-z]/) ||
+	    match(line, /[_0-9A-Za-z][^_0-9A-Za-z ]/))
+	line = substr(line, 1, RSTART) " " substr(line, RSTART+1)
+    # Separate declarations into a type and a list of declarators.
+    # In each declarator, "@{" and "@}" are used in place of parens to
+    # mark function parameter lists, and "@!" is used in place of commas
+    # in parameter lists.  "@<" and "@>" are used in place of
+    # non-parameter list parens.
+    gsub(/ _ +/, " _ ", line)
+    while(1) {
+	if(isfunc && match(line, /\([^()]*\)$/))
+	    line = substr(line, 1, RSTART-1) " _ (" substr(line, RSTART) ")"
+	else if(match(line, / _ \(\([^,()]*,/))
+	    line = substr(line, 1, RSTART+RLENGTH-2) "@!" substr(line, RSTART+RLENGTH)
+	else if(match(line, / _ \(\([^,()]*\)\)/))
+	    line = substr(line, 1, RSTART-1) "@{" substr(line, RSTART+5, RLENGTH-7) "@}" substr(line, RSTART+RLENGTH)
+	else if(match(line, /\([^,()]*\)/))
+	    line = substr(line, 1, RSTART-1) "@<" substr(line, RSTART+1, RLENGTH-2) "@>" substr(line, RSTART+RLENGTH)
+	else
+	    break
+    }
+    sub(/^ */, "", line)
+    match(line, /^((const|enum|static|struct|union) +)*([_0-9A-Za-z]+ +|((char|double|float|int|long|short|unsigned|void) +)+)((const|static) +)*/)
+    dtype = substr(line, 1, RLENGTH)
+    sub(/ *$/, "", dtype)
+    islocal = " " dtype " " ~ / static /
+    line = substr(line, RLENGTH+1) ","
+    # Handle each declarator.
+    output = ""
+    while(match(line, /^[^,]*,/)) {
+	# Separate out the name from the declarator.  Use "@+" and "@-"
+	# to bracket the name within the declarator.  Strip off any
+	# initialiser.
+	dcltor = substr(line, 1, RLENGTH-1)
+	line = substr(line, RLENGTH+1)
+	sub(/\=.*$/, "", dcltor)
+	match(dcltor, /^([^_0-9A-Za-z]| const )*/)
+	dcltor = substr(dcltor, 1, RLENGTH) "@+" substr(dcltor, RLENGTH+1)
+	match(dcltor, /^.*@\+[_0-9A-Za-z]+/)
+	dcltor = substr(dcltor, 1, RLENGTH) "@-" substr(dcltor, RLENGTH+1)
+	dnam = dcltor
+	sub(/^.*@\+/, "", dnam)
+	sub(/@-.*$/, "", dnam)
+
+	# Put parens etc. back
+	gsub(/@[{]/, " _((", dcltor)
+	gsub(/@}/, "))", dcltor)
+	gsub(/@</, "(", dcltor)
+	gsub(/@>/, ")", dcltor)
+	gsub(/@!/, ",", dcltor)
+
+	# If this is a module boot/cleanup function, conditionally rename it.
+	if(" " dtype " " ~ / int / && dcltor ~ / *@\+(boot|cleanup)_[_0-9A-Za-z]+@- *_\(\( *Module +[_0-9A-Za-z]+ *\)\) */) {
+	    modtype = dnam
+	    sub(/_.*$/, "", modtype)
+	    output = output "# if defined(DYNAMIC_NAME_CLASH_OK) && defined(MODULE)\n"
+	    output = output "#  define " dnam " " modtype "_\n"
+	    output = output "# endif\n"
+	}
+
+	# Format the declaration for output
+	dcl = dtype " " dcltor ";"
+	if(!islocal)
+	    dcl = "extern " dcl
+	gsub(/@[+-]/, "", dcl)
+	gsub(/ +/, " ", dcl)
+	while(match(dcl, /[^_0-9A-Za-z] ./) || match(dcl, /. [^_0-9A-Za-z]/))
+	    dcl = substr(dcl, 1, RSTART) substr(dcl, RSTART+2)
+	output = output dcl "\n"
+    }
+
+    # Output global declarations now, but save up locals until the end.
+    if(islocal)
+	locals = locals output
+    else
+	printf "%s", output
+}
+
+END {
+    if(aborting)
+	exit 1
+    printf "\n"
+    printf "#endif /* !have_%s_globals */\n", name
+    if(locals != "") {
+	printf "\n"
+	printf "#ifndef GLOBAL_PROTOTYPES\n"
+	printf "\n"
+	printf locals
+	printf "\n"
+	printf "#endif /* !GLOBAL_PROTOTYPES */\n"
+    }
+}
diff --git a/Src/math.c b/Src/math.c
new file mode 100644
index 000000000..7a0a1f9bd
--- /dev/null
+++ b/Src/math.c
@@ -0,0 +1,883 @@
+/*
+ * math.c - mathematical expression evaluation
+ *
+ * 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 "math.pro"
+
+/* nonzero means we are not evaluating, just parsing */
+ 
+/**/
+int noeval;
+ 
+/* last input base we used */
+
+/**/
+int lastbase;
+ 
+static char *ptr;
+
+static long yyval;
+static LV yylval;
+
+static int mlevel = 0;
+
+/* != 0 means recognize unary plus, minus, etc. */
+
+static int unary = 1;
+
+/* LR = left-to-right associativity *
+ * RL = right-to-left associativity *
+ * BOO = short-circuiting boolean   */
+
+#define LR 0
+#define RL 1
+#define BOOL 2
+
+#define M_INPAR 0
+#define M_OUTPAR 1
+#define NOT 2
+#define COMP 3
+#define POSTPLUS 4
+#define POSTMINUS 5
+#define UPLUS 6
+#define UMINUS 7
+#define AND 8
+#define XOR 9
+#define OR 10
+#define MUL 11
+#define DIV 12
+#define MOD 13
+#define PLUS 14
+#define MINUS 15
+#define SHLEFT 16
+#define SHRIGHT 17
+#define LES 18
+#define LEQ 19
+#define GRE 20
+#define GEQ 21
+#define DEQ 22
+#define NEQ 23
+#define DAND 24
+#define DOR 25
+#define DXOR 26
+#define QUEST 27
+#define COLON 28
+#define EQ 29
+#define PLUSEQ 30
+#define MINUSEQ 31
+#define MULEQ 32
+#define DIVEQ 33
+#define MODEQ 34
+#define ANDEQ 35
+#define XOREQ 36
+#define OREQ 37
+#define SHLEFTEQ 38
+#define SHRIGHTEQ 39
+#define DANDEQ 40
+#define DOREQ 41
+#define DXOREQ 42
+#define COMMA 43
+#define EOI 44
+#define PREPLUS 45
+#define PREMINUS 46
+#define NUM 47
+#define ID 48
+#define POWER 49
+#define CID 50
+#define POWEREQ 51
+#define TOKCOUNT 52
+
+/* precedences */
+
+static int prec[TOKCOUNT] =
+{
+     1, 137,  2,  2,   2,
+     2,   2,  2,  4,   5,
+     6,   8,  8,  8,   9,
+     9,   3,  3, 10,  10,
+    10,  10, 11, 11,  12,
+    13,  13, 14, 14,  15,
+    15,  15, 15, 15,  15,
+    15,  15, 15, 15,  15,
+    15,  15, 15, 16, 200,
+     2,   2,  0,  0,   7,
+     0,  15
+};
+
+#define TOPPREC 16
+#define ARGPREC (TOPPREC-1)
+
+static int type[TOKCOUNT] =
+{
+    LR, LR, RL, RL, RL,
+    RL, RL, RL, LR, LR,
+    LR, LR, LR, LR, LR,
+    LR, LR, LR, LR, LR,
+    LR, LR, LR, LR, BOOL,
+    BOOL, LR, RL, RL, RL,
+    RL, RL, RL, RL, RL,
+    RL, RL, RL, RL, RL,
+    BOOL, BOOL, RL, RL, RL,
+    RL, RL, LR, LR, RL,
+    LR, RL
+};
+
+#define LVCOUNT 32
+
+/* list of lvalues (variables) */
+
+static int lvc;
+static char **lvals;
+
+
+/**/
+static int
+zzlex(void)
+{
+    int cct = 0;
+
+    for (;; cct = 0)
+	switch (*ptr++) {
+	case '+':
+	    if (*ptr == '+' && (unary || !ialnum(*ptr))) {
+		ptr++;
+		return (unary) ? PREPLUS : POSTPLUS;
+	    }
+	    if (*ptr == '=') {
+		unary = 1;
+		ptr++;
+		return PLUSEQ;
+	    }
+	    return (unary) ? UPLUS : PLUS;
+	case '-':
+	    if (*ptr == '-' && (unary || !ialnum(*ptr))) {
+		ptr++;
+		return (unary) ? PREMINUS : POSTMINUS;
+	    }
+	    if (*ptr == '=') {
+		unary = 1;
+		ptr++;
+		return MINUSEQ;
+	    }
+	    return (unary) ? UMINUS : MINUS;
+	case '(':
+	    unary = 1;
+	    return M_INPAR;
+	case ')':
+	    return M_OUTPAR;
+	case '!':
+	    if (*ptr == '=') {
+		unary = 1;
+		ptr++;
+		return NEQ;
+	    }
+	    return NOT;
+	case '~':
+	    return COMP;
+	case '&':
+	    unary = 1;
+	    if (*ptr == '&') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return DANDEQ;
+		}
+		return DAND;
+	    } else if (*ptr == '=') {
+		ptr++;
+		return ANDEQ;
+	    }
+	    return AND;
+	case '|':
+	    unary = 1;
+	    if (*ptr == '|') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return DOREQ;
+		}
+		return DOR;
+	    } else if (*ptr == '=') {
+		ptr++;
+		return OREQ;
+	    }
+	    return OR;
+	case '^':
+	    unary = 1;
+	    if (*ptr == '^') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return DXOREQ;
+		}
+		return DXOR;
+	    } else if (*ptr == '=') {
+		ptr++;
+		return XOREQ;
+	    }
+	    return XOR;
+	case '*':
+	    unary = 1;
+	    if (*ptr == '*') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return POWEREQ;
+		}
+		return POWER;
+	    }
+	    if (*ptr == '=') {
+		ptr++;
+		return MULEQ;
+	    }
+	    return MUL;
+	case '/':
+	    unary = 1;
+	    if (*ptr == '=') {
+		ptr++;
+		return DIVEQ;
+	    }
+	    return DIV;
+	case '%':
+	    unary = 1;
+	    if (*ptr == '=') {
+		ptr++;
+		return MODEQ;
+	    }
+	    return MOD;
+	case '<':
+	    unary = 1;
+	    if (*ptr == '<') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return SHLEFTEQ;
+		}
+		return SHLEFT;
+	    } else if (*ptr == '=') {
+		ptr++;
+		return LEQ;
+	    }
+	    return LES;
+	case '>':
+	    unary = 1;
+	    if (*ptr == '>') {
+		if (*++ptr == '=') {
+		    ptr++;
+		    return SHRIGHTEQ;
+		}
+		return SHRIGHT;
+	    } else if (*ptr == '=') {
+		ptr++;
+		return GEQ;
+	    }
+	    return GRE;
+	case '=':
+	    unary = 1;
+	    if (*ptr == '=') {
+		ptr++;
+		return DEQ;
+	    }
+	    return EQ;
+	case '$':
+	    unary = 0;
+	    yyval = mypid;
+	    return NUM;
+	case '?':
+	    if (unary) {
+		yyval = lastval;
+		unary = 0;
+		return NUM;
+	    }
+	    unary = 1;
+	    return QUEST;
+	case ':':
+	    unary = 1;
+	    return COLON;
+	case ',':
+	    unary = 1;
+	    return COMMA;
+	case '\0':
+	    unary = 1;
+	    ptr--;
+	    return EOI;
+	case '[':
+	    unary = 0;
+	    {
+		int base = zstrtol(ptr, &ptr, 10);
+
+		if (*ptr == ']')
+		    ptr++;
+		yyval = zstrtol(ptr, &ptr, lastbase = base);
+		return NUM;
+	    }
+	case ' ':
+	case '\t':
+	case '\n':
+	    break;
+	case '0':
+	    if (*ptr == 'x' || *ptr == 'X') {
+		unary = 0;
+		/* Should we set lastbase here? */
+		yyval = zstrtol(++ptr, &ptr, lastbase = 16);
+		return NUM;
+	    }
+	/* Fall through! */
+	default:
+	    if (idigit(*--ptr)) {
+		unary = 0;
+		yyval = zstrtol(ptr, &ptr, 10);
+
+		if (*ptr == '#') {
+		    ptr++;
+		    yyval = zstrtol(ptr, &ptr, lastbase = yyval);
+		}
+		return NUM;
+	    }
+	    if (*ptr == '#') {
+		if (*++ptr == '\\') {
+		    ptr++;
+		    yyval = *ptr == Meta ? *++ptr ^ 32 : *ptr;
+		    ptr++;
+		    unary = 0;
+		    return NUM;
+		}
+		cct = 1;
+	    }
+	    if (iident(*ptr)) {
+		char *p, q;
+
+		p = ptr;
+		if (lvc == LVCOUNT) {
+		    zerr("too many identifiers (complain to author)", NULL, 0);
+		    return EOI;
+		}
+		unary = 0;
+		while (iident(*++ptr));
+		if (*ptr == '[') {
+		    int l;
+		    for (ptr++, l = 1; *ptr && l; ptr++) {
+			if (*ptr == '[')
+			    l++;
+			if (*ptr == ']')
+			    l--;
+			if (*ptr == '\\' && ptr[1])
+			    ptr++;
+		    }
+		}
+		q = *ptr;
+		*ptr = '\0';
+		lvals[yylval = lvc++] = ztrdup(p);
+		*ptr = q;
+		return cct ? CID : ID;
+	    }
+	    else if (cct) {
+		yyval = poundgetfn(NULL);
+		unary = 0;
+		return NUM;
+	    }
+	    return EOI;
+	}
+}
+
+/* the value stack */
+
+#define STACKSZ 100
+static int mtok;			/* last token */
+static int sp = -1;			/* stack pointer */
+
+struct mathvalue {
+    LV lval;
+    long val;
+};
+
+static struct mathvalue *stack;
+
+/**/
+static void
+push(long val, LV lval)
+{
+    if (sp == STACKSZ - 1)
+	zerr("stack overflow", NULL, 0);
+    else
+	sp++;
+    stack[sp].val = val;
+    stack[sp].lval = lval;
+}
+
+
+/**/
+static long
+getcvar(LV s)
+{
+    char *t;
+
+    if (!(t = getsparam(lvals[s])))
+	return 0;
+    return STOUC(*t == Meta ? t[1] ^ 32 : *t);
+}
+
+
+/**/
+static long
+setvar(LV s, long v)
+{
+    if (s == -1 || s >= lvc) {
+	zerr("lvalue required", NULL, 0);
+	return 0;
+    }
+    if (noeval)
+	return v;
+    setiparam(lvals[s], v);
+    return v;
+}
+
+
+/**/
+static int
+notzero(long a)
+{
+    if (a == 0) {
+	zerr("division by zero", NULL, 0);
+	return 0;
+    }
+    return 1;
+}
+
+/* macro to pop two values off the value stack */
+#define pop2() { \
+	if (sp < 1) { \
+ 	    zerr("bad math expression: unbalanced stack", NULL, 0); \
+	    return; \
+	} \
+	b = stack[sp--].val; \
+	a = stack[sp--].val; \
+    }
+
+/* macro to pop three values off the value stack */
+#define pop3() { \
+	if (sp < 2) { \
+ 	    zerr("bad math expression: unbalanced stack", NULL, 0); \
+	    return; \
+	} \
+	c = stack[sp--].val; \
+	b = stack[sp--].val; \
+	a = stack[sp--].val; \
+    }
+
+#define nolval() {stack[sp].lval= -1;}
+#define pushv(X) { push(X,-1); }
+#define pop2lv() { pop2() lv = stack[sp+1].lval; }
+#define set(X) { push(setvar(lv,X),lv); }
+
+
+/**/
+void
+op(int what)
+{
+    long a, b, c;
+    LV lv;
+
+    if (sp < 0) {
+	zerr("bad math expression: stack empty", NULL, 0);
+	return;
+    }
+    switch (what) {
+    case NOT:
+	stack[sp].val = !stack[sp].val;
+	nolval();
+	break;
+    case COMP:
+	stack[sp].val = ~stack[sp].val;
+	nolval();
+	break;
+    case POSTPLUS:
+	(void)setvar(stack[sp].lval, stack[sp].val + 1);
+	break;
+    case POSTMINUS:
+	(void)setvar(stack[sp].lval, stack[sp].val - 1);
+	break;
+    case UPLUS:
+	nolval();
+	break;
+    case UMINUS:
+	stack[sp].val = -stack[sp].val;
+	nolval();
+	break;
+    case AND:
+	pop2();
+	pushv(a & b);
+	break;
+    case XOR:
+	pop2();
+	pushv(a ^ b);
+	break;
+    case OR:
+	pop2();
+	pushv(a | b);
+	break;
+    case MUL:
+	pop2();
+	pushv(a * b);
+	break;
+    case DIV:
+	pop2();
+	if (notzero(b))
+	    pushv(a / b);
+	break;
+    case MOD:
+	pop2();
+	if (notzero(b))
+	    pushv(a % b);
+	break;
+    case PLUS:
+	pop2();
+	pushv(a + b);
+	break;
+    case MINUS:
+	pop2();
+	pushv(a - b);
+	break;
+    case SHLEFT:
+	pop2();
+	pushv(a << b);
+	break;
+    case SHRIGHT:
+	pop2();
+	pushv(a >> b);
+	break;
+    case LES:
+	pop2();
+	pushv((long)(a < b));
+	break;
+    case LEQ:
+	pop2();
+	pushv((long)(a <= b));
+	break;
+    case GRE:
+	pop2();
+	pushv((long)(a > b));
+	break;
+    case GEQ:
+	pop2();
+	pushv((long)(a >= b));
+	break;
+    case DEQ:
+	pop2();
+	pushv((long)(a == b));
+	break;
+    case NEQ:
+	pop2();
+	pushv((long)(a != b));
+	break;
+    case DAND:
+	pop2();
+	pushv((long)(a && b));
+	break;
+    case DOR:
+	pop2();
+	pushv((long)(a || b));
+	break;
+    case DXOR:
+	pop2();
+	pushv((long)((a && !b) || (!a && b)));
+	break;
+    case QUEST:
+	pop3();
+	pushv((a) ? b : c);
+	break;
+    case COLON:
+	break;
+    case EQ:
+	pop2();
+	lv = stack[sp + 1].lval;
+	set(b);
+	break;
+    case PLUSEQ:
+	pop2lv();
+	set(a + b);
+	break;
+    case MINUSEQ:
+	pop2lv();
+	set(a - b);
+	break;
+    case MULEQ:
+	pop2lv();
+	set(a * b);
+	break;
+    case DIVEQ:
+	pop2lv();
+	if (notzero(b))
+	    set(a / b);
+	break;
+    case MODEQ:
+	pop2lv();
+	if (notzero(b))
+	    set(a % b);
+	break;
+    case ANDEQ:
+	pop2lv();
+	set(a & b);
+	break;
+    case XOREQ:
+	pop2lv();
+	set(a ^ b);
+	break;
+    case OREQ:
+	pop2lv();
+	set(a | b);
+	break;
+    case SHLEFTEQ:
+	pop2lv();
+	set(a << b);
+	break;
+    case SHRIGHTEQ:
+	pop2lv();
+	set(a >> b);
+	break;
+    case DANDEQ:
+	pop2lv();
+	set((long)(a && b));
+	break;
+    case DOREQ:
+	pop2lv();
+	set((long)(a || b));
+	break;
+    case DXOREQ:
+	pop2lv();
+	set((long)((a && !b) || (!a && b)));
+	break;
+    case COMMA:
+	pop2();
+	pushv(b);
+	break;
+    case PREPLUS:
+	stack[sp].val = setvar(stack[sp].lval,
+			       stack[sp].val + 1);
+	break;
+    case PREMINUS:
+	stack[sp].val = setvar(stack[sp].lval,
+			       stack[sp].val - 1);
+	break;
+    case POWER:
+	pop2();
+	if (b < 0) {
+	    zerr("can't handle negative exponents", NULL, 0);
+	    return;
+	}
+	for (c = 1; b--; c *= a);
+	pushv(c);
+	break;
+    case POWEREQ:
+	pop2lv();
+	if (b < 0) {
+	    zerr("can't handle negative exponents", NULL, 0);
+	    return;
+	}
+	for (c = 1; b--; c *= a);
+	set(c);
+	break;
+    default:
+	zerr("out of integers", NULL, 0);
+	return;
+    }
+}
+
+
+/**/
+static void
+bop(int tk)
+{
+    switch (tk) {
+    case DAND:
+    case DANDEQ:
+	if (!stack[sp].val)
+	    noeval++;
+	break;
+    case DOR:
+    case DOREQ:
+	if (stack[sp].val)
+	    noeval++;
+	break;
+    };
+}
+
+
+/**/
+static long
+mathevall(char *s, int prek, char **ep)
+{
+    int t0;
+    int xlastbase, xnoeval, xunary, xlvc;
+    char *xptr;
+    long xyyval;
+    LV xyylval;
+    char **xlvals = 0;
+    int xsp;
+    struct mathvalue *xstack = 0;
+    long ret;
+
+    xlastbase = xnoeval = xunary = xlvc = xyyval = xyylval = xsp = 0;
+    xptr = NULL;
+    if (mlevel++) {
+	xlastbase = lastbase;
+	xnoeval = noeval;
+	xunary = unary;
+	xlvc = lvc;
+	xptr = ptr;
+	xyyval = yyval;
+	xyylval = yylval;
+	xlvals = lvals;
+
+	xsp = sp;
+	xstack = stack;
+    }
+    stack = (struct mathvalue *)zalloc(STACKSZ*sizeof(struct mathvalue));
+    lastbase = -1;
+    lvals = (char **)zcalloc(LVCOUNT*sizeof(char *));
+    lvc = 0;
+    ptr = s;
+    sp = -1;
+    unary = 1;
+    mathparse(prek);
+    *ep = ptr;
+    if (sp)
+	zerr("bad math expression: unbalanced stack", NULL, 0);
+    for (t0 = 0; t0 != lvc; t0++)
+	zsfree(lvals[t0]);
+
+    ret = stack[0].val;
+
+    zfree(lvals, LVCOUNT*sizeof(char *));
+    zfree(stack, STACKSZ*sizeof(struct mathvalue));
+    if (--mlevel) {
+	lastbase = xlastbase;
+	noeval = xnoeval;
+	unary = xunary;
+	lvc = xlvc;
+	ptr = xptr;
+	yyval = xyyval;
+	yylval = xyylval;
+	lvals = xlvals;
+
+	sp = xsp;
+	stack = xstack;
+    }
+    return ret;
+}
+
+
+/**/
+long
+matheval(char *s)
+{
+    char *junk;
+    long x;
+    int xmtok = mtok;
+
+    if (!*s)
+	return 0;
+    x = mathevall(s, TOPPREC, &junk);
+    mtok = xmtok;
+    if (*junk)
+	zerr("bad math expression: illegal character: %c", NULL, *junk);
+    return x;
+}
+
+
+/**/
+long
+mathevalarg(char *s, char **ss)
+{
+    long x;
+    int xmtok = mtok;
+
+    x = mathevall(s, ARGPREC, ss);
+    if (mtok == COMMA)
+	(*ss)--;
+    mtok = xmtok;
+    return x;
+}
+
+
+/* operator-precedence parse the string and execute */
+
+/**/
+static void
+mathparse(int pc)
+{
+    int q, otok, onoeval;
+
+    if (errflag)
+	return;
+    mtok = zzlex();
+    while (prec[mtok] <= pc) {
+	if (errflag)
+	    return;
+	switch (mtok) {
+	case NUM:
+	    push(yyval, -1);
+	    break;
+	case ID:
+	    push(getiparam(lvals[yylval]), yylval);
+	    break;
+	case CID:
+	    push(getcvar(yylval), yylval);
+	    break;
+	case M_INPAR:
+	    mathparse(TOPPREC);
+	    if (mtok != M_OUTPAR) {
+		if (!errflag)
+		    zerr("')' expected", NULL, 0);
+		return;
+	    }
+	    break;
+	case QUEST:
+	    q = stack[sp].val;
+
+	    if (!q)
+		noeval++;
+	    mathparse(prec[QUEST] - 1);
+	    if (!q)
+		noeval--;
+	    else
+		noeval++;
+	    mathparse(prec[QUEST]);
+	    if (q)
+		noeval--;
+	    op(QUEST);
+	    continue;
+	default:
+	    otok = mtok;
+	    onoeval = noeval;
+	    if (type[otok] == BOOL)
+		bop(otok);
+	    mathparse(prec[otok] - (type[otok] != RL));
+	    noeval = onoeval;
+	    op(otok);
+	    continue;
+	}
+	mtok = zzlex();
+    }
+}
diff --git a/Src/mem.c b/Src/mem.c
new file mode 100644
index 000000000..1145f8c5e
--- /dev/null
+++ b/Src/mem.c
@@ -0,0 +1,1254 @@
+/*
+ * mem.c - memory management
+ *
+ * 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 "mem.pro"
+
+/*
+	There are two ways to allocate memory in zsh.  The first way is
+	to call zalloc/zcalloc, which call malloc/calloc directly.  It
+	is legal to call realloc() or free() on memory allocated this way.
+	The second way is to call halloc/hcalloc, which allocates memory
+	from one of the memory pools on the heap stack.  Such memory pools 
+	will automatically created when the heap allocation routines are
+	called.  To be sure that they are freed at appropriate times
+	one should call pushheap() before one starts using heaps and
+	popheap() after that (when the memory allocated on the heaps since
+	the last pushheap() isn't needed anymore).
+	pushheap() saves the states of all currently allocated heaps and
+	popheap() resets them to the last state saved and destroys the
+	information about that state.  If you called pushheap() and
+	allocated some memory on the heaps and then come to a place where
+	you don't need the allocated memory anymore but you still want
+	to allocate memory on the heap, you should call freeheap().  This
+	works like popheap(), only that it doesn't free the information
+	about the heap states (i.e. the heaps are like after the call to
+	pushheap() and you have to call popheap some time later).
+
+	Memory allocated in this way does not have to be freed explicitly;
+	it will all be freed when the pool is destroyed.  In fact,
+	attempting to free this memory may result in a core dump.
+	The pair of pointers ncalloc and alloc may point to either
+	zalloc & zcalloc or halloc & hcalloc; permalloc() sets them to the
+	former, and heapalloc() sets them to the latter. This can be useful.
+	For example, the dupstruct() routine duplicates a syntax tree,
+	allocating the new memory for the tree using alloc().  If you want
+	to duplicate a structure for a one-time use (i.e. to execute the list
+	in a for loop), call heapalloc(), then dupstruct().  If you want
+	to duplicate a structure in order to preserve it (i.e. a function
+	definition), call permalloc(), then dupstruct().
+
+	If we use zsh's own allocator we use a simple trick to avoid that
+	the (*real*) heap fills up with empty zsh-heaps: we allocate a
+	large block of memory before allocating a heap pool, this memory
+	is freed again immediately after the pool is allocated. If there
+	are only small blocks on the free list this guarantees that the
+	memory for the pool is at the end of the memory which means that
+	we can give it back to the system when the pool is freed.
+*/
+
+/* != 0 if we are allocating in the heaplist */
+ 
+/**/
+int useheap;
+
+/* Current allocation pointers.  ncalloc() is either zalloc() or halloc(); *
+ * alloc() is either zcalloc() or hcalloc().                               */
+
+/**/
+void *(*ncalloc) _((size_t)), *(*alloc) _((size_t));
+
+#ifdef ZSH_MEM_WARNING
+# ifndef DEBUG
+#  define DEBUG 1
+# endif
+#endif
+
+#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG)
+
+static int h_m[1025], h_push, h_pop, h_free;
+
+#endif
+
+#define H_ISIZE  sizeof(long)
+#define HEAPSIZE (8192 - H_ISIZE)
+#define HEAP_ARENA_SIZE (HEAPSIZE - sizeof(struct heap))
+#define HEAPFREE (16384 - H_ISIZE)
+
+/* set default allocation to heap stack */
+
+/**/
+int
+global_heapalloc(void)
+{
+    int luh = useheap;
+
+    alloc = hcalloc;
+    ncalloc = halloc;
+    useheap = 1;
+    return luh;
+}
+
+/* set default allocation to malloc() */
+
+/**/
+int
+global_permalloc(void)
+{
+    int luh = useheap;
+
+    alloc = zcalloc;
+    ncalloc = zalloc;
+    useheap = 0;
+    return luh;
+}
+
+/* heappush saves the current heap state using this structure */
+
+struct heapstack {
+    struct heapstack *next;	/* next one in list for this heap */
+    size_t used;
+};
+
+/* A zsh heap. */
+
+struct heap {
+    struct heap *next;		/* next one                                  */
+    size_t used;		/* bytes used from the heap                  */
+    struct heapstack *sp;	/* used by pushheap() to save the value used */
+#define arena(X)	((char *) (X) + sizeof(struct heap))
+};
+
+/* list of zsh heap */
+
+static Heap heaps;
+
+/* save states of zsh heaps */
+
+/**/
+void
+pushheap(void)
+{
+    Heap h;
+    Heapstack hs;
+
+#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG)
+    h_push++;
+#endif
+
+    for (h = heaps; h; h = h->next) {
+	DPUTS(!h->used, "BUG: empty heap");
+	hs = (Heapstack) zalloc(sizeof(*hs));
+	hs->next = h->sp;
+	h->sp = hs;
+	hs->used = h->used;
+    }
+}
+
+/* reset heaps to previous state */
+
+/**/
+void
+freeheap(void)
+{
+    Heap h, hn, hl = NULL;
+
+#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG)
+    h_free++;
+#endif
+    for (h = heaps; h; h = hn) {
+	hn = h->next;
+	if (h->sp) {
+#ifdef ZSH_MEM_DEBUG
+	    memset(arena(h) + h->sp->used, 0xff, h->used - h->sp->used);
+#endif
+	    h->used = h->sp->used;
+	    hl = h;
+	} else
+	    zfree(h, HEAPSIZE);
+    }
+    if (hl)
+	hl->next = NULL;
+    else
+	heaps = NULL;
+}
+
+/* reset heap to previous state and destroy state information */
+
+/**/
+void
+popheap(void)
+{
+    Heap h, hn, hl = NULL;
+    Heapstack hs;
+
+#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG)
+    h_pop++;
+#endif
+
+    for (h = heaps; h; h = hn) {
+	hn = h->next;
+	if ((hs = h->sp)) {
+	    h->sp = hs->next;
+#ifdef ZSH_MEM_DEBUG
+	    memset(arena(h) + hs->used, 0xff, h->used - hs->used);
+#endif
+	    h->used = hs->used;
+	    zfree(hs, sizeof(*hs));
+
+	    hl = h;
+	} else
+	    zfree(h, HEAPSIZE);
+    }
+    if (hl)
+	hl->next = NULL;
+    else
+	heaps = NULL;
+}
+
+/* allocate memory from the current memory pool */
+
+/**/
+void *
+halloc(size_t size)
+{
+    Heap h;
+    size_t n;
+
+    size = (size + H_ISIZE - 1) & ~(H_ISIZE - 1);
+
+#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG)
+    h_m[size < 1024 ? (size / H_ISIZE) : 1024]++;
+#endif
+
+    /* find a heap with enough free space */
+
+    for (h = heaps; h; h = h->next) {
+	if (HEAP_ARENA_SIZE >= (n = size + h->used)) {
+	    h->used = n;
+	    return arena(h) + n - size;
+	}
+    }
+
+    {
+	Heap hp;
+        /* not found, allocate new heap */
+#ifdef ZSH_MEM
+	static int called = 0;
+	void *foo = called ? (void *)malloc(HEAPFREE) : NULL;
+            /* tricky, see above */
+#endif
+
+	queue_signals();
+	n = HEAP_ARENA_SIZE > size ? HEAPSIZE : size + sizeof(*h);
+	for (hp = NULL, h = heaps; h; hp = h, h = h->next);
+
+	h = (Heap) zalloc(n);
+
+#ifdef ZSH_MEM
+	if (called)
+	    zfree(foo, HEAPFREE);
+	called = 1;
+#endif
+
+	h->used = size;
+	h->next = NULL;
+	h->sp = NULL;
+
+	if (hp)
+	    hp->next = h;
+	else
+	    heaps = h;
+
+	unqueue_signals();
+	return arena(h);
+    }
+}
+
+/**/
+void *
+hrealloc(char *p, size_t old, size_t new)
+{
+    Heap h, ph;
+
+    old = (old + H_ISIZE - 1) & ~(H_ISIZE - 1);
+    new = (new + H_ISIZE - 1) & ~(H_ISIZE - 1);
+
+    if (old == new)
+	return p;
+    if (!old && !p)
+	return halloc(new);
+
+    /* find the heap with p */
+
+    for (h = heaps, ph = NULL; h; ph = h, h = h->next)
+	if (p >= arena(h) && p < arena(h) + HEAP_ARENA_SIZE)
+	    break;
+
+    DPUTS(!h, "BUG: hrealloc() called for non-heap memory.");
+    DPUTS(h->sp && arena(h) + h->sp->used > p,
+	  "BUG: hrealloc() wants to realloc pushed memory");
+
+    if (p + old < arena(h) + h->used) {
+	if (new > old) {
+	    char *ptr = (char *) halloc(new);
+	    memcpy(ptr, p, old);
+	    return ptr;
+	} else
+	    return new ? p : NULL;
+    }
+
+    DPUTS(p + old != arena(h) + h->used, "BUG: hrealloc more than allocated");
+
+    if (p == arena(h)) {
+	if (!new) {
+	    if (ph)
+		ph->next = h->next;
+	    else
+		heaps = h->next;
+	    zfree(h, HEAPSIZE);
+	    return NULL;
+	}
+	if (old > HEAP_ARENA_SIZE || new > HEAP_ARENA_SIZE) {
+	    size_t n = HEAP_ARENA_SIZE > new ? HEAPSIZE : new + sizeof(*h);
+
+	    if (ph)
+		ph->next = h = (Heap) realloc(h, n);
+	    else
+		heaps = h = (Heap) realloc(h, n);
+	}
+	h->used = new;
+	return arena(h);
+    }
+    DPUTS(h->used > HEAP_ARENA_SIZE, "BUG: hrealloc at invalid address");
+    if (h->used + (new - old) <= HEAP_ARENA_SIZE) {
+	h->used += new - old;
+	return p;
+    } else {
+	char *t = halloc(new);
+	memcpy(t, p, old > new ? new : old);
+	h->used -= old;
+#ifdef ZSH_MEM_DEBUG
+	memset(p, 0xff, old);
+#endif
+	return t;
+    }
+}
+
+/* allocate memory from the current memory pool and clear it */
+
+/**/
+void *
+hcalloc(size_t size)
+{
+    void *ptr;
+
+    ptr = halloc(size);
+    memset(ptr, 0, size);
+    return ptr;
+}
+
+/* allocate permanent memory */
+
+/**/
+void *
+zalloc(size_t size)
+{
+    void *ptr;
+
+    if (!size)
+	size = 1;
+    if (!(ptr = (void *) malloc(size))) {
+	zerr("fatal error: out of memory", NULL, 0);
+	exit(1);
+    }
+
+    return ptr;
+}
+
+/**/
+void *
+zcalloc(size_t size)
+{
+    void *ptr;
+
+    if (!size)
+	size = 1;
+    if (!(ptr = (void *) malloc(size))) {
+	zerr("fatal error: out of memory", NULL, 0);
+	exit(1);
+    }
+    memset(ptr, 0, size);
+
+    return ptr;
+}
+
+/* This front-end to realloc is used to make sure we have a realloc *
+ * that conforms to POSIX realloc.  Older realloc's can fail if     *
+ * passed a NULL pointer, but POSIX realloc should handle this.  A  *
+ * better solution would be for configure to check if realloc is    *
+ * POSIX compliant, but I'm not sure how to do that.                */
+
+/**/
+void *
+zrealloc(void *ptr, size_t size)
+{
+    if (ptr) {
+	if (size) {
+	    /* Do normal realloc */
+	    if (!(ptr = (void *) realloc(ptr, size))) {
+		zerr("fatal error: out of memory", NULL, 0);
+		exit(1);
+	    }
+	    return ptr;
+	}
+	else
+	    /* If ptr is not NULL, but size is zero, *
+	     * then object pointed to is freed.      */
+	    free(ptr);
+    } else {
+	/* If ptr is NULL, then behave like malloc */
+	return malloc(size);
+    }
+
+    return NULL;
+}
+
+/**/
+char *
+dupstring(const char *s)
+{
+    char *t;
+
+    if (!s)
+	return NULL;
+    t = (char *)ncalloc(strlen((char *)s) + 1);
+    strcpy(t, s);
+    return t;
+}
+
+/**/
+char *
+ztrdup(const char *s)
+{
+    char *t;
+
+    if (!s)
+	return NULL;
+    t = (char *)zalloc(strlen((char *)s) + 1);
+    strcpy(t, s);
+    return t;
+}
+
+#ifdef ZSH_MEM
+
+/*
+   Below is a simple segment oriented memory allocator for systems on
+   which it is better than the system's one. Memory is given in blocks
+   aligned to an integer multiple of sizeof(long) (4 bytes on most machines,
+   but 8 bytes on e.g. a dec alpha). Each block is preceded by a header
+   which contains the length of the data part (in bytes). In allocated
+   blocks only this field of the structure m_hdr is senseful. In free
+   blocks the second field (next) is a pointer to the next free segment
+   on the free list.
+
+   On top of this simple allocator there is a second allocator for small
+   chunks of data. It should be both faster and less space-consuming than
+   using the normal segment mechanism for such blocks.
+   For the first M_NSMALL-1 possible sizes memory is allocated in arrays
+   that can hold M_SNUM blocks. Each array is stored in one segment of the
+   main allocator. In these segments the third field of the header structure
+   (free) contains a pointer to the first free block in the array. The
+   last field (used) gives the number of already used blocks in the array.
+
+   If the macro name ZSH_MEM_DEBUG is defined, some information about the memory
+   usage is stored. This information can than be viewed by calling the
+   builtin `mem' (which is only available if ZSH_MEM_DEBUG is set).
+
+   If ZSH_MEM_WARNING is defined, error messages are printed in case of errors.
+
+   If ZSH_SECURE_FREE is defined, free() checks if the given address is really
+   one that was returned by malloc(), it ignores it if it wasn't (printing
+   an error message if ZSH_MEM_WARNING is also defined).
+*/
+#if !defined(__hpux) && !defined(DGUX) && !defined(__osf__)
+# if defined(_BSD)
+#  ifndef HAVE_BRK_PROTO
+   extern int brk _((caddr_t));
+#  endif
+#  ifndef HAVE_SBRK_PROTO
+   extern caddr_t sbrk _((int));
+#  endif
+# else
+#  ifndef HAVE_BRK_PROTO
+   extern int brk _((void *));
+#  endif
+#  ifndef HAVE_SBRK_PROTO
+   extern void *sbrk _((int));
+#  endif
+# endif
+#endif
+
+#if defined(_BSD) && !defined(STDC_HEADERS)
+# define FREE_RET_T   int
+# define FREE_ARG_T   char *
+# define FREE_DO_RET
+# define MALLOC_RET_T char *
+# define MALLOC_ARG_T size_t
+#else
+# define FREE_RET_T   void
+# define FREE_ARG_T   void *
+# define MALLOC_RET_T void *
+# define MALLOC_ARG_T size_t
+#endif
+
+/* structure for building free list in blocks holding small blocks */
+
+struct m_shdr {
+    struct m_shdr *next;	/* next one on free list */
+};
+
+struct m_hdr {
+    long len;			/* length of memory block */
+    struct m_hdr *next;		/* if free: next on free list
+				   if block of small blocks: next one with
+				                 small blocks of same size*/
+    struct m_shdr *free;	/* if block of small blocks: free list */
+    long used;			/* if block of small blocks: number of used
+				                                     blocks */
+};
+
+
+/* alignment for memory blocks */
+
+#define M_ALIGN (sizeof(long))
+
+/* length of memory header, length of first field of memory header and
+   minimal size of a block left free (if we allocate memory and take a
+   block from the free list that is larger than needed, it must have at
+   least M_MIN extra bytes to be splitted; if it has, the rest is put on
+   the free list) */
+
+#define M_HSIZE (sizeof(struct m_hdr))
+#define M_ISIZE (sizeof(long))
+#define M_MIN   (2 * M_ISIZE)
+
+/* a pointer to the last free block, a pointer to the free list (the blocks
+   on this list are kept in order - lowest address first) */
+
+static struct m_hdr *m_lfree, *m_free;
+
+/* system's pagesize */
+
+static long m_pgsz = 0;
+
+/* the highest and the lowest valid memory addresses, kept for fast validity
+   checks in free() and to find out if and when we can give memory back to
+   the system */
+
+static char *m_high, *m_low;
+
+/* Management of blocks for small blocks:
+   Such blocks are kept in lists (one list for each of the sizes that are
+   allocated in such blocks).  The lists are stored in the m_small array.
+   M_SIDX() calculates the index into this array for a given size.  M_SNUM
+   is the size (in small blocks) of such blocks.  M_SLEN() calculates the
+   size of the small blocks held in a memory block, given a pointer to the
+   header of it.  M_SBLEN() gives the size of a memory block that can hold
+   an array of small blocks, given the size of these small blocks.  M_BSLEN()
+   caculates the size of the small blocks held in a memory block, given the
+   length of that block (including the header of the memory block.  M_NSMALL
+   is the number of possible block sizes that small blocks should be used
+   for. */
+
+
+#define M_SIDX(S)  ((S) / M_ISIZE)
+#define M_SNUM     50
+#define M_SLEN(M)  ((M)->len / M_SNUM)
+#define M_SBLEN(S) ((S) * M_SNUM + sizeof(struct m_shdr *) +  \
+		    sizeof(long) + sizeof(struct m_hdr *))
+#define M_BSLEN(S) (((S) - sizeof(struct m_shdr *) -  \
+		     sizeof(long) - sizeof(struct m_hdr *)) / M_SNUM)
+#define M_NSMALL 8
+
+static struct m_hdr *m_small[M_NSMALL];
+
+#ifdef ZSH_MEM_DEBUG
+
+static int m_s = 0, m_b = 0;
+static int m_m[1025], m_f[1025];
+
+static struct m_hdr *m_l;
+
+#endif /* ZSH_MEM_DEBUG */
+
+MALLOC_RET_T
+malloc(MALLOC_ARG_T size)
+{
+    struct m_hdr *m, *mp, *mt;
+    long n, s, os = 0;
+    struct heap *h, *hp, *hf = NULL, *hfp = NULL;
+
+    /* some systems want malloc to return the highest valid address plus one
+       if it is called with an argument of zero */
+
+    if (!size)
+	return (MALLOC_RET_T) m_high;
+
+    queue_signals();  /* just queue signals rather than handling them */
+
+    /* first call, get page size */
+
+    if (!m_pgsz) {
+
+#ifdef _SC_PAGESIZE
+	m_pgsz = sysconf(_SC_PAGESIZE);     /* SVR4 */
+#else
+# ifdef _SC_PAGE_SIZE
+	m_pgsz = sysconf(_SC_PAGE_SIZE);    /* HPUX */
+# else
+	m_pgsz = getpagesize();
+# endif
+#endif
+
+	m_free = m_lfree = NULL;
+    }
+    size = (size + M_ALIGN - 1) & ~(M_ALIGN - 1);
+
+    /* Do we need a small block? */
+
+    if ((s = M_SIDX(size)) && s < M_NSMALL) {
+	/* yep, find a memory block with free small blocks of the
+	   appropriate size (if we find it in this list, this means that
+	   it has room for at least one more small block) */
+	for (mp = NULL, m = m_small[s]; m && !m->free; mp = m, m = m->next);
+
+	if (m) {
+	    /* we found one */
+	    struct m_shdr *sh = m->free;
+
+	    m->free = sh->next;
+	    m->used++;
+
+	    /* if all small blocks in this block are allocated, the block is 
+	       put at the end of the list blocks wth small blocks of this
+	       size (i.e., we try to keep blocks with free blocks at the
+	       beginning of the list, to make the search faster */
+
+	    if (m->used == M_SNUM && m->next) {
+		for (mt = m; mt->next; mt = mt->next);
+
+		mt->next = m;
+		if (mp)
+		    mp->next = m->next;
+		else
+		    m_small[s] = m->next;
+		m->next = NULL;
+	    }
+#ifdef ZSH_MEM_DEBUG
+	    m_m[size / M_ISIZE]++;
+#endif
+
+	    unqueue_signals();
+	    return (MALLOC_RET_T) sh;
+	}
+	/* we still want a small block but there were no block with a free
+	   small block of the requested size; so we use the real allocation
+	   routine to allocate a block for small blocks of this size */
+	os = size;
+	size = M_SBLEN(size);
+    } else
+	s = 0;
+
+/* search the free list for an block of at least the requested size */
+    for (mp = NULL, m = m_free; m && m->len < size; mp = m, m = m->next);
+
+ /* if there is an empty zsh heap at a lower address we steal it and take
+    the memory from it, putting the rest on the free list (remember
+    that the blocks on the free list are ordered) */
+
+    for (hp = NULL, h = heaps; h; hp = h, h = h->next)
+	if (!h->used &&
+	    (!hf || h < hf) &&
+	    (!m || ((char *)m) > ((char *)h)))
+	    hf = h, hfp = hp;
+
+    if (hf) {
+	/* we found such a heap */
+	Heapstack hso, hsn;
+
+	/* delete structures on the list holding the heap states */
+	for (hso = hf->sp; hso; hso = hsn) {
+	    hsn = hso->next;
+	    zfree(hso, sizeof(*hso));
+	}
+	/* take it from the list of heaps */
+	if (hfp)
+	    hfp->next = hf->next;
+	else
+	    heaps = hf->next;
+	/* now we simply free it and than search the free list again */
+	zfree(hf, HEAPSIZE);
+
+	for (mp = NULL, m = m_free; m && m->len < size; mp = m, m = m->next);
+    }
+    if (!m) {
+	/* no matching free block was found, we have to request new
+	   memory from the system */
+	n = (size + M_HSIZE + m_pgsz - 1) & ~(m_pgsz - 1);
+
+	if (((char *)(m = (struct m_hdr *)sbrk(n))) == ((char *)-1)) {
+	    DPUTS(1, "MEM: allocation error at sbrk.");
+	    unqueue_signals();
+	    return NULL;
+	}
+	/* set m_low, for the check in free() */
+	if (!m_low)
+	    m_low = (char *)m;
+
+#ifdef ZSH_MEM_DEBUG
+	m_s += n;
+
+	if (!m_l)
+	    m_l = m;
+#endif
+
+	/* save new highest address */
+	m_high = ((char *)m) + n;
+
+	/* initialize header */
+	m->len = n - M_ISIZE;
+	m->next = NULL;
+
+	/* put it on the free list and set m_lfree pointing to it */
+	if ((mp = m_lfree))
+	    m_lfree->next = m;
+	m_lfree = m;
+    }
+    if ((n = m->len - size) > M_MIN) {
+	/* the block we want to use has more than M_MIN bytes plus the
+	   number of bytes that were requested; we split it in two and
+	   leave the rest on the free list */
+	struct m_hdr *mtt = (struct m_hdr *)(((char *)m) + M_ISIZE + size);
+
+	mtt->len = n - M_ISIZE;
+	mtt->next = m->next;
+
+	m->len = size;
+
+	/* put the rest on the list */
+	if (m_lfree == m)
+	    m_lfree = mtt;
+
+	if (mp)
+	    mp->next = mtt;
+	else
+	    m_free = mtt;
+    } else if (mp) {
+	/* the block we found wasn't the first one on the free list */
+	if (m == m_lfree)
+	    m_lfree = mp;
+	mp->next = m->next;
+    } else {
+	/* it was the first one */
+	m_free = m->next;
+	if (m == m_lfree)
+	    m_lfree = m_free;
+    }
+
+    if (s) {
+	/* we are allocating a block that should hold small blocks */
+	struct m_shdr *sh, *shn;
+
+	/* build the free list in this block and set `used' filed */
+	m->free = sh = (struct m_shdr *)(((char *)m) +
+					 sizeof(struct m_hdr) + os);
+
+	for (n = M_SNUM - 2; n--; sh = shn)
+	    shn = sh->next = sh + s;
+	sh->next = NULL;
+
+	m->used = 1;
+
+	/* put the block on the list of blocks holding small blocks if
+	   this size */
+	m->next = m_small[s];
+	m_small[s] = m;
+
+#ifdef ZSH_MEM_DEBUG
+	m_m[os / M_ISIZE]++;
+#endif
+
+	unqueue_signals();
+	return (MALLOC_RET_T) (((char *)m) + sizeof(struct m_hdr));
+    }
+#ifdef ZSH_MEM_DEBUG
+    m_m[m->len < (1024 * M_ISIZE) ? (m->len / M_ISIZE) : 1024]++;
+#endif
+
+    unqueue_signals();
+    return (MALLOC_RET_T) & m->next;
+}
+
+/* this is an internal free(); the second argument may, but need not hold
+   the size of the block the first argument is pointing to; if it is the
+   right size of this block, freeing it will be faster, though; the value
+   0 for this parameter means: `don't know' */
+
+/**/
+void
+zfree(void *p, int sz)
+{
+    struct m_hdr *m = (struct m_hdr *)(((char *)p) - M_ISIZE), *mp, *mt = NULL;
+    int i;
+# ifdef DEBUG
+    int osz = sz;
+# endif
+
+#ifdef ZSH_SECURE_FREE
+    sz = 0;
+#else
+    sz = (sz + M_ALIGN - 1) & ~(M_ALIGN - 1);
+#endif
+
+    if (!p)
+	return;
+
+    /* first a simple check if the given address is valid */
+    if (((char *)p) < m_low || ((char *)p) > m_high ||
+	((long)p) & (M_ALIGN - 1)) {
+	DPUTS(1, "BUG: attempt to free storage at invalid address");
+	return;
+    }
+
+    queue_signals();
+
+  fr_rec:
+
+    if ((i = sz / M_ISIZE) < M_NSMALL || !sz)
+	/* if the given sizes says that it is a small block, find the
+	   memory block holding it; we search all blocks with blocks
+	   of at least the given size; if the size parameter is zero,
+	   this means, that all blocks are searched */
+	for (; i < M_NSMALL; i++) {
+	    for (mp = NULL, mt = m_small[i];
+		 mt && (((char *)mt) > ((char *)p) ||
+			(((char *)mt) + mt->len) < ((char *)p));
+		 mp = mt, mt = mt->next);
+
+	    if (mt) {
+		/* we found the block holding the small block */
+		struct m_shdr *sh = (struct m_shdr *)p;
+
+#ifdef ZSH_SECURE_FREE
+		struct m_shdr *sh2;
+
+		/* check if the given address is equal to the address of
+		   the first small block plus an integer multiple of the
+		   block size */
+		if ((((char *)p) - (((char *)mt) + sizeof(struct m_hdr))) %
+		    M_BSLEN(mt->len)) {
+
+		    DPUTS(1, "BUG: attempt to free storage at invalid address");
+		    unqueue_signals();
+		    return;
+		}
+		/* check, if the address is on the (block-intern) free list */
+		for (sh2 = mt->free; sh2; sh2 = sh2->next)
+		    if (((char *)p) == ((char *)sh2)) {
+
+			DPUTS(1, "BUG: attempt to free already free storage");
+			unqueue_signals();
+			return;
+		    }
+#endif
+		DPUTS(M_BSLEN(mt->len) < osz,
+		      "BUG: attempt to free more than allocated.");
+
+#ifdef ZSH_MEM_DEBUG
+		m_f[M_BSLEN(mt->len) / M_ISIZE]++;
+		memset(sh, 0xff, M_BSLEN(mt->len));
+#endif
+
+		/* put the block onto the free list */
+		sh->next = mt->free;
+		mt->free = sh;
+
+		if (--mt->used) {
+		    /* if there are still used blocks in this block, we
+		       put it at the beginning of the list with blocks
+		       holding small blocks of the same size (since we
+		       know that there is at least one free block in it,
+		       this will make allocation of small blocks faster;
+		       it also guarantees that long living memory blocks
+		       are preferred over younger ones */
+		    if (mp) {
+			mp->next = mt->next;
+			mt->next = m_small[i];
+			m_small[i] = mt;
+		    }
+		    unqueue_signals();
+		    return;
+		}
+		/* if there are no more used small blocks in this
+		   block, we free the whole block */
+		if (mp)
+		    mp->next = mt->next;
+		else
+		    m_small[i] = mt->next;
+
+		m = mt;
+		p = (void *) & m->next;
+
+		break;
+	    } else if (sz) {
+		/* if we didn't find a block and a size was given, try it
+		   again as if no size were given */
+		sz = 0;
+		goto fr_rec;
+	    }
+	}
+#ifdef ZSH_MEM_DEBUG
+    if (!mt)
+	m_f[m->len < (1024 * M_ISIZE) ? (m->len / M_ISIZE) : 1024]++;
+#endif
+
+#ifdef ZSH_SECURE_FREE
+    /* search all memory blocks, if one of them is at the given address */
+    for (mt = (struct m_hdr *)m_low;
+	 ((char *)mt) < m_high;
+	 mt = (struct m_hdr *)(((char *)mt) + M_ISIZE + mt->len))
+	if (((char *)p) == ((char *)&mt->next))
+	    break;
+
+    /* no block was found at the given address */
+    if (((char *)mt) >= m_high) {
+	DPUTS(1, "BUG: attempt to free storage at invalid address");
+	unqueue_signals();
+	return;
+    }
+#endif
+
+    /* see if the block is on the free list */
+    for (mp = NULL, mt = m_free; mt && mt < m; mp = mt, mt = mt->next);
+
+    if (m == mt) {
+	/* it is, ouch! */
+	DPUTS(1, "BUG: attempt to free already free storage");
+	unqueue_signals();
+	return;
+    }
+    DPUTS(m->len < osz, "BUG: attempt to free more than allocated");
+#ifdef ZSH_MEM_DEBUG
+    memset(p, 0xff, m->len);
+#endif
+    if (mt && ((char *)mt) == (((char *)m) + M_ISIZE + m->len)) {
+	/* the block after the one we are freeing is free, we put them
+	   together */
+	m->len += mt->len + M_ISIZE;
+	m->next = mt->next;
+
+	if (mt == m_lfree)
+	    m_lfree = m;
+    } else
+	m->next = mt;
+
+    if (mp && ((char *)m) == (((char *)mp) + M_ISIZE + mp->len)) {
+	/* the block before the one we are freeing is free, we put them
+	   together */
+	mp->len += m->len + M_ISIZE;
+	mp->next = m->next;
+
+	if (m == m_lfree)
+	    m_lfree = mp;
+    } else if (mp)
+	/* otherwise, we just put it on the free list */
+	mp->next = m;
+    else {
+	m_free = m;
+	if (!m_lfree)
+	    m_lfree = m_free;
+    }
+
+    /* if the block we have just freed was at the end of the process heap
+       and now there is more than one page size of memory, we can give
+       it back to the system (and we do it ;-) */
+    if ((((char *)m_lfree) + M_ISIZE + m_lfree->len) == m_high &&
+	m_lfree->len >= m_pgsz + M_MIN) {
+	long n = (m_lfree->len - M_MIN) & ~(m_pgsz - 1);
+
+	m_lfree->len -= n;
+	if (brk(m_high -= n) == -1)
+	    DPUTS(1, "MEM: allocation error at brk.");
+
+#ifdef ZSH_MEM_DEBUG
+	m_b += n;
+#endif
+    }
+    unqueue_signals();
+}
+
+FREE_RET_T
+free(FREE_ARG_T p)
+{
+    zfree(p, 0);		/* 0 means: size is unknown */
+
+#ifdef FREE_DO_RET
+    return 0;
+#endif
+}
+
+/* this one is for strings (and only strings, real strings, real C strings,
+   those that have a zero byte at the end) */
+
+/**/
+void
+zsfree(char *p)
+{
+    if (p)
+	zfree(p, strlen(p) + 1);
+}
+
+MALLOC_RET_T
+realloc(MALLOC_RET_T p, MALLOC_ARG_T size)
+{
+    struct m_hdr *m = (struct m_hdr *)(((char *)p) - M_ISIZE), *mp, *mt;
+    char *r;
+    int i, l = 0;
+
+    /* some system..., see above */
+    if (!p && size)
+	return (MALLOC_RET_T) malloc(size);
+    /* and some systems even do this... */
+    if (!p || !size)
+	return (MALLOC_RET_T) p;
+
+    queue_signals();  /* just queue signals caught rather than handling them */
+
+    /* check if we are reallocating a small block, if we do, we have
+       to compute the size of the block from the sort of block it is in */
+    for (i = 0; i < M_NSMALL; i++) {
+	for (mp = NULL, mt = m_small[i];
+	     mt && (((char *)mt) > ((char *)p) ||
+		    (((char *)mt) + mt->len) < ((char *)p));
+	     mp = mt, mt = mt->next);
+
+	if (mt) {
+	    l = M_BSLEN(mt->len);
+	    break;
+	}
+    }
+    if (!l)
+	/* otherwise the size of the block is in the memory just before
+	   the given address */
+	l = m->len;
+
+    /* now allocate the new block, copy the old contents, and free the
+       old block */
+    r = malloc(size);
+    memcpy(r, (char *)p, (size > l) ? l : size);
+    free(p);
+
+    unqueue_signals();
+    return (MALLOC_RET_T) r;
+}
+
+MALLOC_RET_T
+calloc(MALLOC_ARG_T n, MALLOC_ARG_T size)
+{
+    long l;
+    char *r;
+
+    if (!(l = n * size))
+	return (MALLOC_RET_T) m_high;
+
+    r = malloc(l);
+
+    memset(r, 0, l);
+
+    return (MALLOC_RET_T) r;
+}
+
+#ifdef ZSH_MEM_DEBUG
+
+/**/
+int
+bin_mem(char *name, char **argv, char *ops, int func)
+{
+    int i, ii, fi, ui, j;
+    struct m_hdr *m, *mf, *ms;
+    char *b, *c, buf[40];
+    long u = 0, f = 0;
+
+    if (ops['v']) {
+	printf("The lower and the upper addresses of the heap. Diff gives\n");
+	printf("the difference between them, i.e. the size of the heap.\n\n");
+    }
+    printf("low mem %ld\t high mem %ld\t diff %ld\n",
+	   (long)m_l, (long)m_high, (long)(m_high - ((char *)m_l)));
+
+    if (ops['v']) {
+	printf("\nThe number of bytes that were allocated using sbrk() and\n");
+	printf("the number of bytes that were given back to the system\n");
+	printf("via brk().\n");
+    }
+    printf("\nsbrk %d\tbrk %d\n", m_s, m_b);
+
+    if (ops['v']) {
+	printf("\nInformation about the sizes that were allocated or freed.\n");
+	printf("For each size that were used the number of mallocs and\n");
+	printf("frees is shown. Diff gives the difference between these\n");
+	printf("values, i.e. the number of blocks of that size that is\n");
+	printf("currently allocated. Total is the product of size and diff,\n");
+	printf("i.e. the number of bytes that are allocated for blocks of\n");
+	printf("this size.\n");
+    }
+    printf("\nsize\tmalloc\tfree\tdiff\ttotal\n");
+    for (i = 0; i < 1024; i++)
+	if (m_m[i] || m_f[i])
+	    printf("%ld\t%d\t%d\t%d\t%ld\n", (long)i * M_ISIZE, m_m[i], m_f[i],
+		   m_m[i] - m_f[i], (long)i * M_ISIZE * (m_m[i] - m_f[i]));
+
+    if (m_m[i] || m_f[i])
+	printf("big\t%d\t%d\t%d\n", m_m[i], m_f[i], m_m[i] - m_f[i]);
+
+    if (ops['v']) {
+	printf("\nThe list of memory blocks. For each block the following\n");
+	printf("information is shown:\n\n");
+	printf("num\tthe number of this block\n");
+	printf("tnum\tlike num but counted separatedly for used and free\n");
+	printf("\tblocks\n");
+	printf("addr\tthe address of this block\n");
+	printf("len\tthe length of the block\n");
+	printf("state\tthe state of this block, this can be:\n");
+	printf("\t  used\tthis block is used for one big block\n");
+	printf("\t  free\tthis block is free\n");
+	printf("\t  small\tthis block is used for an array of small blocks\n");
+	printf("cum\tthe accumulated sizes of the blocks, counted\n");
+	printf("\tseparatedly for used and free blocks\n");
+	printf("\nFor blocks holding small blocks the number of free\n");
+	printf("blocks, the number of used blocks and the size of the\n");
+	printf("blocks is shown. For otherwise used blocks the first few\n");
+	printf("bytes are shown as an ASCII dump.\n");
+    }
+    printf("\nblock list:\nnum\ttnum\taddr\tlen\tstate\tcum\n");
+    for (m = m_l, mf = m_free, ii = fi = ui = 1; ((char *)m) < m_high;
+	 m = (struct m_hdr *)(((char *)m) + M_ISIZE + m->len), ii++) {
+	for (j = 0, ms = NULL; j < M_NSMALL && !ms; j++)
+	    for (ms = m_small[j]; ms; ms = ms->next)
+		if (ms == m)
+		    break;
+
+	if (m == mf)
+	    buf[0] = '\0';
+	else if (m == ms)
+	    sprintf(buf, "%ld %ld %ld", M_SNUM - ms->used, ms->used,
+		    (m->len - sizeof(struct m_hdr)) / M_SNUM + 1);
+
+	else {
+	    for (i = 0, b = buf, c = (char *)&m->next; i < 20 && i < m->len;
+		 i++, c++)
+		*b++ = (*c >= ' ' && *c < 127) ? *c : '.';
+	    *b = '\0';
+	}
+
+	printf("%d\t%d\t%ld\t%ld\t%s\t%ld\t%s\n", ii,
+	       (m == mf) ? fi++ : ui++,
+	       (long)m, m->len,
+	       (m == mf) ? "free" : ((m == ms) ? "small" : "used"),
+	       (m == mf) ? (f += m->len) : (u += m->len),
+	       buf);
+
+	if (m == mf)
+	    mf = mf->next;
+    }
+
+    if (ops['v']) {
+	printf("\nHere is some information about the small blocks used.\n");
+	printf("For each size the arrays with the number of free and the\n");
+	printf("number of used blocks are shown.\n");
+    }
+    printf("\nsmall blocks:\nsize\tblocks (free/used)\n");
+
+    for (i = 0; i < M_NSMALL; i++)
+	if (m_small[i]) {
+	    printf("%ld\t", (long)i * M_ISIZE);
+
+	    for (ii = 0, m = m_small[i]; m; m = m->next) {
+		printf("(%ld/%ld) ", M_SNUM - m->used, m->used);
+		if (!((++ii) & 7))
+		    printf("\n\t");
+	    }
+	    putchar('\n');
+	}
+    if (ops['v']) {
+	printf("\n\nBelow is some information about the allocation\n");
+	printf("behaviour of the zsh heaps. First the number of times\n");
+	printf("pushheap(), popheap(), and freeheap() were called.\n");
+    }
+    printf("\nzsh heaps:\n\n");
+
+    printf("push %d\tpop %d\tfree %d\n\n", h_push, h_pop, h_free);
+
+    if (ops['v']) {
+	printf("\nThe next list shows for several sizes the number of times\n");
+	printf("memory of this size were taken from heaps.\n\n");
+    }
+    printf("size\tmalloc\ttotal\n");
+    for (i = 0; i < 1024; i++)
+	if (h_m[i])
+	    printf("%ld\t%d\t%ld\n", (long)i * H_ISIZE, h_m[i],
+		   (long)i * H_ISIZE * h_m[i]);
+    if (h_m[1024])
+	printf("big\t%d\n", h_m[1024]);
+
+    return 0;
+}
+
+#endif
+
+#else				/* not ZSH_MEM */
+
+/**/
+void
+zfree(void *p, int sz)
+{
+    if (p)
+	free(p);
+}
+
+/**/
+void
+zsfree(char *p)
+{
+    if (p)
+	free(p);
+}
+
+#endif
diff --git a/Src/mkbltnmlst.sh b/Src/mkbltnmlst.sh
new file mode 100644
index 000000000..4a90ecd20
--- /dev/null
+++ b/Src/mkbltnmlst.sh
@@ -0,0 +1,60 @@
+#! /bin/sh
+#
+# mkbltnmlst.sh: generate boot code for linked-in modules
+#
+# Written by Andrew Main
+#
+srcdir=${srcdir-`echo $0|sed 's%/[^/][^/]*$%%'`}
+test "x$srcdir" = "x$0" && srcdir=.
+test "x$srcdir" = "x"   && srcdir=.
+MODBINS=${MODBINS-modules-bltin}
+XMODCF=${XMODCF-$srcdir/xmods.conf}
+
+bin_mods=" zsh "`sed 's/^/ /;s/$/ /' $MODBINS`
+x_mods=`cat $XMODCF`
+. ./modules.index
+
+trap "rm -f $1; exit 1" 1 2 15
+
+exec > $1
+
+echo "#ifdef DYNAMIC"
+for x_mod in $x_mods; do
+    case $bin_mods in
+	*" $x_mod "*) ;;
+	*)  echo "/* non-linked-in known module \`$x_mod' */"
+	    eval "loc=\$loc_$x_mod"
+	    unset moddeps autobins
+	    . $srcdir/../$loc/${x_mod}.mdd
+	    for bin in $autobins; do
+		echo "    add_autobin(\"$bin\", \"$x_mod\");"
+	    done
+	    for dep in $moddeps; do
+		case $bin_mods in
+		    *" $dep "*)
+			echo "    /* depends on \`$dep' */" ;;
+		    *)	echo "    add_dep(\"$x_mod\", \"$dep\");" ;;
+		esac
+	    done ;;
+    esac
+done
+echo "#endif /* DYNAMIC */"
+echo
+done_mods=" "
+for bin_mod in $bin_mods; do
+    echo "/* linked-in module \`$bin_mod' */"
+    eval "loc=\$loc_$bin_mod"
+    unset moddeps
+    . $srcdir/../$loc/${bin_mod}.mdd
+    for dep in $moddeps; do
+	case $done_mods in
+	    *" $dep "*)
+		echo "    /* depends on \`$dep' */" ;;
+	    *)	echo >&2 "ERROR: linked-in module \`$bin_mod' depends on \`$dep'"
+		rm -f $1
+		exit 1 ;;
+	esac
+    done
+    echo "    mod.nam = \"$bin_mod\"; boot_$bin_mod(&mod);"
+    done_mods="$done_mods$bin_mod "
+done
diff --git a/Src/mkmakemod.sh b/Src/mkmakemod.sh
new file mode 100644
index 000000000..b088929fa
--- /dev/null
+++ b/Src/mkmakemod.sh
@@ -0,0 +1,315 @@
+#!/bin/sh
+#
+# mkmakemod.sh: generate Makefile.in files for module building
+#
+# Options:
+#   -m = file is already generated; only build the second stage
+#   -i = do not build second stage
+#
+# Args:
+#   $1 = subdirectory to look in, relative to $top_srcdir
+#   $2 = final output filename, within the $1 directory
+#
+# This script must be run from the top-level build directory, and $top_srcdir
+# must be set correctly in the environment.
+#
+# This looks in $1, and uses all the *.mdd files there.  Each .mdd file
+# defines one module.  The .mdd file is actually a shell script, which will
+# be sourced.  It may define the following shell variables:
+#
+#   moddeps       modules on which this module depends (default none)
+#   nozshdep      non-empty indicates no dependence on the `zsh' pseudo-module
+#   alwayslink    if non-empty, always link the module into the executable
+#   autobins      builtins defined by the module, for autoloading
+#   objects       .o files making up this module (*must* be defined)
+#   proto         .pro files for this module (default generated from $objects)
+#   headers       extra headers for this module (default none)
+#   hdrdeps       extra headers on which the .mdh depends (default none)
+#   otherincs     extra headers that are included indirectly (default none)
+#
+# The .mdd file may also include a Makefile.in fragment between lines
+# `:<<\Make' and `Make' -- this will be copied into Makemod.in.
+#
+# The resulting Makemod.in knows how to build each module that is defined.
+# For each module in also knows how to build a .mdh file.  Each source file
+# should #include the .mdh file for the module it is a part of.  The .mdh
+# file #includes the .mdh files for any module dependencies, then each of
+# $headers, and then each of $proto (for global declarations).  It will
+# be recreated if any of the dependency .mdh files changes, or if any of
+# $headers or $hdrdeps changes.  When anything depends on it, all of $proto
+# and $otherincs will be made up to date, but the .mdh file won't actually
+# be rebuilt if those files change.
+#
+# The order of sections of the output file is thus:
+#   simple generated macros
+#   macros generated from *.mdd
+#   included Makemod.in.in
+#   rules generated from *.mdd
+# The order dependencies are basically that the generated macros are required
+# in Makemod.in.in, but some of the macros that it creates are needed in the
+# later rules.
+#
+
+# sed script to normalise a pathname
+sed_normalise='
+    s,^,/,
+    s,$,/,
+    :1
+    s,/\./,/,
+    t1
+    :2
+    s,/[^/.][^/]*/\.\./,/,
+    s,/\.[^/.][^/]*/\.\./,/,
+    s,/\.\.[^/][^/]*/\.\./,/,
+    t2
+    s,^/$,.,
+    s,^/,,
+    s,\(.\)/$,\1,
+'
+
+# decide which stages to process
+first_stage=true
+second_stage=true
+if test ."$1" = .-m; then
+    shift
+    first_stage=false
+elif test ."$1" = .-i; then
+    shift
+    second_stage=false
+fi
+
+top_srcdir=`echo $top_srcdir | sed "$sed_normalise"`
+the_subdir=$1
+the_makefile=$2
+
+if $first_stage; then
+
+    trap "rm -f $the_subdir/${the_makefile}.in" 1 2 15
+    echo "creating $the_subdir/${the_makefile}.in"
+    exec 3>&1 >$the_subdir/${the_makefile}.in
+    echo "##### ${the_makefile}.in generated automatically by mkmakemod.sh"
+    echo "##### DO NOT EDIT!"
+    echo
+    echo "##### ===== DEFINITIONS ===== #####"
+    echo
+    echo "makefile = ${the_makefile}"
+    echo "dir_top = "`echo $the_subdir | sed 's,[^/][^/]*,..,g'`
+    echo "subdir = $the_subdir"
+    echo
+
+    . Src/modules.index
+    bin_mods=" zsh "`sed 's/^/ /;s/$/ /' Src/modules-bltin`
+    if grep '%@D@%D%' config.status >/dev/null; then
+	is_dynamic=true
+    else
+	is_dynamic=false
+    fi
+
+    here_modules=
+    all_subdirs=
+    all_modobjs=
+    all_modules=
+    all_mdds=
+    all_mdhs=
+    all_proto=
+    lastsub=//
+    for module in $module_list; do
+	eval "loc=\$loc_$module"
+	case $loc in
+	    $the_subdir)
+		here_modules="$here_modules $module"
+		build=$is_dynamic
+		case $is_dynamic@$bin_mods in
+		    *" $module "*)
+			build=true
+			all_modobjs="$all_modobjs modobjs.${module}" ;;
+		    true@*)
+			all_modules="$all_modules ${module}.\$(DL_EXT)" ;;
+		esac
+		all_mdds="$all_mdds ${module}.mdd"
+		$build && all_mdhs="$all_mdhs ${module}.mdh"
+		$build && all_proto="$all_proto proto.${module}"
+		;;
+	    $lastsub | $lastsub/*) ;;
+	    $the_subdir/*)
+		all_subdirs="$all_subdirs $loc"
+		lastsub=$loc
+		;;
+	esac
+    done
+    all_subdirs=`echo "$all_subdirs" | sed "s' $the_subdir/' 'g"`
+    echo "MODOBJS =$all_modobjs"
+    echo "MODULES =$all_modules"
+    echo "MDDS    =$all_mdds"
+    echo "MDHS    =$all_mdhs"
+    echo "PROTOS  =$all_proto"
+    echo "SUBDIRS =$all_subdirs"
+    echo
+
+    echo "##### ===== INCLUDING Makemod.in.in ===== #####"
+    echo
+    cat $top_srcdir/Src/Makemod.in.in
+    echo
+
+    case $the_subdir in
+	Src) modobjs_sed= ;;
+	Src/*) modobjs_sed="| sed 's\" \" "`echo $the_subdir | sed 's,^Src/,,'`"/\"g' " ;;
+	*) modobjs_sed="| sed 's\" \" ../$the_subdir/\"g' " ;;
+    esac
+
+    other_mdhs=
+    remote_mdhs=
+    for module in $here_modules; do
+
+	unset moddeps nozshdep alwayslink
+	unset autobins
+	unset objects proto headers hdrdeps otherincs
+	. $top_srcdir/$the_subdir/${module}.mdd
+	test -n "${moddeps+set}" || moddeps=
+	test -n "$nozshdep" || moddeps="$moddeps zsh"
+	test -n "${proto+set}" ||
+	    proto=`echo $objects '' | sed 's,\.o ,.pro ,g'`
+
+	dobjects=`echo $objects '' | sed 's,\.o ,..o ,g'`
+	modhdeps=
+	for dep in $moddeps; do
+	    eval "loc=\$loc_$dep"
+	    case $the_subdir in
+		$loc)
+		    mdh="${dep}.mdh"
+		    ;;
+		$loc/*)
+		    mdh="\$(dir_top)/$loc/${dep}.mdh"
+		    case "$other_mdhs " in
+			*" $mdh "*) ;;
+			*) other_mdhs="$other_mdhs $mdh" ;;
+		    esac
+		    ;;
+		*)
+		    mdh="\$(dir_top)/$loc/${dep}.mdh"
+		    case "$remote_mdhs " in
+			*" $mdh "*) ;;
+			*) remote_mdhs="$remote_mdhs $mdh" ;;
+		    esac
+		    ;;
+	    esac
+	    modhdeps="$modhdeps $mdh"
+	done
+
+	echo "##### ===== DEPENDENCIES GENERATED FROM ${module}.mdd ===== #####"
+	echo
+	echo "MODOBJS_${module} = $objects"
+	echo "MODDOBJS_${module} = $dobjects"
+	echo "PROTO_${module} = $proto"
+	echo "INCS_${module} = \$(PROTO_${module}) $otherincs"
+	echo
+	echo "proto.${module}: \$(PROTO_${module})"
+	echo "\$(PROTO_${module}): \$(PROTODEPS)"
+	echo
+	echo "modobjs.${module}: \$(MODOBJS_${module})"
+	echo "	echo '' \$(MODOBJS_${module}) $modobjs_sed>> \$(dir_src)/stamp-modobjs.tmp"
+	echo
+	if test -z "$alwayslink"; then
+	    echo "${module}.\$(DL_EXT): \$(MODDOBJS_${module})"
+	    echo '	rm -f $@'
+	    echo "	\$(DLLINK) \$(MODDOBJS_${module}) \$(LIBS)"
+	    echo
+	fi
+	echo "${module}.mdhi: ${module}.mdhs \$(INCS_${module})"
+	echo "	@test -f \$@ || echo 'do not delete this file' > \$@"
+	echo
+	echo "${module}.mdhs: ${module}.mdd"
+	echo "	@\$(MAKE) -f \$(makefile) \$(MAKEDEFS) ${module}.mdh.tmp"
+	echo "	@if cmp -s ${module}.mdh ${module}.mdh.tmp; then \\"
+	echo "	    rm -f ${module}.mdh.tmp; \\"
+	echo "	    echo \"\\\`${module}.mdh' is up to date.\"; \\"
+	echo "	else \\"
+	echo "	    mv -f ${module}.mdh.tmp ${module}.mdh; \\"
+	echo "	    echo \"Updated \\\`${module}.mdh'.\"; \\"
+	echo "	fi"
+	echo "	echo 'timestamp for ${module}.mdh against ${module}.mdd' > \$@"
+	echo
+	echo "${module}.mdh: ${modhdeps} ${headers} ${hdrdeps} ${module}.mdhi"
+	echo "	@\$(MAKE) -f \$(makefile) \$(MAKEDEFS) ${module}.mdh.tmp"
+	echo "	@mv -f ${module}.mdh.tmp ${module}.mdh"
+	echo "	@echo \"Updated \\\`${module}.mdh'.\""
+	echo
+	echo "${module}.mdh.tmp:"
+	echo "	@( \\"
+	echo "	    echo '#ifndef have_${module}_module'; \\"
+	echo "	    echo '#define have_${module}_module'; \\"
+	echo "	    echo; \\"
+	if test -n "$moddeps"; then
+	    echo "	    echo '/* Module dependencies */'; \\"
+	    echo "	    for mod in $modhdeps; do \\"
+	    echo "		echo '# define USING_MODULE'; \\"
+	    echo "		echo '# include \"'\$\$mod'\"'; \\"
+	    echo "	    done; \\"
+	    echo "	    echo '# undef USING_MODULE'; \\"
+	    echo "	    echo; \\"
+	fi
+	if test -n "$headers"; then
+	    echo "	    echo '/* Extra headers for this module */'; \\"
+	    echo "	    for hdr in $headers; do \\"
+	    echo "		if test -f \$\$hdr; then \\"
+	    echo "		    echo '# include \"'\$\$hdr'\"'; \\"
+	    echo "		else \\"
+	    echo "		    echo '# include \"\$(sdir)/'\$\$hdr'\"'; \\"
+	    echo "		fi; \\"
+	    echo "	    done; \\"
+	    echo "	    echo; \\"
+	fi
+	if test -n "$proto"; then
+	    echo "	    echo '# define GLOBAL_PROTOTYPES'; \\"
+	    echo "	    for pro in \$(PROTO_${module}); do \\"
+	    echo "		echo '# include \"'\$\$pro'\"'; \\"
+	    echo "	    done; \\"
+	    echo "	    echo '# undef GLOBAL_PROTOTYPES'; \\"
+	    echo "	    echo; \\"
+	fi
+	echo "	    echo '#endif /* !have_${module}_module */'; \\"
+	echo "	) > \$@"
+	echo
+	echo "\$(MODOBJS_${module}) \$(MODDOBJS_${module}): ${module}.mdh"
+	sed -e '/^ *: *<< *\\Make *$/,/^Make$/!d' \
+	    -e 's/^ *: *<< *\\Make *$//; /^Make$/d' \
+	    < $top_srcdir/$the_subdir/${module}.mdd
+	echo
+
+    done
+
+    if test -n "$remote_mdhs$other_mdhs"; then
+	echo "##### ===== DEPENDENCIES FOR REMOTE MODULES ===== #####"
+	echo
+	for mdh in $remote_mdhs; do
+	    echo "$mdh: FORCE"
+	    echo "	@cd @%@ && \$(MAKE) \$(MAKEDEFS) @%@$mdh"
+	    echo
+	done | sed 's,^\(.*\)@%@\(.*\)@%@\(.*\)/\([^/]*\)$,\1\3\2\4,'
+	if test -n "$other_mdhs"; then
+	    echo "${other_mdhs}:"
+	    echo "	false # should only happen with make -n"
+	    echo
+	fi
+    fi
+
+    echo "##### End of ${the_makefile}.in"
+
+    exec >&3 3>&-
+
+fi
+
+if $second_stage; then
+
+    trap "rm -f $the_subdir/${the_makefile}" 1 2 15
+
+    # The standard config.status requires the pathname for the .in file to
+    # be relative to the top of the source tree.  As we have it in the build
+    # tree, this is a problem.  zsh's configure script edits config.status,
+    # adding the feature that an input filename starting with "!" has the
+    # "!" removed and is not mangled further.
+    CONFIG_FILES=$the_subdir/${the_makefile}:\!$the_subdir/${the_makefile}.in CONFIG_HEADERS= ./config.status
+
+fi
+
+exit 0
diff --git a/Src/mkmodindex.sh b/Src/mkmodindex.sh
new file mode 100644
index 000000000..b4616f638
--- /dev/null
+++ b/Src/mkmodindex.sh
@@ -0,0 +1,43 @@
+#!/bin/sh
+#
+# mkmodindex.sh: search for *.mdd files, and index the modules
+#
+# $@ = directories to search from
+#
+
+echo "# module index generated by mkmodindex.sh"
+echo
+
+module_list=' '
+while test $# -ne 0; do
+    dir=$1
+    shift
+    ( set $dir/*.mdd; test -f $1 ) || continue
+    dosubs=false
+    for mod in `echo '' $dir/*.mdd '' | sed 's, [^ ]*/, ,g;s,\.mdd , ,g'`; do
+	case `echo "$mod@ $module_list " | sed 's,^.*[^_0-9A-Za-z].*@,@@,'` in
+	    @@*)
+		echo >&2 "WARNING: illegally named module \`$mod' in $dir"
+		echo >&2 "         (ignoring it)"
+		;;
+	    *@*" $mod "*)
+		eval "loc=\$loc_$mod"
+		echo >&2 "WARNING: module \`$mod' (in $loc) duplicated in $dir"
+		echo >&2 "         (ignoring duplicate)"
+		dosubs=true
+		;;
+	    *)
+		module_list="$module_list$mod "
+		echo "loc_$mod=$dir"
+		eval "loc_$mod=\$dir"
+		dosubs=true
+		;;
+	esac
+    done
+    $dosubs && set `echo $dir/*/. '' | sed 's,/\. , ,g'` "$@"
+done
+
+echo
+echo $module_list | sed 's/^/module_list="/;s/$/"/'
+
+exit 0
diff --git a/Src/module.c b/Src/module.c
new file mode 100644
index 000000000..ce5989f07
--- /dev/null
+++ b/Src/module.c
@@ -0,0 +1,651 @@
+/*
+ * module.c - deal with dynamic modules
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1996-1997 Zoltán Hidvégi
+ * 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 Zoltán Hidvégi 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 Zoltán Hidvégi and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Zoltán Hidvégi 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 Zoltán Hidvégi and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "zsh.mdh"
+#include "module.pro"
+
+/* The `zsh' module contains all the base code that can't actually be built *
+ * as a separate module.  It is initialised by main(), so there's nothing   *
+ * for the boot function to do.                                             */
+
+/**/
+int
+boot_zsh(Module m)
+{
+    return 0;
+}
+
+/* addbuiltin() can be used to add a new builtin.  It returns zero on *
+ * success, 1 on failure.  The only possible type of failure is that  *
+ * a builtin with the specified name already exists.  An autoloaded   *
+ * builtin can be replaced using this function.                       */
+
+/**/
+int
+addbuiltin(Builtin b)
+{
+    Builtin bn = (Builtin) builtintab->getnode2(builtintab, b->nam);
+    if (bn && (bn->flags & BINF_ADDED))
+	return 1;
+    if (bn)
+	builtintab->freenode(builtintab->removenode(builtintab, b->nam));
+    PERMALLOC {
+	builtintab->addnode(builtintab, b->nam, b);
+    } LASTALLOC;
+    return 0;
+}
+
+/* Add multiple builtins.  binl points to a table of `size' builtin      *
+ * structures.  Those for which (.flags & BINF_ADDED) is false are to be *
+ * added; that flag is set if they succeed.  If any fail, an error       *
+ * message is printed, using nam as the leading name.  Returns 1 if all  *
+ * additions succeed, 2 if some succeed and some fail, and 0 if all (and *
+ * at least 1) fail.  The usual usage in a boot_*() function would be    *
+ *  return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)); */
+
+/**/
+int
+addbuiltins(char const *nam, Builtin binl, int size)
+{
+    int hads = 0, hadf = 0, n;
+
+    for(n = 0; n < size; n++) {
+	Builtin b = &binl[n];
+	if(b->flags & BINF_ADDED)
+	    continue;
+	if(addbuiltin(b)) {
+	    zwarnnam(nam, "name clash when adding builtin `%s'", b->nam, 0);
+	    hadf = 1;
+	} else {
+	    b->flags |= BINF_ADDED;
+	    hads = 2;
+	}
+    }
+    return hadf ? hads : 1;
+}
+
+#ifdef DYNAMIC
+
+/* $module_path ($MODULE_PATH) */
+
+/**/
+char **module_path;
+
+/* List of modules */
+
+/**/
+LinkList modules;
+
+/* Define an autoloadable builtin.  It returns 0 on success, or 1 on *
+ * failure.  The only possible cause of failure is that a builtin    *
+ * with the specified name already exists.                           */
+
+/**/
+int
+add_autobin(char *nam, char *module)
+{
+    Builtin bn = zcalloc(sizeof(*bn));
+    bn->nam = ztrdup(nam);
+    bn->optstr = ztrdup(module);
+    return addbuiltin(bn);
+}
+
+/* Remove the builtin added previously by addbuiltin().  Returns *
+ * zero on succes and -1 if there is no builtin with that name.  */
+
+/**/
+int
+deletebuiltin(char *nam)
+{
+    Builtin bn;
+
+    bn = (Builtin) builtintab->removenode(builtintab, nam);
+    if (!bn)
+	return -1;
+    builtintab->freenode((HashNode)bn);
+    return 0;
+}
+
+/* Delete multiple builtins.  binl points to a table of `size' builtin  *
+ * structures.  Those for which (.flags & BINF_ADDED) is true are to be *
+ * deleted; that flag is cleared.  If any fail, an error message is     *
+ * printed, using nam as the leading name.  Returns 1 if all deletions  *
+ * succeed, 2 if some succeed and some fail, and 0 if all (and at least *
+ * 1) fail.  In normal use, from a cleanup_*() function, this return    *
+ * value would be ignored -- the only cause of failure would be that a  *
+ * wayward module had deleted our builtin without telling us.           */
+
+/**/
+int
+deletebuiltins(char const *nam, Builtin binl, int size)
+{
+    int hads = 0, hadf = 0, n;
+
+    for(n = 0; n < size; n++) {
+	Builtin b = &binl[n];
+	if(!(b->flags & BINF_ADDED))
+	    continue;
+	if(deletebuiltin(b->nam)) {
+	    zwarnnam(nam, "builtin `%s' already deleted", b->nam, 0);
+	    hadf = 1;
+	} else
+	    hads = 2;
+	b->flags &= ~BINF_ADDED;
+    }
+    return hadf ? hads : 1;
+}
+
+#ifdef HAVE_DLFCN_H
+# include <dlfcn.h>
+#else
+# include <sys/types.h>
+# include <nlist.h>
+# include <link.h>
+#endif
+#ifndef RTLD_LAZY
+# define RTLD_LAZY 1
+#endif
+#ifndef RTLD_GLOBAL
+# define RTLD_GLOBAL 0
+#endif
+#ifndef HAVE_DLCLOSE
+# define dlclose(X) ((X), 0)
+#endif
+
+#ifdef DLSYM_NEEDS_UNDERSCORE
+# define STR_BOOT      "_boot_"
+# define STR_BOOT_S    "_boot_%s"
+# define STR_CLEANUP   "_cleanup_"
+# define STR_CLEANUP_S "_cleanup_%s"
+#else /* !DLSYM_NEEDS_UNDERSCORE */
+# define STR_BOOT      "boot_"
+# define STR_BOOT_S    "boot_%s"
+# define STR_CLEANUP   "cleanup_"
+# define STR_CLEANUP_S "cleanup_%s"
+#endif /* !DLSYM_NEEDS_UNDERSCORE */
+typedef int (*Module_func) _((Module));
+
+/**/
+static void *
+try_load_module(char const *name)
+{
+    char buf[PATH_MAX + 1];
+    char **pp;
+    void *ret = NULL;
+    int l;
+
+    if (strchr(name, '/')) {
+	ret = dlopen(unmeta(name), RTLD_LAZY | RTLD_GLOBAL);
+	if (ret || 
+	    unset(PATHDIRS) ||
+	    (*name == '/') ||
+	    (*name == '.' && name[1] == '/') ||
+	    (*name == '.' && name[1] == '.' && name[2] == '/'))
+	    return ret;
+    }
+
+    l = strlen(name) + 1;
+    for (pp = module_path; !ret && *pp; pp++) {
+	if (l + (**pp ? strlen(*pp) : 1) > PATH_MAX)
+	    continue;
+	sprintf(buf, "%s/%s", **pp ? *pp : ".", name);
+	ret = dlopen(unmeta(buf), RTLD_LAZY | RTLD_GLOBAL);
+    }
+
+    return ret;
+}
+
+/**/
+static void *
+do_load_module(char const *name)
+{
+    void *ret = NULL;
+    char buf[PATH_MAX + 1];
+
+    if (strlen(name) + strlen(DL_EXT) < PATH_MAX) {
+	sprintf(buf, "%s.%s", name, DL_EXT);
+	ret = try_load_module(buf);
+    }
+    if (!ret)
+	ret = try_load_module(name);
+    if (!ret) {
+	int waserr = errflag;
+	zerr("failed to load module: %s", name, 0);
+	errflag = waserr;
+    }
+    return ret;
+}
+
+/**/
+static LinkNode
+find_module(const char *name)
+{
+    Module m;
+    LinkNode node;
+
+    for (node = firstnode(modules); node; incnode(node)) {
+	m = (Module) getdata(node);
+	if (!strcmp(m->nam, name))
+	    return node;
+    }
+    return NULL;
+}
+
+/**/
+static int
+init_module(Module m)
+{
+    char *s, *t;
+#ifndef DYNAMIC_NAME_CLASH_OK
+    char buf[PATH_MAX + 1];
+#endif
+    Module_func fn;
+
+    s = strrchr(m->nam, '/');
+    if (s)
+	s = dupstring(++s);
+    else
+	s = m->nam;
+    if ((t = strrchr(s, '.')))
+	*t = '\0';
+#ifdef DYNAMIC_NAME_CLASH_OK
+    fn = (Module_func) dlsym(m->handle, STR_BOOT);
+#else /* !DYNAMIC_NAME_CLASH_OK */
+    if (strlen(s) + 6 > PATH_MAX)
+	return 1;
+    sprintf(buf, STR_BOOT_S, s);
+    fn = (Module_func) dlsym(m->handle, buf);
+#endif /* !DYNAMIC_NAME_CLASH_OK */
+    if(fn)
+	return fn(m);
+    zwarnnam(m->nam, "no boot function", NULL, 0);
+    return 1;
+}
+
+/**/
+Module
+load_module(char const *name)
+{
+    Module m;
+    void *handle;
+    LinkNode node, n;
+
+    if (!(node = find_module(name))) {
+	if (!(handle = do_load_module(name)))
+	    return NULL;
+	m = zcalloc(sizeof(*m));
+	m->nam = ztrdup(name);
+	m->handle = handle;
+	if (init_module(m)) {
+	    dlclose(handle);
+	    zsfree(m->nam);
+	    zfree(m, sizeof(*m));
+	    return NULL;
+	}
+	PERMALLOC {
+	    addlinknode(modules, m);
+	} LASTALLOC;
+	return m;
+    }
+    m = (Module) getdata(node);
+    if (m->handle)
+	return m;
+    if (m->flags & MOD_BUSY) {
+	zerr("circular dependencies for module %s", name, 0);
+	return NULL;
+    }
+    m->flags |= MOD_BUSY;
+    for (n = firstnode(m->deps); n; incnode(n))
+	if (!load_module((char *) getdata(n))) {
+	    m->flags &= ~MOD_BUSY;
+	    return NULL;
+	}
+    m->flags &= ~MOD_BUSY;
+    if (!(m->handle = do_load_module(name)))
+	return NULL;
+    if (init_module(m)) {
+	dlclose(m->handle);
+	m->handle = NULL;
+	return NULL;
+    }
+    return m;
+}
+
+/**/
+static int
+cleanup_module(Module m)
+{
+    char *s, *t;
+#ifndef DYNAMIC_NAME_CLASH_OK
+    char buf[PATH_MAX + 1];
+#endif
+    Module_func fn;
+
+    s = strrchr(m->nam, '/');
+    if (s)
+	s = dupstring(++s);
+    else
+	s = m->nam;
+    if ((t = strrchr(s, '.')))
+	*t = '\0';
+#ifdef DYNAMIC_NAME_CLASH_OK
+    fn = (Module_func) dlsym(m->handle, STR_CLEANUP);
+#else /* !DYNAMIC_NAME_CLASH_OK */
+    if (strlen(s) + 9 > PATH_MAX)
+	return 1;
+    sprintf(buf, STR_CLEANUP_S, s);
+    fn = (Module_func) dlsym(m->handle, buf);
+#endif /* !DYNAMIC_NAME_CLASH_OK */
+    if(fn)
+	return fn(m);
+    zwarnnam(m->nam, "no cleanup function", NULL, 0);
+    return 1;
+}
+
+/**/
+void
+add_dep(char *name, char *from)
+{
+    LinkNode node;
+    Module m;
+
+    PERMALLOC {
+	if (!(node = find_module(name))) {
+	    m = zcalloc(sizeof(*m));
+	    m->nam = ztrdup(name);
+	    addlinknode(modules, m);
+	} else
+	    m = (Module) getdata(node);
+	if (!m->deps)
+	    m->deps = newlinklist();
+	for (node = firstnode(m->deps);
+	     node && strcmp((char *) getdata(node), from);
+	     incnode(node));
+	if (!node)
+	    addlinknode(m->deps, ztrdup(from));
+    } LASTALLOC;
+}
+
+/**/
+static void
+autoloadscan(HashNode hn, int printflags)
+{
+    Builtin bn = (Builtin) hn;
+
+    if(bn->flags & BINF_ADDED)
+	return;
+    if(printflags & PRINT_LIST) {
+	fputs("zmodload -a ", stdout);
+	if(bn->optstr[0] == '-')
+	    fputs("-- ", stdout);
+	quotedzputs(bn->optstr, stdout);
+	if(strcmp(bn->nam, bn->optstr)) {
+	    putchar(' ');
+	    quotedzputs(bn->nam, stdout);
+	}
+    } else {
+	nicezputs(bn->nam, stdout);
+	if(strcmp(bn->nam, bn->optstr)) {
+	    fputs(" (", stdout);
+	    nicezputs(bn->optstr, stdout);
+	    putchar(')');
+	}
+    }
+    putchar('\n');
+}
+
+/**/
+int
+bin_zmodload(char *nam, char **args, char *ops, int func)
+{
+    if(ops['d'] && ops['a']) {
+	zwarnnam(nam, "-d cannot be combined with -a", NULL, 0);
+	return 1;
+    }
+    if (ops['u'] && !*args) {
+	zwarnnam(nam, "what do you want to unload?", NULL, 0);
+	return 1;
+    }
+    if(ops['d'])
+	return bin_zmodload_dep(nam, args, ops);
+    else if(ops['a'])
+	return bin_zmodload_auto(nam, args, ops);
+    else
+	return bin_zmodload_load(nam, args, ops);
+}
+
+/**/
+static int
+bin_zmodload_dep(char *nam, char **args, char *ops)
+{
+    LinkNode node;
+    Module m;
+    if(ops['u']) {
+	/* remove dependencies */
+	char *tnam = *args++;
+	node = find_module(tnam);
+	if (!node)
+	    return 0;
+	m = (Module) getdata(node);
+	if(*args && m->deps) {
+	    do {
+		for(node = firstnode(m->deps); node; incnode(node))
+		    if(!strcmp(*args, getdata(node))) {
+			zsfree(getdata(node));
+			remnode(m->deps, node);
+			break;
+		    }
+	    } while(*++args);
+	    if(empty(m->deps)) {
+		freelinklist(m->deps, freestr);
+		m->deps = NULL;
+	    }
+	} else {
+	    if (m->deps) {
+		freelinklist(m->deps, freestr);
+		m->deps = NULL;
+	    }
+	}
+	if (!m->deps && !m->handle) {
+	    remnode(modules, node);
+	    zsfree(m->nam);
+	    zfree(m, sizeof(*m));
+	}
+	return 0;
+    } else if(!args[0] || !args[1]) {
+	/* list dependencies */
+	for (node = firstnode(modules); node; incnode(node)) {
+	    m = (Module) getdata(node);
+	    if (m->deps && (!args[0] || !strcmp(args[0], m->nam))) {
+		LinkNode n;
+		if(ops['L']) {
+		    printf("zmodload -d ");
+		    if(m->nam[0] == '-')
+			fputs("-- ", stdout);
+		    quotedzputs(m->nam, stdout);
+		} else {
+		    nicezputs(m->nam, stdout);
+		    putchar(':');
+		}
+		for (n = firstnode(m->deps); n; incnode(n)) {
+		    putchar(' ');
+		    if(ops['L'])
+			quotedzputs((char *) getdata(n), stdout);
+		    else
+			nicezputs((char *) getdata(n), stdout);
+		}
+		putchar('\n');
+	    }
+	}
+	return 0;
+    } else {
+	/* add dependencies */
+	int ret = 0;
+	char *tnam = *args++;
+
+	for(; *args; args++) {
+	    if(isset(RESTRICTED) && strchr(*args, '/')) {
+		zwarnnam(nam, "%s: restricted", *args, 0);
+		ret = 1;
+	    } else
+		add_dep(tnam, *args);
+	}
+	return ret;
+    }
+}
+
+/**/
+static int
+bin_zmodload_auto(char *nam, char **args, char *ops)
+{
+    int ret = 0;
+    if(ops['u']) {
+	/* remove autoloaded builtins */
+	for (; *args; args++) {
+	    Builtin bn = (Builtin) builtintab->getnode2(builtintab, *args);
+	    if (!bn) {
+		if(!ops['i']) {
+		    zwarnnam(nam, "%s: no such builtin", *args, 0);
+		    ret = 1;
+		}
+	    } else if (bn->flags & BINF_ADDED) {
+		zwarnnam(nam, "%s: builtin is already defined", *args, 0);
+		ret = 1;
+	    } else
+		deletebuiltin(*args);
+	}
+	return ret;
+    } else if(!*args) {
+	/* list autoloaded builtins */
+	scanhashtable(builtintab, 0, 0, 0,
+	    autoloadscan, ops['L'] ? PRINT_LIST : 0);
+	return 0;
+    } else {
+	/* add autoloaded builtins */
+	char *modnam;
+	modnam = *args++;
+	if(isset(RESTRICTED) && strchr(modnam, '/')) {
+	    zwarnnam(nam, "%s: restricted", modnam, 0);
+	    return 1;
+	}
+	do {
+	    char *bnam = *args ? *args++ : modnam;
+	    if (strchr(bnam, '/')) {
+		zwarnnam(nam, "%s: `/' is illegal in a builtin", bnam, 0);
+		ret = 1;
+	    } else if (add_autobin(bnam, modnam) && !ops['i']) {
+		zwarnnam(nam, "failed to add builtin %s", bnam, 0);
+		ret = 1;
+	    }
+	} while(*args);
+	return ret;
+    }
+}
+
+/**/
+static int
+bin_zmodload_load(char *nam, char **args, char *ops)
+{
+    LinkNode node;
+    Module m;
+    int ret = 0;
+    if(ops['u']) {
+	/* unload modules */
+	for(; *args; args++) {
+	    node = find_module(*args);
+	    if (node) {
+		LinkNode mn, dn;
+
+		for (mn = firstnode(modules); mn; incnode(mn)) {
+		    m = (Module) getdata(mn);
+		    if (m->deps && m->handle)
+			for (dn = firstnode(m->deps); dn; incnode(dn))
+			    if (!strcmp((char *) getdata(dn), *args)) {
+				zwarnnam(nam, "module %s is in use by another module and cannot be unloaded", *args, 0);
+				ret = 1;
+				goto cont;
+			    }
+		}
+
+		m = (Module) getdata(node);
+		if (m->handle && cleanup_module(m))
+		    ret = 1;
+		else {
+		    if (m->handle)
+			dlclose(m->handle);
+		    m->handle = NULL;
+		    if(!m->deps) {
+			remnode(modules, node);
+			zsfree(m->nam);
+			zfree(m, sizeof(*m));
+		    }
+		}
+	    } else if (!ops['i']) {
+		zwarnnam(nam, "no such module %s", *args, 0);
+		ret = 1;
+	    }
+	    cont: ;
+	}
+	return ret;
+    } else if(!*args) {
+	/* list modules */
+	for (node = firstnode(modules); node; incnode(node)) {
+	    m = (Module) getdata(node);
+	    if (m->handle) {
+		if(ops['L']) {
+		    printf("zmodload ");
+		    if(m->nam[0] == '-')
+			fputs("-- ", stdout);
+		    quotedzputs(m->nam, stdout);
+		} else
+		    nicezputs(m->nam, stdout);
+		putchar('\n');
+	    }
+	}
+	return 0;
+    } else {
+	/* load modules */
+	for (; *args; args++) {
+	    node = find_module(*args);
+	    if (node && ((Module) getdata(node))->handle) {
+		if (!ops['i']) {
+		    zwarnnam(nam, "module %s already loaded.", *args, 0);
+		    ret = 1;
+		}
+	    } else if (isset(RESTRICTED) && strchr(*args, '/')) {
+		zwarnnam(nam, "%s: restricted", *args, 0);
+		ret = 1;
+	    } else if (!load_module(*args))
+		ret = 1;
+	}
+	return ret;
+    }
+}
+
+#endif /* DYNAMIC */
diff --git a/Src/options.c b/Src/options.c
new file mode 100644
index 000000000..745a6627c
--- /dev/null
+++ b/Src/options.c
@@ -0,0 +1,663 @@
+/*
+ * options.c - shell options
+ *
+ * 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 "options.pro"
+
+/* current emulation (used to decide which set of option letters is used) */
+
+/**/
+int emulation;
+ 
+/* the options; e.g. if opts[SHGLOB] != 0, SH_GLOB is turned on */
+ 
+/**/
+char opts[OPT_SIZE];
+ 
+/* Option name hash table */
+
+/**/
+HashTable optiontab;
+ 
+typedef struct optname *Optname;
+
+struct optname {
+    HashNode next;		/* next in hash chain */
+    char *nam;			/* hash data */
+    int flags;
+    int optno;			/* option number */
+};
+
+/* The canonical option name table */
+
+#define OPT_CSH		EMULATE_CSH
+#define OPT_KSH		EMULATE_KSH
+#define OPT_SH		EMULATE_SH
+#define OPT_ZSH		EMULATE_ZSH
+
+#define OPT_ALL		(OPT_CSH|OPT_KSH|OPT_SH|OPT_ZSH)
+#define OPT_BOURNE	(OPT_KSH|OPT_SH)
+#define OPT_BSHELL	(OPT_KSH|OPT_SH|OPT_ZSH)
+#define OPT_NONBOURNE	(OPT_ALL & ~OPT_BOURNE)
+#define OPT_NONZSH	(OPT_ALL & ~OPT_ZSH)
+
+#define OPT_EMULATE	(1<<5)	/* option is relevant to emulation */
+#define OPT_SPECIAL	(1<<6)	/* option should never be set by emulate() */
+#define OPT_ALIAS	(1<<7)	/* option is an alias to an other option */
+
+#define defset(X) (!!((X)->flags & emulation))
+
+static struct optname optns[] = {
+{NULL, "allexport",	      0,			 ALLEXPORT},
+{NULL, "alwayslastprompt",    OPT_ALL,			 ALWAYSLASTPROMPT},
+{NULL, "alwaystoend",	      0,			 ALWAYSTOEND},
+{NULL, "appendhistory",	      OPT_ALL,			 APPENDHISTORY},
+{NULL, "autocd",	      0,			 AUTOCD},
+{NULL, "autolist",	      OPT_ALL,			 AUTOLIST},
+{NULL, "automenu",	      OPT_ALL,			 AUTOMENU},
+{NULL, "autonamedirs",	      0,			 AUTONAMEDIRS},
+{NULL, "autoparamkeys",	      OPT_ALL,			 AUTOPARAMKEYS},
+{NULL, "autoparamslash",      OPT_ALL,			 AUTOPARAMSLASH},
+{NULL, "autopushd",	      0,			 AUTOPUSHD},
+{NULL, "autoremoveslash",     OPT_ALL,			 AUTOREMOVESLASH},
+{NULL, "autoresume",	      0,			 AUTORESUME},
+{NULL, "badpattern",	      OPT_EMULATE|OPT_NONBOURNE, BADPATTERN},
+{NULL, "banghist",	      OPT_EMULATE|OPT_NONBOURNE, BANGHIST},
+{NULL, "bareglobqual",        OPT_EMULATE|OPT_ZSH,       BAREGLOBQUAL},
+{NULL, "beep",		      OPT_ALL,			 BEEP},
+{NULL, "bgnice",	      OPT_EMULATE|OPT_NONBOURNE, BGNICE},
+{NULL, "braceccl",	      0,			 BRACECCL},
+{NULL, "bsdecho",	      OPT_EMULATE|OPT_SH,	 BSDECHO},
+{NULL, "cdablevars",	      0,			 CDABLEVARS},
+{NULL, "chaselinks",	      0,			 CHASELINKS},
+{NULL, "clobber",	      OPT_ALL,			 CLOBBER},
+{NULL, "completealiases",     0,			 COMPLETEALIASES},
+{NULL, "completeinword",      0,			 COMPLETEINWORD},
+{NULL, "correct",	      0,			 CORRECT},
+{NULL, "correctall",	      0,			 CORRECTALL},
+{NULL, "cshjunkiehistory",    OPT_EMULATE|OPT_CSH,	 CSHJUNKIEHISTORY},
+{NULL, "cshjunkieloops",      OPT_EMULATE|OPT_CSH,	 CSHJUNKIELOOPS},
+{NULL, "cshjunkiequotes",     OPT_EMULATE|OPT_CSH,	 CSHJUNKIEQUOTES},
+{NULL, "cshnullglob",	      OPT_EMULATE|OPT_CSH,	 CSHNULLGLOB},
+{NULL, "equals",	      OPT_EMULATE|OPT_ZSH,	 EQUALS},
+{NULL, "errexit",	      0,			 ERREXIT},
+{NULL, "exec",		      OPT_ALL,			 EXECOPT},
+{NULL, "extendedglob",	      0,			 EXTENDEDGLOB},
+{NULL, "extendedhistory",     OPT_EMULATE|OPT_CSH,	 EXTENDEDHISTORY},
+{NULL, "flowcontrol",	      OPT_ALL,			 FLOWCONTROL},
+{NULL, "functionargzero",     OPT_EMULATE|OPT_NONBOURNE, FUNCTIONARGZERO},
+{NULL, "glob",		      OPT_ALL,			 GLOBOPT},
+{NULL, "globassign",	      OPT_EMULATE|OPT_CSH,	 GLOBASSIGN},
+{NULL, "globcomplete",	      0,			 GLOBCOMPLETE},
+{NULL, "globdots",	      0,			 GLOBDOTS},
+{NULL, "globsubst",	      OPT_EMULATE|OPT_NONZSH,	 GLOBSUBST},
+{NULL, "hashcmds",	      OPT_ALL,			 HASHCMDS},
+{NULL, "hashdirs",	      OPT_ALL,			 HASHDIRS},
+{NULL, "hashlistall",	      OPT_ALL,			 HASHLISTALL},
+{NULL, "histallowclobber",    0,			 HISTALLOWCLOBBER},
+{NULL, "histbeep",	      OPT_ALL,			 HISTBEEP},
+{NULL, "histignoredups",      0,			 HISTIGNOREDUPS},
+{NULL, "histignorespace",     0,			 HISTIGNORESPACE},
+{NULL, "histnofunctions",     0,			 HISTNOFUNCTIONS},
+{NULL, "histnostore",	      0,			 HISTNOSTORE},
+{NULL, "histreduceblanks",    0,			 HISTREDUCEBLANKS},
+{NULL, "histverify",	      0,			 HISTVERIFY},
+{NULL, "hup",		      OPT_EMULATE|OPT_ZSH,	 HUP},
+{NULL, "ignorebraces",	      OPT_EMULATE|OPT_SH,	 IGNOREBRACES},
+{NULL, "ignoreeof",	      0,			 IGNOREEOF},
+{NULL, "interactive",	      OPT_SPECIAL,		 INTERACTIVE},
+{NULL, "interactivecomments", OPT_EMULATE|OPT_BOURNE,	 INTERACTIVECOMMENTS},
+{NULL, "ksharrays",	      OPT_EMULATE|OPT_BOURNE,	 KSHARRAYS},
+{NULL, "kshautoload",	      OPT_EMULATE|OPT_BOURNE,	 KSHAUTOLOAD},
+{NULL, "kshglob",             OPT_EMULATE|OPT_KSH,       KSHGLOB},
+{NULL, "kshoptionprint",      OPT_EMULATE|OPT_KSH,	 KSHOPTIONPRINT},
+{NULL, "listambiguous",	      OPT_ALL,			 LISTAMBIGUOUS},
+{NULL, "listbeep",	      OPT_ALL,			 LISTBEEP},
+{NULL, "listtypes",	      OPT_ALL,			 LISTTYPES},
+{NULL, "localoptions",	      OPT_EMULATE|OPT_KSH,	 LOCALOPTIONS},
+{NULL, "login",		      OPT_SPECIAL,		 LOGINSHELL},
+{NULL, "longlistjobs",	      0,			 LONGLISTJOBS},
+{NULL, "magicequalsubst",     0,			 MAGICEQUALSUBST},
+{NULL, "mailwarning",	      0,			 MAILWARNING},
+{NULL, "markdirs",	      0,			 MARKDIRS},
+{NULL, "menucomplete",	      0,			 MENUCOMPLETE},
+{NULL, "monitor",	      OPT_SPECIAL,		 MONITOR},
+{NULL, "multios",	      OPT_EMULATE|OPT_ZSH,	 MULTIOS},
+{NULL, "nomatch",	      OPT_EMULATE|OPT_NONBOURNE, NOMATCH},
+{NULL, "notify",	      OPT_ZSH,			 NOTIFY},
+{NULL, "nullglob",	      OPT_EMULATE,		 NULLGLOB},
+{NULL, "numericglobsort",     0,			 NUMERICGLOBSORT},
+{NULL, "overstrike",	      0,			 OVERSTRIKE},
+{NULL, "pathdirs",	      0,			 PATHDIRS},
+{NULL, "posixbuiltins",	      OPT_EMULATE|OPT_BOURNE,	 POSIXBUILTINS},
+{NULL, "printeightbit",       0,                         PRINTEIGHTBIT},
+{NULL, "printexitvalue",      0,			 PRINTEXITVALUE},
+{NULL, "privileged",	      OPT_SPECIAL,		 PRIVILEGED},
+{NULL, "promptbang",	      OPT_EMULATE|OPT_KSH,	 PROMPTBANG},
+{NULL, "promptcr",	      OPT_ALL,			 PROMPTCR},
+{NULL, "promptpercent",	      OPT_EMULATE|OPT_NONBOURNE, PROMPTPERCENT},
+{NULL, "promptsubst",	      OPT_EMULATE|OPT_KSH,	 PROMPTSUBST},
+{NULL, "pushdignoredups",     0,			 PUSHDIGNOREDUPS},
+{NULL, "pushdminus",	      0,			 PUSHDMINUS},
+{NULL, "pushdsilent",	      0,			 PUSHDSILENT},
+{NULL, "pushdtohome",	      0,			 PUSHDTOHOME},
+{NULL, "rcexpandparam",	      0,			 RCEXPANDPARAM},
+{NULL, "rcquotes",	      0,			 RCQUOTES},
+{NULL, "rcs",		      OPT_ALL,			 RCS},
+{NULL, "recexact",	      0,			 RECEXACT},
+{NULL, "restricted",	      OPT_SPECIAL,		 RESTRICTED},
+{NULL, "rmstarsilent",	      OPT_BOURNE,		 RMSTARSILENT},
+{NULL, "rmstarwait",	      0,			 RMSTARWAIT},
+{NULL, "shfileexpansion",     OPT_EMULATE|OPT_BOURNE,	 SHFILEEXPANSION},
+{NULL, "shglob",	      OPT_EMULATE|OPT_BOURNE,	 SHGLOB},
+{NULL, "shinstdin",	      OPT_SPECIAL,		 SHINSTDIN},
+{NULL, "shoptionletters",     OPT_EMULATE|OPT_BOURNE,	 SHOPTIONLETTERS},
+{NULL, "shortloops",	      OPT_ALL,			 SHORTLOOPS},
+{NULL, "shwordsplit",	      OPT_EMULATE|OPT_BOURNE,	 SHWORDSPLIT},
+{NULL, "singlecommand",	      OPT_SPECIAL,		 SINGLECOMMAND},
+{NULL, "singlelinezle",	      OPT_KSH,			 SINGLELINEZLE},
+{NULL, "sunkeyboardhack",     0,			 SUNKEYBOARDHACK},
+{NULL, "unset",		      OPT_EMULATE|OPT_BSHELL,	 UNSET},
+{NULL, "verbose",	      0,			 VERBOSE},
+{NULL, "xtrace",	      0,			 XTRACE},
+{NULL, "zle",		      OPT_SPECIAL,		 USEZLE},
+{NULL, "braceexpand",	      OPT_ALIAS, /* ksh/bash */	 -IGNOREBRACES},
+{NULL, "dotglob",	      OPT_ALIAS, /* bash */	 GLOBDOTS},
+{NULL, "hashall",	      OPT_ALIAS, /* bash */	 HASHCMDS},
+{NULL, "histappend",	      OPT_ALIAS, /* bash */	 APPENDHISTORY},
+{NULL, "histexpand",	      OPT_ALIAS, /* bash */	 BANGHIST},
+{NULL, "log",		      OPT_ALIAS, /* ksh */	 -HISTNOFUNCTIONS},
+{NULL, "mailwarn",	      OPT_ALIAS, /* bash */	 MAILWARNING},
+{NULL, "onecmd",	      OPT_ALIAS, /* bash */	 SINGLECOMMAND},
+{NULL, "physical",	      OPT_ALIAS, /* ksh/bash */	 CHASELINKS},
+{NULL, "promptvars",	      OPT_ALIAS, /* bash */	 PROMPTSUBST},
+{NULL, "stdin",		      OPT_ALIAS, /* ksh */	 SHINSTDIN},
+{NULL, "trackall",	      OPT_ALIAS, /* ksh */	 HASHCMDS},
+{NULL, NULL, 0, 0}
+};
+
+/* Option letters */
+
+#define optletters (isset(SHOPTIONLETTERS) ? kshletters : zshletters)
+
+#define FIRST_OPT '0'
+#define LAST_OPT 'y'
+
+static short zshletters[LAST_OPT - FIRST_OPT + 1] = {
+    /* 0 */  CORRECT,
+    /* 1 */  PRINTEXITVALUE,
+    /* 2 */ -BADPATTERN,
+    /* 3 */ -NOMATCH,
+    /* 4 */  GLOBDOTS,
+    /* 5 */  NOTIFY,
+    /* 6 */  BGNICE,
+    /* 7 */  IGNOREEOF,
+    /* 8 */  MARKDIRS,
+    /* 9 */  AUTOLIST,
+    /* : */  0,
+    /* ; */  0,
+    /* < */  0,
+    /* = */  0,
+    /* > */  0,
+    /* ? */  0,
+    /* @ */  0,
+    /* A */  0,
+    /* B */ -BEEP,
+    /* C */ -CLOBBER,
+    /* D */  PUSHDTOHOME,
+    /* E */  PUSHDSILENT,
+    /* F */ -GLOBOPT,
+    /* G */  NULLGLOB,
+    /* H */  RMSTARSILENT,
+    /* I */  IGNOREBRACES,
+    /* J */  AUTOCD,
+    /* K */ -BANGHIST,
+    /* L */  SUNKEYBOARDHACK,
+    /* M */  SINGLELINEZLE,
+    /* N */  AUTOPUSHD,
+    /* O */  CORRECTALL,
+    /* P */  RCEXPANDPARAM,
+    /* Q */  PATHDIRS,
+    /* R */  LONGLISTJOBS,
+    /* S */  RECEXACT,
+    /* T */  CDABLEVARS,
+    /* U */  MAILWARNING,
+    /* V */ -PROMPTCR,
+    /* W */  AUTORESUME,
+    /* X */  LISTTYPES,
+    /* Y */  MENUCOMPLETE,
+    /* Z */  USEZLE,
+    /* [ */  0,
+    /* \ */  0,
+    /* ] */  0,
+    /* ^ */  0,
+    /* _ */  0,
+    /* ` */  0,
+    /* a */  ALLEXPORT,
+    /* b */  0,
+    /* c */  0,
+    /* d */  0,
+    /* e */  ERREXIT,
+    /* f */ -RCS,
+    /* g */  HISTIGNORESPACE,
+    /* h */  HISTIGNOREDUPS,
+    /* i */  INTERACTIVE,
+    /* j */  0,
+    /* k */  INTERACTIVECOMMENTS,
+    /* l */  LOGINSHELL,
+    /* m */  MONITOR,
+    /* n */ -EXECOPT,
+    /* o */  0,
+    /* p */  PRIVILEGED,
+    /* q */  0,
+    /* r */  RESTRICTED,
+    /* s */  SHINSTDIN,
+    /* t */  SINGLECOMMAND,
+    /* u */ -UNSET,
+    /* v */  VERBOSE,
+    /* w */  CHASELINKS,
+    /* x */  XTRACE,
+    /* y */  SHWORDSPLIT,
+};
+
+static short kshletters[LAST_OPT - FIRST_OPT + 1] = {
+    /* 0 */  0,
+    /* 1 */  0,
+    /* 2 */  0,
+    /* 3 */  0,
+    /* 4 */  0,
+    /* 5 */  0,
+    /* 6 */  0,
+    /* 7 */  0,
+    /* 8 */  0,
+    /* 9 */  0,
+    /* : */  0,
+    /* ; */  0,
+    /* < */  0,
+    /* = */  0,
+    /* > */  0,
+    /* ? */  0,
+    /* @ */  0,
+    /* A */  0,
+    /* B */  0,
+    /* C */ -CLOBBER,
+    /* D */  0,
+    /* E */  0,
+    /* F */  0,
+    /* G */  0,
+    /* H */  0,
+    /* I */  0,
+    /* J */  0,
+    /* K */  0,
+    /* L */  0,
+    /* M */  0,
+    /* N */  0,
+    /* O */  0,
+    /* P */  0,
+    /* Q */  0,
+    /* R */  0,
+    /* S */  0,
+    /* T */  0,
+    /* U */  0,
+    /* V */  0,
+    /* W */  0,
+    /* X */  MARKDIRS,
+    /* Y */  0,
+    /* Z */  0,
+    /* [ */  0,
+    /* \ */  0,
+    /* ] */  0,
+    /* ^ */  0,
+    /* _ */  0,
+    /* ` */  0,
+    /* a */  ALLEXPORT,
+    /* b */  NOTIFY,
+    /* c */  0,
+    /* d */  0,
+    /* e */  ERREXIT,
+    /* f */ -GLOBOPT,
+    /* g */  0,
+    /* h */  0,
+    /* i */  INTERACTIVE,
+    /* j */  0,
+    /* k */  0,
+    /* l */  LOGINSHELL,
+    /* m */  MONITOR,
+    /* n */ -EXECOPT,
+    /* o */  0,
+    /* p */  PRIVILEGED,
+    /* q */  0,
+    /* r */  RESTRICTED,
+    /* s */  SHINSTDIN,
+    /* t */  SINGLECOMMAND,
+    /* u */ -UNSET,
+    /* v */  VERBOSE,
+    /* w */  0,
+    /* x */  XTRACE,
+    /* y */  0,
+};
+
+/* Initialisation of the option name hash table */
+
+/**/
+static void
+printoptionnode(HashNode hn, int set)
+{
+    Optname on = (Optname) hn;
+    int optno = on->optno;
+
+    if (optno < 0)
+	optno = -optno;
+    if (isset(KSHOPTIONPRINT)) {
+	if (defset(on))
+	    printf("no%-20s%s\n", on->nam, isset(optno) ? "off" : "on");
+	else
+	    printf("%-22s%s\n", on->nam, isset(optno) ? "on" : "off");
+    } else if (set == (isset(optno) ^ defset(on))) {
+	if (set ^ isset(optno))
+	    fputs("no", stdout);
+	puts(on->nam);
+    }
+}
+
+/**/
+void
+createoptiontable(void)
+{
+    Optname on;
+
+    optiontab = newhashtable(101, "optiontab", NULL);
+
+    optiontab->hash        = hasher;
+    optiontab->emptytable  = NULL;
+    optiontab->filltable   = NULL;
+    optiontab->addnode     = addhashnode;
+    optiontab->getnode     = gethashnode;
+    optiontab->getnode2    = gethashnode2;
+    optiontab->removenode  = NULL;
+    optiontab->disablenode = disablehashnode;
+    optiontab->enablenode  = enablehashnode;
+    optiontab->freenode    = NULL;
+    optiontab->printnode   = printoptionnode;
+
+    for (on = optns; on->nam; on++)
+	optiontab->addnode(optiontab, on->nam, on);
+}
+
+/* Setting of default options */
+
+/**/
+static void
+setemulate(HashNode hn, int fully)
+{
+    Optname on = (Optname) hn;
+
+    /* Set options: each non-special option is set according to the *
+     * current emulation mode if either it is considered relevant   *
+     * to emulation or we are doing a full emulation (as indicated  *
+     * by the `fully' parameter).                                   */
+    if (!(on->flags & OPT_ALIAS) &&
+	((fully && !(on->flags & OPT_SPECIAL)) ||
+	 (on->flags & OPT_EMULATE)))
+	opts[on->optno] = defset(on);
+}
+
+/**/
+void
+emulate(const char *zsh_name, int fully)
+{
+    char ch = *zsh_name;
+
+    if (ch == 'r')
+	ch = zsh_name[1];
+
+    /* Work out the new emulation mode */
+    if (ch == 'c')
+	emulation = EMULATE_CSH;
+    else if (ch == 'k')
+	emulation = EMULATE_KSH;
+    else if (ch == 's' || ch == 'b')
+	emulation = EMULATE_SH;
+    else
+	emulation = EMULATE_ZSH;
+
+    scanhashtable(optiontab, 0, 0, 0, setemulate, fully);
+}
+
+/* setopt, unsetopt */
+
+/**/
+static void
+setoption(HashNode hn, int value)
+{
+    dosetopt(((Optname) hn)->optno, value, 0);
+}
+
+/**/
+int
+bin_setopt(char *nam, char **args, char *ops, int isun)
+{
+    int action, optno, match = 0;
+
+    /* With no arguments or options, display options. */
+    if (!*args) {
+	scanhashtable(optiontab, 1, 0, OPT_ALIAS, optiontab->printnode, !isun);
+	return 0;
+    }
+
+    /* loop through command line options (begins with "-" or "+") */
+    while (*args && (**args == '-' || **args == '+')) {
+	action = (**args == '-') ^ isun;
+	if(!args[0][1])
+	    *args = "--";
+	while (*++*args) {
+	    if(**args == Meta)
+		*++*args ^= 32;
+	    /* The pseudo-option `--' signifies the end of options. */
+	    if (**args == '-') {
+		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 == 'm') {
+		match = 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:
+
+    if (!match) {
+	/* Not globbing the arguments -- arguments are simply option names. */
+	while (*args) {
+	    if(!(optno = optlookup(*args++)))
+		zwarnnam(nam, "no such option: %s", args[-1], 0);
+	    else if(dosetopt(optno, !isun, 0))
+		zwarnnam(nam, "can't change option: %s", args[-1], 0);
+	}
+    } else {
+	/* Globbing option (-m) set. */
+	while (*args) {
+	    Comp com;
+
+	    /* Expand the current arg. */
+	    tokenize(*args);
+	    if (!(com = parsereg(*args))) {
+		untokenize(*args);
+		zwarnnam(nam, "bad pattern: %s", *args, 0);
+		continue;
+	    }
+	    /* Loop over expansions. */
+	    scanmatchtable(optiontab, com, 0, OPT_ALIAS, setoption, !isun);
+	    args++;
+	}
+    }
+    inittyptab();
+    return 0;
+}
+
+/* Identify an option name */
+
+/**/
+int
+optlookup(char const *name)
+{
+    char *s, *t;
+    Optname n;
+
+    s = t = dupstring(name);
+
+    /* exorcise underscores, and change to lowercase */
+    while (*t)
+	if (*t == '_')
+	    chuck(t);
+	else {
+	    *t = tulower(*t);
+	    t++;
+	}
+
+    /* look up name in the table */
+    if (s[0] == 'n' && s[1] == 'o' &&
+	(n = (Optname) optiontab->getnode(optiontab, s + 2))) {
+	return -n->optno;
+    } else if ((n = (Optname) optiontab->getnode(optiontab, s)))
+	return n->optno;
+    else
+	return OPT_INVALID;
+}
+
+/* Identify an option letter */
+
+/**/
+int
+optlookupc(char c)
+{
+    if(c < FIRST_OPT || c > LAST_OPT)
+	return 0;
+
+    return optletters[c - FIRST_OPT];
+}
+
+/**/
+static void
+restrictparam(char *nam)
+{
+    Param pm = (Param) paramtab->getnode(paramtab, nam);
+
+    if (pm) {
+	pm->flags |= PM_SPECIAL | PM_RESTRICTED;
+	return;
+    }
+    createparam(nam, PM_SCALAR | PM_UNSET | PM_SPECIAL | PM_RESTRICTED);
+}
+
+/* list of restricted parameters which are not otherwise special */
+static char *rparams[] = {
+    "SHELL", "HISTFILE", "LD_LIBRARY_PATH", "LD_AOUT_LIBRARY_PATH",
+    "LD_PRELOAD", "LD_AOUT_PRELOAD", NULL
+};
+
+/* Set or unset an option, as a result of user request.  The option *
+ * number may be negative, indicating that the sense is reversed    *
+ * from the usual meaning of the option.                            */
+
+/**/
+int
+dosetopt(int optno, int value, int force)
+{
+    if(!optno)
+	return -1;
+    if(optno < 0) {
+	optno = -optno;
+	value = !value;
+    }
+    if (optno == RESTRICTED) {
+	if (isset(RESTRICTED))
+	    return value ? 0 : -1;
+	if (value) {
+	    char **s;
+
+	    for (s = rparams; *s; s++)
+		restrictparam(*s);
+	}
+    } else if(!force && (optno == INTERACTIVE || optno == SHINSTDIN ||
+	    optno == SINGLECOMMAND)) {
+	/* it is not permitted to change the value of these options */
+	return -1;
+    } else if(!force && optno == USEZLE && value) {
+	/* we require a terminal in order to use ZLE */
+	if(!interact || SHTTY == -1 || !shout)
+	    return -1;
+    } else if(optno == PRIVILEGED && !value) {
+	/* unsetting PRIVILEGED causes the shell to make itself unprivileged */
+#ifdef HAVE_SETUID
+	setuid(getuid());
+	setgid(getgid());
+#endif /* HAVE_SETUID */
+    }
+    opts[optno] = value;
+    if (optno == BANGHIST || optno == SHINSTDIN)
+	inittyptab();
+    return 0;
+}
+
+/* Function to get value for special parameter `-' */
+
+/**/
+char *
+dashgetfn(Param pm)
+{
+    static char buf[LAST_OPT - FIRST_OPT + 2];
+    char *val = buf;
+    int i;
+
+    for(i = 0; i <= LAST_OPT - FIRST_OPT; i++) {
+	int optno = optletters[i];
+	if(optno && ((optno > 0) ? isset(optno) : unset(-optno)))
+	    *val++ = FIRST_OPT + i;
+    }
+    *val = '\0';
+    return buf;
+}
diff --git a/Src/params.c b/Src/params.c
new file mode 100644
index 000000000..4f7846820
--- /dev/null
+++ b/Src/params.c
@@ -0,0 +1,2191 @@
+/*
+ * params.c - parameters
+ *
+ * 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 "params.pro"
+
+#include "version.h"
+
+/* what level of localness we are at */
+ 
+/**/
+int locallevel;
+ 
+/* Variables holding values of special parameters */
+ 
+/**/
+char **pparams,		/* $argv        */
+     **cdpath,		/* $cdpath      */
+     **fignore,		/* $fignore     */
+     **fpath,		/* $fpath       */
+     **mailpath,	/* $mailpath    */
+     **manpath,		/* $manpath     */
+     **path,		/* $path        */
+     **psvar,		/* $psvar       */
+     **watch;		/* $watch       */
+ 
+/**/
+char *argzero,		/* $0           */
+     *underscore,	/* $_           */
+     *home,		/* $HOME        */
+     *hostnam,		/* $HOST        */
+     *ifs,		/* $IFS         */
+     *nullcmd,		/* $NULLCMD     */
+     *oldpwd,		/* $OLDPWD      */
+     *zoptarg,		/* $OPTARG      */
+     *postedit,		/* $POSTEDIT    */
+     *prompt,		/* $PROMPT      */
+     *prompt2,		/* $PROMPT2     */
+     *prompt3,		/* $PROMPT3     */
+     *prompt4,		/* $PROMPT4     */
+     *pwd,		/* $PWD         */
+     *readnullcmd,	/* $READNULLCMD */
+     *rprompt,		/* $RPROMPT     */
+     *sprompt,		/* $SPROMPT     */
+     *term,		/* $TERM        */
+     *ttystrname,	/* $TTY         */
+     *wordchars,	/* $WORDCHARS   */
+     *zsh_name;		/* $ZSH_NAME    */
+
+/**/
+long lastval,		/* $?           */
+     mypid,		/* $$           */
+     lastpid,		/* $!           */
+     columns,		/* $COLUMNS     */
+     lineno,		/* $LINENO      */
+     lines,		/* $LINES       */
+     zoptind,		/* $OPTIND      */
+     ppid,		/* $PPID        */
+     shlvl;		/* $SHLVL       */
+
+/* $histchars */
+ 
+/**/
+unsigned char bangchar, hatchar, hashchar;
+ 
+/* $SECONDS = time(NULL) - shtimer.tv_sec */
+ 
+/**/
+struct timeval shtimer;
+ 
+/* 0 if this $TERM setup is usable, otherwise it contains TERM_* flags */
+
+/**/
+int termflags;
+ 
+/* Nodes for special parameters for parameter hash table */
+
+static
+#ifdef HAVE_UNION_INIT
+# define BR(X) {X}
+struct param
+#else
+# define BR(X) X
+struct iparam {
+    struct hashnode *next;
+    char *nam;			/* hash data                             */
+    int flags;			/* PM_* flags (defined in zsh.h)         */
+    void *value;
+    void (*func1) _((void));	/* set func                              */
+    char *(*func2) _((void));	/* get func                              */
+    void (*unsetfn) _((Param, int));	/* unset func                    */
+    int ct;			/* output base or field width            */
+    char *env;			/* location in environment, if exported  */
+    char *ename;		/* name of corresponding environment var */
+    Param old;			/* old struct for use with local         */
+    int level;			/* if (old != NULL), level of localness  */
+}
+#endif
+special_params[] ={
+#define SFN(X) BR(((void (*)_((Param, char *)))(X)))
+#define GFN(X) BR(((char *(*)_((Param)))(X)))
+#define IPDEF1(A,B,C,D) {NULL,A,PM_INTEGER|PM_SPECIAL|D,BR(NULL),SFN(C),GFN(B),stdunsetfn,10,NULL,NULL,NULL,0}
+IPDEF1("#", poundgetfn, nullsetfn, PM_READONLY),
+IPDEF1("ERRNO", errnogetfn, nullsetfn, PM_READONLY),
+IPDEF1("GID", gidgetfn, gidsetfn, PM_DONTIMPORT | PM_RESTRICTED),
+IPDEF1("EGID", egidgetfn, egidsetfn, PM_DONTIMPORT | PM_RESTRICTED),
+IPDEF1("HISTSIZE", histsizegetfn, histsizesetfn, PM_RESTRICTED),
+IPDEF1("RANDOM", randomgetfn, randomsetfn, 0),
+IPDEF1("SECONDS", secondsgetfn, secondssetfn, 0),
+IPDEF1("UID", uidgetfn, uidsetfn, PM_DONTIMPORT | PM_RESTRICTED),
+IPDEF1("EUID", euidgetfn, euidsetfn, PM_DONTIMPORT | PM_RESTRICTED),
+IPDEF1("TTYIDLE", ttyidlegetfn, nullsetfn, PM_READONLY),
+
+#define IPDEF2(A,B,C,D) {NULL,A,PM_SCALAR|PM_SPECIAL|D,BR(NULL),SFN(C),GFN(B),stdunsetfn,0,NULL,NULL,NULL,0}
+IPDEF2("USERNAME", usernamegetfn, usernamesetfn, PM_DONTIMPORT|PM_RESTRICTED),
+IPDEF2("-", dashgetfn, nullsetfn, PM_READONLY),
+IPDEF2("histchars", histcharsgetfn, histcharssetfn, PM_DONTIMPORT),
+IPDEF2("HOME", homegetfn, homesetfn, 0),
+IPDEF2("TERM", termgetfn, termsetfn, 0),
+IPDEF2("WORDCHARS", wordcharsgetfn, wordcharssetfn, 0),
+IPDEF2("IFS", ifsgetfn, ifssetfn, PM_DONTIMPORT),
+IPDEF2("_", underscoregetfn, nullsetfn, PM_READONLY),
+
+#ifdef LC_ALL
+# define LCIPDEF(name) IPDEF2(name, strgetfn, lcsetfn, PM_UNSET)
+IPDEF2("LANG", strgetfn, langsetfn, PM_UNSET),
+IPDEF2("LC_ALL", strgetfn, lc_allsetfn, PM_UNSET),
+# ifdef LC_COLLATE
+LCIPDEF("LC_COLLATE"),
+# endif
+# ifdef LC_CTYPE
+LCIPDEF("LC_CTYPE"),
+# endif
+# ifdef LC_MESSAGES
+LCIPDEF("LC_MESSAGES"),
+# endif
+# ifdef LC_TIME
+LCIPDEF("LC_TIME"),
+# endif
+#endif
+
+#define IPDEF4(A,B) {NULL,A,PM_INTEGER|PM_READONLY|PM_SPECIAL,BR((void *)B),SFN(nullsetfn),GFN(intvargetfn),stdunsetfn,10,NULL,NULL,NULL,0}
+IPDEF4("!", &lastpid),
+IPDEF4("$", &mypid),
+IPDEF4("?", &lastval),
+IPDEF4("LINENO", &lineno),
+IPDEF4("PPID", &ppid),
+
+#define IPDEF5(A,B,F) {NULL,A,PM_INTEGER|PM_SPECIAL,BR((void *)B),SFN(F),GFN(intvargetfn),stdunsetfn,10,NULL,NULL,NULL,0}
+IPDEF5("COLUMNS", &columns, zlevarsetfn),
+IPDEF5("LINES", &lines, zlevarsetfn),
+IPDEF5("OPTIND", &zoptind, intvarsetfn),
+IPDEF5("SHLVL", &shlvl, intvarsetfn),
+
+#define IPDEF7(A,B) {NULL,A,PM_SCALAR|PM_SPECIAL,BR((void *)B),SFN(strvarsetfn),GFN(strvargetfn),stdunsetfn,0,NULL,NULL,NULL,0}
+IPDEF7("OPTARG", &zoptarg),
+IPDEF7("NULLCMD", &nullcmd),
+IPDEF7("POSTEDIT", &postedit),
+IPDEF7("READNULLCMD", &readnullcmd),
+IPDEF7("RPROMPT", &rprompt),
+IPDEF7("PS1", &prompt),
+IPDEF7("PS2", &prompt2),
+IPDEF7("PS3", &prompt3),
+IPDEF7("PS4", &prompt4),
+IPDEF7("RPS1", &rprompt),
+IPDEF7("SPROMPT", &sprompt),
+IPDEF7("0", &argzero),
+
+#define IPDEF8(A,B,C,D) {NULL,A,D|PM_SCALAR|PM_SPECIAL,BR((void *)B),SFN(colonarrsetfn),GFN(colonarrgetfn),stdunsetfn,0,NULL,C,NULL,0}
+IPDEF8("CDPATH", &cdpath, "cdpath", 0),
+IPDEF8("FIGNORE", &fignore, "fignore", 0),
+IPDEF8("FPATH", &fpath, "fpath", 0),
+IPDEF8("MAILPATH", &mailpath, "mailpath", 0),
+IPDEF8("WATCH", &watch, "watch", 0),
+IPDEF8("PATH", &path, "path", PM_RESTRICTED),
+IPDEF8("PSVAR", &psvar, "psvar", 0),
+
+#ifdef DYNAMIC
+/* MODULE_PATH is not imported for security reasons */
+IPDEF8("MODULE_PATH", &module_path, "module_path", PM_DONTIMPORT|PM_RESTRICTED),
+#endif
+
+#define IPDEF9F(A,B,C,D) {NULL,A,D|PM_ARRAY|PM_SPECIAL|PM_DONTIMPORT,BR((void *)B),SFN(arrvarsetfn),GFN(arrvargetfn),stdunsetfn,0,NULL,C,NULL,0}
+#define IPDEF9(A,B,C) IPDEF9F(A,B,C,0)
+IPDEF9("*", &pparams, NULL),
+IPDEF9("@", &pparams, NULL),
+{NULL, NULL},
+
+/* The following parameters are not avaible in sh/ksh compatibility *
+ * mode. All of these has sh compatible equivalents.                */
+IPDEF1("ARGC", poundgetfn, nullsetfn, PM_READONLY),
+IPDEF2("HISTCHARS", histcharsgetfn, histcharssetfn, PM_DONTIMPORT),
+IPDEF4("status", &lastval),
+IPDEF7("prompt", &prompt),
+IPDEF7("PROMPT", &prompt),
+IPDEF7("PROMPT2", &prompt2),
+IPDEF7("PROMPT3", &prompt3),
+IPDEF7("PROMPT4", &prompt4),
+IPDEF8("MANPATH", &manpath, "manpath", 0),
+IPDEF9("argv", &pparams, NULL),
+IPDEF9("fignore", &fignore, "FIGNORE"),
+IPDEF9("cdpath", &cdpath, "CDPATH"),
+IPDEF9("fpath", &fpath, "FPATH"),
+IPDEF9("mailpath", &mailpath, "MAILPATH"),
+IPDEF9("manpath", &manpath, "MANPATH"),
+IPDEF9("psvar", &psvar, "PSVAR"),
+IPDEF9("watch", &watch, "WATCH"),
+
+#ifdef DYNAMIC
+IPDEF9F("module_path", &module_path, "MODULE_PATH", PM_RESTRICTED),
+#endif
+IPDEF9F("path", &path, "PATH", PM_RESTRICTED),
+
+{NULL, NULL}
+};
+#undef BR
+
+static Param argvparam;
+
+/* hash table containing the parameters */
+ 
+/**/
+HashTable paramtab;
+ 
+/* Set up parameter hash table.  This will add predefined  *
+ * parameter entries as well as setting up parameter table *
+ * entries for environment variables we inherit.           */
+
+/**/
+void
+createparamtable(void)
+{
+    Param ip, pm;
+    char **new_environ, **envp, **envp2, **sigptr, **t;
+    char buf[50], *str, *iname;
+    int num_env;
+
+    paramtab = newhashtable(151, "paramtab", NULL);
+
+    paramtab->hash        = hasher;
+    paramtab->emptytable  = NULL;
+    paramtab->filltable   = NULL;
+    paramtab->addnode     = addhashnode;
+    paramtab->getnode     = gethashnode2;
+    paramtab->getnode2    = gethashnode2;
+    paramtab->removenode  = removehashnode;
+    paramtab->disablenode = NULL;
+    paramtab->enablenode  = NULL;
+    paramtab->freenode    = freeparamnode;
+    paramtab->printnode   = printparamnode;
+
+    /* Add the special parameters to the hash table */
+    for (ip = special_params; ip->nam; ip++)
+	paramtab->addnode(paramtab, ztrdup(ip->nam), ip);
+    if (emulation != EMULATE_SH && emulation != EMULATE_KSH)
+	while ((++ip)->nam)
+	    paramtab->addnode(paramtab, ztrdup(ip->nam), ip);
+
+    argvparam = (Param) paramtab->getnode(paramtab, "*");
+
+    noerrs = 1;
+
+    HEAPALLOC {
+	/* Add the standard non-special parameters which have to    *
+	 * be initialized before we copy the environment variables. *
+	 * We don't want to override whatever values the users has  *
+	 * given them in the environment.                           */
+	setiparam("MAILCHECK", 60);
+	setiparam("LOGCHECK", 60);
+	setiparam("KEYTIMEOUT", 40);
+	setiparam("LISTMAX", 100);
+#ifdef HAVE_SELECT
+	setiparam("BAUD", getbaudrate(&shttyinfo));  /* get the output baudrate */
+#endif
+	setsparam("FCEDIT", ztrdup(DEFAULT_FCEDIT));
+	setsparam("TMPPREFIX", ztrdup(DEFAULT_TMPPREFIX));
+	setsparam("TIMEFMT", ztrdup(DEFAULT_TIMEFMT));
+	setsparam("WATCHFMT", ztrdup(default_watchfmt));
+	setsparam("HOST", ztrdup(hostnam));
+	setsparam("LOGNAME", ztrdup((str = getlogin()) && *str ? str : cached_username));
+
+	/* Copy the environment variables we are inheriting to dynamic *
+	 * memory, so we can do mallocs and frees on it.               */
+	num_env = arrlen(environ);
+	new_environ = (char **) zalloc(sizeof(char *) * (num_env + 1));
+	*new_environ = NULL;
+
+	/* Now incorporate environment variables we are inheriting *
+	 * into the parameter hash table.                          */
+	for (envp = new_environ, envp2 = environ; *envp2; envp2++) {
+	    for (str = *envp2; *str && *str != '='; str++);
+	    if (*str == '=') {
+		iname = NULL;
+		*str = '\0';
+		if (!idigit(**envp2) && isident(*envp2) && !strchr(*envp2, '[')) {
+		    iname = *envp2;
+		    if ((!(pm = (Param) paramtab->getnode(paramtab, iname)) ||
+			 !(pm->flags & PM_DONTIMPORT)) &&
+			(pm = setsparam(iname, metafy(str + 1, -1, META_DUP))) &&
+			!(pm->flags & PM_EXPORTED)) {
+			*str = '=';
+			pm->flags |= PM_EXPORTED;
+			pm->env = *envp++ = ztrdup(*envp2);
+			*envp = NULL;
+			if (pm->flags & PM_SPECIAL)
+			    pm->env = replenv(pm->env, getsparam(pm->nam));
+		    }
+		}
+		*str = '=';
+	    }
+	}
+	environ = new_environ;
+
+	pm = (Param) paramtab->getnode(paramtab, "HOME");
+	if (!(pm->flags & PM_EXPORTED)) {
+	    pm->flags |= PM_EXPORTED;
+	    pm->env = addenv("HOME", home);
+	}
+	pm = (Param) paramtab->getnode(paramtab, "LOGNAME");
+	if (!(pm->flags & PM_EXPORTED)) {
+	    pm->flags |= PM_EXPORTED;
+	    pm->env = addenv("LOGNAME", pm->u.str);
+	}
+	pm = (Param) paramtab->getnode(paramtab, "SHLVL");
+	if (!(pm->flags & PM_EXPORTED))
+	    pm->flags |= PM_EXPORTED;
+	sprintf(buf, "%d", (int)++shlvl);
+	pm->env = addenv("SHLVL", buf);
+
+	/* Add the standard non-special parameters */
+	set_pwd_env();
+	setsparam("MACHTYPE", ztrdup(MACHTYPE));
+	setsparam("OSTYPE", ztrdup(OSTYPE));
+	setsparam("TTY", ztrdup(ttystrname));
+	setsparam("VENDOR", ztrdup(VENDOR));
+	setsparam("ZSH_NAME", ztrdup(zsh_name));
+	setsparam("ZSH_VERSION", ztrdup(ZSH_VERSION));
+	setaparam("signals", sigptr = zalloc((SIGCOUNT+4) * sizeof(char *)));
+	for (t = sigs; (*sigptr++ = ztrdup(*t++)); );
+    } LASTALLOC;
+
+    noerrs = 0;
+}
+
+/* Create a parameter, so that it can be assigned to.  Returns NULL if the *
+ * parameter already exists or can't be created, otherwise returns the     *
+ * parameter node.  If a parameter of the same name exists in an outer     *
+ * scope, it is hidden by a newly created parameter.  An already existing  *
+ * parameter node at the current level may be `created' and returned       *
+ * provided it is unset and not special.  If the parameter can't be        *
+ * created because it already exists, the PM_UNSET flag is cleared.        */
+
+/**/
+Param
+createparam(char *name, int flags)
+{
+    Param pm, oldpm;
+
+    if (name != nulstring) {
+	oldpm = (Param) paramtab->getnode(paramtab, name);
+
+	if (oldpm && oldpm->level == locallevel) {
+	    if (!(oldpm->flags & PM_UNSET) || (oldpm->flags & PM_SPECIAL)) {
+		oldpm->flags &= ~PM_UNSET;
+		return NULL;
+	    }
+	    if ((oldpm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+		zerr("%s: restricted", name, 0);
+		return NULL;
+	    }
+
+	    pm = oldpm;
+	    pm->ct = 0;
+	    oldpm = pm->old;
+	} else {
+	    pm = (Param) zcalloc(sizeof *pm);
+	    if ((pm->old = oldpm)) {
+		/* needed to avoid freeing oldpm */
+		paramtab->removenode(paramtab, name);
+	    }
+	    paramtab->addnode(paramtab, ztrdup(name), pm);
+	}
+
+	if (isset(ALLEXPORT) && !oldpm)
+	    flags |= PM_EXPORTED;
+    } else
+	pm = (Param) alloc(sizeof *pm);
+    pm->flags = flags;
+
+    if(!(pm->flags & PM_SPECIAL)) {
+	switch (PM_TYPE(flags)) {
+	case PM_SCALAR:
+	    pm->sets.cfn = strsetfn;
+	    pm->gets.cfn = strgetfn;
+	    break;
+	case PM_INTEGER:
+	    pm->sets.ifn = intsetfn;
+	    pm->gets.ifn = intgetfn;
+	    break;
+	case PM_ARRAY:
+	    pm->sets.afn = arrsetfn;
+	    pm->gets.afn = arrgetfn;
+	    break;
+	default:
+	    DPUTS(1, "BUG: tried to create param node without valid flag");
+	    break;
+	}
+	pm->unsetfn = stdunsetfn;
+    }
+    return pm;
+}
+
+/* Return 1 if the string s is a valid identifier, else return 0. */
+
+/**/
+int
+isident(char *s)
+{
+    char *ss;
+    int ne;
+
+    ne = noeval;		/* save the current value of noeval     */
+    if (!*s)			/* empty string is definitely not valid */
+	return 0;
+
+    /* find the first character in `s' not in the iident type table */
+    for (ss = s; *ss; ss++)
+	if (!iident(*ss))
+	    break;
+
+    /* If this exhaust `s' or the next two characters *
+     * are [(, then it is a valid identifier.         */
+    if (!*ss || (*ss == '[' && ss[1] == '('))
+	return 1;
+
+    /* Else if the next character is not [, then it is *
+     * definitely not a valid identifier.              */
+    if (*ss != '[')
+	return 0;
+    noeval = 1;
+    (void)mathevalarg(++ss, &ss);
+    if (*ss == ',')
+	(void)mathevalarg(++ss, &ss);
+    noeval = ne;		/* restore the value of noeval */
+    if (*ss != ']' || ss[1])
+	return 0;
+    return 1;
+}
+
+static char **garr;
+
+/**/
+static long
+getarg(char **str, int *inv, Value v, int a2, long *w)
+{
+    int num = 1, word = 0, rev = 0, ind = 0, down = 0, l, i;
+    char *s = *str, *sep = NULL, *t, sav, *d, **ta, **p, *tt;
+    long r = 0;
+    Comp c;
+
+    /* first parse any subscription flags */
+    if (*s == '(' || *s == Inpar) {
+	int escapes = 0;
+	int waste;
+	for (s++; *s != ')' && *s != Outpar && s != *str; s++) {
+	    switch (*s) {
+	    case 'r':
+		rev = 1;
+		down = ind = 0;
+		break;
+	    case 'R':
+		rev = down = 1;
+		ind = 0;
+		break;
+	    case 'i':
+		rev = ind = 1;
+		down = 0;
+		break;
+	    case 'I':
+		rev = ind = down = 1;
+		break;
+	    case 'w':
+		/* If the parameter is a scalar, then make subscription *
+		 * work on a per-word basis instead of characters.      */
+		word = 1;
+		break;
+	    case 'f':
+		word = 1;
+		sep = "\n";
+		break;
+	    case 'e':
+		/* obsolate compatibility flag without any real effect */
+		break;
+	    case 'n':
+		t = get_strarg(++s);
+		if (!*t)
+		    goto flagerr;
+		sav = *t;
+		*t = '\0';
+		num = mathevalarg(s + 1, &d);
+		if (!num)
+		    num = 1;
+		*t = sav;
+		s = t;
+		break;
+	    case 'p':
+		escapes = 1;
+		break;
+	    case 's':
+		/* This gives the string that separates words *
+		 * (for use with the `w' flag.                */
+		t = get_strarg(++s);
+		if (!*t)
+		    goto flagerr;
+		sav = *t;
+		*t = '\0';
+		sep = escapes ? getkeystring(s + 1, &waste, 1, &waste) :
+				dupstring(s + 1);
+		*t = sav;
+		s = t;
+		break;
+	    default:
+	      flagerr:
+		num = 1;
+		word = rev = ind = down = 0;
+		sep = NULL;
+		s = *str - 1;
+	    }
+	}
+	if (s != *str)
+	    s++;
+    }
+    if (num < 0) {
+	down = !down;
+	num = -num;
+    }
+    *inv = ind;
+
+    for (t=s, i=0; *t && ((*t != ']' && *t != Outbrack && *t != ',') || i); t++)
+	if (*t == '[' || *t == Inbrack)
+	    i++;
+	else if (*t == ']' || *t == Outbrack)
+	    i--;
+
+    if (!*t)
+	return 0;
+    s = dupstrpfx(s, t - s);
+    *str = tt = t;
+    if (parsestr(s))
+	return 0;
+    singsub(&s);
+
+    if (!rev) {
+	if (!(r = mathevalarg(s, &s)) || (isset(KSHARRAYS) && r >= 0))
+	    r++;
+	if (word && !v->isarr) {
+	    s = t = getstrvalue(v);
+	    i = wordcount(s, sep, 0);
+	    if (r < 0)
+		r += i + 1;
+	    if (r < 1)
+		r = 1;
+	    if (r > i)
+		r = i;
+	    if (!s || !*s)
+		return 0;
+	    while ((d = findword(&s, sep)) && --r);
+	    if (!d)
+		return 0;
+
+	    if (!a2 && *tt != ',')
+		*w = (long)(s - t) - 1;
+
+	    return (a2 ? s : d + 1) - t;
+	} else if (!v->isarr && !word) {
+	    s = getstrvalue(v);
+	    if (r > 0) {
+		for (t = s + r - 1; *s && s < t;)
+		    if (*s++ == Meta)
+			s++, t++, r++;
+	    } else {
+		r += ztrlen(s);
+		for (t = s + r; *s && s < t; r--)
+		    if (*s++ == Meta)
+			t++, r++;
+		r -= strlen(s);
+	    }
+	}
+    } else {
+	if (!v->isarr && !word) {
+	    l = strlen(s);
+	    if (a2) {
+		if (!l || *s != '*') {
+		    d = (char *) ncalloc(l + 2);
+		    *d = '*';
+		    strcpy(d + 1, s);
+		    s = d;
+		}
+	    } else {
+		if (!l || s[l - 1] != '*') {
+		    d = (char *) ncalloc(l + 2);
+		    strcpy(d, s);
+		    strcat(d, "*");
+		    s = d;
+		}
+	    }
+	}
+	tokenize(s);
+
+	if ((c = parsereg(s))) {
+	    if (v->isarr) {
+		ta = getarrvalue(v);
+		if (!ta || !*ta)
+		    return 0;
+		if (down)
+		    for (r = -1, p = ta + arrlen(ta) - 1; p >= ta; r--, p--) {
+			if (domatch(*p, c, 0) && !--num)
+			    return r;
+		} else
+		    for (r = 1, p = ta; *p; r++, p++)
+			if (domatch(*p, c, 0) && !--num)
+			    return r;
+	    } else if (word) {
+		ta = sepsplit(d = s = getstrvalue(v), sep, 1);
+		if (down) {
+		    for (p = ta + (r = arrlen(ta)) - 1; p >= ta; p--, r--)
+			if (domatch(*p, c, 0) && !--num)
+			    break;
+		    if (p < ta)
+			return 0;
+		} else {
+		    for (r = 1, p = ta; *p; r++, p++)
+			if (domatch(*p, c, 0) && !--num)
+			    break;
+		    if (!*p)
+			return 0;
+		}
+		if (a2)
+		    r++;
+		for (i = 0; (t = findword(&d, sep)) && *t; i++)
+		    if (!--r) {
+			r = (long)(t - s + (a2 ? -1 : 1));
+			if (!a2 && *tt != ',')
+			    *w = r + strlen(ta[i]) - 2;
+			return r;
+		    }
+		return a2 ? -1 : 0;
+	    } else {
+		d = getstrvalue(v);
+		if (!d || !*d)
+		    return 0;
+		if (a2) {
+		    if (down)
+			for (r = -2, t = d + strlen(d) - 1; t >= d; r--, t--) {
+			    sav = *t;
+			    *t = '\0';
+			    if (domatch(d, c, 0) && !--num) {
+				*t = sav;
+				return r;
+			    }
+			    *t = sav;
+		    } else
+			for (r = 0, t = d; *t; r++, t++) {
+			    sav = *t;
+			    *t = '\0';
+			    if (domatch(d, c, 0) && !--num) {
+				*t = sav;
+				return r;
+			    }
+			    *t = sav;
+			}
+		} else {
+		    if (down)
+			for (r = -1, t = d + strlen(d) - 1; t >= d; r--, t--) {
+			    if (domatch(t, c, 0) && !--num)
+				return r;
+		    } else
+			for (r = 1, t = d; *t; r++, t++)
+			    if (domatch(t, c, 0) && !--num)
+				return r;
+		}
+		return 0;
+	    }
+	}
+    }
+    return r;
+}
+
+/**/
+int
+getindex(char **pptr, Value v)
+{
+    int a, b, inv = 0;
+    char *s = *pptr, *tbrack;
+
+    *s++ = '[';
+    for (tbrack = s; *tbrack && *tbrack != ']' && *tbrack != Outbrack; tbrack++)
+	if (itok(*tbrack))
+	    *tbrack = ztokens[*tbrack - Pound];
+    if (*tbrack == Outbrack)
+	*tbrack = ']';
+    if ((s[0] == '*' || s[0] == '@') && s[1] == ']') {
+	if (v->isarr)
+	    v->isarr = (s[0] == '*') ? 1 : -1;
+	v->a = 0;
+	v->b = -1;
+	s += 2;
+    } else {
+	long we = 0, dummy;
+
+	a = getarg(&s, &inv, v, 0, &we);
+
+	if (inv) {
+	    if (!v->isarr && a != 0) {
+		char *t, *p;
+		t = getstrvalue(v);
+		if (a > 0) {
+		    for (p = t + a - 1; p-- > t; )
+			if (*p == Meta)
+			    a--;
+		} else
+		    a = -ztrlen(t + a + strlen(t));
+	    }
+	    if (a > 0 && isset(KSHARRAYS))
+		a--;
+	    v->inv = 1;
+	    v->isarr = 0;
+	    v->a = v->b = a;
+	    if (*s == ',') {
+		zerr("invalid subscript", NULL, 0);
+		while (*s != ']' && *s != Outbrack)
+		    s++;
+		*pptr = s;
+		return 1;
+	    }
+	    if (*s == ']' || *s == Outbrack)
+		s++;
+	} else {
+	    if (a > 0)
+		a--;
+	    if (*s == ',') {
+		s++;
+		b = getarg(&s, &inv, v, 1, &dummy);
+		if (b > 0)
+		    b--;
+	    } else {
+		b = we ? we : a;
+	    }
+	    if (*s == ']' || *s == Outbrack) {
+		s++;
+		if (v->isarr && a == b)
+		    v->isarr = 0;
+		v->a = a;
+		v->b = b;
+	    } else
+		s = *pptr;
+	}
+    }
+    *pptr = s;
+    return 0;
+}
+
+
+/**/
+Value
+getvalue(char **pptr, int bracks)
+{
+    char *s, *t;
+    char sav;
+    Value v;
+    int ppar = 0;
+
+    s = t = *pptr;
+    garr = NULL;
+
+    if (idigit(*s))
+	if (bracks >= 0)
+	    ppar = zstrtol(s, &s, 10);
+	else
+	    ppar = *s++ - '0';
+    else if (iident(*s))
+	while (iident(*s))
+	    s++;
+    else if (*s == Quest)
+	*s++ = '?';
+    else if (*s == Pound)
+	*s++ = '#';
+    else if (*s == String)
+	*s++ = '$';
+    else if (*s == Qstring)
+	*s++ = '$';
+    else if (*s == Star)
+	*s++ = '*';
+    else if (*s == '#' || *s == '-' || *s == '?' || *s == '$' ||
+	     *s == '_' || *s == '!' || *s == '@' || *s == '*')
+	s++;
+    else
+	return NULL;
+
+    if ((sav = *s))
+	*s = '\0';
+    if (ppar) {
+	v = (Value) hcalloc(sizeof *v);
+	v->pm = argvparam;
+	v->inv = 0;
+	v->a = v->b = ppar - 1;
+	if (sav)
+	    *s = sav;
+    } else {
+	Param pm;
+	int isvarat;
+
+        isvarat = !strcmp(t, "@");
+	pm = (Param) paramtab->getnode(paramtab, *t == '0' ? "0" : t);
+	if (sav)
+	    *s = sav;
+	*pptr = s;
+	if (!pm || (pm->flags & PM_UNSET))
+	    return NULL;
+	v = (Value) hcalloc(sizeof *v);
+	if (PM_TYPE(pm->flags) == PM_ARRAY)
+	    v->isarr = isvarat ? -1 : 1;
+	v->pm = pm;
+	v->inv = 0;
+	v->a = 0;
+	v->b = -1;
+	if (bracks > 0 && (*s == '[' || *s == Inbrack)) {
+	    if (getindex(&s, v)) {
+		*pptr = s;
+		return v;
+	    }
+	} else if (v->isarr && iident(*t) && isset(KSHARRAYS))
+	    v->b = 0, v->isarr = 0;
+    }
+    if (!bracks && *s)
+	return NULL;
+    *pptr = s;
+    if (v->a > MAX_ARRLEN ||
+	v->a < -MAX_ARRLEN) {
+	zerr("subscript to %s: %d", (v->a < 0) ? "small" : "big", v->a);
+	return NULL;
+    }
+    if (v->b > MAX_ARRLEN ||
+	v->b < -MAX_ARRLEN) {
+	zerr("subscript to %s: %d", (v->b < 0) ? "small" : "big", v->b);
+	return NULL;
+    }
+    return v;
+}
+
+/**/
+char *
+getstrvalue(Value v)
+{
+    char *s, **ss;
+    static char buf[(sizeof(long) * 8) + 4];
+
+    if (!v)
+	return hcalloc(1);
+    HEAPALLOC {
+	if (v->inv) {
+	    sprintf(buf, "%d", v->a);
+	    s = dupstring(buf);
+	    LASTALLOC_RETURN s;
+	}
+
+	switch(PM_TYPE(v->pm->flags)) {
+	case PM_ARRAY:
+	    if (v->isarr)
+		s = sepjoin(v->pm->gets.afn(v->pm), NULL);
+	    else {
+		ss = v->pm->gets.afn(v->pm);
+		if (v->a < 0)
+		    v->a += arrlen(ss);
+		s = (v->a >= arrlen(ss) || v->a < 0) ? (char *) hcalloc(1) : ss[v->a];
+	    }
+	    LASTALLOC_RETURN s;
+	case PM_INTEGER:
+	    convbase(s = buf, v->pm->gets.ifn(v->pm), v->pm->ct);
+	    break;
+	case PM_SCALAR:
+	    s = v->pm->gets.cfn(v->pm);
+	    break;
+	default:
+	    s = NULL;
+	    DPUTS(1, "BUG: param node without valid type");
+	    break;
+	}
+
+	if (v->a == 0 && v->b == -1)
+	    LASTALLOC_RETURN s;
+	if (v->a < 0)
+	    v->a += strlen(s);
+	if (v->b < 0)
+	    v->b += strlen(s);
+	s = (v->a > (int)strlen(s)) ? dupstring("") : dupstring(s + v->a);
+	if (v->b < v->a)
+	    s[0] = '\0';
+	else if (v->b - v->a < (int)strlen(s))
+	    s[v->b - v->a + 1 + (s[v->b - v->a] == Meta)] = '\0';
+    } LASTALLOC;
+    return s;
+}
+
+static char *nular[] = {"", NULL};
+
+/**/
+char **
+getarrvalue(Value v)
+{
+    char **s;
+
+    if (!v)
+	return arrdup(nular);
+    if (v->inv) {
+	char buf[DIGBUFSIZE];
+
+	s = arrdup(nular);
+	sprintf(buf, "%d", v->a);
+	s[0] = dupstring(buf);
+	return s;
+    }
+    s = v->pm->gets.afn(v->pm);
+    if (v->a == 0 && v->b == -1)
+	return s;
+    if (v->a < 0)
+	v->a += arrlen(s);
+    if (v->b < 0)
+	v->b += arrlen(s);
+    if (v->a > arrlen(s) || v->a < 0)
+	s = arrdup(nular);
+    else
+	s = arrdup(s) + v->a;
+    if (v->b < v->a)
+	s[0] = NULL;
+    else if (v->b - v->a < arrlen(s))
+	s[v->b - v->a + 1] = NULL;
+    return s;
+}
+
+/**/
+long
+getintvalue(Value v)
+{
+    if (!v || v->isarr)
+	return 0;
+    if (v->inv)
+	return v->a;
+    if (PM_TYPE(v->pm->flags) == PM_INTEGER)
+	return v->pm->gets.ifn(v->pm);
+    return matheval(getstrvalue(v));
+}
+
+/**/
+static void
+setstrvalue(Value v, char *val)
+{
+    char buf[(sizeof(long) * 8) + 4];
+
+    if (v->pm->flags & PM_READONLY) {
+	zerr("read-only variable: %s", v->pm->nam, 0);
+	zsfree(val);
+	return;
+    }
+    if ((v->pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	zerr("%s: restricted", v->pm->nam, 0);
+	zsfree(val);
+	return;
+    }
+    switch (PM_TYPE(v->pm->flags)) {
+    case PM_SCALAR:
+	MUSTUSEHEAP("setstrvalue");
+	if (v->a == 0 && v->b == -1) {
+	    (v->pm->sets.cfn) (v->pm, val);
+	    if (v->pm->flags & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z) && !v->pm->ct)
+		v->pm->ct = strlen(val);
+	} else {
+	    char *z, *x;
+	    int zlen;
+
+	    z = dupstring((v->pm->gets.cfn) (v->pm));
+	    zlen = strlen(z);
+	    if (v->inv && unset(KSHARRAYS))
+		v->a--, v->b--;
+	    if (v->a < 0) {
+		v->a += zlen;
+		if (v->a < 0)
+		    v->a = 0;
+	    }
+	    if (v->a > zlen)
+		v->a = zlen;
+	    if (v->b < 0)
+		v->b += zlen;
+	    if (v->b > zlen - 1)
+		v->b = zlen - 1;
+	    x = (char *) zalloc(v->a + strlen(val) + zlen - v->b);
+	    strncpy(x, z, v->a);
+	    strcpy(x + v->a, val);
+	    strcat(x + v->a, z + v->b + 1);
+	    (v->pm->sets.cfn) (v->pm, x);
+	    zsfree(val);
+	}
+	break;
+    case PM_INTEGER:
+	if (val) {
+	    (v->pm->sets.ifn) (v->pm, matheval(val));
+	    zsfree(val);
+	}
+	if (!v->pm->ct && lastbase != -1)
+	    v->pm->ct = lastbase;
+	break;
+    case PM_ARRAY:
+	MUSTUSEHEAP("setstrvalue");
+	{
+	    char **ss = (char **) zalloc(2 * sizeof(char *));
+
+	    ss[0] = val;
+	    ss[1] = NULL;
+	    setarrvalue(v, ss);
+	}
+	break;
+    }
+    if ((!v->pm->env && !(v->pm->flags & PM_EXPORTED) &&
+	 !(isset(ALLEXPORT) && !v->pm->old)) ||
+	(v->pm->flags & PM_ARRAY) || v->pm->ename)
+	return;
+    if (PM_TYPE(v->pm->flags) == PM_INTEGER)
+	convbase(val = buf, v->pm->gets.ifn(v->pm), v->pm->ct);
+    else
+	val = v->pm->gets.cfn(v->pm);
+    if (v->pm->env)
+	v->pm->env = replenv(v->pm->env, val);
+    else {
+	v->pm->flags |= PM_EXPORTED;
+	v->pm->env = addenv(v->pm->nam, val);
+    }
+}
+
+/**/
+static void
+setintvalue(Value v, long val)
+{
+    char buf[DIGBUFSIZE];
+
+    if (v->pm->flags & PM_READONLY) {
+	zerr("read-only variable: %s", v->pm->nam, 0);
+	return;
+    }
+    if ((v->pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	zerr("%s: restricted", v->pm->nam, 0);
+	return;
+    }
+    switch (PM_TYPE(v->pm->flags)) {
+    case PM_SCALAR:
+    case PM_ARRAY:
+	sprintf(buf, "%ld", val);
+	setstrvalue(v, ztrdup(buf));
+	break;
+    case PM_INTEGER:
+	(v->pm->sets.ifn) (v->pm, val);
+	setstrvalue(v, NULL);
+	break;
+    }
+}
+
+/**/
+static void
+setarrvalue(Value v, char **val)
+{
+    if (v->pm->flags & PM_READONLY) {
+	zerr("read-only variable: %s", v->pm->nam, 0);
+	freearray(val);
+	return;
+    }
+    if ((v->pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	zerr("%s: restricted", v->pm->nam, 0);
+	freearray(val);
+	return;
+    }
+    if (PM_TYPE(v->pm->flags) != PM_ARRAY) {
+	freearray(val);
+	zerr("attempt to assign array value to non-array", NULL, 0);
+	return;
+    }
+    if (v->a == 0 && v->b == -1)
+	(v->pm->sets.afn) (v->pm, val);
+    else {
+	char **old, **new, **p, **q, **r;
+	int n, ll, i;
+
+	if (v->inv && unset(KSHARRAYS))
+	    v->a--, v->b--;
+	q = old = v->pm->gets.afn(v->pm);
+	n = arrlen(old);
+	if (v->a < 0)
+	    v->a += n;
+	if (v->b < 0)
+	    v->b += n;
+	if (v->a < 0)
+	    v->a = 0;
+	if (v->b < 0)
+	    v->b = 0;
+
+	ll = v->a + arrlen(val);
+	if (v->b < n)
+	    ll += n - v->b;
+
+	p = new = (char **) zcalloc(sizeof(char *) * (ll + 1));
+
+	for (i = 0; i < v->a; i++)
+	    *p++ = i < n ? ztrdup(*q++) : ztrdup("");
+	for (r = val; *r;)
+	    *p++ = ztrdup(*r++);
+	if (v->b + 1 < n)
+	    for (q = old + v->b + 1; *q;)
+		*p++ = ztrdup(*q++);
+	*p = NULL;
+
+	(v->pm->sets.afn) (v->pm, new);
+	freearray(val);
+    }
+}
+
+/* Retrieve an integer parameter */
+
+/**/
+long
+getiparam(char *s)
+{
+    Value v;
+
+    if (!(v = getvalue(&s, 1)))
+	return 0;
+    return getintvalue(v);
+}
+
+/* Retrieve a scalar (string) parameter */
+
+/**/
+char *
+getsparam(char *s)
+{
+    Value v;
+
+    if (!(v = getvalue(&s, 0)))
+	return NULL;
+    return getstrvalue(v);
+}
+
+/* Retrieve an array parameter */
+
+/**/
+char **
+getaparam(char *s)
+{
+    Value v;
+
+    if (!idigit(*s) && (v = getvalue(&s, 0)) &&
+	PM_TYPE(v->pm->flags) == PM_ARRAY)
+	return v->pm->gets.afn(v->pm);
+    return NULL;
+}
+
+/**/
+Param
+setsparam(char *s, char *val)
+{
+    Value v;
+    char *t = s;
+    char *ss;
+
+    if (!isident(s)) {
+	zerr("not an identifier: %s", s, 0);
+	zsfree(val);
+	errflag = 1;
+	return NULL;
+    }
+    if ((ss = strchr(s, '['))) {
+	*ss = '\0';
+	if (!(v = getvalue(&s, 1)))
+	    createparam(t, PM_ARRAY);
+	*ss = '[';
+	v = NULL;
+    } else {
+	if (!(v = getvalue(&s, 1)))
+	    createparam(t, PM_SCALAR);
+	else if (PM_TYPE(v->pm->flags) == PM_ARRAY &&
+		 !(v->pm->flags & PM_SPECIAL) && unset(KSHARRAYS)) {
+	    unsetparam(t);
+	    createparam(t, PM_SCALAR);
+	    v = NULL;
+	}
+    }
+    if (!v && !(v = getvalue(&t, 1))) {
+	zsfree(val);
+	return NULL;
+    }
+    setstrvalue(v, val);
+    return v->pm;
+}
+
+/**/
+Param
+setaparam(char *s, char **val)
+{
+    Value v;
+    char *t = s;
+    char *ss;
+
+    if (!isident(s)) {
+	zerr("not an identifier: %s", s, 0);
+	freearray(val);
+	errflag = 1;
+	return NULL;
+    }
+    if ((ss = strchr(s, '['))) {
+	*ss = '\0';
+	if (!(v = getvalue(&s, 1)))
+	    createparam(t, PM_ARRAY);
+	*ss = '[';
+	v = NULL;
+    } else {
+	if (!(v = getvalue(&s, 1)))
+	    createparam(t, PM_ARRAY);
+	else if (PM_TYPE(v->pm->flags) != PM_ARRAY &&
+		 !(v->pm->flags & PM_SPECIAL)) {
+	    int uniq = v->pm->flags & PM_UNIQUE;
+	    unsetparam(t);
+	    createparam(t, PM_ARRAY | uniq);
+	    v = NULL;
+	}
+    }
+    if (!v)
+	if (!(v = getvalue(&t, 1)))
+	    return NULL;
+    if (isset(KSHARRAYS) && !ss)
+	/* the whole array should be set instead of only the first element */
+	v->b = -1;
+    setarrvalue(v, val);
+    return v->pm;
+}
+
+/**/
+Param
+setiparam(char *s, long val)
+{
+    Value v;
+    char *t = s;
+    Param pm;
+
+    if (!isident(s)) {
+	zerr("not an identifier: %s", s, 0);
+	errflag = 1;
+	return NULL;
+    }
+    if (!(v = getvalue(&s, 1))) {
+	pm = createparam(t, PM_INTEGER);
+	DPUTS(!pm, "BUG: parameter not created");
+	pm->u.val = val;
+	return pm;
+    }
+    setintvalue(v, val);
+    return v->pm;
+}
+
+/* Unset a parameter */
+
+/**/
+void
+unsetparam(char *s)
+{
+    Param pm;
+
+    if ((pm = (Param) paramtab->getnode(paramtab, s)))
+	unsetparam_pm(pm, 0, 1);
+}
+
+/* Unset a parameter */
+
+/**/
+void
+unsetparam_pm(Param pm, int altflag, int exp)
+{
+    Param oldpm, altpm;
+
+    if ((pm->flags & PM_READONLY) && pm->level <= locallevel) {
+	zerr("read-only variable: %s", pm->nam, 0);
+	return;
+    }
+    if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	zerr("%s: restricted", pm->nam, 0);
+	return;
+    }
+    pm->unsetfn(pm, exp);
+    if ((pm->flags & PM_EXPORTED) && pm->env) {
+	delenv(pm->env);
+	zsfree(pm->env);
+	pm->env = NULL;
+    }
+
+    /* remove it under its alternate name if necessary */
+    if (pm->ename && !altflag) {
+	altpm = (Param) paramtab->getnode(paramtab, pm->ename);
+	if (altpm)
+	    unsetparam_pm(altpm, 1, exp);
+    }
+
+    /* If this was a local variable, we need to keep the old     *
+     * struct so that it is resurrected at the right level.      *
+     * This is partly because when an array/scalar value is set  *
+     * and the parameter used to be the other sort, unsetparam() *
+     * is called.  Beyond that, there is an ambiguity:  should   *
+     * foo() { local bar; unset bar; } make the global bar       *
+     * available or not?  The following makes the answer "no".   */
+    if (locallevel >= pm->level)
+	return;
+
+    paramtab->removenode(paramtab, pm->nam); /* remove parameter node from table */
+
+    if (pm->old) {
+	oldpm = pm->old;
+	paramtab->addnode(paramtab, oldpm->nam, oldpm);
+	if ((PM_TYPE(oldpm->flags) == PM_SCALAR) && oldpm->sets.cfn == strsetfn)
+	    adduserdir(oldpm->nam, oldpm->u.str, 0, 0);
+    }
+
+    paramtab->freenode((HashNode) pm); /* free parameter node */
+}
+
+/* Standard function to unset a parameter.  This is mostly delegated to *
+ * the specific set function.                                           */
+
+/**/
+void
+stdunsetfn(Param pm, int exp)
+{
+    switch (PM_TYPE(pm->flags)) {
+	case PM_SCALAR: pm->sets.cfn(pm, NULL); break;
+	case PM_ARRAY:  pm->sets.afn(pm, NULL); break;
+    }
+    pm->flags |= PM_UNSET;
+}
+
+/* Function to get value of an integer parameter */
+
+/**/
+static long
+intgetfn(Param pm)
+{
+    return pm->u.val;
+}
+
+/* Function to set value of an integer parameter */
+
+/**/
+static void
+intsetfn(Param pm, long x)
+{
+    pm->u.val = x;
+}
+
+/* Function to get value of a scalar (string) parameter */
+
+/**/
+char *
+strgetfn(Param pm)
+{
+    return pm->u.str ? pm->u.str : (char *) hcalloc(1);
+}
+
+/* Function to set value of a scalar (string) parameter */
+
+/**/
+static void
+strsetfn(Param pm, char *x)
+{
+    zsfree(pm->u.str);
+    pm->u.str = x;
+    adduserdir(pm->nam, x, 0, 0);
+}
+
+/* Function to get value of an array parameter */
+
+/**/
+static char **
+arrgetfn(Param pm)
+{
+    static char *nullarray = NULL;
+
+    return pm->u.arr ? pm->u.arr : &nullarray;
+}
+
+/* Function to set value of an array parameter */
+
+/**/
+static void
+arrsetfn(Param pm, char **x)
+{
+    if (pm->u.arr && pm->u.arr != x)
+	freearray(pm->u.arr);
+    if (pm->flags & PM_UNIQUE)
+	uniqarray(x);
+    pm->u.arr = x;
+}
+
+/* This function is used as the set function for      *
+ * special parameters that cannot be set by the user. */
+
+/**/
+void
+nullsetfn(Param pm, char *x)
+{
+    zsfree(x);
+}
+
+/* Function to get value of generic special integer *
+ * parameter.  data is pointer to global variable   *
+ * containing the integer value.                    */
+
+/**/
+long
+intvargetfn(Param pm)
+{
+    return *((long *)pm->u.data);
+}
+
+/* Function to set value of generic special integer *
+ * parameter.  data is pointer to global variable   *
+ * where the value is to be stored.                 */
+
+/**/
+void
+intvarsetfn(Param pm, long x)
+{
+    *((long *)pm->u.data) = x;
+}
+
+/* Function to set value of any ZLE-related integer *
+ * parameter.  data is pointer to global variable   *
+ * where the value is to be stored.                 */
+
+/**/
+void
+zlevarsetfn(Param pm, long x)
+{
+    if ((long *)pm->u.data == & columns) {
+	if(x <= 0)
+	    x = tccolumns > 0 ? tccolumns : 80;
+	if (x > 2)
+	    termflags &= ~TERM_NARROW;
+	else
+	    termflags |= TERM_NARROW;
+    } else if ((long *)pm->u.data == & lines) {
+	if(x <= 0)
+	    x = tclines > 0 ? tclines : 24;
+	if (x > 2)
+	    termflags &= ~TERM_SHORT;
+	else
+	    termflags |= TERM_SHORT;
+    }
+
+    *((long *)pm->u.data) = x;
+}
+
+/* Function to set value of generic special scalar    *
+ * parameter.  data is pointer to a character pointer *
+ * representing the scalar (string).                  */
+
+/**/
+void
+strvarsetfn(Param pm, char *x)
+{
+    char **q = ((char **)pm->u.data);
+
+    zsfree(*q);
+    *q = x;
+}
+
+/* Function to get value of generic special scalar    *
+ * parameter.  data is pointer to a character pointer *
+ * representing the scalar (string).                  */
+
+/**/
+char *
+strvargetfn(Param pm)
+{
+    char *s = *((char **)pm->u.data);
+
+    if (!s)
+	return hcalloc(1);
+    return s;
+}
+
+/* Function to get value of generic special array  *
+ * parameter.  data is a pointer to the pointer to *
+ * a pointer (a pointer to a variable length array *
+ * of pointers).                                   */
+
+/**/
+char **
+arrvargetfn(Param pm)
+{
+    return *((char ***)pm->u.data);
+}
+
+/* Function to set value of generic special array parameter.    *
+ * data is pointer to a variable length array of pointers which *
+ * represents this array of scalars (strings).  If pm->ename is *
+ * non NULL, then it is a colon separated environment variable  *
+ * version of this array which will need to be updated.         */
+
+/**/
+void
+arrvarsetfn(Param pm, char **x)
+{
+    char ***dptr = (char ***)pm->u.data;
+
+    if (*dptr != x)
+	freearray(*dptr);
+    if (pm->flags & PM_UNIQUE)
+	uniqarray(x);
+    *dptr = x ? x : mkarray(NULL);
+    if (pm->ename && x)
+	arrfixenv(pm->ename, x);
+}
+
+/**/
+char *
+colonarrgetfn(Param pm)
+{
+    return zjoin(*(char ***)pm->u.data, ':');
+}
+
+/**/
+void
+colonarrsetfn(Param pm, char *x)
+{
+    char ***dptr = (char ***)pm->u.data;
+
+    freearray(*dptr);
+    *dptr = x ? colonsplit(x, pm->flags & PM_UNIQUE) : mkarray(NULL);
+    if (pm->ename)
+	arrfixenv(pm->nam, *dptr);
+    zsfree(x);
+}
+
+/**/
+int
+uniqarray(char **x)
+{
+    int changes = 0;
+    char **t, **p = x;
+
+    if (!x || !*x)
+	return 0;
+    while (*++p)
+	for (t = x; t < p; t++)
+	    if (!strcmp(*p, *t)) {
+		zsfree(*p);
+		for (t = p--; (*t = t[1]) != NULL; t++);
+		changes++;
+		break;
+	    }
+    return changes;
+}
+
+/* Function to get value of special parameter `#' and `ARGC' */
+
+/**/
+long
+poundgetfn(Param pm)
+{
+    return arrlen(pparams);
+}
+
+/* Function to get value for special parameter `RANDOM' */
+
+/**/
+long
+randomgetfn(Param pm)
+{
+    return rand() & 0x7fff;
+}
+
+/* Function to set value of special parameter `RANDOM' */
+
+/**/
+void
+randomsetfn(Param pm, long v)
+{
+    srand((unsigned int)v);
+}
+
+/* Function to get value for special parameter `SECONDS' */
+
+/**/
+long
+secondsgetfn(Param pm)
+{
+    return time(NULL) - shtimer.tv_sec;
+}
+
+/* Function to set value of special parameter `SECONDS' */
+
+/**/
+void
+secondssetfn(Param pm, long x)
+{
+    shtimer.tv_sec = time(NULL) - x;
+    shtimer.tv_usec = 0;
+}
+
+/* Function to get value for special parameter `USERNAME' */
+
+/**/
+char *
+usernamegetfn(Param pm)
+{
+    return get_username();
+}
+
+/* Function to set value of special parameter `USERNAME' */
+
+/**/
+void
+usernamesetfn(Param pm, char *x)
+{
+#if defined(HAVE_SETUID) && defined(HAVE_GETPWNAM)
+    struct passwd *pswd;
+
+    if (x && (pswd = getpwnam(x)) && (pswd->pw_uid != cached_uid)) {
+# ifdef HAVE_INITGROUPS
+	initgroups(x, pswd->pw_gid);
+# endif
+	if(!setgid(pswd->pw_gid) && !setuid(pswd->pw_uid)) {
+	    zsfree(cached_username);
+	    cached_username = ztrdup(pswd->pw_name);
+	    cached_uid = pswd->pw_uid;
+	}
+    }
+#endif /* HAVE_SETUID && HAVE_GETPWNAM */
+}
+
+/* Function to get value for special parameter `UID' */
+
+/**/
+long
+uidgetfn(Param pm)
+{
+    return getuid();
+}
+
+/* Function to set value of special parameter `UID' */
+
+/**/
+void
+uidsetfn(Param pm, uid_t x)
+{
+#ifdef HAVE_SETUID
+    setuid(x);
+#endif
+}
+
+/* Function to get value for special parameter `EUID' */
+
+/**/
+long
+euidgetfn(Param pm)
+{
+    return geteuid();
+}
+
+/* Function to set value of special parameter `EUID' */
+
+/**/
+void
+euidsetfn(Param pm, uid_t x)
+{
+#ifdef HAVE_SETEUID
+    seteuid(x);
+#endif
+}
+
+/* Function to get value for special parameter `GID' */
+
+/**/
+long
+gidgetfn(Param pm)
+{
+    return getgid();
+}
+
+/* Function to set value of special parameter `GID' */
+
+/**/
+void
+gidsetfn(Param pm, gid_t x)
+{
+#ifdef HAVE_SETUID
+    setgid(x);
+#endif
+}
+
+/* Function to get value for special parameter `EGID' */
+
+/**/
+long
+egidgetfn(Param pm)
+{
+    return getegid();
+}
+
+/* Function to set value of special parameter `EGID' */
+
+/**/
+void
+egidsetfn(Param pm, gid_t x)
+{
+#ifdef HAVE_SETEUID
+    setegid(x);
+#endif
+}
+
+/**/
+long
+ttyidlegetfn(Param pm)
+{
+    struct stat ttystat;
+
+    if (SHTTY == -1 || fstat(SHTTY, &ttystat))
+	return -1;
+    return time(NULL) - ttystat.st_atime;
+}
+
+/* Function to get value for special parameter `IFS' */
+
+/**/
+char *
+ifsgetfn(Param pm)
+{
+    return ifs;
+}
+
+/* Function to set value of special parameter `IFS' */
+
+/**/
+void
+ifssetfn(Param pm, char *x)
+{
+    zsfree(ifs);
+    ifs = x;
+    inittyptab();
+}
+
+/* Functions to set value of special parameters `LANG' and `LC_*' */
+
+#ifdef LC_ALL
+static struct localename {
+    char *name;
+    int category;
+} lc_names[] = {
+#ifdef LC_COLLATE
+    {"LC_COLLATE", LC_COLLATE},
+#endif
+#ifdef LC_CTYPE
+    {"LC_CTYPE", LC_CTYPE},
+#endif
+#ifdef LC_MESSAGES
+    {"LC_MESSAGES", LC_MESSAGES},
+#endif
+#ifdef LC_TIME
+    {"LC_TIME", LC_TIME},
+#endif
+    {NULL, 0}
+};
+
+/**/
+static void
+setlang(char *x)
+{
+    struct localename *ln;
+
+    setlocale(LC_ALL, x ? x : "");
+    for (ln = lc_names; ln->name; ln++)
+	if ((x = getsparam(ln->name)))
+	    setlocale(ln->category, x);
+}
+
+/**/
+void
+lc_allsetfn(Param pm, char *x)
+{
+    strsetfn(pm, x);
+    if (!x)
+	setlang(getsparam("LANG"));
+    else
+	setlocale(LC_ALL, x);
+}
+
+/**/
+void
+langsetfn(Param pm, char *x)
+{
+    strsetfn(pm, x);
+    setlang(x);
+}
+
+/**/
+void
+lcsetfn(Param pm, char *x)
+{
+    struct localename *ln;
+
+    strsetfn(pm, x);
+    if (getsparam("LC_ALL"))
+	return;
+    if (!x)
+	x = getsparam("LANG");
+
+    for (ln = lc_names; ln->name; ln++)
+	if (!strcmp(ln->name, pm->nam))
+	    setlocale(ln->category, x ? x : "");
+}
+#endif
+
+/* Function to get value for special parameter `HISTSIZE' */
+
+/**/
+long
+histsizegetfn(Param pm)
+{
+    return histsiz;
+}
+
+/* Function to set value of special parameter `HISTSIZE' */
+
+/**/
+void
+histsizesetfn(Param pm, long v)
+{
+    if ((histsiz = v) <= 2)
+	histsiz = 2;
+    resizehistents();
+}
+
+/* Function to get value for special parameter `ERRNO' */
+
+/**/
+long
+errnogetfn(Param pm)
+{
+    return errno;
+}
+
+/* Function to get value for special parameter `histchar' */
+
+/**/
+char *
+histcharsgetfn(Param pm)
+{
+    static char buf[4];
+
+    buf[0] = bangchar;
+    buf[1] = hatchar;
+    buf[2] = hashchar;
+    buf[3] = '\0';
+    return buf;
+}
+
+/* Function to set value of special parameter `histchar' */
+
+/**/
+void
+histcharssetfn(Param pm, char *x)
+{
+    if (x) {
+	bangchar = x[0];
+	hatchar = (bangchar) ? x[1] : '\0';
+	hashchar = (hatchar) ? x[2] : '\0';
+	zsfree(x);
+    } else {
+	bangchar = '!';
+	hashchar = '#';
+	hatchar = '^';
+    }
+    inittyptab();
+}
+
+/* Function to get value for special parameter `HOME' */
+
+/**/
+char *
+homegetfn(Param pm)
+{
+    return home;
+}
+
+/* Function to set value of special parameter `HOME' */
+
+/**/
+void
+homesetfn(Param pm, char *x)
+{
+    zsfree(home);
+    if (x && isset(CHASELINKS) && (home = xsymlink(x)))
+	zsfree(x);
+    else
+	home = x ? x : ztrdup("");
+    finddir(NULL);
+}
+
+/* Function to get value for special parameter `WORDCHARS' */
+
+/**/
+char *
+wordcharsgetfn(Param pm)
+{
+    return wordchars;
+}
+
+/* Function to set value of special parameter `WORDCHARS' */
+
+/**/
+void
+wordcharssetfn(Param pm, char *x)
+{
+    zsfree(wordchars);
+    wordchars = x;
+    inittyptab();
+}
+
+/* Function to get value for special parameter `_' */
+
+/**/
+char *
+underscoregetfn(Param pm)
+{
+    return underscore;
+}
+
+/* Function to get value for special parameter `TERM' */
+
+/**/
+char *
+termgetfn(Param pm)
+{
+    return term;
+}
+
+/* Function to set value of special parameter `TERM' */
+
+/**/
+void
+termsetfn(Param pm, char *x)
+{
+    zsfree(term);
+    term = x ? x : ztrdup("");
+
+    /* If non-interactive, delay setting up term till we need it. */
+    if (unset(INTERACTIVE) || !*term)
+	termflags |= TERM_UNKNOWN;
+    else 
+	init_term();
+}
+
+/* We could probably replace the replenv with the actual code to *
+ * do the replacing, since we've already scanned for the string. */
+
+/**/
+static void
+arrfixenv(char *s, char **t)
+{
+    char **ep, *u;
+    int len_s;
+    Param pm;
+
+    MUSTUSEHEAP("arrfixenv");
+    if (t == path)
+	cmdnamtab->emptytable(cmdnamtab);
+    u = zjoin(t, ':');
+    len_s = strlen(s);
+    pm = (Param) paramtab->getnode(paramtab, s);
+    for (ep = environ; *ep; ep++)
+	if (!strncmp(*ep, s, len_s) && (*ep)[len_s] == '=') {
+	    pm->env = replenv(*ep, u);
+	    return;
+	}
+    if (isset(ALLEXPORT))
+	pm->flags |= PM_EXPORTED;
+    if (pm->flags & PM_EXPORTED)
+	pm->env = addenv(s, u);
+}
+
+/* Given *name = "foo", it searchs the environment for string *
+ * "foo=bar", and returns a pointer to the beginning of "bar" */
+
+/**/
+char *
+zgetenv(char *name)
+{
+    char **ep, *s, *t;
+ 
+    for (ep = environ; *ep; ep++) {
+	for (s = *ep, t = name; *s && *s == *t; s++, t++);
+	if (*s == '=' && !*t)
+	    return s + 1;
+    }
+    return NULL;
+}
+
+/* Change the value of an existing environment variable */
+
+/**/
+char *
+replenv(char *e, char *value)
+{
+    char **ep, *s;
+    int len_value;
+
+    for (ep = environ; *ep; ep++)
+	if (*ep == e) {
+	    for (len_value = 0, s = value;
+		 *s && (*s++ != Meta || *s++ != 32); len_value++);
+	    s = e;
+	    while (*s++ != '=');
+	    *ep = (char *) zrealloc(e, s - e + len_value + 1);
+	    s = s - e + *ep - 1;
+	    while (*s++)
+		if ((*s = *value++) == Meta)
+		    *s = *value++ ^ 32;
+	    return *ep;
+	}
+    return NULL;
+}
+
+/* Given strings *name = "foo", *value = "bar", *
+ * return a new string *str = "foo=bar".        */
+
+/**/
+static char *
+mkenvstr(char *name, char *value)
+{
+    char *str, *s;
+    int len_name, len_value;
+
+    len_name = strlen(name);
+    for (len_value = 0, s = value;
+	 *s && (*s++ != Meta || *s++ != 32); len_value++);
+    s = str = (char *) zalloc(len_name + len_value + 2);
+    strcpy(s, name);
+    s += len_name;
+    *s = '=';
+    while (*s++)
+	if ((*s = *value++) == Meta)
+	    *s = *value++ ^ 32;
+    return str;
+}
+
+/* Given *name = "foo", *value = "bar", add the    *
+ * string "foo=bar" to the environment.  Return a  *
+ * pointer to the location of this new environment *
+ * string.                                         */
+
+/**/
+char *
+addenv(char *name, char *value)
+{
+    char **ep, *s, *t;
+    int num_env;
+
+    /* First check if there is already an environment *
+     * variable matching string `name'.               */
+    for (ep = environ; *ep; ep++) {
+	for (s = *ep, t = name; *s && *s == *t; s++, t++);
+	if (*s == '=' && !*t) {
+	    zsfree(*ep);
+	    return *ep = mkenvstr(name, value);
+	}
+    }
+
+    /* Else we have to make room and add it */
+    num_env = arrlen(environ);
+    environ = (char **) zrealloc(environ, (sizeof(char *)) * (num_env + 2));
+
+    /* Now add it at the end */
+    ep = environ + num_env;
+    *ep = mkenvstr(name, value);
+    *(ep + 1) = NULL;
+    return *ep;
+}
+
+/* Delete a pointer from the list of pointers to environment *
+ * variables by shifting all the other pointers up one slot. */
+
+/**/
+void
+delenv(char *x)
+{
+    char **ep;
+
+    for (ep = environ; *ep; ep++) {
+	if (*ep == x)
+	    break;
+    }
+    if (*ep)
+	for (; (ep[0] = ep[1]); ep++);
+}
+
+/**/
+static void
+convbase(char *s, long v, int base)
+{
+    int digs = 0;
+    unsigned long x;
+
+    if (v < 0)
+	*s++ = '-', v = -v;
+    if (base <= 1)
+	base = 10;
+
+    if (base != 10) {
+	sprintf(s, "%d#", base);
+	s += strlen(s);
+    }
+    for (x = v; x; digs++)
+	x /= base;
+    if (!digs)
+	digs = 1;
+    s[digs--] = '\0';
+    x = v;
+    while (digs >= 0) {
+	int dig = x % base;
+
+	s[digs--] = (dig < 10) ? '0' + dig : dig - 10 + 'A';
+	x /= base;
+    }
+}
+
+/* Start a parameter scope */
+
+/**/
+void
+startparamscope(void)
+{
+    locallevel++;
+}
+
+/* End a parameter scope: delete the parameters local to the scope. */
+
+/**/
+void
+endparamscope(void)
+{
+    locallevel--;
+    scanhashtable(paramtab, 0, 0, 0, scanendscope, 0);
+}
+
+/**/
+static void
+scanendscope(HashNode hn, int flags)
+{
+    Param pm = (Param)hn;
+    if(pm->level > locallevel)
+	unsetparam_pm(pm, 0, 0);
+}
diff --git a/Src/parse.c b/Src/parse.c
new file mode 100644
index 000000000..d42be2f2f
--- /dev/null
+++ b/Src/parse.c
@@ -0,0 +1,1379 @@
+/*
+ * parse.c - parser
+ *
+ * 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 "parse.pro"
+
+/* != 0 if we are about to read a command word */
+ 
+/**/
+int incmdpos;
+ 
+/* != 0 if we are in the middle of a [[ ... ]] */
+ 
+/**/
+int incond;
+ 
+/* != 0 if we are after a redirection (for ctxtlex only) */
+ 
+/**/
+int inredir;
+ 
+/* != 0 if we are about to read a case pattern */
+ 
+/**/
+int incasepat;
+ 
+/* != 0 if we just read a newline */
+ 
+/**/
+int isnewlin;
+
+/* != 0 if we are after a for keyword */
+
+/**/
+int infor;
+
+/* list of here-documents */
+
+/**/
+struct heredocs *hdocs;
+ 
+/* used in arrays of lists instead of NULL pointers */
+ 
+/**/
+struct list dummy_list;
+
+#define YYERROR  { tok = LEXERR; return NULL; }
+#define YYERRORV { tok = LEXERR; return; }
+#define COND_ERROR(X,Y) do{herrflush();zerr(X,Y,0);YYERROR}while(0)
+
+#define make_list()     allocnode(N_LIST)
+#define make_sublist()  allocnode(N_SUBLIST)
+#define make_pline()    allocnode(N_PLINE)
+#define make_cmd()      allocnode(N_CMD)
+#define make_forcmd()   allocnode(N_FOR)
+#define make_casecmd()  allocnode(N_CASE)
+#define make_ifcmd()    allocnode(N_IF)
+#define make_whilecmd() allocnode(N_WHILE)
+#define make_varnode()  allocnode(N_VARASG)
+#define make_cond()     allocnode(N_COND)
+
+/*
+ * event	: ENDINPUT
+ *			| SEPER
+ *			| sublist [ SEPER | AMPER | AMPERBANG ]
+ */
+/**/
+List
+parse_event(void)
+{
+    tok = ENDINPUT;
+    incmdpos = 1;
+    yylex();
+    return par_event();
+}
+
+/**/
+static List
+par_event(void)
+{
+    Sublist sl;
+    List l = NULL;
+
+    while (tok == SEPER) {
+	if (isnewlin > 0)
+	    return NULL;
+	yylex();
+    }
+    if (tok == ENDINPUT)
+	return NULL;
+    if ((sl = par_sublist()))
+	if (tok == ENDINPUT) {
+	    l = (List) make_list();
+	    l->type = Z_SYNC;
+	    l->left = sl;
+	} else if (tok == SEPER) {
+	    l = (List) make_list();
+	    l->type = Z_SYNC;
+	    l->left = sl;
+	    if (isnewlin <= 0)
+		yylex();
+	} else if (tok == AMPER) {
+	    l = (List) make_list();
+	    l->type = Z_ASYNC;
+	    l->left = sl;
+	    yylex();
+	} else if (tok == AMPERBANG) {
+	    l = (List) make_list();
+	    l->type = Z_ASYNC | Z_DISOWN;
+	    l->left = sl;
+	    yylex();
+	} else
+	    l = NULL;
+    if (!l) {
+	if (errflag) {
+	    yyerror();
+	    return NULL;
+	}
+	herrflush();
+	yyerror();
+	return NULL;
+    } else {
+	l->right = par_event();
+    }
+    return l;
+}
+
+/**/
+List
+parse_list(void)
+{
+    List ret;
+
+    tok = ENDINPUT;
+    incmdpos = 1;
+    yylex();
+    ret = par_list();
+    if (tok == LEXERR) {
+	yyerror();
+	return NULL;
+    }
+    return ret;
+}
+
+/*
+ * list	: { SEPER } [ sublist [ { SEPER | AMPER | AMPERBANG } list ] ]
+ */
+
+/**/
+static List
+par_list(void)
+{
+    Sublist sl;
+    List l = NULL;
+
+    while (tok == SEPER)
+	yylex();
+    if ((sl = par_sublist()))
+	if (tok == SEPER || tok == AMPER || tok == AMPERBANG) {
+	    l = (List) make_list();
+	    l->left = sl;
+	    l->type = (tok == SEPER) ? Z_SYNC :
+		(tok == AMPER) ? Z_ASYNC : Z_ASYNC | Z_DISOWN;
+	    incmdpos = 1;
+	    do {
+		yylex();
+	    } while (tok == SEPER);
+	    l->right = par_list();
+	} else {
+	    l = (List) make_list();
+	    l->left = sl;
+	    l->type = Z_SYNC;
+	}
+    return l;
+}
+
+/**/
+static List
+par_list1(void)
+{
+    Sublist sl;
+    List l = NULL;
+
+    if ((sl = par_sublist())) {
+	l = (List) make_list();
+	l->type = Z_SYNC;
+	l->left = sl;
+    }
+    return l;
+}
+
+/*
+ * sublist	: sublist2 [ ( DBAR | DAMPER ) { SEPER } sublist ]
+ */
+
+/**/
+static Sublist
+par_sublist(void)
+{
+    Sublist sl;
+
+    if ((sl = par_sublist2()))
+	if (tok == DBAR || tok == DAMPER) {
+	    int qtok = tok;
+
+	    cmdpush(tok == DBAR ? CS_CMDOR : CS_CMDAND);
+	    yylex();
+	    while (tok == SEPER)
+		yylex();
+	    sl->right = par_sublist();
+	    sl->type = (qtok == DBAR) ? ORNEXT : ANDNEXT;
+	    cmdpop();
+	}
+    return sl;
+}
+
+/*
+ * sublist2	: [ COPROC | BANG ] pline
+ */
+
+/**/
+static Sublist
+par_sublist2(void)
+{
+    Sublist sl;
+    Pline p;
+
+    sl = (Sublist) make_sublist();
+    if (tok == COPROC) {
+	sl->flags |= PFLAG_COPROC;
+	yylex();
+    } else if (tok == BANG) {
+	sl->flags |= PFLAG_NOT;
+	yylex();
+    }
+    if (!(p = par_pline()) && !sl->flags)
+	return NULL;
+    sl->left = p;
+    return sl;
+}
+
+/*
+ * pline	: cmd [ ( BAR | BARAMP ) { SEPER } pline ]
+ */
+
+/**/
+static Pline
+par_pline(void)
+{
+    Cmd c;
+    Pline p, p2;
+
+    if (!(c = par_cmd()))
+	return NULL;
+    if (tok == BAR) {
+	cmdpush(CS_PIPE);
+	yylex();
+	while (tok == SEPER)
+	    yylex();
+	p2 = par_pline();
+	cmdpop();
+	p = (Pline) make_pline();
+	p->left = c;
+	p->right = p2;
+	p->type = PIPE;
+	return p;
+    } else if (tok == BARAMP) {
+	struct redir *rdr = (struct redir *)allocnode(N_REDIR);
+
+	rdr->type = MERGEOUT;
+	rdr->fd1 = 2;
+	rdr->name = dupstring("1");
+	addlinknode(c->redir, rdr);
+
+	cmdpush(CS_ERRPIPE);
+	yylex();
+	p2 = par_pline();
+	cmdpop();
+	p = (Pline) make_pline();
+	p->left = c;
+	p->right = p2;
+	p->type = PIPE;
+	return p;
+    } else {
+	p = (Pline) make_pline();
+	p->left = c;
+	p->type = END;
+	return p;
+    }
+}
+
+/*
+ * cmd	: { redir } ( for | case | if | while | repeat |
+ *				subsh | funcdef | time | dinbrack | dinpar | simple ) { redir }
+ */
+
+/**/
+static Cmd
+par_cmd(void)
+{
+    Cmd c;
+
+    c = (Cmd) make_cmd();
+    c->lineno = lineno;
+    c->args = newlinklist();
+    c->redir = newlinklist();
+    c->vars = newlinklist();
+    while (IS_REDIROP(tok))
+	par_redir(c->redir);
+    switch (tok) {
+    case FOR:
+	cmdpush(CS_FOR);
+	par_for(c);
+	cmdpop();
+	break;
+    case FOREACH:
+	cmdpush(CS_FOREACH);
+	par_for(c);
+	cmdpop();
+	break;
+    case SELECT:
+	cmdpush(CS_SELECT);
+	par_for(c);
+	cmdpop();
+	break;
+    case CASE:
+	cmdpush(CS_CASE);
+	par_case(c);
+	cmdpop();
+	break;
+    case IF:
+	par_if(c);
+	break;
+    case WHILE:
+	cmdpush(CS_WHILE);
+	par_while(c);
+	cmdpop();
+	break;
+    case UNTIL:
+	cmdpush(CS_UNTIL);
+	par_while(c);
+	cmdpop();
+	break;
+    case REPEAT:
+	cmdpush(CS_REPEAT);
+	par_repeat(c);
+	cmdpop();
+	break;
+    case INPAR:
+	cmdpush(CS_SUBSH);
+	par_subsh(c);
+	cmdpop();
+	break;
+    case INBRACE:
+	cmdpush(CS_CURSH);
+	par_subsh(c);
+	cmdpop();
+	break;
+    case FUNC:
+	cmdpush(CS_FUNCDEF);
+	par_funcdef(c);
+	cmdpop();
+	break;
+    case TIME:
+	par_time(c);
+	break;
+    case DINBRACK:
+	cmdpush(CS_COND);
+	par_dinbrack(c);
+	cmdpop();
+	break;
+    case DINPAR:
+	c->type = CARITH;
+	addlinknode(c->args, tokstr);
+	yylex();
+	break;
+    default:
+	if (!par_simple(c))
+	    return NULL;
+	break;
+    }
+    while (IS_REDIROP(tok))
+	par_redir(c->redir);
+    incmdpos = 1;
+    incasepat = 0;
+    incond = 0;
+    return c;
+}
+
+/*
+ * for  : ( FOR DINPAR expr SEMI expr SEMI expr DOUTPAR |
+ *    ( FOR[EACH] | SELECT ) name ( "in" wordlist | INPAR wordlist OUTPAR ) )
+ *	{ SEPER } ( DO list DONE | INBRACE list OUTBRACE | list ZEND | list1 )
+ */
+
+/**/
+static void
+par_for(Cmd c)
+{
+    Forcmd f;
+    int csh = (tok == FOREACH);
+
+    f = (Forcmd) make_forcmd();
+    c->type = (tok == SELECT) ? CSELECT : CFOR;
+    incmdpos = 0;
+    infor = tok == FOR ? 2 : 0;
+    yylex();
+    if (tok == DINPAR) {
+	yylex();
+	if (tok != DINPAR)
+	    YYERRORV;
+	f->name = tokstr;
+	yylex();
+	if (tok != DINPAR)
+	    YYERRORV;
+	f->condition = tokstr;
+	yylex();
+	if (tok != DOUTPAR)
+	    YYERRORV;
+	f->advance = tokstr;
+	infor = 0;
+	incmdpos = 1;
+	yylex();
+    } else {
+	infor = 0;
+	if (tok != STRING || !isident(tokstr))
+	    YYERRORV;
+	f->name = tokstr;
+	incmdpos = 1;
+	yylex();
+	if (tok == STRING && !strcmp(tokstr, "in")) {
+	    f->inflag = 1;
+	    incmdpos = 0;
+	    yylex();
+	    c->args = par_wordlist();
+	    if (tok != SEPER)
+		YYERRORV;
+	} else if (tok == INPAR) {
+	    f->inflag = 1;
+	    incmdpos = 0;
+	    yylex();
+	    c->args = par_nl_wordlist();
+	    if (tok != OUTPAR)
+		YYERRORV;
+	    incmdpos = 1;
+	    yylex();
+	}
+    }
+    incmdpos = 1;
+    while (tok == SEPER)
+	yylex();
+    if (tok == DO) {
+	yylex();
+	f->list = par_list();
+	if (tok != DONE)
+	    YYERRORV;
+	yylex();
+    } else if (tok == INBRACE) {
+	yylex();
+	f->list = par_list();
+	if (tok != OUTBRACE)
+	    YYERRORV;
+	yylex();
+    } else if (csh || isset(CSHJUNKIELOOPS)) {
+	f->list = par_list();
+	if (tok != ZEND)
+	    YYERRORV;
+	yylex();
+    } else if (unset(SHORTLOOPS)) {
+	YYERRORV;
+    } else
+	f->list = par_list1();
+    c->u.forcmd = f;
+}
+
+/*
+ * case	: CASE STRING { SEPER } ( "in" | INBRACE )
+				{ { SEPER } STRING { BAR STRING } OUTPAR
+					list [ DSEMI | SEMIAMP ] }
+				{ SEPER } ( "esac" | OUTBRACE )
+ */
+
+/**/
+static void
+par_case(Cmd c)
+{
+    int brflag;
+    LinkList pats, lists;
+    int n = 1;
+    char **pp;
+    List *ll;
+    LinkNode no;
+    struct casecmd *cc;
+
+    c->type = CCASE;
+    incmdpos = 0;
+    yylex();
+    if (tok != STRING)
+	YYERRORV;
+    pats = newlinklist();
+    addlinknode(pats, tokstr);
+    incmdpos = 1;
+    yylex();
+    while (tok == SEPER)
+	yylex();
+    if (!(tok == STRING && !strcmp(tokstr, "in")) && tok != INBRACE)
+	YYERRORV;
+    brflag = (tok == INBRACE);
+    incasepat = 1;
+    incmdpos = 0;
+    yylex();
+    cc = c->u.casecmd = (struct casecmd *)make_casecmd();
+    lists = newlinklist();
+    for (;;) {
+	char *str;
+
+	while (tok == SEPER)
+	    yylex();
+	if (tok == OUTBRACE)
+	    break;
+	if (tok != STRING)
+	    YYERRORV;
+	if (!strcmp(tokstr, "esac"))
+	    break;
+	str = ncalloc(strlen(tokstr) + 2);
+	*str = ';';
+	strcpy(str + 1, tokstr);
+	incasepat = 0;
+	incmdpos = 1;
+	for (;;) {
+	    yylex();
+	    if (tok == OUTPAR) {
+		incasepat = 0;
+		incmdpos = 1;
+		yylex();
+		break;
+	    } else if (tok == BAR) {
+		char *str2;
+		int sl = strlen(str);
+
+		incasepat = 1;
+		incmdpos = 0;
+		str2 = ncalloc(sl + 2);
+		strcpy(str2, str);
+		str2[sl] = Bar;
+		str2[sl+1] = '\0';
+		str = str2;
+	    } else {
+		int sl = strlen(str);
+
+		if (str[sl - 1] != Bar) {
+		    /* POSIX allows (foo*) patterns */
+		    int pct;
+		    char *s;
+
+		    for (s = str + 1, pct = 0; *s; s++) {
+			if (*s == Inpar)
+			    pct++;
+			if (!pct)
+			    break;
+			if (pct == 1) {
+			    if (*s == Bar || *s == Inpar)
+				while (iblank(s[1]))
+				    chuck(s+1);
+			    if (*s == Bar || *s == Outpar)
+				while (iblank(s[-1]) &&
+				       (s < str+2 || s[-2] != Meta))
+				    chuck(--s);
+			}
+			if (*s == Outpar)
+			    pct--;
+		    }
+		    if (*s || pct || s == str + 1)
+			YYERRORV;
+		    break;
+		} else {
+		    char *str2;
+
+		    if (tok != STRING)
+			YYERRORV;
+		    str2 = ncalloc(sl + strlen(tokstr) + 1);
+		    strcpy(str2, str);
+		    strcpy(str2 + sl, tokstr);
+		    str = str2;
+		}
+	    }
+	}
+	addlinknode(pats, str);
+	addlinknode(lists, par_list());
+	n++;
+	if ((tok == ESAC && !brflag) || (tok == OUTBRACE && brflag))
+	    break;
+	if(tok == SEMIAMP)
+	    *str = '&';
+	else if (tok != DSEMI)
+	    YYERRORV;
+	incasepat = 1;
+	incmdpos = 0;
+	yylex();
+    }
+
+    incmdpos = 1;
+    yylex();
+
+    cc->pats = (char **)alloc((n + 1) * sizeof(char *));
+
+    for (pp = cc->pats, no = firstnode(pats); no; incnode(no))
+	*pp++ = (char *)getdata(no);
+    *pp = NULL;
+    cc->lists = (List *) alloc((n + 1) * sizeof(List));
+    for (ll = cc->lists, no = firstnode(lists); no; incnode(no), ll++)
+	if (!(*ll = (List) getdata(no)))
+	    *ll = &dummy_list;
+    *ll = NULL;
+}
+
+/*
+ * if	: { ( IF | ELIF ) { SEPER } ( INPAR list OUTPAR | list )
+			{ SEPER } ( THEN list | INBRACE list OUTBRACE | list1 ) }
+			[ FI | ELSE list FI | ELSE { SEPER } INBRACE list OUTBRACE ]
+			(you get the idea...?)
+ */
+
+/**/
+static void
+par_if(Cmd c)
+{
+    struct ifcmd *i;
+    int xtok;
+    unsigned char nc;
+    LinkList ifsl, thensl;
+    LinkNode no;
+    int ni = 0, nt = 0, usebrace = 0;
+    List l, *ll;
+
+    ifsl = newlinklist();
+    thensl = newlinklist();
+
+    c->type = CIF;
+    for (;;) {
+	xtok = tok;
+	cmdpush(xtok == IF ? CS_IF : CS_ELIF);
+	yylex();
+	if (xtok == FI)
+	    break;
+	if (xtok == ELSE)
+	    break;
+	while (tok == SEPER)
+	    yylex();
+	if (!(xtok == IF || xtok == ELIF)) {
+	    cmdpop();
+	    YYERRORV;
+	}
+	addlinknode(ifsl, par_list());
+	ni++;
+	incmdpos = 1;
+	while (tok == SEPER)
+	    yylex();
+	xtok = FI;
+	nc = cmdstack[cmdsp - 1] == CS_IF ? CS_IFTHEN : CS_ELIFTHEN;
+	if (tok == THEN) {
+	    usebrace = 0;
+	    cmdpop();
+	    cmdpush(nc);
+	    yylex();
+	    addlinknode(thensl, par_list());
+	    nt++;
+	    incmdpos = 1;
+	    cmdpop();
+	} else {
+	    if (tok == INBRACE) {
+		usebrace = 1;
+		cmdpop();
+		cmdpush(nc);
+		yylex();
+		l = par_list();
+		if (tok != OUTBRACE) {
+		    cmdpop();
+		    YYERRORV;
+		}
+		addlinknode(thensl, l);
+		nt++;
+		yylex();
+		incmdpos = 1;
+		if (tok == SEPER)
+		    break;
+		cmdpop();
+	    } else if (unset(SHORTLOOPS)) {
+		cmdpop();
+		YYERRORV;
+	    } else {
+		cmdpop();
+		cmdpush(nc);
+		addlinknode(thensl, par_list1());
+		nt++;
+		incmdpos = 1;
+		break;
+	    }
+	}
+    }
+    cmdpop();
+    if (xtok == ELSE) {
+	cmdpush(CS_ELSE);
+	while (tok == SEPER)
+	    yylex();
+	if (tok == INBRACE && usebrace) {
+	    yylex();
+	    l = par_list();
+	    if (tok != OUTBRACE) {
+		cmdpop();
+		YYERRORV;
+	    }
+	} else {
+	    l = par_list();
+	    if (tok != FI) {
+		cmdpop();
+		YYERRORV;
+	    }
+	}
+	addlinknode(thensl, l);
+	nt++;
+	yylex();
+	cmdpop();
+    }
+    i = (struct ifcmd *)make_ifcmd();
+    i->ifls = (List *) alloc((ni + 1) * sizeof(List));
+    i->thenls = (List *) alloc((nt + 1) * sizeof(List));
+
+    for (ll = i->ifls, no = firstnode(ifsl); no; incnode(no), ll++)
+	if (!(*ll = (List) getdata(no)))
+	    *ll = &dummy_list;
+    *ll = NULL;
+    for (ll = i->thenls, no = firstnode(thensl); no; incnode(no), ll++)
+	if (!(*ll = (List) getdata(no)))
+	    *ll = &dummy_list;
+    *ll = NULL;
+
+    c->u.ifcmd = i;
+}
+
+/*
+ * while	: ( WHILE | UNTIL ) ( INPAR list OUTPAR | list ) { SEPER }
+				( DO list DONE | INBRACE list OUTBRACE | list ZEND )
+ */
+
+/**/
+static void
+par_while(Cmd c)
+{
+    struct whilecmd *w;
+
+    c->type = CWHILE;
+    w = c->u.whilecmd = (struct whilecmd *)make_whilecmd();
+    w->cond = (tok == UNTIL);
+    yylex();
+    w->cont = par_list();
+    incmdpos = 1;
+    while (tok == SEPER)
+	yylex();
+    if (tok == DO) {
+	yylex();
+	w->loop = par_list();
+	if (tok != DONE)
+	    YYERRORV;
+	yylex();
+    } else if (tok == INBRACE) {
+	yylex();
+	w->loop = par_list();
+	if (tok != OUTBRACE)
+	    YYERRORV;
+	yylex();
+    } else if (isset(CSHJUNKIELOOPS)) {
+	w->loop = par_list();
+	if (tok != ZEND)
+	    YYERRORV;
+	yylex();
+    } else
+	YYERRORV;
+}
+
+/*
+ * repeat	: REPEAT STRING { SEPER } ( DO list DONE | list1 )
+ */
+
+/**/
+static void
+par_repeat(Cmd c)
+{
+    c->type = CREPEAT;
+    incmdpos = 0;
+    yylex();
+    if (tok != STRING)
+	YYERRORV;
+    addlinknode(c->args, tokstr);
+    incmdpos = 1;
+    yylex();
+    while (tok == SEPER)
+	yylex();
+    if (tok == DO) {
+	yylex();
+	c->u.list = par_list();
+	if (tok != DONE)
+	    YYERRORV;
+	yylex();
+    } else if (tok == INBRACE) {
+	yylex();
+	c->u.list = par_list();
+	if (tok != OUTBRACE)
+	    YYERRORV;
+	yylex();
+    } else if (isset(CSHJUNKIELOOPS)) {
+	c->u.list = par_list();
+	if (tok != ZEND)
+	    YYERRORV;
+	yylex();
+    } else if (unset(SHORTLOOPS)) {
+	YYERRORV;
+    } else
+	c->u.list = par_list1();
+}
+
+/*
+ * subsh	: ( INPAR | INBRACE ) list ( OUTPAR | OUTBRACE )
+ */
+
+/**/
+static void
+par_subsh(Cmd c)
+{
+    c->type = (tok == INPAR) ? SUBSH : CURSH;
+    yylex();
+    c->u.list = par_list();
+    if (tok != ((c->type == SUBSH) ? OUTPAR : OUTBRACE))
+	YYERRORV;
+    incmdpos = 1;
+    yylex();
+}
+
+/*
+ * funcdef	: FUNCTION wordlist [ INOUTPAR ] { SEPER }
+ *					( list1 | INBRACE list OUTBRACE )
+ */
+
+/**/
+static void
+par_funcdef(Cmd c)
+{
+    nocorrect = 1;
+    incmdpos = 0;
+    yylex();
+    c->type = FUNCDEF;
+    c->args = newlinklist();
+    incmdpos = 1;
+    while (tok == STRING) {
+	if (*tokstr == Inbrace && !tokstr[1]) {
+	    tok = INBRACE;
+	    break;
+	}
+	addlinknode(c->args, tokstr);
+	yylex();
+    }
+    nocorrect = 0;
+    if (tok == INOUTPAR)
+	yylex();
+    while (tok == SEPER)
+	yylex();
+    if (tok == INBRACE) {
+	yylex();
+	c->u.list = par_list();
+	if (tok != OUTBRACE)
+	    YYERRORV;
+	yylex();
+    } else if (unset(SHORTLOOPS)) {
+	YYERRORV;
+    } else
+	c->u.list = par_list1();
+}
+
+/*
+ * time	: TIME sublist2
+ */
+
+/**/
+static void
+par_time(Cmd c)
+{
+    yylex();
+    c->type = ZCTIME;
+    c->u.pline = par_sublist2();
+}
+
+/*
+ * dinbrack	: DINBRACK cond DOUTBRACK
+ */
+
+/**/
+static void
+par_dinbrack(Cmd c)
+{
+    c->type = COND;
+    incond = 1;
+    incmdpos = 0;
+    yylex();
+    c->u.cond = par_cond();
+    if (tok != DOUTBRACK)
+	YYERRORV;
+    incond = 0;
+    incmdpos = 1;
+    yylex();
+}
+
+/*
+ * simple	: { COMMAND | EXEC | NOGLOB | NOCORRECT | DASH }
+					{ STRING | ENVSTRING | ENVARRAY wordlist OUTPAR | redir }
+					[ INOUTPAR { SEPER } ( list1 | INBRACE list OUTBRACE ) ]
+ */
+
+/**/
+static Cmd
+par_simple(Cmd c)
+{
+    int isnull = 1;
+
+    c->type = SIMPLE;
+    for (;;) {
+	if (tok == NOCORRECT)
+	    nocorrect = 1;
+	else if (tok == ENVSTRING) {
+	    struct varasg *v = (struct varasg *)make_varnode();
+
+	    v->type = PM_SCALAR;
+	    equalsplit(v->name = tokstr, &v->str);
+	    addlinknode(c->vars, v);
+	    isnull = 0;
+	} else if (tok == ENVARRAY) {
+	    struct varasg *v = (struct varasg *)make_varnode();
+	    int oldcmdpos = incmdpos;
+
+	    v->type = PM_ARRAY;
+	    incmdpos = 0;
+	    v->name = tokstr;
+	    cmdpush(CS_ARRAY);
+	    yylex();
+	    v->arr = par_nl_wordlist();
+	    cmdpop();
+	    if (tok != OUTPAR)
+		YYERROR;
+	    incmdpos = oldcmdpos;
+	    addlinknode(c->vars, v);
+	    isnull = 0;
+	} else
+	    break;
+	yylex();
+    }
+    if (tok == AMPER || tok == AMPERBANG)
+	YYERROR;
+    for (;;) {
+	if (tok == STRING) {
+	    incmdpos = 0;
+	    addlinknode(c->args, tokstr);
+	    yylex();
+	} else if (IS_REDIROP(tok)) {
+	    par_redir(c->redir);
+	} else if (tok == INOUTPAR) {
+	    incmdpos = 1;
+	    cmdpush(CS_FUNCDEF);
+	    yylex();
+	    while (tok == SEPER)
+		yylex();
+	    if (tok == INBRACE) {
+		yylex();
+		c->u.list = par_list();
+		if (tok != OUTBRACE) {
+		    cmdpop();
+		    YYERROR;
+		}
+		yylex();
+	    } else
+		c->u.list = (List) expandstruct((struct node *) par_cmd(), N_LIST);
+	    cmdpop();
+	    c->type = FUNCDEF;
+	} else
+	    break;
+	isnull = 0;
+    }
+    if (isnull && empty(c->redir))
+	return NULL;
+    incmdpos = 1;
+    return c;
+}
+
+/*
+ * condlex is yylex for normal parsing, but is altered to allow
+ * the test builtin to use par_cond.
+ */
+
+/**/
+void (*condlex) _((void)) = yylex;
+
+/*
+ * cond	: cond_1 { SEPER } [ DBAR { SEPER } cond ]
+ */
+
+/**/
+Cond
+par_cond(void)
+{
+    Cond c, c2;
+
+    c = par_cond_1();
+    while (tok == SEPER)
+	condlex();
+    if (tok == DBAR) {
+	condlex();
+	while (tok == SEPER)
+	    condlex();
+	c2 = (Cond) make_cond();
+	c2->left = (void *) c;
+	c2->right = (void *) par_cond();
+	c2->type = COND_OR;
+	return c2;
+    }
+    return c;
+}
+
+/*
+ * cond_1 : cond_2 { SEPER } [ DAMPER { SEPER } cond_1 ]
+ */
+
+/**/
+static Cond
+par_cond_1(void)
+{
+    Cond c, c2;
+
+    c = par_cond_2();
+    while (tok == SEPER)
+	condlex();
+    if (tok == DAMPER) {
+	condlex();
+	while (tok == SEPER)
+	    condlex();
+	c2 = (Cond) make_cond();
+	c2->left = (void *) c;
+	c2->right = (void *) par_cond_1();
+	c2->type = COND_AND;
+	return c2;
+    }
+    return c;
+}
+
+/*
+ * cond_2	: BANG cond_2
+				| INPAR { SEPER } cond_2 { SEPER } OUTPAR
+				| STRING STRING STRING
+				| STRING STRING
+				| STRING ( INANG | OUTANG ) STRING
+ */
+
+/**/
+static Cond
+par_cond_2(void)
+{
+    Cond c, c2;
+    char *s1, *s2, *s3;
+    int dble = 0;
+
+    if (condlex == testlex) {
+	/* See the description of test in POSIX 1003.2 */
+	if (tok == NULLTOK)
+	    /* no arguments: false */
+	    return par_cond_double(dupstring("-n"), dupstring(""));
+	if (!*testargs) {
+	    /* one argument: [ foo ] is equivalent to [ -n foo ] */
+	    s1 = tokstr;
+	    condlex();
+	    return par_cond_double(dupstring("-n"), s1);
+	}
+	if (testargs[1] && !testargs[2]) {
+	    /* three arguments: if the second argument is a binary operator, *
+	     * perform that binary test on the first and the trird argument  */
+	    if (!strcmp(*testargs, "=")  ||
+		!strcmp(*testargs, "==") ||
+		!strcmp(*testargs, "!=") ||
+		(**testargs == '-' && get_cond_num(*testargs + 1) >= 0)) {
+		s1 = tokstr;
+		condlex();
+		s2 = tokstr;
+		condlex();
+		s3 = tokstr;
+		condlex();
+		return par_cond_triple(s1, s2, s3);
+	    }
+	}
+    }
+    if (tok == BANG) {
+	condlex();
+	c = par_cond_2();
+	c2 = (Cond) make_cond();
+	c2->left = (void *) c;
+	c2->type = COND_NOT;
+	return c2;
+    }
+    if (tok == INPAR) {
+	condlex();
+	while (tok == SEPER)
+	    condlex();
+	c = par_cond();
+	while (tok == SEPER)
+	    condlex();
+	if (tok != OUTPAR)
+	    YYERROR;
+	condlex();
+	return c;
+    }
+    if (tok != STRING)
+	if (tok && tok != LEXERR && condlex == testlex) {
+	    s1 = tokstr;
+	    condlex();
+	    return par_cond_double("-n", s1);
+	} else
+	    YYERROR;
+    s1 = tokstr;
+    if (condlex == testlex)
+	dble = (*s1 == '-' && strspn(s1+1, "abcdefghknoprstuwxzLONGS") == 1
+		  && !s1[2]);
+    condlex();
+    if (tok == INANG || tok == OUTANG) {
+	int xtok = tok;
+	condlex();
+	if (tok != STRING)
+	    YYERROR;
+	s3 = tokstr;
+	condlex();
+	c = (Cond) make_cond();
+	c->left = (void *) s1;
+	c->right = (void *) s3;
+	c->type = (xtok == INANG) ? COND_STRLT : COND_STRGTR;
+	c->ntype = NT_SET(N_COND, NT_STR, NT_STR, 0, 0);
+	return c;
+    }
+    if (tok != STRING)
+	if (tok != LEXERR && condlex == testlex) {
+	    if (!dble)
+		return par_cond_double("-n", s1);
+	    else if (!strcmp(s1, "-t"))
+		return par_cond_double(s1, "1");
+	} else
+	    YYERROR;
+    s2 = tokstr;
+    incond++;			/* parentheses do globbing */
+    condlex();
+    incond--;			/* parentheses do grouping */
+    if (tok == STRING && !dble) {
+	s3 = tokstr;
+	condlex();
+	return par_cond_triple(s1, s2, s3);
+    } else
+	return par_cond_double(s1, s2);
+}
+
+/*
+ * redir	: ( OUTANG | ... | TRINANG ) STRING
+ */
+
+static int redirtab[TRINANG - OUTANG + 1] = {
+    WRITE,
+    WRITENOW,
+    APP,
+    APPNOW,
+    READ,
+    READWRITE,
+    HEREDOC,
+    HEREDOCDASH,
+    MERGEIN,
+    MERGEOUT,
+    ERRWRITE,
+    ERRWRITENOW,
+    ERRAPP,
+    ERRAPPNOW,
+    HERESTR,
+};
+
+/**/
+static void
+par_redir(LinkList l)
+{
+    struct redir *fn = (struct redir *)allocnode(N_REDIR);
+    int oldcmdpos, oldnc;
+
+    oldcmdpos = incmdpos;
+    incmdpos = 0;
+    oldnc = nocorrect;
+    if (tok != INANG && tok != INOUTANG)
+	nocorrect = 1;
+    fn->type = redirtab[tok - OUTANG];
+    fn->fd1 = tokfd;
+    yylex();
+    if (tok != STRING && tok != ENVSTRING)
+	YYERRORV;
+    incmdpos = oldcmdpos;
+    nocorrect = oldnc;
+
+    /* assign default fd */
+    if (fn->fd1 == -1)
+	fn->fd1 = IS_READFD(fn->type) ? 0 : 1;
+
+    fn->name = tokstr;
+
+    switch (fn->type) {
+    case HEREDOC:
+    case HEREDOCDASH: {
+	/* <<[-] name */
+	struct heredocs **hd;
+
+	for (hd = &hdocs; *hd; hd = &(*hd)->next);
+	*hd = zalloc(sizeof(struct heredocs));
+	(*hd)->next = NULL;
+	(*hd)->rd = fn;
+	break;
+    }
+    case WRITE:
+    case WRITENOW:
+	if (tokstr[0] == Outang && tokstr[1] == Inpar)
+	    /* > >(...) */
+	    fn->type = OUTPIPE;
+	else if (tokstr[0] == Inang && tokstr[1] == Inpar)
+	    YYERRORV;
+	break;
+    case READ:
+	if (tokstr[0] == Inang && tokstr[1] == Inpar)
+	    /* < <(...) */
+	    fn->type = INPIPE;
+	else if (tokstr[0] == Outang && tokstr[1] == Inpar)
+	    YYERRORV;
+	break;
+    case READWRITE:
+	if ((tokstr[0] == Inang || tokstr[0] == Outang) && tokstr[1] == Inpar)
+	    fn->type = tokstr[0] == Inang ? INPIPE : OUTPIPE;
+	break;
+    }
+    yylex();
+    addlinknode(l, fn);
+}
+
+/*
+ * wordlist	: { STRING }
+ */
+
+/**/
+static LinkList
+par_wordlist(void)
+{
+    LinkList l;
+
+    l = newlinklist();
+    while (tok == STRING) {
+	addlinknode(l, tokstr);
+	yylex();
+    }
+    return l;
+}
+
+/*
+ * nl_wordlist	: { STRING | SEPER }
+ */
+
+/**/
+static LinkList
+par_nl_wordlist(void)
+{
+    LinkList l;
+
+    l = newlinklist();
+    while (tok == STRING || tok == SEPER) {
+	if (tok != SEPER)
+	    addlinknode(l, tokstr);
+	yylex();
+    }
+    return l;
+}
+
+/**/
+static Cond
+par_cond_double(char *a, char *b)
+{
+    Cond n = (Cond) make_cond();
+
+    if (a[0] != '-' || !a[1] || a[2])
+	COND_ERROR("parse error: condition expected: %s", a);
+    n->left = (void *) b;
+    n->type = a[1];
+    n->ntype = NT_SET(N_COND, NT_STR, NT_STR, 0, 0);
+    return n;
+}
+
+/**/
+static int
+get_cond_num(char *tst)
+{
+    static char *condstrs[] =
+    {
+	"nt", "ot", "ef", "eq", "ne", "lt", "gt", "le", "ge", NULL
+    };
+    int t0;
+
+    for (t0 = 0; condstrs[t0]; t0++)
+	if (!strcmp(condstrs[t0], tst))
+	    return t0;
+    return -1;
+}
+
+/**/
+static Cond
+par_cond_triple(char *a, char *b, char *c)
+{
+    Cond n = (Cond) make_cond();
+    int t0;
+
+    if ((b[0] == Equals || b[0] == '=') &&
+	(!b[1] || ((b[1] == Equals || b[1] == '=') && !b[2])))
+	n->type = COND_STREQ;
+    else if (b[0] == '!' && (b[1] == Equals || b[1] == '=') && !b[2])
+	n->type = COND_STRNEQ;
+    else if (b[0] == '-') {
+	if ((t0 = get_cond_num(b + 1)) > -1)
+	    n->type = t0 + COND_NT;
+	else
+	    COND_ERROR("unrecognized condition: %s", b);
+    } else
+	COND_ERROR("condition expected: %s", b);
+    n->left = (void *) a;
+    n->right = (void *) c;
+    n->ntype = NT_SET(N_COND, NT_STR, NT_STR, 0, 0);
+    return n;
+}
+
+/**/
+static void
+yyerror(void)
+{
+    int t0;
+
+    for (t0 = 0; t0 != 20; t0++)
+	if (!yytext || !yytext[t0] || yytext[t0] == '\n')
+	    break;
+    if (t0 == 20)
+	zerr("parse error near `%l...'", yytext, 20);
+    else if (t0)
+	zerr("parse error near `%l'", yytext, t0);
+    else
+	zerr("parse error", NULL, 0);
+}
diff --git a/Src/prompt.c b/Src/prompt.c
new file mode 100644
index 000000000..8c9216f95
--- /dev/null
+++ b/Src/prompt.c
@@ -0,0 +1,766 @@
+/*
+ * prompt.c - construct zsh prompts
+ *
+ * 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 "prompt.pro"
+
+/* text attribute mask */
+ 
+/**/
+unsigned txtattrmask;
+
+/* text change - attribute change made by prompts */
+
+/**/
+unsigned txtchange;
+
+/* the command stack for use with %_ in prompts */
+ 
+/**/
+unsigned char *cmdstack;
+/**/
+int cmdsp;
+
+/* parser states, for %_ */
+
+static char *cmdnames[] = {
+    "for",      "while",     "repeat",    "select",
+    "until",    "if",        "then",      "else",
+    "elif",     "math",      "cond",      "cmdor",
+    "cmdand",   "pipe",      "errpipe",   "foreach",
+    "case",     "function",  "subsh",     "cursh",
+    "array",    "quote",     "dquote",    "bquote",
+    "cmdsubst", "mathsubst", "elif-then", "heredoc",
+    "heredocd", "brace",     "braceparam",
+};
+ 
+/* The buffer into which an expanded and metafied prompt is being written, *
+ * and its size.                                                           */
+
+static char *buf;
+static int bufspc;
+
+/* bp is the pointer to the current position in the buffer, where the next *
+ * character will be added.                                                */
+
+static char *bp;
+
+/* bp1 is an auxilliary pointer into the buffer, which when non-NULL is *
+ * moved whenever the buffer is reallocated.  It is used when data is   *
+ * being temporarily held in the buffer.                                */
+
+static char *bp1;
+
+/* The format string, for %-expansion. */
+
+static char *fm;
+
+/* Current truncation string (metafied), the length at which truncation *
+ * occurs, and the direction in which it occurs.                        */
+
+static char *truncstr;
+static int trunclen, truncatleft;
+
+/* Current level of nesting of %{ / %} sequences. */
+
+static int dontcount;
+
+/* Strings to use for %r and %R (for the spelling prompt). */
+
+static char *rstring, *Rstring;
+
+/* If non-zero, Inpar, Outpar and Nularg can be added to the buffer. */
+
+static int nonsp;
+
+/* Perform prompt expansion on a string, putting the result in a *
+ * permanently-allocated string.  If ns is non-zero, this string *
+ * may have embedded Inpar and Outpar, which indicate a toggling *
+ * between spacing and non-spacing parts of the prompt, and      *
+ * Nularg, which (in a non-spacing sequence) indicates a         *
+ * `glitch' space.                                               */
+
+/**/
+char *
+promptexpand(char *s, int ns, char *rs, char *Rs)
+{
+    if(!s)
+	return ztrdup("");
+
+    if ((termflags & TERM_UNKNOWN) && (unset(INTERACTIVE)))
+        init_term();
+
+    if (isset(PROMPTSUBST)) {
+	int olderr = errflag;
+
+	HEAPALLOC {
+	    s = dupstring(s);
+	    if (!parsestr(s))
+		singsub(&s);
+	} LASTALLOC;
+	/* Ignore errors in prompt substitution */
+	errflag = olderr;
+    }
+
+    rstring = rs;
+    Rstring = Rs;
+    nonsp = ns;
+    fm = s;
+    bp = buf = zalloc(bufspc = 256);
+    bp1 = NULL;
+    trunclen = 0;
+    putpromptchar(1, '\0');
+    addbufspc(1);
+    if(dontcount)
+	*bp++ = Outpar;
+    *bp = 0;
+    return buf;
+}
+
+/* Perform %- and !-expansion as required on a section of the prompt.  The *
+ * section is ended by an instance of endchar.  If doprint is 0, the valid *
+ * % sequences are merely skipped over, and nothing is stored.             */
+
+/**/
+static int
+putpromptchar(int doprint, int endchar)
+{
+    char *ss, *tmbuf = NULL;
+    int t0, arg, test, sep;
+    struct tm *tm;
+    time_t timet;
+    Nameddir nd;
+
+    for (; *fm && *fm != endchar; fm++) {
+	arg = 0;
+	if (*fm == '%' && isset(PROMPTPERCENT)) {
+	    if (idigit(*++fm)) {
+		arg = zstrtol(fm, &fm, 10);
+	    }
+	    if (*fm == '(') {
+		int tc;
+
+		if (idigit(*++fm)) {
+		    arg = zstrtol(fm, &fm, 10);
+		}
+		test = 0;
+		ss = pwd;
+		switch (tc = *fm) {
+		case 'c':
+		case '.':
+		case '~':
+		    if ((nd = finddir(ss))) {
+			arg--;
+			ss += strlen(nd->dir);
+		    }
+		case '/':
+		case 'C':
+		    for (; *ss; ss++)
+			if (*ss == '/')
+			    arg--;
+		    if (arg <= 0)
+			test = 1;
+		    break;
+		case 't':
+		case 'T':
+		case 'd':
+		case 'D':
+		case 'w':
+		    timet = time(NULL);
+		    tm = localtime(&timet);
+		    switch (tc) {
+		    case 't':
+			test = (arg == tm->tm_min);
+			break;
+		    case 'T':
+			test = (arg == tm->tm_hour);
+			break;
+		    case 'd':
+			test = (arg == tm->tm_mday);
+			break;
+		    case 'D':
+			test = (arg == tm->tm_mon);
+			break;
+		    case 'w':
+			test = (arg == tm->tm_wday);
+			break;
+		    }
+		    break;
+		case '?':
+		    if (lastval == arg)
+			test = 1;
+		    break;
+		case '#':
+		    if (geteuid() == arg)
+			test = 1;
+		    break;
+		case 'g':
+		    if (getegid() == arg)
+			test = 1;
+		    break;
+		case 'L':
+		    if (shlvl >= arg)
+			test = 1;
+		    break;
+		case 'S':
+		    if (time(NULL) - shtimer.tv_sec >= arg)
+			test = 1;
+		    break;
+		case 'v':
+		    if (arrlen(psvar) >= arg)
+			test = 1;
+		    break;
+		case '_':
+		    test = (cmdsp >= arg);
+		    break;
+		case '!':
+		    test = privasserted();
+		    break;
+		default:
+		    test = -1;
+		    break;
+		}
+		if (!*fm || !(sep = *++fm))
+		    return 0;
+		fm++;
+		if (!putpromptchar(test == 1 && doprint, sep) || !*++fm ||
+		    !putpromptchar(test == 0 && doprint, ')')) {
+		    return 0;
+		}
+		continue;
+	    }
+	    if (!doprint)
+		switch(*fm) {
+		  case '[':
+		    while(idigit(*++fm));
+		    while(*++fm != ']');
+		    continue;
+		  case '<':
+		    while(*++fm != '<');
+		    continue;
+		  case '>':
+		    while(*++fm != '>');
+		    continue;
+		  case 'D':
+		    if(fm[1]=='{')
+			while(*++fm != '}');
+		    continue;
+		  default:
+		    continue;
+		}
+	    switch (*fm) {
+	    case '~':
+		if ((nd = finddir(pwd))) {
+		    char *t = tricat("~", nd->nam, pwd + strlen(nd->dir));
+		    stradd(t);
+		    zsfree(t);
+		    break;
+		}
+	    case 'd':
+	    case '/':
+		stradd(pwd);
+		break;
+	    case 'c':
+	    case '.':
+	        {
+		    char *t;
+
+		    if ((nd = finddir(pwd)))
+			t = tricat("~", nd->nam, pwd + strlen(nd->dir));
+		    else
+			t = ztrdup(pwd);
+		    if (!arg)
+			arg++;
+		    for (ss = t + strlen(t); ss > t; ss--)
+			if (*ss == '/' && !--arg) {
+			    ss++;
+			    break;
+			}
+		    if(*ss == '/' && ss[1] && ss != t)
+			ss++;
+		    stradd(ss);
+		    zsfree(t);
+		    break;
+		}
+	    case 'C':
+		if (!arg)
+		    arg++;
+		for (ss = pwd + strlen(pwd); ss > pwd; ss--)
+		    if (*ss == '/' && !--arg) {
+			ss++;
+			break;
+		    }
+		if (*ss == '/' && ss[1] && (ss != pwd))
+		    ss++;
+		stradd(ss);
+		break;
+	    case 'h':
+	    case '!':
+		addbufspc(DIGBUFSIZE);
+		sprintf(bp, "%d", curhist);
+		bp += strlen(bp);
+		break;
+	    case 'M':
+		stradd(hostnam);
+		break;
+	    case 'm':
+		if (!arg)
+		    arg++;
+		for (ss = hostnam; *ss; ss++)
+		    if (*ss == '.' && !--arg)
+			break;
+		t0 = *ss;
+		*ss = '\0';
+		stradd(hostnam);
+		*ss = t0;
+		break;
+	    case 'S':
+		txtchangeset(TXTSTANDOUT, TXTNOSTANDOUT);
+		txtset(TXTSTANDOUT);
+		tsetcap(TCSTANDOUTBEG, 1);
+		break;
+	    case 's':
+		txtchangeset(TXTNOSTANDOUT, TXTSTANDOUT);
+		txtset(TXTDIRTY);
+		txtunset(TXTSTANDOUT);
+		tsetcap(TCSTANDOUTEND, 1);
+		break;
+	    case 'B':
+		txtchangeset(TXTBOLDFACE, TXTNOBOLDFACE);
+		txtset(TXTDIRTY);
+		txtset(TXTBOLDFACE);
+		tsetcap(TCBOLDFACEBEG, 1);
+		break;
+	    case 'b':
+		txtchangeset(TXTNOBOLDFACE, TXTBOLDFACE);
+		txtchangeset(TXTNOSTANDOUT, TXTSTANDOUT);
+		txtchangeset(TXTNOUNDERLINE, TXTUNDERLINE);
+		txtset(TXTDIRTY);
+		txtunset(TXTBOLDFACE);
+		tsetcap(TCALLATTRSOFF, 1);
+		break;
+	    case 'U':
+		txtchangeset(TXTUNDERLINE, TXTNOUNDERLINE);
+		txtset(TXTUNDERLINE);
+		tsetcap(TCUNDERLINEBEG, 1);
+		break;
+	    case 'u':
+		txtchangeset(TXTNOUNDERLINE, TXTUNDERLINE);
+		txtset(TXTDIRTY);
+		txtunset(TXTUNDERLINE);
+		tsetcap(TCUNDERLINEEND, 1);
+		break;
+	    case '[':
+                if (idigit(*++fm))
+                    trunclen = zstrtol(fm, &fm, 10);
+                else
+                    trunclen = arg;
+                if (trunclen) {
+		    truncatleft = *fm && *fm != ']' && *fm++ == '<';
+		    bp1 = bp;
+		    while (*fm && *fm != ']') {
+			if (*fm == '\\' && fm[1])
+			    ++fm;
+			addbufspc(1);
+			*bp++ = *fm++;
+		    }
+		    addbufspc(2);
+		    if (bp1 == bp)
+			*bp++ = '<';
+                    *bp = '\0';
+		    zsfree(truncstr);
+                    truncstr = ztrdup(bp = bp1);
+		    bp1 = NULL;
+                } else {
+		    while (*fm && *fm != ']') {
+			if (*fm == '\\' && fm[1])
+			    fm++;
+			fm++;
+		    }
+		}
+		if(!*fm)
+		    return 0;
+		break;
+	    case '<':
+	    case '>':
+		if((trunclen = arg)) {
+		    char ch = *fm++;
+		    truncatleft = ch == '<';
+		    bp1 = bp;
+		    while (*fm && *fm != ch) {
+			if (*fm == '\\' && fm[1])
+			    ++fm;
+			addbufspc(1);
+			*bp++ = *fm++;
+		    }
+		    addbufspc(1);
+                    *bp = '\0';
+		    zsfree(truncstr);
+                    truncstr = ztrdup(bp = bp1);
+		    bp1 = NULL;
+		} else {
+		    char ch = *fm++;
+		    while(*fm && *fm != ch) {
+			if (*fm == '\\' && fm[1])
+			    fm++;
+			fm++;
+		    }
+		}
+		if(!*fm)
+		    return 0;
+		break;
+	    case '{': /*}*/
+		if (!dontcount++ && nonsp) {
+		    addbufspc(1);
+		    *bp++ = Inpar;
+		}
+		break;
+	    case /*{*/ '}':
+		if (dontcount && !--dontcount && nonsp) {
+		    addbufspc(1);
+		    *bp++ = Outpar;
+		}
+		break;
+	    case 't':
+	    case '@':
+	    case 'T':
+	    case '*':
+	    case 'w':
+	    case 'W':
+	    case 'D':
+		{
+		    char *tmfmt, *dd;
+
+		    switch (*fm) {
+		    case 'T':
+			tmfmt = "%K:%M";
+			break;
+		    case '*':
+			tmfmt = "%K:%M:%S";
+			break;
+		    case 'w':
+			tmfmt = "%a %f";
+			break;
+		    case 'W':
+			tmfmt = "%m/%d/%y";
+			break;
+		    case 'D':
+			if (fm[1] == '{') /*}*/ {
+			    for (ss = fm + 2; *ss && *ss != /*{*/ '}'; ss++)
+				if(*ss == '\\' && ss[1])
+				    ss++;
+			    dd = tmfmt = tmbuf = zalloc(ss - fm);
+			    for (ss = fm + 2; *ss && *ss != /*{*/ '}'; ss++) {
+				if(*ss == '\\' && ss[1])
+				    ss++;
+				*dd++ = *ss;
+			    }
+			    *dd = 0;
+			    fm = ss - !*ss;
+			} else
+			    tmfmt = "%y-%m-%d";
+			break;
+		    default:
+			tmfmt = "%l:%M%p";
+			break;
+		    }
+		    timet = time(NULL);
+		    tm = localtime(&timet);
+		    for(t0=80; ; t0*=2) {
+			addbufspc(t0);
+			if(ztrftime(bp, t0, tmfmt, tm) != t0)
+			    break;
+		    }
+		    bp += strlen(bp);
+		    free(tmbuf);
+		    tmbuf = NULL;
+		    break;
+		}
+	    case 'n':
+		stradd(get_username());
+		break;
+	    case 'l':
+		if (*ttystrname) {
+		    ss = (strncmp(ttystrname, "/dev/tty", 8) ?
+			    ttystrname + 5 : ttystrname + 8);
+		    stradd(ss);
+		} else
+		    stradd("()");
+		break;
+	    case 'L':
+		addbufspc(DIGBUFSIZE);
+		sprintf(bp, "%ld", (long)shlvl);
+		bp += strlen(bp);
+		break;
+	    case '?':
+		addbufspc(DIGBUFSIZE);
+		sprintf(bp, "%ld", (long)lastval);
+		bp += strlen(bp);
+		break;
+	    case '%':
+	    case ')':
+		addbufspc(1);
+		*bp++ = *fm;
+		break;
+	    case '#':
+		addbufspc(1);
+		*bp++ = privasserted() ? '#' : '%';
+		break;
+	    case 'v':
+		if (!arg)
+		    arg = 1;
+		if (arrlen(psvar) >= arg)
+		    stradd(psvar[arg - 1]);
+		break;
+	    case 'E':
+                tsetcap(TCCLEAREOL, 1);
+		break;
+	    case '_':
+		if (cmdsp) {
+		    if (arg > cmdsp || arg <= 0)
+			arg = cmdsp;
+		    for (t0 = cmdsp - arg; arg--; t0++) {
+			stradd(cmdnames[cmdstack[t0]]);
+			if (arg) {
+			    addbufspc(1);
+			    *bp++=' ';
+			}
+		    }
+		}
+		break;
+	    case 'r':
+		if(rstring)
+		    stradd(rstring);
+		break;
+	    case 'R':
+		if(Rstring)
+		    stradd(Rstring);
+		break;
+	    case '\0':
+		return 0;
+	    case Meta:
+		fm++;
+		break;
+	    }
+	} else if(*fm == '!' && isset(PROMPTBANG)) {
+	    if(doprint)
+		if(fm[1] == '!') {
+		    fm++;
+		    addbufspc(1);
+		    pputc('!');
+		} else {
+		    addbufspc(DIGBUFSIZE);
+		    sprintf(bp, "%d", curhist);
+		    bp += strlen(bp);
+		}
+	} else {
+	    char c = *fm == Meta ? *++fm ^ 32 : *fm;
+
+	    if (doprint) {
+		addbufspc(1);
+		pputc(c);
+	    }
+	}
+    }
+
+    return *fm;
+}
+
+/* pputc adds a character to the buffer, metafying.  There must *
+ * already be space.                                            */
+
+/**/
+static void
+pputc(char c)
+{
+    if(imeta(STOUC(c))) {
+	*bp++ = Meta;
+	c ^= 32;
+    }
+    *bp++ = c;
+}
+
+/* Make sure there is room for `need' more characters in the buffer. */
+
+/**/
+static void
+addbufspc(int need)
+{
+    need *= 2;   /* for metafication */
+    if((bp - buf) + need > bufspc) {
+	int bo = bp - buf;
+	int bo1 = bp1 ? bp1 - buf : -1;
+
+	if(need & 255)
+	    need = (need | 255) + 1;
+	buf = realloc(buf, bufspc += need);
+	bp = buf + bo;
+	if(bo1 != -1)
+	    bp1 = buf + bo1;
+    }
+}
+
+/* stradd() adds a metafied string to the prompt, *
+ * in a visible representation, doing truncation. */
+
+/**/
+void
+stradd(char *d)
+{
+    /* dlen is the full length of the string we want to add */
+    int dlen = niceztrlen(d);
+    char *ps, *pd, *pc, *t;
+    int tlen, maxlen;
+    addbufspc(dlen);
+    /* This loop puts the nice representation of the string into the prompt *
+     * buffer.  It might be modified later.  Note that bp isn't changed.    */
+    for(ps=d, pd=bp; *ps; ps++)
+	for(pc=nicechar(*ps == Meta ? STOUC(*++ps)^32 : STOUC(*ps)); *pc; pc++)
+	    *pd++ = *pc;
+    if(!trunclen || dlen <= trunclen) {
+	/* No truncation is needed, so update bp and return, *
+	 * leaving the full string in the prompt.            */
+	bp += dlen;
+	return;
+    }
+    /* We need to truncate.  t points to the truncation string -- which is *
+     * inserted literally, without nice representation.  tlen is its       *
+     * length, and maxlen is the amout of the main string that we want to  *
+     * keep.  Note that if the truncation string is longer than the        *
+     * truncation length (tlen > trunclen), the truncation string is used  *
+     * in full.                                                            */
+    addbufspc(tlen = ztrlen(t = truncstr));
+    maxlen = tlen < trunclen ? trunclen - tlen : 0;
+    if(truncatleft) {
+	memmove(bp + strlen(t), bp + dlen - maxlen, maxlen);
+	while(*t)
+	    *bp++ = *t++;
+	bp += maxlen;
+    } else {
+	bp += maxlen;
+	while(*t)
+	    *bp++ = *t++;
+    }
+}
+
+/* tsetcap(), among other things, can write a termcap string into the buffer. */
+
+/**/
+void
+tsetcap(int cap, int flag)
+{
+    if (!(termflags & TERM_SHORT) && tcstr[cap]) {
+	switch(flag) {
+	case -1:
+	    tputs(tcstr[cap], 1, putraw);
+	    break;
+	case 0:
+	    tputs(tcstr[cap], 1, putshout);
+	    break;
+	case 1:
+	    if (!dontcount && nonsp) {
+		addbufspc(1);
+		*bp++ = Inpar;
+	    }
+	    tputs(tcstr[cap], 1, putstr);
+	    if (!dontcount && nonsp) {
+		int glitch = 0;
+
+		if (cap == TCSTANDOUTBEG || cap == TCSTANDOUTEND)
+		    glitch = tgetnum("sg");
+		else if (cap == TCUNDERLINEBEG || cap == TCUNDERLINEEND)
+		    glitch = tgetnum("ug");
+		if(glitch < 0)
+		    glitch = 0;
+		addbufspc(glitch + 1);
+		while(glitch--)
+		    *bp++ = Nularg;
+		*bp++ = Outpar;
+	    }
+	    break;
+	}
+
+	if (txtisset(TXTDIRTY)) {
+	    txtunset(TXTDIRTY);
+	    if (txtisset(TXTBOLDFACE) && cap != TCBOLDFACEBEG)
+		tsetcap(TCBOLDFACEBEG, flag);
+	    if (txtisset(TXTSTANDOUT))
+		tsetcap(TCSTANDOUTBEG, flag);
+	    if (txtisset(TXTUNDERLINE))
+		tsetcap(TCUNDERLINEBEG, flag);
+	}
+    }
+}
+
+/**/
+int
+putstr(int d)
+{
+    addbufspc(1);
+    pputc(d);
+    return 0;
+}
+
+/* Count height etc. of a prompt string returned by promptexpand(). *
+ * This depends on the current terminal width, and tabs and         *
+ * newlines require nontrivial processing.                          */
+
+/**/
+void
+countprompt(char *str, int *wp, int *hp)
+{
+    int w = 0, h = 1;
+    int s = 1;
+    for(; *str; str++) {
+	if(*str == Meta)
+	    str++;
+	if(*str == Inpar)
+	    s = 0;
+	else if(*str == Outpar)
+	    s = 1;
+	else if(*str == Nularg)
+	    w++;
+	else if(s) {
+	    if(*str == '\t')
+		w = (w | 7) + 1;
+	    else if(*str == '\n')
+		w = columns;
+	    else
+		w++;
+	}
+	if(w >= columns) {
+	    w = 0;
+	    h++;
+	}
+    }
+    if(wp)
+	*wp = w;
+    if(hp)
+	*hp = h;
+}
diff --git a/Src/prototypes.h b/Src/prototypes.h
new file mode 100644
index 000000000..f7f560111
--- /dev/null
+++ b/Src/prototypes.h
@@ -0,0 +1,120 @@
+/*
+ * prototypes.h - prototypes header file
+ *
+ * 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.
+ *
+ */
+
+#ifndef HAVE_STDLIB_H
+char *malloc _((size_t));
+char *realloc _((void *, size_t));
+char *calloc _((size_t, size_t));
+#endif
+
+#ifndef HAVE_TERMCAP_H
+extern int tgetent _((char *bp, char *name));
+extern int tgetnum _((char *id));
+extern int tgetflag _((char *id));
+extern char *tgetstr _((char *id, char **area));
+extern char *tgoto _((char *cm, int destcol, int destline));
+extern int tputs _((char *cp, int affcnt, int (*outc) (int)));
+#endif
+
+/* MISSING PROTOTYPES FOR VARIOUS OPERATING SYSTEMS */
+
+/* HP/UX 9 c89 */
+#if defined(__hpux) && defined(_XPG3) && !defined(_POSIX1_1988)
+# define WRITE_ARG_2_T void *
+#else
+# define WRITE_ARG_2_T char *
+#endif
+
+#if defined(__hpux) && defined(_HPUX_SOURCE)
+# define SELECT_ARG_2_T int *
+#else
+# define SELECT_ARG_2_T fd_set *
+#endif
+
+#ifdef __osf__
+char *mktemp _((char *));
+#endif
+
+#if defined(__osf__) && defined(__alpha) && defined(__GNUC__)
+/* Digital cc does not need these prototypes, gcc does need them */
+# ifndef HAVE_IOCTL_PROTO
+int ioctl _((int d, unsigned long request, void *argp));
+# endif
+int mknod _((const char *pathname, int mode, dev_t device));
+int nice _((int increment));
+int select _((int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval *timeout));
+#endif
+
+#if defined(DGUX) && defined(__STDC__)
+/* Just plain missing. */
+extern int getrlimit _((int resource, struct rlimit *rlp));
+extern int setrlimit _((int resource, const struct rlimit *rlp));
+extern int getrusage _((int who, struct rusage *rusage));
+extern int gettimeofday _((struct timeval *tv, struct timezone *tz));
+extern int wait3 _((union wait *wait_status, int options, struct rusage *rusage));
+extern int getdomainname _((char *name, int maxlength));
+extern int select _((int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval *timeout));
+#endif /* DGUX and __STDC__ */
+
+#ifdef __NeXT__
+extern pid_t getppid(void);
+#endif
+
+#if defined(__sun__) && !defined(__SVR4)  /* SunOS */
+extern char *strerror _((int errnum));
+#endif
+
+/**************************************************/
+/*** prototypes for functions built in compat.c ***/
+#ifndef HAVE_STRSTR
+extern char *strstr _((const char *s, const char *t));
+#endif
+
+#ifndef HAVE_GETHOSTNAME
+extern int gethostname _((char *name, size_t namelen));
+#endif
+
+#ifndef HAVE_GETTIMEOFDAY
+extern int gettimeofday _((struct timeval *tv, struct timezone *tz));
+#endif
+
+#ifndef HAVE_DIFFTIME
+extern double difftime _((time_t t2, time_t t1));
+#endif
+
+#ifndef HAVE_STRERROR
+extern char *strerror _((int errnum));
+#endif
+
+/*** end of prototypes for functions in compat.c ***/
+/***************************************************/
+
+#ifndef HAVE_MEMMOVE
+extern void bcopy _((const void *, void *, int));
+#endif
diff --git a/Src/signals.c b/Src/signals.c
new file mode 100644
index 000000000..5dc19dd22
--- /dev/null
+++ b/Src/signals.c
@@ -0,0 +1,748 @@
+/*
+ * signals.c - signals handling code
+ *
+ * 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 "signals.pro"
+ 
+/* Array describing the state of each signal: an element contains *
+ * 0 for the default action or some ZSIG_* flags ored together.   */
+
+/**/
+int sigtrapped[VSIGCOUNT];
+
+/* trap functions for each signal */
+
+/**/
+List sigfuncs[VSIGCOUNT];
+
+/* Variables used by signal queueing */
+
+/**/
+int queueing_enabled, queue_front, queue_rear;
+/**/
+int signal_queue[MAX_QUEUE_SIZE];
+/**/
+sigset_t signal_mask_queue[MAX_QUEUE_SIZE];
+
+/* This is only used on machines that don't understand signal sets.  *
+ * On SYSV machines this will represent the signals that are blocked *
+ * (held) using sighold.  On machines which can't block signals at   *
+ * all, we will simulate this by ignoring them and remembering them  *
+ * in this variable.                                                 */
+#if !defined(POSIX_SIGNALS) && !defined(BSD_SIGNALS)
+static sigset_t blocked_set;
+#endif
+
+#ifdef POSIX_SIGNALS
+# define signal_jmp_buf       sigjmp_buf
+# define signal_setjmp(b)     sigsetjmp((b),1)
+# define signal_longjmp(b,n)  siglongjmp((b),(n))
+#else
+# define signal_jmp_buf       jmp_buf
+# define signal_setjmp(b)     setjmp(b)
+# define signal_longjmp(b,n)  longjmp((b),(n))
+#endif
+ 
+#ifdef NO_SIGNAL_BLOCKING
+# define signal_process(sig)  signal_ignore(sig)
+# define signal_reset(sig)    install_handler(sig)
+#else
+# define signal_process(sig)  ;
+# define signal_reset(sig)    ;
+#endif
+
+/* Install signal handler for given signal.           *
+ * If possible, we want to make sure that interrupted *
+ * system calls are not restarted.                    */
+
+/**/
+void
+install_handler(int sig)
+{
+#ifdef POSIX_SIGNALS
+    struct sigaction act;
+ 
+    act.sa_handler = (SIGNAL_HANDTYPE) handler;
+    sigemptyset(&act.sa_mask);        /* only block sig while in handler */
+    act.sa_flags = 0;
+# ifdef SA_INTERRUPT                  /* SunOS 4.x */
+    if (interact)
+        act.sa_flags |= SA_INTERRUPT; /* make sure system calls are not restarted */
+# endif
+    sigaction(sig, &act, (struct sigaction *)NULL);
+#else
+# ifdef BSD_SIGNALS
+    struct sigvec vec;
+ 
+    vec.sv_handler = (SIGNAL_HANDTYPE) handler;
+    vec.sv_mask = sigmask(sig);    /* mask out this signal while in handler    */
+#  ifdef SV_INTERRUPT
+    vec.sv_flags = SV_INTERRUPT;   /* make sure system calls are not restarted */
+#  endif
+    sigvec(sig, &vec, (struct sigvec *)NULL);
+# else
+#  ifdef SYSV_SIGNALS
+    /* we want sigset rather than signal because it will   *
+     * block sig while in handler.  signal usually doesn't */
+    sigset(sig, handler);
+#  else  /* NO_SIGNAL_BLOCKING (bummer) */
+    signal(sig, handler);
+
+#  endif /* SYSV_SIGNALS  */
+# endif  /* BSD_SIGNALS   */
+#endif   /* POSIX_SIGNALS */
+}
+
+/* enable ^C interrupts */
+ 
+/**/
+void
+intr(void)
+{
+    if (interact)
+        install_handler(SIGINT);
+}
+
+#if 0
+/* disable ^C interrupts */
+ 
+/**/
+void
+nointr(void)
+{
+    if (interact)
+        signal_ignore(SIGINT);
+}
+#endif
+ 
+/* temporarily block ^C interrupts */
+ 
+/**/
+void
+holdintr(void)
+{
+    if (interact)
+        signal_block(signal_mask(SIGINT));
+}
+
+/* release ^C interrupts */
+ 
+/**/
+void
+noholdintr(void)
+{
+    if (interact)
+        signal_unblock(signal_mask(SIGINT));
+}
+ 
+/* create a signal mask containing *
+ * only the given signal           */
+ 
+/**/
+sigset_t
+signal_mask(int sig)
+{
+    sigset_t set;
+ 
+    sigemptyset(&set);
+    if (sig)
+        sigaddset(&set, sig);
+    return set;
+}
+
+/* Block the signals in the given signal *
+ * set. Return the old signal set.       */
+ 
+/**/
+sigset_t
+signal_block(sigset_t set)
+{
+    sigset_t oset;
+ 
+#ifdef POSIX_SIGNALS
+    sigprocmask(SIG_BLOCK, &set, &oset);
+#else
+# ifdef BSD_SIGNALS
+    oset = sigblock(set);
+# else
+#  ifdef SYSV_SIGNALS
+    int i;
+ 
+    oset = blocked_set;
+    for (i = 1; i <= NSIG; ++i) {
+        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {
+            sigaddset(&blocked_set, i);
+            sighold(i);
+        }
+    }
+#  else  /* NO_SIGNAL_BLOCKING */
+/* We will just ignore signals if the system doesn't have *
+ * the ability to block them.                             */
+    int i;
+
+    oset = blocked_set;
+    for (i = 1; i <= NSIG; ++i) {
+        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {
+            sigaddset(&blocked_set, i);
+            signal_ignore(i);
+        }
+   }
+#  endif /* SYSV_SIGNALS  */
+# endif  /* BSD_SIGNALS   */
+#endif   /* POSIX_SIGNALS */
+ 
+    return oset;
+}
+
+/* Unblock the signals in the given signal *
+ * set. Return the old signal set.         */
+
+/**/
+sigset_t
+signal_unblock(sigset_t set)
+{
+    sigset_t oset;
+ 
+#ifdef POSIX_SIGNALS
+    sigprocmask(SIG_UNBLOCK, &set, &oset);
+#else
+# ifdef BSD_SIGNALS
+    sigfillset(&oset);
+    oset = sigsetmask(oset);
+    sigsetmask(oset & ~set);
+# else
+#  ifdef SYSV_SIGNALS
+    int i;
+ 
+    oset = blocked_set;
+    for (i = 1; i <= NSIG; ++i) {
+        if (sigismember(&set, i) && sigismember(&blocked_set, i)) {
+            sigdelset(&blocked_set, i);
+            sigrelse(i);
+        }
+    }
+#  else  /* NO_SIGNAL_BLOCKING */
+/* On systems that can't block signals, we are just ignoring them.  So *
+ * to unblock signals, we just reenable the signal handler for them.   */
+    int i;
+
+    oset = blocked_set;
+    for (i = 1; i <= NSIG; ++i) {
+        if (sigismember(&set, i) && sigismember(&blocked_set, i)) {
+            sigdelset(&blocked_set, i);
+            install_handler(i);
+        }
+   }
+#  endif /* SYSV_SIGNALS  */
+# endif  /* BSD_SIGNALS   */
+#endif   /* POSIX_SIGNALS */
+ 
+    return oset;
+}
+
+/* set the process signal mask to *
+ * be the given signal mask       */
+
+/**/
+sigset_t
+signal_setmask(sigset_t set)
+{
+    sigset_t oset;
+ 
+#ifdef POSIX_SIGNALS
+    sigprocmask(SIG_SETMASK, &set, &oset);
+#else
+# ifdef BSD_SIGNALS
+    oset = sigsetmask(set);
+# else
+#  ifdef SYSV_SIGNALS
+    int i;
+ 
+    oset = blocked_set;
+    for (i = 1; i <= NSIG; ++i) {
+        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {
+            sigaddset(&blocked_set, i);
+            sighold(i);
+        } else if (!sigismember(&set, i) && sigismember(&blocked_set, i)) {
+            sigdelset(&blocked_set, i);
+            sigrelse(i);
+        }
+    }
+#  else  /* NO_SIGNAL_BLOCKING */
+    int i;
+
+    oset = blocked_set;
+    for (i = 1; i < NSIG; ++i) {
+        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {
+            sigaddset(&blocked_set, i);
+            signal_ignore(i);
+        } else if (!sigismember(&set, i) && sigismember(&blocked_set, i)) {
+            sigdelset(&blocked_set, i);
+            install_handler(i);
+        }
+    }
+#  endif /* SYSV_SIGNALS  */
+# endif  /* BSD_SIGNALS   */
+#endif   /* POSIX_SIGNALS */
+ 
+    return oset;
+}
+
+#if defined(NO_SIGNAL_BLOCKING)
+static int suspend_longjmp = 0;
+static signal_jmp_buf suspend_jmp_buf;
+#endif
+ 
+/**/
+int
+signal_suspend(int sig, int sig2)
+{
+    int ret;
+ 
+#ifdef POSIX_SIGNALS
+    sigset_t set;
+
+    sigfillset(&set);
+    sigdelset(&set, sig);
+    sigdelset(&set, SIGHUP);  /* still don't know why we add this? */
+    if (sig2)
+        sigdelset(&set, sig2);
+    ret = sigsuspend(&set);
+#else
+# ifdef BSD_SIGNALS
+    sigset_t set;
+
+    sigfillset(&set);
+    sigdelset(&set, sig);
+    if (sig2)
+      sigdelset(&set, sig2);
+    ret = sigpause(set);
+# else
+#  ifdef SYSV_SIGNALS
+    ret = sigpause(sig);
+
+#  else  /* NO_SIGNAL_BLOCKING */
+    /* need to use signal_longjmp to make this race-free *
+     * between the child_unblock() and pause()           */
+    if (signal_setjmp(suspend_jmp_buf) == 0) {
+        suspend_longjmp = 1;   /* we want to signal_longjmp after catching signal */
+        child_unblock();       /* do we need to unblock sig2 as well?             */
+        ret = pause();
+    }
+    suspend_longjmp = 0;       /* turn off using signal_longjmp since we are past *
+                                * the pause() function.                           */
+#  endif /* SYSV_SIGNALS  */
+# endif  /* BSD_SIGNALS   */
+#endif   /* POSIX_SIGNALS */
+ 
+    return ret;
+}
+
+/* What flavor of waitpid/wait3/wait shall we use? */
+ 
+#ifdef HAVE_WAITPID
+# define  WAIT(pid, statusp, options) waitpid(pid, statusp, options)
+#else
+# ifdef HAVE_WAIT3
+#  define WAIT(pid, statusp, options) wait3((void *) statusp, options, NULL)
+# else
+#  define WAIT(pid, statusp, options) wait(statusp)
+# endif
+#endif
+
+/* the signal handler */
+ 
+/**/
+RETSIGTYPE
+handler(int sig)
+{
+    sigset_t newmask, oldmask;
+
+#if defined(NO_SIGNAL_BLOCKING)
+    int do_jump;
+    signal_jmp_buf jump_to;
+#endif
+ 
+    signal_process(sig);
+ 
+    sigfillset(&newmask);
+    oldmask = signal_block(newmask);        /* Block all signals temporarily           */
+ 
+#if defined(NO_SIGNAL_BLOCKING)
+    do_jump = suspend_longjmp;              /* do we need to longjmp to signal_suspend */
+    suspend_longjmp = 0;                    /* In case a SIGCHLD somehow arrives       */
+
+    if (sig == SIGCHLD) {                   /* Traps can cause nested child_suspend()  */
+        if (do_jump)
+            jump_to = suspend_jmp_buf;      /* Copy suspend_jmp_buf                    */
+    }
+#endif
+
+    if (queueing_enabled) {           /* Are we queueing signals now?      */
+        int temp_rear = ++queue_rear % MAX_QUEUE_SIZE;
+
+	DPUTS(temp_rear == queue_front, "BUG: signal queue full");
+        if (temp_rear != queue_front) { /* Make sure it's not full (extremely unlikely) */
+            queue_rear = temp_rear;                  /* ok, not full, so add to queue   */
+            signal_queue[queue_rear] = sig;          /* save signal caught              */
+            signal_mask_queue[queue_rear] = oldmask; /* save current signal mask        */
+        }
+        signal_reset(sig);
+        return;
+    }
+ 
+    signal_setmask(oldmask);          /* Reset signal mask, signal traps ok now */
+ 
+    switch (sig) {
+    case SIGCHLD:
+
+	/* keep WAITING until no more child processes to reap */
+	for (;;)
+	  cont: {
+            int old_errno = errno; /* save the errno, since WAIT may change it */
+	    int status;
+	    Job jn;
+	    Process pn;
+            pid_t pid;
+	    pid_t *procsubpid = &cmdoutpid;
+	    int *procsubval = &cmdoutval;
+	    struct execstack *es = exstack;
+
+            pid = WAIT(-1, &status, WNOHANG|WUNTRACED);  /* reap the child process */
+
+            if (!pid)  /* no more children to reap */
+                break;
+
+	    /* check if child returned was from process substitution */
+	    for (;;) {
+		if (pid == *procsubpid) {
+		    *procsubpid = 0;
+		    if (WIFSIGNALED(status))
+			*procsubval = (0200 | WTERMSIG(status));
+		    else
+			*procsubval = WEXITSTATUS(status);
+		    times(&shtms);
+		    goto cont;
+		}
+		if (!es)
+		    break;
+		procsubpid = &es->cmdoutpid;
+		procsubval = &es->cmdoutval;
+		es = es->next;
+	    }
+
+	    /* check for WAIT error */
+            if (pid == -1) {
+                if (errno != ECHILD)
+                    zerr("wait failed: %e", NULL, errno);
+                errno = old_errno;    /* WAIT changed errno, so restore the original */
+                break;
+            }
+
+	    /* Find the process and job containing this pid and update it. */
+	    if (findproc(pid, &jn, &pn)) {
+		update_process(pn, status);
+		update_job(jn);
+	    } else {
+		/* If not found, update the shell record of time spent by
+		 * children in sub processes anyway:  otherwise, this
+		 * will get added on to the next found process that terminates.
+		 */
+		times(&shtms);
+	    }
+        }
+        break;
+ 
+    case SIGHUP:
+        if (sigtrapped[SIGHUP])
+            dotrap(SIGHUP);
+        else {
+            stopmsg = 1;
+            zexit(SIGHUP, 1);
+        }
+        break;
+ 
+    case SIGINT:
+        if (sigtrapped[SIGINT])
+            dotrap(SIGINT);
+        else {
+	    if ((isset(PRIVILEGED) || isset(RESTRICTED)) &&
+		isset(INTERACTIVE) && noerrexit < 0)
+		zexit(SIGINT, 1);
+            if (list_pipe || chline || simple_pline) {
+                breaks = loops;
+                errflag = 1;
+		inerrflush();
+            }
+        }
+        break;
+
+#ifdef SIGWINCH
+    case SIGWINCH:
+        adjustwinsize();  /* check window size and adjust */
+	if (sigtrapped[SIGWINCH])
+	    dotrap(SIGWINCH);
+        break;
+#endif
+
+    case SIGALRM:
+        if (sigtrapped[SIGALRM]) {
+	    int tmout;
+            dotrap(SIGALRM);
+            if ((tmout = getiparam("TMOUT")))
+                alarm(tmout);           /* reset the alarm */
+        } else {
+	    int idle = ttyidlegetfn(NULL);
+	    int tmout = getiparam("TMOUT");
+	    if (idle >= 0 && idle < tmout)
+		alarm(tmout - idle);
+	    else {
+		errflag = noerrs = 0;
+		zerr("timeout", NULL, 0);
+		errflag = 0;
+		stopmsg = 1;
+		zexit(SIGALRM, 1);
+	    }
+        }
+        break;
+ 
+    default:
+        dotrap(sig);
+        break;
+    }   /* end of switch(sig) */
+ 
+    signal_reset(sig);
+
+/* This is used to make signal_suspend() race-free */
+#if defined(NO_SIGNAL_BLOCKING)
+    if (do_jump)
+        signal_longjmp(jump_to, 1);
+#endif
+
+} /* handler */
+
+ 
+/* SIGHUP any jobs left running */
+ 
+/**/
+void
+killrunjobs(int from_signal)
+{
+    int i, killed = 0;
+ 
+    if (unset(HUP))
+        return;
+    for (i = 1; i < MAXJOB; i++)
+        if ((from_signal || i != thisjob) && (jobtab[i].stat & STAT_LOCKED) &&
+            !(jobtab[i].stat & STAT_NOPRINT) &&
+            !(jobtab[i].stat & STAT_STOPPED)) {
+            if (killpg(jobtab[i].gleader, SIGHUP) != -1)
+                killed++;
+        }
+    if (killed)
+        zerr("warning: %d jobs SIGHUPed", NULL, killed);
+}
+
+
+/* send a signal to a job (simply involves kill if monitoring is on) */
+ 
+/**/
+int
+killjb(Job jn, int sig)
+{
+    Process pn;
+    int err = 0;
+ 
+    if (jobbing) {
+        if (jn->stat & STAT_SUPERJOB) {
+            if (sig == SIGCONT) {
+                for (pn = jobtab[jn->other].procs; pn; pn = pn->next)
+                    kill(pn->pid, sig);
+ 
+                for (pn = jn->procs; pn->next; pn = pn->next)
+                    err = kill(pn->pid, sig);
+ 
+                return err;
+            }
+ 
+            killpg(jobtab[jn->other].gleader, sig);
+            return killpg(jn->gleader, sig);
+        }
+        else
+            return (killpg(jn->gleader, sig));
+    }
+    for (pn = jn->procs; pn; pn = pn->next)
+        if ((err = kill(pn->pid, sig)) == -1 && errno != ESRCH)
+            return -1;
+    return err;
+}
+
+/**/
+int
+settrap(int sig, List l)
+{
+    if (sig == -1)
+        return 1;
+    if (jobbing && (sig == SIGTTOU || sig == SIGTSTP || sig == SIGTTIN)) {
+        zerr("can't trap SIG%s in interactive shells", sigs[sig], 0);
+        return 1;
+    }
+    if (sigfuncs[sig])
+	unsettrap(sig);
+    sigfuncs[sig] = l;
+    if (!l) {
+	sigtrapped[sig] = ZSIG_IGNORED;
+        if (sig && sig <= SIGCOUNT &&
+#ifdef SIGWINCH
+            sig != SIGWINCH &&
+#endif
+            sig != SIGCHLD)
+            signal_ignore(sig);
+    } else {
+        sigtrapped[sig] = ZSIG_TRAPPED;
+        if (sig && sig <= SIGCOUNT &&
+#ifdef SIGWINCH
+            sig != SIGWINCH &&
+#endif
+            sig != SIGCHLD)
+            install_handler(sig);
+    }
+    return 0;
+}
+
+/**/
+void
+unsettrap(int sig)
+{
+    int trapped;
+
+    if (sig == -1 || !(trapped = sigtrapped[sig]) ||
+	(jobbing && (sig == SIGTTOU || sig == SIGTSTP || sig == SIGTTIN))) {
+        return;
+    }
+    sigtrapped[sig] = 0;
+    if (sig == SIGINT && interact) {
+	/* PWS 1995/05/16:  added test for interactive, also noholdintr() *
+	 * as subshells ignoring SIGINT have it blocked from delivery     */
+        intr();
+	noholdintr();
+    } else if (sig == SIGHUP)
+        install_handler(sig);
+    else if (sig && sig <= SIGCOUNT &&
+#ifdef SIGWINCH
+             sig != SIGWINCH &&
+#endif
+             sig != SIGCHLD)
+        signal_default(sig);
+    if (trapped & ZSIG_FUNC) {
+	char func[20];
+	HashNode hn;
+
+	sprintf(func, "TRAP%s", sigs[sig]);
+	if ((hn = shfunctab->removenode(shfunctab, func)))
+	    shfunctab->freenode(hn);
+    } else if (sigfuncs[sig]) {
+	freestruct(sigfuncs[sig]);
+	sigfuncs[sig] = NULL;
+    }
+}
+
+/* Execute a trap function for a given signal, possibly
+ * with non-standard sigtrapped & sigfuncs values
+ */
+
+/**/
+void
+dotrapargs(int sig, int *sigtr, void *sigfn)
+{
+    LinkList args;
+    char *name, num[4];
+    int trapret = 0;
+    int obreaks = breaks;
+ 
+    /* if signal is being ignored or the trap function		      *
+     * is NULL, then return					      *
+     *								      *
+     * Also return if errflag is set.  In fact, the code in the       *
+     * function will test for this, but this way we keep status flags *
+     * intact without working too hard.  Special cases (e.g. calling  *
+     * a trap for SIGINT after the error flag was set) are handled    *
+     * by the calling code.  (PWS 1995/06/08).			      */
+    if ((*sigtr & ZSIG_IGNORED) || !sigfn || errflag)
+        return;
+
+    *sigtr |= ZSIG_IGNORED;
+
+    lexsave();
+    execsave();
+    breaks = 0;
+    if (*sigtr & ZSIG_FUNC) {
+	PERMALLOC {
+	    args = newlinklist();
+	    name = (char *) zalloc(5 + strlen(sigs[sig]));
+	    sprintf(name, "TRAP%s", sigs[sig]);
+	    addlinknode(args, name);
+	    sprintf(num, "%d", sig);
+	    addlinknode(args, num);
+	} LASTALLOC;
+	trapreturn = -1;
+	doshfunc(sigfn, args, 0, 1);
+	freelinklist(args, (FreeFunc) NULL);
+	zsfree(name);
+    } else HEAPALLOC {
+	execlist(dupstruct(sigfn), 1, 0);
+    } LASTALLOC;
+    if (trapreturn > 0)
+	trapret = trapreturn;
+    else if (errflag)
+	trapret = 1;
+    execrestore();
+    lexrestore();
+
+    if (trapret > 0) {
+	breaks = loops;
+	errflag = 1;
+    } else {
+	breaks += obreaks;
+	if (breaks > loops)
+	    breaks = loops;
+    }
+
+    if (*sigtr != ZSIG_IGNORED)
+	*sigtr &= ~ZSIG_IGNORED;
+}
+
+/* Standard call to execute a trap for a given signal */
+
+/**/
+void
+dotrap(int sig)
+{
+    dotrapargs(sig, sigtrapped+sig, sigfuncs[sig]);
+}
diff --git a/Src/signals.h b/Src/signals.h
new file mode 100644
index 000000000..b6485e6b3
--- /dev/null
+++ b/Src/signals.h
@@ -0,0 +1,94 @@
+/*
+ * signals.h - header file for signals handling code
+ *
+ * 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.
+ *
+ */
+
+#define SIGNAL_HANDTYPE RETSIGTYPE (*)_((int))
+
+#ifndef HAVE_KILLPG
+# define killpg(pgrp,sig) kill(-(pgrp),sig)
+#endif
+
+#define SIGZERR   (SIGCOUNT+1)
+#define SIGDEBUG  (SIGCOUNT+2)
+#define VSIGCOUNT (SIGCOUNT+3)
+#define SIGEXIT    0
+
+#ifdef SV_BSDSIG
+# define SV_INTERRUPT SV_BSDSIG
+#endif
+
+/* If not a POSIX machine, then we create our *
+ * own POSIX style signal sets functions.     */
+#ifndef POSIX_SIGNALS
+# define sigemptyset(s)    (*(s) = 0)
+# if NSIG == 32
+#  define sigfillset(s)    (*(s) = ~(sigset_t)0, 0)
+# else
+#  define sigfillset(s)    (*(s) = (1 << NSIG) - 1, 0)
+# endif
+# define sigaddset(s,n)    (*(s) |=  (1 << ((n) - 1)), 0)
+# define sigdelset(s,n)    (*(s) &= ~(1 << ((n) - 1)), 0)
+# define sigismember(s,n)  ((*(s) & (1 << ((n) - 1))) != 0)
+#endif   /* ifndef POSIX_SIGNALS */
+ 
+#define child_block()      signal_block(signal_mask(SIGCHLD))
+#define child_unblock()    signal_unblock(signal_mask(SIGCHLD))
+#define child_suspend(S)   signal_suspend(SIGCHLD, S)
+
+/* ignore a signal */
+#define signal_ignore(S)   signal(S, SIG_IGN)
+
+/* return a signal to it default action */
+#define signal_default(S)  signal(S, SIG_DFL)
+
+/* Use a circular queue to save signals caught during    *
+ * critical sections of code.  You call queue_signals to *
+ * start queueing, and unqueue_signals to process the    *
+ * queue and stop queueing.  Since the kernel doesn't    *
+ * queue signals, it is probably overkill for zsh to do  *
+ * this, but it shouldn't hurt anything to do it anyway. */
+
+/* Right now I'm queueing all signals, but maybe we only *
+ * need to queue SIGCHLD.  Anybody know?                 */
+
+#define MAX_QUEUE_SIZE 16
+
+#define queue_signals()    (queueing_enabled++)
+
+#define unqueue_signals()  do { \
+    DPUTS(!queueing_enabled, "BUG: unqueue_signals called but not queueing"); \
+    if (!--queueing_enabled) { \
+	while (queue_front != queue_rear) {      /* while signals in queue */ \
+	    sigset_t oset; \
+	    queue_front = (queue_front + 1) % MAX_QUEUE_SIZE; \
+	    oset = signal_setmask(signal_mask_queue[queue_front]); \
+	    handler(signal_queue[queue_front]);  /* handle queued signal   */ \
+	    signal_setmask(oset); \
+	} \
+    } \
+} while (0)
diff --git a/Src/signames.awk b/Src/signames.awk
new file mode 100755
index 000000000..5d2eeb61e
--- /dev/null
+++ b/Src/signames.awk
@@ -0,0 +1,98 @@
+#
+# {g,n}awk script to generate signames.c
+#
+# NB: On SunOS 4.1.3 - user-functions don't work properly, also \" problems
+# Without 0 + hacks some nawks compare numbers as strings
+#
+/^[\t ]*#[\t ]*define[\t _]*SIG[A-Z][A-Z0-9]*[\t ]*[1-9][0-9]*/ { 
+    sigindex = index($0, "SIG")
+    sigtail = substr($0, sigindex, 80)
+    split(sigtail, tmp)
+    signam = substr(tmp[1], 4, 20)
+    signum = tmp[2]
+    if (sig[signum] == "") {
+	sig[signum] = signam
+	if (0 + max < 0 + signum && signum < 60)
+	    max = signum
+	if (signam == "ABRT")   { msg[signum] = "abort" }
+	if (signam == "ALRM")   { msg[signum] = "alarm" }
+	if (signam == "BUS")    { msg[signum] = "bus error" }
+	if (signam == "CHLD")   { msg[signum] = "death of child" }
+	if (signam == "CLD")    { msg[signum] = "death of child" }
+	if (signam == "CONT")   { msg[signum] = "continued" }
+	if (signam == "EMT")    { msg[signum] = "EMT instruction" }
+	if (signam == "FPE")    { msg[signum] = "floating point exception" }
+	if (signam == "HUP")    { msg[signum] = "hangup" }
+	if (signam == "ILL")    { msg[signum] = "illegal hardware instruction" }
+	if (signam == "INFO")   { msg[signum] = "status request from keyboard" }
+	if (signam == "INT")    { msg[signum] = "interrupt" }
+	if (signam == "IO")     { msg[signum] = "i/o ready" }
+	if (signam == "IOT")    { msg[signum] = "IOT instruction" }
+	if (signam == "KILL")   { msg[signum] = "killed" }
+	if (signam == "LOST")	{ msg[signum] = "resource lost" }
+	if (signam == "PIPE")   { msg[signum] = "broken pipe" }
+	if (signam == "POLL")	{ msg[signum] = "pollable event occurred" }
+	if (signam == "PROF")   { msg[signum] = "profile signal" }
+	if (signam == "PWR")    { msg[signum] = "power fail" }
+	if (signam == "QUIT")   { msg[signum] = "quit" }
+	if (signam == "SEGV")   { msg[signum] = "segmentation fault" }
+	if (signam == "SYS")    { msg[signum] = "invalid system call" }
+	if (signam == "TERM")   { msg[signum] = "terminated" }
+	if (signam == "TRAP")   { msg[signum] = "trace trap" }
+	if (signam == "URG")	{ msg[signum] = "urgent condition" }
+	if (signam == "USR1")   { msg[signum] = "user-defined signal 1" }
+	if (signam == "USR2")   { msg[signum] = "user-defined signal 2" }
+	if (signam == "VTALRM") { msg[signum] = "virtual time alarm" }
+	if (signam == "WINCH")  { msg[signum] = "window size changed" }
+	if (signam == "XCPU")   { msg[signum] = "cpu limit exceeded" }
+	if (signam == "XFSZ")   { msg[signum] = "file size limit exceeded" }
+    }
+}
+
+END {
+    ps = "%s"
+    ifdstr = sprintf("# ifdef USE_SUSPENDED\n\t%csuspended%s%c,\n%s else\n\t%cstopped%s%c,\n# endif\n", 34, ps, 34, "#", 34, ps, 34)
+
+    printf "/** signames.c                                 **/\n"
+    printf "/** architecture-customized signames.c for zsh **/\n"
+    printf "\n"
+    printf "#define SIGCOUNT\t%d\n", max
+    printf "\n"
+    printf "#include %czsh.mdh%c\n", 34, 34
+    printf "\n"
+    printf "/**/\n"
+    printf "char *sigmsg[SIGCOUNT+2] = {\n"
+    printf "\t%c%s%c,\n", 34, "done", 34
+
+    for (i = 1; i <= 0 + max; i++)
+	if (msg[i] == "") {
+	    if (sig[i] == "")
+		printf("\t%c%c,\n", 34, 34)
+	    else if (sig[i] == "STOP")
+		printf ifdstr, " (signal)", " (signal)"
+	    else if (sig[i] == "TSTP")
+		printf ifdstr, "", ""
+	    else if (sig[i] == "TTIN")
+		printf ifdstr, " (tty input)", " (tty input)"
+	    else if (sig[i] == "TTOU")
+		printf ifdstr, " (tty output)", " (tty output)"
+	    else
+		printf("\t%cSIG%s%c,\n", 34, sig[i], 34)
+	} else
+	    printf("\t%c%s%c,\n", 34, msg[i], 34)
+    print "\tNULL"
+    print "};"
+    print ""
+    print "/**/"
+    printf "char *sigs[SIGCOUNT+4] = {\n"
+    printf("\t%cEXIT%c,\n", 34, 34)
+    for (i = 1; i <= 0 + max; i++)
+	if (sig[i] == "")
+	    printf("\t%c%d%c,\n", 34, i, 34)
+	else
+	    printf("\t%c%s%c,\n", 34, sig[i], 34)
+    printf("\t%cZERR%c,\n", 34, 34)
+    printf("\t%cDEBUG%c,\n", 34, 34)
+    print "\tNULL"
+    print "};"
+}
diff --git a/Src/subst.c b/Src/subst.c
new file mode 100644
index 000000000..8f840d266
--- /dev/null
+++ b/Src/subst.c
@@ -0,0 +1,1773 @@
+/*
+ * subst.c - various substitutions
+ *
+ * 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 "subst.pro"
+
+/**/
+char nulstring[] = {Nularg, '\0'};
+
+/* Do substitutions before fork. These are:
+ *  - Process substitution: <(...), >(...), =(...)
+ *  - Parameter substitution
+ *  - Command substitution
+ * Followed by
+ *  - Quote removal
+ *  - Brace expansion
+ *  - Tilde and equals substitution
+ *
+ * Bits 0 and 1 of flags are used in filesub.
+ * bit 0 is set when we are doing MAGIC_EQUALSUBST or normal
+ *	 assignment but not a typeset.
+ * bit 1 is set on a real assignment (both typeset and normal).
+ * bit 2 is a flag to paramsubst (single word sub)
+ */
+
+/**/
+void
+prefork(LinkList list, int flags)
+{
+    LinkNode node;
+
+    MUSTUSEHEAP("prefork");
+    for (node = firstnode(list); node; incnode(node)) {
+	char *str, *str3;
+
+	str = str3 = (char *)getdata(node);
+	if ((*str == Inang || *str == Outang || *str == Equals) &&
+	    str[1] == Inpar) {
+	    if (*str == Inang || *str == Outang)
+		setdata(node, (void *) getproc(str));	/* <(...) or >(...) */
+	    else
+		setdata(node, (void *) getoutputfile(str));	/* =(...) */
+	    if (!getdata(node))
+		return;
+	} else {
+	    if (isset(SHFILEEXPANSION))
+		filesub((char **)getaddrdata(node), flags & 3);
+	    if (!(node = stringsubst(list, node, flags & 4)))
+		return;
+	}
+    }
+    for (node = firstnode(list); node; incnode(node)) {
+	if (*(char *)getdata(node)) {
+	    remnulargs(getdata(node));
+	    if (unset(IGNOREBRACES) && !(flags & 4))
+		while (hasbraces(getdata(node)))
+		    xpandbraces(list, &node);
+	    if (unset(SHFILEEXPANSION))
+		filesub((char **)getaddrdata(node), flags & 3);
+	} else if (!(flags & 4))
+	    uremnode(list, node);
+	if (errflag)
+	    return;
+    }
+}
+
+/**/
+static LinkNode
+stringsubst(LinkList list, LinkNode node, int ssub)
+{
+    int qt;
+    char *str3 = (char *)getdata(node);
+    char *str  = str3;
+
+    while (!errflag && *str) {
+	if ((qt = *str == Qstring) || *str == String)
+	    if (str[1] == Inpar) {
+		str++;
+		goto comsub;
+	    } else if (str[1] == Inbrack) {
+		/* $[...] */
+		char *str2 = str;
+		str2++;
+		if (skipparens(Inbrack, Outbrack, &str2)) {
+		    zerr("closing bracket missing", NULL, 0);
+		    return NULL;
+		}
+		str2[-1] = *str = '\0';
+		str = arithsubst(str + 2, &str3, str2);
+		setdata(node, (void *) str3);
+		continue;
+	    } else if (str[1] == Snull) {
+		str = getkeystring(str, NULL, 4, NULL);
+		continue;
+	    } else {
+		node = paramsubst(list, node, &str, qt, ssub);
+		if (errflag || !node)
+		    return NULL;
+		str3 = (char *)getdata(node);
+		continue;
+	    }
+	else if ((qt = *str == Qtick) || *str == Tick)
+	  comsub: {
+	    LinkList pl;
+	    char *s, *str2 = str;
+	    char endchar;
+	    int l1, l2;
+
+	    if (*str == Inpar) {
+		endchar = Outpar;
+		str[-1] = '\0';
+		if (skipparens(Inpar, Outpar, &str))
+		    DPUTS(1, "BUG: parse error in command substitution");
+		str--;
+	    } else {
+		endchar = *str;
+		*str = '\0';
+
+		while (*++str != endchar)
+		    DPUTS(!*str, "BUG: parse error in command substitution");
+	    }
+	    *str++ = '\0';
+	    if (endchar == Outpar && str2[1] == '(' && str[-2] == ')') {
+		/* Math substitution of the form $((...)) */
+		str = arithsubst(str2 + 1, &str3, str);
+		setdata(node, (void *) str3);
+		continue;
+	    }
+
+	    /* It is a command substitution, which will be parsed again   *
+	     * by the lexer, so we untokenize it first, but we cannot use *
+	     * untokenize() since in the case of `...` some Bnulls should *
+	     * be left unchanged.  Note that the lexer doesn't tokenize   *
+	     * the body of a command substitution so if there are some    *
+	     * tokens here they are from a ${(e)~...} substitution.       */
+	    for (str = str2; *++str; )
+		if (itok(*str) && *str != Nularg &&
+		    !(endchar != Outpar && *str == Bnull &&
+		      (str[1] == '$' || str[1] == '\\' || str[1] == '`' ||
+		       (qt && str[1] == '"'))))
+		    *str = ztokens[*str - Pound];
+	    str++;
+	    if (!(pl = getoutput(str2 + 1, qt || ssub))) {
+		zerr("parse error in command substitution", NULL, 0);
+		return NULL;
+	    }
+	    if (endchar == Outpar)
+		str2--;
+	    if (!(s = (char *) ugetnode(pl))) {
+		str = strcpy(str2, str);
+		continue;
+	    }
+	    if (!qt && ssub && isset(GLOBSUBST))
+		tokenize(s);
+	    l1 = str2 - str3;
+	    l2 = strlen(s);
+	    if (nonempty(pl)) {
+		LinkNode n = lastnode(pl);
+		str2 = (char *) ncalloc(l1 + l2 + 1);
+		strcpy(str2, str3);
+		strcpy(str2 + l1, s);
+		setdata(node, str2);
+		insertlinklist(pl, node, list);
+		s = (char *) getdata(node = n);
+		l1 = 0;
+		l2 = strlen(s);
+	    }
+	    str2 = (char *) ncalloc(l1 + l2 + strlen(str) + 1);
+	    if (l1)
+		strcpy(str2, str3);
+	    strcpy(str2 + l1, s);
+	    str = strcpy(str2 + l1 + l2, str);
+	    str3 = str2;
+	    setdata(node, str3);
+	    continue;
+	}
+	str++;
+    }
+    return errflag ? NULL : node;
+}
+
+/**/
+void
+globlist(LinkList list)
+{
+    LinkNode node, next;
+
+    badcshglob = 0;
+    for (node = firstnode(list); !errflag && node; node = next) {
+	next = nextnode(node);
+	glob(list, node);
+    }
+    if (badcshglob == 1)
+	zerr("no match", NULL, 0);
+}
+
+/* perform substitution on a single word */
+
+/**/
+void
+singsub(char **s)
+{
+    LinkList foo;
+
+    foo = newlinklist();
+    addlinknode(foo, *s);
+    prefork(foo, 4);
+    if (errflag)
+	return;
+    *s = (char *) ugetnode(foo);
+    DPUTS(nonempty(foo), "BUG: singsub() produced more than one word!");
+}
+
+/* Perform substitution on a single word. Unlike with singsub, the      *
+ * result can have more than one words. A single word result is sroted  *
+ * in *s and *isarr is set to zero; otherwise *isarr is set to 1 and    *
+ * the result is stored in *a. If `a' is zero a multiple word result is *
+ * joined using sep or the IFS parameter if sep is zero and the result  *
+ * is returned in *s.  The return value is true iff the expansion       *
+ * resulted in an empty list                                            */
+
+/**/
+static int
+multsub(char **s, char ***a, int *isarr, char *sep)
+{
+    LinkList foo;
+    int l;
+    char **r, **p;
+
+    foo = newlinklist();
+    addlinknode(foo, *s);
+    prefork(foo, 0);
+    if (errflag) {
+	if (isarr)
+	    *isarr = 0;
+	return 0;
+    }
+    if ((l = countlinknodes(foo)) > 1) {
+	p = r = ncalloc((l + 1) * sizeof(char*));
+	while (nonempty(foo))
+	    *p++ = (char *)ugetnode(foo);
+	*p = NULL;
+	if (a) {
+	    *a = r;
+	    *isarr = 1;
+	    return 0;
+	}
+	*s = sepjoin(r, NULL);
+	return 0;
+    }
+    if (l)
+	*s = (char *) ugetnode(foo);
+    else
+	*s = dupstring("");
+    if (isarr)
+	*isarr = 0;
+    return !l;
+}
+
+/* ~, = subs: assign = 2 => typeset; assign = 1 => something that looks
+	like an assignment but may not be; assign = 3 => normal assignment */
+
+/**/
+void
+filesub(char **namptr, int assign)
+{
+    char *sub = NULL, *str, *ptr;
+    int len;
+
+    filesubstr(namptr, assign);
+
+    if (!assign)
+	return;
+
+    if (assign < 3)
+	if ((*namptr)[1] && (sub = strchr(*namptr + 1, Equals))) {
+	    if (assign == 1)
+		for (ptr = *namptr; ptr != sub; ptr++)
+		    if (!iident(*ptr) && !INULL(*ptr))
+			return;
+	    str = sub + 1;
+	    if ((sub[1] == Tilde || sub[1] == Equals) && filesubstr(&str, assign)) {
+		sub[1] = '\0';
+		*namptr = dyncat(*namptr, str);
+	    }
+	} else
+	    return;
+
+    ptr = *namptr;
+    while ((sub = strchr(ptr, ':'))) {
+	str = sub + 1;
+	len = sub - *namptr;
+	if ((sub[1] == Tilde || sub[1] == Equals) && filesubstr(&str, assign)) {
+	    sub[1] = '\0';
+	    *namptr = dyncat(*namptr, str);
+	}
+	ptr = *namptr + len + 1;
+    }
+}
+
+/**/
+int
+filesubstr(char **namptr, int assign)
+{
+#define isend(c) ( !(c) || (c)=='/' || (c)==Inpar || (assign && (c)==':') )
+#define isend2(c) ( !(c) || (c)==Inpar || (assign && (c)==':') )
+    char *str = *namptr;
+
+    if (*str == Tilde && str[1] != '=' && str[1] != Equals) {
+	char *ptr;
+	int val;
+
+	val = zstrtol(str + 1, &ptr, 10);
+	if (isend(str[1])) {   /* ~ */
+	    *namptr = dyncat(home, str + 1);
+	    return 1;
+	} else if (str[1] == '+' && isend(str[2])) {   /* ~+ */
+	    *namptr = dyncat(pwd, str + 2);
+	    return 1;
+	} else if (str[1] == '-' && isend(str[2])) {   /* ~- */
+	    char *tmp;
+	    *namptr = dyncat((tmp = oldpwd) ? tmp : pwd, str + 2);
+	    return 1;
+	} else if (!inblank(str[1]) && isend(*ptr) &&
+		   (!idigit(str[1]) || (ptr - str < 4))) {
+	    char *ds;
+
+	    if (val < 0)
+		val = -val;
+	    ds = dstackent(str[1], val);
+	    if (!ds)
+		return 0;
+	    *namptr = dyncat(ds, ptr);
+	    return 1;
+	} else if (iuser(str[1])) {   /* ~foo */
+	    char *ptr, *hom, save;
+
+	    for (ptr = ++str; *ptr && iuser(*ptr); ptr++);
+	    save = *ptr;
+	    if (!isend(save))
+		return 0;
+	    *ptr = 0;
+	    if (!(hom = getnameddir(str))) {
+		if (isset(NOMATCH))
+		    zerr("no such user or named directory: %s", str, 0);
+		*ptr = save;
+		return 0;
+	    }
+	    *ptr = save;
+	    *namptr = dyncat(hom, ptr);
+	    return 1;
+	}
+    } else if (*str == Equals && isset(EQUALS) && str[1]) {   /* =foo */
+	char sav, *pp, *cnam;
+
+	for (pp = str + 1; !isend2(*pp); pp++);
+	sav = *pp;
+	*pp = 0;
+	if (!(cnam = findcmd(str + 1))) {
+	    Alias a = (Alias) aliastab->getnode(aliastab, str + 1);
+	    
+	    if (a)
+		cnam = ztrdup(a->text);
+	    else {
+		if (isset(NOMATCH))
+		    zerr("%s not found", str + 1, 0);
+		return 0;
+	    }
+	}
+	*namptr = dupstring(cnam);
+	zsfree(cnam);
+	if (sav) {
+	    *pp = sav;
+	    *namptr = dyncat(*namptr, pp);
+	}
+	return 1;
+    }
+    return 0;
+#undef isend
+#undef isend2
+}
+
+/**/
+static char *
+strcatsub(char **d, char *pb, char *pe, char *src, int l, char *s, int glbsub)
+{
+    int pl = pe - pb;
+    char *dest = ncalloc(pl + l + (s ? strlen(s) : 0) + 1);
+
+    *d = dest;
+    strncpy(dest, pb, pl);
+    dest += pl;
+    strcpy(dest, src);
+    if (glbsub)
+	tokenize(dest);
+    dest += l;
+    if (s)
+	strcpy(dest, s);
+    return dest;
+}
+
+typedef int (*CompareFn) _((const void *, const void *));
+
+/**/
+int
+strpcmp(const void *a, const void *b)
+{
+#ifdef HAVE_STRCOLL
+    return strcoll(*(char **)a, *(char **)b);
+#else
+    return strcmp(*(char **)a, *(char **)b);
+#endif
+}
+
+/**/
+int
+invstrpcmp(const void *a, const void *b)
+{
+#ifdef HAVE_STRCOLL
+    return -strcoll(*(char **)a, *(char **)b);
+#else
+    return -strcmp(*(char **)a, *(char **)b);
+#endif
+}
+
+/**/
+int
+cstrpcmp(const void *a, const void *b)
+{
+#ifdef HAVE_STRCOLL
+    VARARR(char, c, strlen(*(char **) a) + 1);
+    VARARR(char, d, strlen(*(char **) b) + 1);
+    char *s, *t;
+    int   cmp;
+
+    for (s = *(char **) a, t = c; (*t++ = tulower(*s++)););
+    for (s = *(char **) b, t = d; (*t++ = tulower(*s++)););
+
+    cmp = strcoll(c, d);
+
+    return cmp;
+#else
+    char *c = *(char **)a, *d = *(char **)b;
+
+    for (; *c && tulower(*c) == tulower(*d); c++, d++);
+
+    return (int)STOUC(tulower(*c)) - (int)STOUC(tulower(*d));
+#endif
+}
+
+/**/
+int
+invcstrpcmp(const void *a, const void *b)
+{
+#ifdef HAVE_STRCOLL
+    VARARR(char, c, strlen(*(char **) a) + 1);
+    VARARR(char, d, strlen(*(char **) b) + 1);
+    char *s, *t;
+    int   cmp;
+
+    for (s = *(char **) a, t = c; (*t++ = tulower(*s++)););
+    for (s = *(char **) b, t = d; (*t++ = tulower(*s++)););
+
+    cmp = strcoll(c, d);
+
+    return -cmp;
+#else
+    char *c = *(char **)a, *d = *(char **)b;
+
+    for (; *c && tulower(*c) == tulower(*d); c++, d++);
+
+    return (int)STOUC(tulower(*d)) - (int)STOUC(tulower(*c));
+#endif
+}
+
+/**/
+static char *
+dopadding(char *str, int prenum, int postnum, char *preone, char *postone, char *premul, char *postmul)
+{
+    char def[3], *ret, *t, *r;
+    int ls, ls2, lpreone, lpostone, lpremul, lpostmul, lr, f, m, c, cc;
+
+    def[0] = *ifs ? *ifs : ' ';
+    def[1] = *ifs == Meta ? ifs[1] ^ 32 : '\0';
+    def[2] = '\0';
+    if (preone && !*preone)
+	preone = def;
+    if (postone && !*postone)
+	postone = def;
+    if (!premul || !*premul)
+	premul = def;
+    if (!postmul || !*postmul)
+	postmul = def;
+
+    ls = strlen(str);
+    lpreone = preone ? strlen(preone) : 0;
+    lpostone = postone ? strlen(postone) : 0;
+    lpremul = strlen(premul);
+    lpostmul = strlen(postmul);
+
+    lr = prenum + postnum;
+
+    if (lr == ls)
+	return str;
+
+    r = ret = (char *)halloc(lr + 1);
+
+    if (prenum) {
+	if (postnum) {
+	    ls2 = ls / 2;
+
+	    f = prenum - ls2;
+	    if (f <= 0)
+		for (str -= f, c = prenum; c--; *r++ = *str++);
+	    else {
+		if (f <= lpreone)
+		    for (c = f, t = preone + lpreone - f; c--; *r++ = *t++);
+		else {
+		    f -= lpreone;
+		    if ((m = f % lpremul))
+			for (c = m, t = premul + lpremul - m; c--; *r++ = *t++);
+		    for (cc = f / lpremul; cc--;)
+			for (c = lpremul, t = premul; c--; *r++ = *t++);
+		    for (c = lpreone; c--; *r++ = *preone++);
+		}
+		for (c = ls2; c--; *r++ = *str++);
+	    }
+	    ls2 = ls - ls2;
+	    f = postnum - ls2;
+	    if (f <= 0)
+		for (c = postnum; c--; *r++ = *str++);
+	    else {
+		for (c = ls2; c--; *r++ = *str++);
+		if (f <= lpostone)
+		    for (c = f; c--; *r++ = *postone++);
+		else {
+		    f -= lpostone;
+		    for (c = lpostone; c--; *r++ = *postone++);
+		    for (cc = f / lpostmul; cc--;)
+			for (c = lpostmul, t = postmul; c--; *r++ = *t++);
+		    if ((m = f % lpostmul))
+			for (; m--; *r++ = *postmul++);
+		}
+	    }
+	} else {
+	    f = prenum - ls;
+	    if (f <= 0)
+		for (c = prenum, str -= f; c--; *r++ = *str++);
+	    else {
+		if (f <= lpreone)
+		    for (c = f, t = preone + lpreone - f; c--; *r++ = *t++);
+		else {
+		    f -= lpreone;
+		    if ((m = f % lpremul))
+			for (c = m, t = premul + lpremul - m; c--; *r++ = *t++);
+		    for (cc = f / lpremul; cc--;)
+			for (c = lpremul, t = premul; c--; *r++ = *t++);
+		    for (c = lpreone; c--; *r++ = *preone++);
+		}
+		for (c = ls; c--; *r++ = *str++);
+	    }
+	}
+    } else if (postnum) {
+	f = postnum - ls;
+	if (f <= 0)
+	    for (c = postnum; c--; *r++ = *str++);
+	else {
+	    for (c = ls; c--; *r++ = *str++);
+	    if (f <= lpostone)
+		for (c = f; c--; *r++ = *postone++);
+	    else {
+		f -= lpostone;
+		for (c = lpostone; c--; *r++ = *postone++);
+		for (cc = f / lpostmul; cc--;)
+		    for (c = lpostmul, t = postmul; c--; *r++ = *t++);
+		if ((m = f % lpostmul))
+		    for (; m--; *r++ = *postmul++);
+	    }
+	}
+    }
+    *r = '\0';
+
+    return ret;
+}
+
+/**/
+char *
+get_strarg(char *s)
+{
+    char t = *s++;
+
+    if (!t)
+	return s - 1;
+
+    switch (t) {
+    case '(':
+	t = ')';
+	break;
+    case '[':
+	t = ']';
+	break;
+    case '{':
+	t = '}';
+	break;
+    case '<':
+	t = '>';
+	break;
+    case Inpar:
+	t = Outpar;
+	break;
+    case Inang:
+	t = Outang;
+	break;
+    case Inbrace:
+	t = Outbrace;
+	break;
+    case Inbrack:
+	t = Outbrack;
+	break;
+    }
+
+    while (*s && *s != t)
+	s++;
+
+    return s;
+}
+
+/**/
+static int
+get_intarg(char **s)
+{
+    char *t = get_strarg(*s + 1);
+    char *p, sav;
+    long ret;
+
+    if (!*t)
+	return -1;
+    sav = *t;
+    *t = '\0';
+    p = dupstring(*s + 2);
+    *s = t;
+    *t = sav;
+    if (parsestr(p))
+	return -1;
+    singsub(&p);
+    if (errflag)
+	return -1;
+    ret = matheval(p);
+    if (errflag)
+	return -1;
+    if (ret < 0)
+	ret = -ret;
+    return ret < 0 ? -ret : ret;
+}
+
+/* parameter substitution */
+
+#define	isstring(c) ((c) == '$' || (char)(c) == String || (char)(c) == Qstring)
+#define isbrack(c)  ((c) == '[' || (char)(c) == Inbrack)
+
+/**/
+LinkNode
+paramsubst(LinkList l, LinkNode n, char **str, int qt, int ssub)
+{
+    char *aptr = *str;
+    char *s = aptr, *fstr, *idbeg, *idend, *ostr = (char *) getdata(n);
+    int colf;			/* != 0 means we found a colon after the name */
+    int doub = 0;		/* != 0 means we have %%, not %, or ##, not # */
+    int isarr = 0;
+    int plan9 = isset(RCEXPANDPARAM);
+    int globsubst = isset(GLOBSUBST);
+    int getlen = 0;
+    int whichlen = 0;
+    int chkset = 0;
+    int vunset = 0;
+    int spbreak = isset(SHWORDSPLIT) && !ssub && !qt;
+    char *val = NULL, **aval = NULL;
+    unsigned int fwidth = 0;
+    Value v;
+    int flags = 0;
+    int flnum = 0;
+    int substr = 0;
+    int sortit = 0, casind = 0;
+    int casmod = 0;
+    char *sep = NULL, *spsep = NULL;
+    char *premul = NULL, *postmul = NULL, *preone = NULL, *postone = NULL;
+    long prenum = 0, postnum = 0;
+    int copied = 0;
+    int arrasg = 0;
+    int eval = 0;
+    int nojoin = 0;
+    char inbrace = 0;		/* != 0 means ${...}, otherwise $... */
+
+    *s++ = '\0';
+    if (!ialnum(*s) && *s != '#' && *s != Pound && *s != '-' &&
+	*s != '!' && *s != '$' && *s != String && *s != Qstring &&
+	*s != '?' && *s != Quest && *s != '_' &&
+	*s != '*' && *s != Star && *s != '@' && *s != '{' &&
+	*s != Inbrace && *s != '=' && *s != Equals && *s != Hat &&
+	*s != '^' && *s != '~' && *s != Tilde && *s != '+') {
+	s[-1] = '$';
+	*str = s;
+	return n;
+    }
+    DPUTS(*s == '{', "BUG: inbrace == '{' in paramsubst()");
+    if (*s == Inbrace) {
+	inbrace = 1;
+	s++;
+	if (*s == '(' || *s == Inpar) {
+	    char *t, sav;
+	    int tt = 0;
+	    long num;
+	    int escapes = 0;
+	    int klen;
+#define UNTOK_AND_ESCAPE(X) {\
+		untokenize(X = dupstring(s + 1));\
+		if (escapes) {\
+		    X = getkeystring(X, &klen, 3, NULL);\
+		    X = metafy(X, klen, META_HREALLOC);\
+		}\
+	    }
+
+	    for (s++; *s != ')' && *s != Outpar; s++, tt = 0) {
+		switch (*s) {
+		case ')':
+		case Outpar:
+		    break;
+		case 'A':
+		    arrasg = 1;
+		    break;
+		case '@':
+		    nojoin = 1;
+		    break;
+		case 'M':
+		    flags |= 8;
+		    break;
+		case 'R':
+		    flags |= 16;
+		    break;
+		case 'B':
+		    flags |= 32;
+		    break;
+		case 'E':
+		    flags |= 64;
+		    break;
+		case 'N':
+		    flags |= 128;
+		    break;
+		case 'S':
+		    substr = 1;
+		    break;
+		case 'I':
+		    flnum = get_intarg(&s);
+		    if (flnum < 0)
+			goto flagerr;
+		    break;
+
+		case 'L':
+		    casmod = 2;
+		    break;
+		case 'U':
+		    casmod = 1;
+		    break;
+		case 'C':
+		    casmod = 3;
+		    break;
+
+		case 'o':
+		    sortit = 1;
+		    break;
+		case 'O':
+		    sortit = 2;
+		    break;
+		case 'i':
+		    casind = 1;
+		    break;
+		case 'e':
+		    eval = 1;
+		    break;
+
+		case 'c':
+		    whichlen = 1;
+		    break;
+		case 'w':
+		    whichlen = 2;
+		    break;
+		case 'W':
+		    whichlen = 3;
+		    break;
+
+		case 'f':
+		    spsep = "\n";
+		    break;
+		case 'F':
+		    sep = "\n";
+		    break;
+
+		case 's':
+		    tt = 1;
+		/* fall through */
+		case 'j':
+		    t = get_strarg(++s);
+		    if (*t) {
+			sav = *t;
+			*t = '\0';
+			if (tt)
+			    UNTOK_AND_ESCAPE(spsep)
+			else
+			    UNTOK_AND_ESCAPE(sep)
+			*t = sav;
+			s = t;
+		    } else
+			goto flagerr;
+		    break;
+
+		case 'l':
+		    tt = 1;
+		/* fall through */
+		case 'r':
+		    sav = s[1];
+		    num = get_intarg(&s);
+		    if (num < 0)
+			goto flagerr;
+		    if (tt)
+			prenum = num;
+		    else
+			postnum = num;
+		    if (s[1] != sav)
+			break;
+		    t = get_strarg(++s);
+		    if (!*t)
+			goto flagerr;
+		    sav = *t;
+		    *t = '\0';
+		    if (tt)
+			UNTOK_AND_ESCAPE(premul)
+		    else
+			UNTOK_AND_ESCAPE(postmul)
+		    *t = sav;
+		    sav = *s;
+		    s = t + 1;
+		    if (*s != sav) {
+			s--;
+			break;
+		    }
+		    t = get_strarg(s);
+		    if (!*t)
+			goto flagerr;
+		    sav = *t;
+		    *t = '\0';
+		    if (tt)
+			UNTOK_AND_ESCAPE(preone)
+		    else
+			UNTOK_AND_ESCAPE(postone)
+		    *t = sav;
+		    s = t;
+		    break;
+
+		case 'p':
+		    escapes = 1;
+		    break;
+
+		default:
+		  flagerr:
+		    zerr("error in flags", NULL, 0);
+		    return NULL;
+		}
+	    }
+	    s++;
+	}
+    }
+    if (sortit)
+	sortit += (casind << 1);
+
+    if (!premul)
+	premul = " ";
+    if (!postmul)
+	postmul = " ";
+
+    for (;;) {
+	if (*s == '^' || *s == Hat) {
+	    if (*++s == '^' || *s == Hat) {
+		plan9 = 0;
+		s++;
+	    } else
+		plan9 = 1;
+	} else if (*s == '=' || *s == Equals) {
+	    if (*++s == '=' || *s == Equals) {
+		spbreak = 0;
+		s++;
+	    } else
+		spbreak = 1;
+	} else if ((*s == '#' || *s == Pound) &&
+		   (iident(s[1])
+		    || s[1] == '*' || s[1] == Star || s[1] == '@'
+		    || (isstring(s[1]) && (s[2] == Inbrace || s[2] == Inpar))))
+	    getlen = 1 + whichlen, s++;
+	else if (*s == '~' || *s == Tilde) {
+	    if (*++s == '~' || *s == Tilde) {
+		globsubst = 0;
+		s++;
+	    } else
+		globsubst = 1;
+	} else if (*s == '+')
+	    if (iident(s[1]))
+		chkset = 1, s++;
+	    else if (!inbrace) {
+		*aptr = '$';
+		*str = aptr + 1;
+		return n;
+	    } else {
+		zerr("bad substitution", NULL, 0);
+		return NULL;
+	    }
+	else
+	    break;
+    }
+    globsubst = globsubst && !qt;
+
+    idbeg = s;
+    if (s[-1] && isstring(*s) && (s[1] == Inbrace || s[1] == Inpar)) {
+	int sav;
+	int quoted = *s == Qstring;
+
+	val = s++;
+	skipparens(*s, *s == Inpar ? Outpar : Outbrace, &s);
+	sav = *s;
+	*s = 0;
+	if (multsub(&val, &aval, &isarr, NULL) && quoted) {
+	    isarr = -1;
+	    aval = alloc(sizeof(char *));
+	}
+	if (isarr)
+	    isarr = -1;
+	copied = 1;
+	*s = sav;
+	v = (Value) NULL;
+    } else if (!(v = getvalue(&s, (unset(KSHARRAYS) || inbrace) ? 1 : -1)))
+	vunset = 1;
+    while (v || ((inbrace || (unset(KSHARRAYS) && vunset)) && isbrack(*s))) {
+	if (!v) {
+	    Param pm;
+	    char *os = s;
+
+	    if (!isbrack(*s))
+		break;
+	    if (vunset) {
+		val = dupstring("");
+		isarr = 0;
+	    }
+	    pm = createparam(nulstring, isarr ? PM_ARRAY : PM_SCALAR);
+	    if (isarr)
+		pm->u.arr = aval;
+	    else
+		pm->u.str = val;
+	    v = (Value) hcalloc(sizeof *v);
+	    v->isarr = isarr;
+	    v->pm = pm;
+	    v->b = -1;
+	    if (getindex(&s, v) || s == os)
+		break;
+	}
+	if ((isarr = v->isarr))
+	    aval = getarrvalue(v);
+	else {
+	    if (v->pm->flags & PM_ARRAY) {
+		int tmplen = arrlen(v->pm->gets.afn(v->pm));
+
+		if (v->a < 0)
+		    v->a += tmplen + v->inv;
+		if (!v->inv && (v->a >= tmplen || v->a < 0))
+		    vunset = 1;
+	    }
+	    if (!vunset) {
+		val = getstrvalue(v);
+		fwidth = v->pm->ct ? v->pm->ct : strlen(val);
+		switch (v->pm->flags & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z)) {
+		    char *t;
+		    unsigned int t0;
+
+		case PM_LEFT:
+		case PM_LEFT | PM_RIGHT_Z:
+		    t = val;
+		    if (v->pm->flags & PM_RIGHT_Z)
+			while (*t == '0')
+			    t++;
+		    else
+			while (iblank(*t))
+			    t++;
+		    val = (char *)ncalloc(fwidth + 1);
+		    val[fwidth] = '\0';
+		    if ((t0 = strlen(t)) > fwidth)
+			t0 = fwidth;
+		    memset(val, ' ', fwidth);
+		    strncpy(val, t, t0);
+		    break;
+		case PM_RIGHT_B:
+		case PM_RIGHT_Z:
+		case PM_RIGHT_Z | PM_RIGHT_B:
+		    if (strlen(val) < fwidth) {
+			t = (char *)ncalloc(fwidth + 1);
+			memset(t, (v->pm->flags & PM_RIGHT_B) ? ' ' : '0', fwidth);
+			if ((t0 = strlen(val)) > fwidth)
+			    t0 = fwidth;
+			strcpy(t + (fwidth - t0), val);
+			val = t;
+		    } else {
+			t = (char *)ncalloc(fwidth + 1);
+			t[fwidth] = '\0';
+			strncpy(t, val + strlen(val) - fwidth, fwidth);
+			val = t;
+		    }
+		    break;
+		}
+		switch (v->pm->flags & (PM_LOWER | PM_UPPER)) {
+		    char *t;
+
+		case PM_LOWER:
+		    t = val;
+		    for (; *t; t++)
+			*t = tulower(*t);
+		    break;
+		case PM_UPPER:
+		    t = val;
+		    for (; *t; t++)
+			*t = tuupper(*t);
+		    break;
+		}
+	    }
+	}
+	v = NULL;
+	if (!inbrace)
+	    break;
+    }
+    if (isarr) {
+	if (nojoin)
+	    isarr = -1;
+	if (qt && !getlen && isarr > 0) {
+	    val = sepjoin(aval, sep);
+	    isarr = 0;
+	}
+    }
+
+    idend = s;
+    if ((colf = *s == ':'))
+	s++;
+
+
+    /* fstr is to be the text following the substitution.  If we have *
+     * braces, we look for it here, else we infer it later on.        */
+    fstr = s;
+    if (inbrace) {
+	int bct;
+	for (bct = 1;; fstr++) {
+	    if (!*fstr)
+		break;
+	    else if (*fstr == Inbrace)
+		bct++;
+	    else if (*fstr == Outbrace && !--bct)
+		break;
+	}
+
+	if (bct) {
+	noclosebrace:
+	    zerr("closing brace expected", NULL, 0);
+	    return NULL;
+	}
+	if (*fstr)
+	    *fstr++ = '\0';
+    }
+
+    /* Check for ${..?..} or ${..=..} or one of those. *
+     * Only works if the name is in braces.            */
+
+    if (inbrace && (*s == '-' ||
+		    *s == '+' ||
+		    *s == ':' ||
+		    *s == '=' || *s == Equals ||
+		    *s == '%' ||
+		    *s == '#' || *s == Pound ||
+		    *s == '?' || *s == Quest)) {
+
+	if (!flnum)
+	    flnum++;
+	if (*s == '%')
+	    flags |= 1;
+
+	/* Check for ${..%%..} or ${..##..} */
+	if ((*s == '%' || *s == '#' || *s == Pound) && *s == s[1]) {
+	    s++;
+	    doub = 1;
+	}
+	s++;
+
+	flags |= (doub << 1) | (substr << 2) | (colf << 8);
+	if (!(flags & 0xf8))
+	    flags |= 16;
+
+	if (colf && !vunset)
+	    vunset = (isarr) ? !*aval : !*val || (*val == Nularg && !val[1]);
+
+	switch (s[-1]) {
+	case '+':
+	    if (vunset) {
+		val = dupstring("");
+		copied = 1;
+		isarr = 0;
+		break;
+	    }
+	    vunset = 1;
+	/* Fall Through! */
+	case '-':
+	    if (vunset) {
+		val = dupstring(s);
+		multsub(&val, &aval, &isarr, NULL);
+		copied = 1;
+	    }
+	    break;
+	case ':':
+	    if (*s != '=' && *s != Equals)
+		goto noclosebrace;
+	    vunset = 1;
+	    s++;
+	    /* Fall through */
+	case '=':
+	case Equals:
+	    if (vunset) {
+		char sav = *idend;
+		int l;
+
+		*idend = '\0';
+		val = dupstring(s);
+		isarr = 0;
+		if (spsep || spbreak || !arrasg)
+		    multsub(&val, NULL, NULL, sep);
+		else
+		    multsub(&val, &aval, &isarr, NULL);
+		if (arrasg) {
+		    char *arr[2], **t, **a, **p;
+		    if (spsep || spbreak) {
+			aval = sepsplit(val, spsep, 0);
+			isarr = 2;
+			sep = spsep = NULL;
+			spbreak = 0;
+			l = arrlen(aval);
+			if (l && !*(aval[l-1]))
+			    l--;
+			if (l && !**aval)
+			    l--, t = aval + 1;
+			else
+			    t = aval;
+		    } else if (!isarr) {
+			arr[0] = val;
+			arr[1] = NULL;
+			t = aval = arr;
+			l = 1;
+		    } else
+			l = arrlen(aval), t = aval;
+		    p = a = zalloc(sizeof(char *) * (l + 1));
+		    while (l--) {
+			untokenize(*t);
+			*p++ = ztrdup(*t++);
+		    }
+		    *p++ = NULL;
+		    setaparam(idbeg, a);
+		} else {
+		    untokenize(val);
+		    setsparam(idbeg, ztrdup(val));
+		}
+		*idend = sav;
+		copied = 1;
+	    }
+	    break;
+	case '?':
+	case Quest:
+	    if (vunset) {
+		char *msg;
+
+		*idend = '\0';
+		msg = tricat(idbeg, ": ", *s ? s : "parameter not set");
+		zerr("%s", msg, 0);
+		zsfree(msg);
+		if (!interact)
+		    exit(1);
+		return NULL;
+	    }
+	    break;
+	case '%':
+	case '#':
+	case Pound:
+	    if (qt)
+		if (parse_subst_string(s)) {
+		    zerr("parse error in ${...%c...} substitution",
+			 NULL, s[-1]);
+		    return NULL;
+		}
+	    singsub(&s);
+
+	    if (!vunset && isarr) {
+		char **ap = aval;
+		char **pp = aval = (char **)ncalloc(sizeof(char *) * (arrlen(aval) + 1));
+
+		while ((*pp = *ap++)) {
+		    if (getmatch(pp, s, flags, flnum))
+			pp++;
+		}
+		copied = 1;
+	    } else {
+		if (vunset)
+		    val = dupstring("");
+		getmatch(&val, s, flags, flnum);
+		copied = 1;
+	    }
+	    break;
+	}
+    } else {			/* no ${...=...} or anything, but possible modifiers. */
+	if (chkset) {
+	    val = dupstring(vunset ? "0" : "1");
+	    isarr = 0;
+	} else if (vunset) {
+	    if (unset(UNSET)) {
+		*idend = '\0';
+		zerr("%s: parameter not set", idbeg, 0);
+		return NULL;
+	    }
+	    val = dupstring("");
+	}
+	if (colf) {
+	    s--;
+	    if (unset(KSHARRAYS) || inbrace) {
+		if (!isarr)
+		    modify(&val, &s);
+		else {
+		    char *ss;
+		    char **ap = aval;
+		    char **pp = aval = (char **)ncalloc(sizeof(char *) * (arrlen(aval) + 1));
+
+		    while ((*pp = *ap++)) {
+			ss = s;
+			modify(pp++, &ss);
+		    }
+		    if (pp == aval) {
+			char *t = "";
+			ss = s;
+			modify(&t, &ss);
+		    }
+		    s = ss;
+		}
+		if (inbrace && *s) {
+		    if (*s == ':' && !imeta(s[1]))
+			zerr("unrecognized modifier `%c'", NULL, s[1]);
+		    else
+			zerr("unrecognized modifier", NULL, 0);
+		    return NULL;
+		}
+	    }
+	}
+	if (!inbrace)
+	    fstr = s;
+    }
+    if (errflag)
+	return NULL;
+    if (getlen) {
+	long len = 0;
+	char buf[14];
+
+	if (isarr) {
+	    char **ctr;
+	    int sl = sep ? ztrlen(sep) : 1;
+
+	    if (getlen == 1)
+		for (ctr = aval; *ctr; ctr++, len++);
+	    else if (getlen == 2) {
+		if (*aval)
+		    for (len = -sl, ctr = aval;
+			 len += sl + ztrlen(*ctr), *++ctr;);
+	    }
+	    else
+		for (ctr = aval;
+		     *ctr;
+		     len += wordcount(*ctr, spsep, getlen > 3), ctr++);
+	} else {
+	    if (getlen < 3)
+		len = ztrlen(val);
+	    else
+		len = wordcount(val, spsep, getlen > 3);
+	}
+
+	sprintf(buf, "%ld", len);
+	val = dupstring(buf);
+	isarr = 0;
+    }
+    if (isarr > 0 && !plan9 && (!aval || !aval[0])) {
+	val = dupstring("");
+	isarr = 0;
+    } else if (isarr && aval && aval[0] && !aval[1]) {
+	val = aval[0];
+	isarr = 0;
+    }
+    /* ssub is true when we are called from singsub (via prefork).
+     * It means that we must join arrays and should not split words. */
+    if (ssub || spbreak || spsep || sep) {
+	if (isarr)
+	    val = sepjoin(aval, sep), isarr = 0;
+	if (!ssub && (spbreak || spsep)) {
+	    aval = sepsplit(val, spsep, 0);
+	    if (!aval || !aval[0])
+		val = dupstring("");
+	    else if (!aval[1])
+		val = aval[0];
+	    else
+		isarr = 2;
+	}
+    }
+    if (casmod) {
+	if (isarr) {
+	    char **ap;
+
+	    if (!copied)
+		aval = arrdup(aval), copied = 1;
+	    ap = aval;
+
+	    if (casmod == 1)
+		for (; *ap; ap++)
+		    makeuppercase(ap);
+	    else if (casmod == 2)
+		for (; *ap; ap++)
+		    makelowercase(ap);
+	    else
+		for (; *ap; ap++)
+		    makecapitals(ap);
+
+	} else {
+	    if (!copied)
+		val = dupstring(val), copied = 1;
+	    if (casmod == 1)
+		makeuppercase(&val);
+	    else if (casmod == 2)
+		makelowercase(&val);
+	    else
+		makecapitals(&val);
+	}
+    }
+    if (isarr) {
+	char *x;
+	char *y;
+	int xlen;
+	int i;
+	LinkNode on = n;
+
+	if (!aval[0] && !plan9) {
+	    if (aptr > (char *) getdata(n) &&
+		aptr[-1] == Dnull && *fstr == Dnull)
+		*--aptr = '\0', fstr++;
+	    y = (char *)ncalloc((aptr - ostr) + strlen(fstr) + 1);
+	    strcpy(y, ostr);
+	    *str = y + (aptr - ostr);
+	    strcpy(*str, fstr);
+	    setdata(n, y);
+	    return n;
+	}
+	if (sortit) {
+	    static CompareFn sortfn[] = {
+		strpcmp, invstrpcmp, cstrpcmp, invcstrpcmp
+	    };
+
+	    if (!copied)
+		aval = arrdup(aval);
+
+	    i = arrlen(aval);
+	    if (i && (*aval[i-1] || --i))
+		qsort(aval, i, sizeof(char *), sortfn[sortit-1]);
+	}
+	if (plan9) {
+	    LinkList tl = newlinklist();
+	    LinkNode tn;
+
+	    *--fstr = Marker;
+	    addlinknode(tl, fstr);
+	    if (!eval && !stringsubst(tl, firstnode(tl), ssub))
+		return NULL;
+	    *str = aptr;
+	    tn = firstnode(tl);
+	    while ((x = *aval++)) {
+		if (prenum || postnum)
+		    x = dopadding(x, prenum, postnum, preone, postone,
+				  premul, postmul);
+		if (eval && parsestr(x))
+		    return NULL;
+		xlen = strlen(x);
+		for (tn = firstnode(tl);
+		     tn && *(y = (char *) getdata(tn)) == Marker;
+		     incnode(tn)) {
+		    strcatsub(&y, ostr, aptr, x, xlen, y + 1, globsubst);
+		    if (qt && !*y && isarr != 2)
+			y = dupstring(nulstring);
+		    if (plan9)
+			setdata(n, (void *) y), plan9 = 0;
+		    else
+			insertlinknode(l, n, (void *) y), incnode(n);
+		}
+	    }
+	    for (; tn; incnode(tn)) {
+		y = (char *) getdata(tn);
+		if (*y == Marker)
+		    continue;
+		if (qt && !*y && isarr != 2)
+		    y = dupstring(nulstring);
+		if (plan9)
+		    setdata(n, (void *) y), plan9 = 0;
+		else
+		    insertlinknode(l, n, (void *) y), incnode(n);
+	    }
+	    if (plan9) {
+		uremnode(l, n);
+		return n;
+	    }
+	} else {
+	    x = aval[0];
+	    if (prenum || postnum)
+		x = dopadding(x, prenum, postnum, preone, postone,
+			      premul, postmul);
+	    if (eval && parsestr(x))
+		return NULL;
+	    xlen = strlen(x);
+	    strcatsub(&y, ostr, aptr, x, xlen, NULL, globsubst);
+	    if (qt && !*y && isarr != 2)
+		y = dupstring(nulstring);
+	    setdata(n, (void *) y);
+
+	    i = 1;
+	    /* aval[1] is non-null here */
+	    while (aval[i + 1]) {
+		x = aval[i++];
+		if (prenum || postnum)
+		    x = dopadding(x, prenum, postnum, preone, postone,
+				  premul, postmul);
+		if (eval && parsestr(x))
+		    return NULL;
+		if (qt && !*x && isarr != 2)
+		    y = dupstring(nulstring);
+		else {
+		    y = dupstring(x);
+		    if (globsubst)
+			tokenize(y);
+		}
+		insertlinknode(l, n, (void *) y), incnode(n);
+	    }
+
+	    x = aval[i];
+	    if (prenum || postnum)
+		x = dopadding(x, prenum, postnum, preone, postone,
+			      premul, postmul);
+	    if (eval && parsestr(x))
+		return NULL;
+	    xlen = strlen(x);
+	    *str = strcatsub(&y, aptr, aptr, x, xlen, fstr, globsubst);
+	    if (qt && !*y && isarr != 2)
+		y = dupstring(nulstring);
+	    insertlinknode(l, n, (void *) y), incnode(n);
+	}
+	if (eval)
+	    n = on;
+    } else {
+	int xlen;
+	char *x;
+	char *y;
+
+	x = val;
+	if (prenum || postnum)
+	    x = dopadding(x, prenum, postnum, preone, postone,
+			  premul, postmul);
+	if (eval && parsestr(x))
+	    return NULL;
+	xlen = strlen(x);
+	*str = strcatsub(&y, ostr, aptr, x, xlen, fstr, globsubst);
+	if (qt && !*y && isarr != 2)
+	    y = dupstring(nulstring);
+	setdata(n, (void *) y);
+    }
+    if (eval)
+	*str = (char *) getdata(n);
+
+    return n;
+}
+
+/*
+ * Arithmetic substitution: `a' is the string to be evaluated, `bptr'
+ * points to the beginning of the string containing it.  The tail of
+ * the string is given by `rest'. *bptr is modified with the substituted
+ * string. The function returns a pointer to the tail in the substituted
+ * string.
+ */
+
+/**/
+static char *
+arithsubst(char *a, char **bptr, char *rest)
+{
+    char *s = *bptr, *t, buf[DIGBUFSIZE];
+    char *b = buf;
+    long v;
+
+    singsub(&a);
+    v = matheval(a);
+    sprintf(buf, "%ld", v);
+    t = *bptr = (char *)ncalloc(strlen(*bptr) + strlen(buf) + strlen(rest) + 1);
+    t--;
+    while ((*++t = *s++));
+    t--;
+    while ((*++t = *b++));
+    strcat(t, rest);
+    return t;
+}
+
+/**/
+void
+modify(char **str, char **ptr)
+{
+    char *ptr1, *ptr2, *ptr3, del, *lptr, c, *test, *sep, *t, *tt, tc, *e;
+    char *copy, *all, *tmp, sav;
+    int gbal, wall, rec, al, nl;
+
+    test = NULL;
+
+    if (**ptr == ':')
+	*str = dupstring(*str);
+
+    while (**ptr == ':') {
+	lptr = *ptr;
+	(*ptr)++;
+	wall = gbal = 0;
+	rec = 1;
+	c = '\0';
+	sep = NULL;
+
+	for (; !c && **ptr;) {
+	    switch (**ptr) {
+	    case 'h':
+	    case 'r':
+	    case 'e':
+	    case 't':
+	    case 'l':
+	    case 'u':
+		c = **ptr;
+		break;
+
+	    case 's':
+		c = **ptr;
+		(*ptr)++;
+		ptr1 = *ptr;
+		del = *ptr1++;
+		for (ptr2 = ptr1; *ptr2 != del && *ptr2; ptr2++);
+		if (!*ptr2) {
+		    zerr("bad substitution", NULL, 0);
+		    return;
+		}
+		*ptr2++ = '\0';
+		for (ptr3 = ptr2; *ptr3 != del && *ptr3; ptr3++);
+		if ((sav = *ptr3))
+		    *ptr3++ = '\0';
+		if (*ptr1) {
+		    zsfree(hsubl);
+		    hsubl = ztrdup(ptr1);
+		}
+		if (!hsubl) {
+		    zerr("no previous substitution", NULL, 0);
+		    return;
+		}
+		zsfree(hsubr);
+		for (tt = hsubl; *tt; tt++)
+		    if (INULL(*tt))
+			chuck(tt--);
+		untokenize(hsubl);
+		for (tt = hsubr = ztrdup(ptr2); *tt; tt++)
+		    if (INULL(*tt))
+			chuck(tt--);
+		ptr2[-1] = del;
+		if (sav)
+		    ptr3[-1] = sav;
+		*ptr = ptr3 - 1;
+		break;
+
+	    case '&':
+		c = 's';
+		break;
+
+	    case 'g':
+		(*ptr)++;
+		gbal = 1;
+		break;
+
+	    case 'w':
+		wall = 1;
+		(*ptr)++;
+		break;
+	    case 'W':
+		wall = 1;
+		(*ptr)++;
+		ptr1 = get_strarg(ptr2 = *ptr);
+		if ((sav = *ptr1))
+		    *ptr1 = '\0';
+		sep = dupstring(ptr2 + 1);
+		if (sav)
+		    *ptr1 = sav;
+		*ptr = ptr1 + 1;
+		c = '\0';
+		break;
+
+	    case 'f':
+		rec = -1;
+		(*ptr)++;
+		break;
+	    case 'F':
+		rec = get_intarg(ptr);
+		(*ptr)++;
+		break;
+	    default:
+		*ptr = lptr;
+		return;
+	    }
+	}
+	(*ptr)++;
+	if (!c) {
+	    *ptr = lptr;
+	    return;
+	}
+	if (rec < 0)
+	    test = dupstring(*str);
+
+	while (rec--) {
+	    if (wall) {
+		al = 0;
+		all = NULL;
+		for (t = e = *str; (tt = findword(&e, sep));) {
+		    tc = *e;
+		    *e = '\0';
+		    copy = dupstring(tt);
+		    *e = tc;
+		    switch (c) {
+		    case 'h':
+			remtpath(&copy);
+			break;
+		    case 'r':
+			remtext(&copy);
+			break;
+		    case 'e':
+			rembutext(&copy);
+			break;
+		    case 't':
+			remlpaths(&copy);
+			break;
+		    case 'l':
+			downcase(&copy);
+			break;
+		    case 'u':
+			upcase(&copy);
+			break;
+		    case 's':
+			if (hsubl && hsubr)
+			    subst(&copy, hsubl, hsubr, gbal);
+			break;
+		    }
+		    tc = *tt;
+		    *tt = '\0';
+		    nl = al + strlen(t) + strlen(copy);
+		    ptr1 = tmp = (char *)halloc(nl + 1);
+		    if (all)
+			for (ptr2 = all; *ptr2;)
+			    *ptr1++ = *ptr2++;
+		    for (ptr2 = t; *ptr2;)
+			*ptr1++ = *ptr2++;
+		    *tt = tc;
+		    for (ptr2 = copy; *ptr2;)
+			*ptr1++ = *ptr2++;
+		    *ptr1 = '\0';
+		    al = nl;
+		    all = tmp;
+		    t = e;
+		}
+		*str = all;
+
+	    } else {
+		switch (c) {
+		case 'h':
+		    remtpath(str);
+		    break;
+		case 'r':
+		    remtext(str);
+		    break;
+		case 'e':
+		    rembutext(str);
+		    break;
+		case 't':
+		    remlpaths(str);
+		    break;
+		case 'l':
+		    downcase(str);
+		    break;
+		case 'u':
+		    upcase(str);
+		    break;
+		case 's':
+		    if (hsubl && hsubr) {
+			char *oldstr = *str;
+
+			subst(str, hsubl, hsubr, gbal);
+			if (*str != oldstr) {
+			    *str = dupstring(oldstr = *str);
+			    zsfree(oldstr);
+			}
+		    }
+		    break;
+		}
+	    }
+	    if (rec < 0) {
+		if (!strcmp(test, *str))
+		    rec = 0;
+		else
+		    test = dupstring(*str);
+	    }
+	}
+    }
+}
+
+/* get a directory stack entry */
+
+/**/
+static char *
+dstackent(char ch, int val)
+{
+    int backwards;
+    LinkNode end=(LinkNode)dirstack, n;
+
+    backwards = ch == (isset(PUSHDMINUS) ? '+' : '-');
+    if(!backwards && !val--)
+	return pwd;
+    if (backwards)
+	for (n=lastnode(dirstack); n != end && val; val--, n=prevnode(n));
+    else
+	for (end=NULL, n=firstnode(dirstack); n && val; val--, n=nextnode(n));
+    if (n == end) {
+	if (isset(NOMATCH))
+	    zerr("not enough directory stack entries.", NULL, 0);
+	return NULL;
+    }
+    return (char *)getdata(n);
+}
diff --git a/Src/system.h b/Src/system.h
new file mode 100644
index 000000000..e42f3b891
--- /dev/null
+++ b/Src/system.h
@@ -0,0 +1,598 @@
+/*
+ * system.h - system configuration header file
+ *
+ * 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.
+ *
+ */
+
+#ifdef __hpux
+# define _INCLUDE_POSIX_SOURCE 1
+# define _INCLUDE_XOPEN_SOURCE 1
+# define _INCLUDE_HPUX_SOURCE 1
+#endif
+
+#ifdef sinix
+# define _XPG_IV 1
+#endif
+
+/* NeXT has half-implemented POSIX support *
+ * which currently fools configure         */
+#ifdef __NeXT__
+# undef HAVE_TERMIOS_H
+# undef HAVE_SYS_UTSNAME_H
+#endif
+
+#ifdef PROTOTYPES
+# define _(Args) Args
+#else
+# define _(Args) ()
+#endif
+
+#ifndef HAVE_ALLOCA
+# define alloca halloc
+#else
+# ifdef __GNUC__
+#  define alloca __builtin_alloca
+# else
+#  if HAVE_ALLOCA_H
+#   include <alloca.h>
+#  else
+#   ifdef _AIX
+ #   pragma alloca
+#   else
+#    ifndef alloca
+char *alloca _((size_t));
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+#ifdef HAVE_LIBC_H     /* NeXT */
+# include <libc.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <setjmp.h>
+
+#ifdef HAVE_PWD_H
+# include <pwd.h>
+#endif
+
+#ifdef HAVE_GRP_H
+# include <grp.h>
+#endif
+
+#ifdef HAVE_DIRENT_H
+# include <dirent.h>
+#else /* !HAVE_DIRENT_H */
+# ifdef HAVE_SYS_NDIR_H
+#  include <sys/ndir.h>
+# endif
+# ifdef HAVE_SYS_DIR_H
+#  include <sys/dir.h>
+# endif
+# ifdef HAVE_NDIR_H
+#  include <ndir.h>
+# endif
+# define dirent direct
+# undef HAVE_STRUCT_DIRENT_D_INO
+# undef HAVE_STRUCT_DIRENT_D_STAT
+# ifdef HAVE_STRUCT_DIRECT_D_INO
+#  define HAVE_STRUCT_DIRENT_D_INO HAVE_STRUCT_DIRECT_D_INO
+# endif
+# ifdef HAVE_STRUCT_DIRECT_D_STAT
+#  define HAVE_STRUCT_DIRENT_D_STAT HAVE_STRUCT_DIRECT_D_STAT
+# endif
+#endif /* !HAVE_DIRENT_H */
+
+#ifdef HAVE_STDLIB_H
+# ifdef ZSH_MEM
+   /* malloc and calloc are macros in GNU's stdlib.h unless the
+    * the __MALLOC_0_RETURNS_NULL macro is defined */
+#  define __MALLOC_0_RETURNS_NULL
+# endif
+# include <stdlib.h>
+#endif
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif
+
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+/* This is needed by some old SCO unices */
+#ifndef HAVE_STRUCT_TIMEZONE
+struct timezone {
+    int tz_minuteswest;
+    int tz_dsttime;
+};
+#endif
+
+/* There's more than one non-standard way to get at this data */
+#if !defined(HAVE_STRUCT_DIRENT_D_INO) && defined(HAVE_STRUCT_DIRENT_D_STAT)
+# define d_ino d_stat.st_ino
+# define HAVE_STRUCT_DIRENT_D_INO HAVE_STRUCT_DIRENT_D_STAT
+#endif /* !HAVE_STRUCT_DIRENT_D_INO && HAVE_STRUCT_DIRENT_D_STAT */
+
+/* Sco needs the following include for struct utimbuf *
+ * which is strange considering we do not use that    *
+ * anywhere in the code                               */
+#ifdef __sco
+# include <utime.h>
+#endif
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif
+
+#if STDC_HEADERS || HAVE_STRING_H
+# include <string.h>
+/* An ANSI string.h and pre-ANSI memory.h might conflict.  */
+# if !STDC_HEADERS && HAVE_MEMORY_H
+#  include <memory.h>
+# endif /* not STDC_HEADERS and HAVE_MEMORY_H */
+#else   /* not STDC_HEADERS and not HAVE_STRING_H */
+# include <strings.h>
+/* memory.h and strings.h conflict on some systems.  */
+#endif /* not STDC_HEADERS and not HAVE_STRING_H */
+
+#ifdef HAVE_LOCALE_H
+# include <locale.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#ifdef HAVE_VARIABLE_LENGTH_ARRAYS
+# define VARARR(X,Y,Z)	X (Y)[Z]
+#else
+# define VARARR(X,Y,Z)	X *(Y) = (X *) alloca(sizeof(X) * (Z))
+#endif
+
+/* we should be getting this value from pathconf(_PC_PATH_MAX) */
+/* but this is too much trouble                                */
+#ifndef PATH_MAX
+# ifdef MAXPATHLEN
+#  define PATH_MAX MAXPATHLEN
+# else
+   /* so we will just pick something */
+#  define PATH_MAX 1024
+# endif
+#endif
+
+/* we should be getting this value from sysconf(_SC_OPEN_MAX) */
+/* but this is too much trouble                               */
+#ifndef OPEN_MAX
+# ifdef NOFILE
+#  define OPEN_MAX NOFILE
+# else
+   /* so we will just pick something */
+#  define OPEN_MAX 64
+# endif
+#endif
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#else
+# include <sys/file.h>
+#endif
+
+/* The following will only be defined if <sys/wait.h> is POSIX.    *
+ * So we don't have to worry about union wait. But some machines   *
+ * (NeXT) include <sys/wait.h> from other include files, so we     *
+ * need to undef and then redefine the wait macros if <sys/wait.h> *
+ * is not POSIX.                                                   */
+
+#ifdef HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+#else
+# undef WIFEXITED
+# undef WEXITSTATUS
+# undef WIFSIGNALED
+# undef WTERMSIG
+# undef WCOREDUMP
+# undef WIFSTOPPED
+# undef WSTOPSIG
+#endif
+
+/* missing macros for wait/waitpid/wait3 */
+#ifndef WIFEXITED
+# define WIFEXITED(X) (((X)&0377)==0)
+#endif
+#ifndef WEXITSTATUS
+# define WEXITSTATUS(X) (((X)>>8)&0377)
+#endif
+#ifndef WIFSIGNALED
+# define WIFSIGNALED(X) (((X)&0377)!=0&&((X)&0377)!=0177)
+#endif
+#ifndef WTERMSIG
+# define WTERMSIG(X) ((X)&0177)
+#endif
+#ifndef WCOREDUMP
+# define WCOREDUMP(X) ((X)&0200)
+#endif
+#ifndef WIFSTOPPED
+# define WIFSTOPPED(X) (((X)&0377)==0177)
+#endif
+#ifndef WSTOPSIG
+# define WSTOPSIG(X) (((X)>>8)&0377)
+#endif
+
+#ifdef HAVE_SYS_SELECT_H
+# ifndef TIME_H_SELECT_H_CONFLICTS
+#  include <sys/select.h>
+# endif
+#endif
+
+#ifdef HAVE_SYS_FILIO_H
+# include <sys/filio.h>
+#endif
+
+#ifdef HAVE_TERMIOS_H
+# ifdef __sco
+   /* termios.h includes sys/termio.h instead of sys/termios.h; *
+    * hence the declaration for struct termios is missing       */
+#  include <sys/termios.h>
+# else
+#  include <termios.h>
+# endif
+# ifdef _POSIX_VDISABLE
+#  define VDISABLEVAL _POSIX_VDISABLE
+# else
+#  define VDISABLEVAL 0
+# endif
+# define HAS_TIO 1
+#else    /* not TERMIOS */
+# ifdef HAVE_TERMIO_H
+#  include <termio.h>
+#  define VDISABLEVAL -1
+#  define HAS_TIO 1
+# else   /* not TERMIOS and TERMIO */
+#  include <sgtty.h>
+# endif  /* HAVE_TERMIO_H  */
+#endif   /* HAVE_TERMIOS_H */
+
+#ifdef HAVE_TERMCAP_H
+# include <termcap.h>
+#endif
+
+#if defined(GWINSZ_IN_SYS_IOCTL) || defined(CLOBBERS_TYPEAHEAD)
+# include <sys/ioctl.h>
+#endif
+#ifdef WINSIZE_IN_PTEM
+# include <sys/stream.h>
+# include <sys/ptem.h>
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#endif
+
+#ifdef HAVE_SYS_UTSNAME_H
+# include <sys/utsname.h>
+#endif
+
+#define DEFAULT_WORDCHARS "*?_-.[]~=/&;!#$%^(){}<>"
+#define DEFAULT_TIMEFMT   "%J  %U user %S system %P cpu %*E total"
+
+/* Posix getpgrp takes no argument, while the BSD version *
+ * takes the process ID as an argument                    */
+#ifdef GETPGRP_VOID
+# define GETPGRP() getpgrp()
+#else
+# define GETPGRP() getpgrp(0)
+#endif
+
+#ifndef HAVE_GETLOGIN
+# define getlogin() cuserid(NULL)
+#endif
+
+#ifdef HAVE_SETPGID
+# define setpgrp setpgid
+#endif
+
+/* can we set the user/group id of a process */
+
+#ifndef HAVE_SETUID
+# ifdef HAVE_SETREUID
+#  define setuid(X) setreuid(X,X)
+#  define setgid(X) setregid(X,X)
+#  define HAVE_SETUID
+# endif
+#endif
+
+/* can we set the effective user/group id of a process */
+
+#ifndef HAVE_SETEUID
+# ifdef HAVE_SETREUID
+#  define seteuid(X) setreuid(-1,X)
+#  define setegid(X) setregid(-1,X)
+#  define HAVE_SETEUID
+# else
+#  ifdef HAVE_SETRESUID
+#   define seteuid(X) setresuid(-1,X,-1)
+#   define setegid(X) setresgid(-1,X,-1)
+#   define HAVE_SETEUID
+#  endif
+# endif
+#endif
+
+#ifdef HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+# if defined(__hpux) && !defined(RLIMIT_CPU)
+/* HPUX does have the BSD rlimits in the kernel.  Officially they are *
+ * unsupported but quite a few of them like RLIMIT_CORE seem to work. *
+ * All the following are in the <sys/resource.h> but made visible     *
+ * only for the kernel.                                               */
+#  define	RLIMIT_CPU	0
+#  define	RLIMIT_FSIZE	1
+#  define	RLIMIT_DATA	2
+#  define	RLIMIT_STACK	3
+#  define	RLIMIT_CORE	4
+#  define	RLIMIT_RSS	5
+#  define	RLIMIT_NOFILE   6
+#  define	RLIMIT_OPEN_MAX	RLIMIT_NOFILE
+#  define	RLIM_NLIMITS	7
+#  define	RLIM_INFINITY	0x7fffffff
+# endif
+#endif
+
+/* we use the SVR4 constant instead of the BSD one */
+#if !defined(RLIMIT_NOFILE) && defined(RLIMIT_OFILE)
+# define RLIMIT_NOFILE RLIMIT_OFILE
+#endif
+#if !defined(RLIMIT_VMEM) && defined(RLIMIT_AS)
+# define RLIMIT_VMEM RLIMIT_AS
+#endif
+
+#ifdef HAVE_SYS_CAPABILITY_H
+# include <sys/capability.h>
+#endif
+
+/* DIGBUFSIZ is the length of a buffer which can hold the -LONG_MAX-1 *
+ * converted to printable decimal form including the sign and the     *
+ * terminating null character. Below 0.30103 > lg 2.                  */
+#define DIGBUFSIZE ((int)(((sizeof(long) * 8) - 1) * 0.30103) + 3)
+
+/* If your stat macros are broken, we will *
+ * just undefine them.                     */
+
+#ifdef STAT_MACROS_BROKEN
+# undef S_ISBLK
+# undef S_ISCHR
+# undef S_ISDIR
+# undef S_ISFIFO
+# undef S_ISLNK
+# undef S_ISMPB
+# undef S_ISMPC
+# undef S_ISNWK
+# undef S_ISOFD
+# undef S_ISOFL
+# undef S_ISREG
+# undef S_ISSOCK
+#endif  /* STAT_MACROS_BROKEN.  */
+
+/* If you are missing the stat macros, we *
+ * define our own                         */
+
+#ifndef S_IFMT
+# define S_IFMT 0170000
+#endif
+
+#if !defined(S_ISBLK) && defined(S_IFBLK)
+# define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
+#endif
+#if !defined(S_ISCHR) && defined(S_IFCHR)
+# define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
+#endif
+#if !defined(S_ISDIR) && defined(S_IFDIR)
+# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+#if !defined(S_ISFIFO) && defined(S_IFIFO)
+# define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
+#endif
+#if !defined(S_ISLNK) && defined(S_IFLNK)
+# define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+#endif
+#if !defined(S_ISMPB) && defined(S_IFMPB)        /* V7 */
+# define S_ISMPB(m) (((m) & S_IFMT) == S_IFMPB)
+#endif
+#if !defined(S_ISMPC) && defined(S_IFMPC)        /* V7 */
+# define S_ISMPC(m) (((m) & S_IFMT) == S_IFMPC)
+#endif
+#if !defined(S_ISNWK) && defined(S_IFNWK)        /* HP/UX */
+# define S_ISNWK(m) (((m) & S_IFMT) == S_IFNWK)
+#endif
+#if !defined(S_ISOFD) && defined(S_IFOFD)        /* Cray */
+# define S_ISOFD(m) (((m) & S_IFMT) == S_IFOFD)
+#endif
+#if !defined(S_ISOFL) && defined(S_IFOFL)        /* Cray */
+# define S_ISOFL(m) (((m) & S_IFMT) == S_IFOFL)
+#endif
+#if !defined(S_ISREG) && defined(S_IFREG)
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif
+#if !defined(S_ISSOCK) && defined(S_IFSOCK)
+# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
+#endif
+
+/* We will pretend to have all file types on any system. */
+
+#ifndef S_ISBLK
+# define S_ISBLK(m) ((void)(m), 0)
+#endif
+#ifndef S_ISCHR
+# define S_ISCHR(m) ((void)(m), 0)
+#endif
+#ifndef S_ISDIR
+# define S_ISDIR(m) ((void)(m), 0)
+#endif
+#ifndef S_ISFIFO
+# define S_ISFIFO(m) ((void)(m), 0)
+#endif
+#ifndef S_ISLNK
+# define S_ISLNK(m) ((void)(m), 0)
+#endif
+#ifndef S_ISMPB
+# define S_ISMPB(m) ((void)(m), 0)
+#endif
+#ifndef S_ISMPC
+# define S_ISMPC(m) ((void)(m), 0)
+#endif
+#ifndef S_ISNWK
+# define S_ISNWK(m) ((void)(m), 0)
+#endif
+#ifndef S_ISOFD
+# define S_ISOFD(m) ((void)(m), 0)
+#endif
+#ifndef S_ISOFL
+# define S_ISOFL(m) ((void)(m), 0)
+#endif
+#ifndef S_ISREG
+# define S_ISREG(m) ((void)(m), 0)
+#endif
+#ifndef S_ISSOCK
+# define S_ISSOCK(m) ((void)(m), 0)
+#endif
+
+/* file mode permission bits */
+
+#ifndef S_ISUID
+# define S_ISUID 04000
+#endif
+#ifndef S_ISGID
+# define S_ISGID 02000
+#endif
+#ifndef S_ISVTX
+# define S_ISVTX 01000
+#endif
+#ifndef S_IRUSR
+# define S_IRUSR 00400
+#endif
+#ifndef S_IWUSR
+# define S_IWUSR 00200
+#endif
+#ifndef S_IXUSR
+# define S_IXUSR 00100
+#endif
+#ifndef S_IRGRP
+# define S_IRGRP 00040
+#endif
+#ifndef S_IWGRP
+# define S_IWGRP 00020
+#endif
+#ifndef S_IXGRP
+# define S_IXGRP 00010
+#endif
+#ifndef S_IROTH
+# define S_IROTH 00004
+#endif
+#ifndef S_IWOTH
+# define S_IWOTH 00002
+#endif
+#ifndef S_IXOTH
+# define S_IXOTH 00001
+#endif
+#ifndef S_IRWXU
+# define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR)
+#endif
+#ifndef S_IRWXG
+# define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP)
+#endif
+#ifndef S_IRWXO
+# define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH)
+#endif
+#ifndef S_IRUGO
+# define S_IRUGO (S_IRUSR|S_IRGRP|S_IROTH)
+#endif
+#ifndef S_IWUGO
+# define S_IWUGO (S_IWUSR|S_IWGRP|S_IWOTH)
+#endif
+#ifndef S_IXUGO
+# define S_IXUGO (S_IXUSR|S_IXGRP|S_IXOTH)
+#endif
+
+#ifndef HAVE_LSTAT
+# define lstat stat
+#endif
+
+#ifndef HAVE_READLINK
+# define readlink(PATH, BUF, BUFSZ) \
+    ((void)(PATH), (void)(BUF), (void)(BUFSZ), errno = ENOSYS, -1)
+#endif
+
+#ifndef F_OK          /* missing macros for access() */
+# define F_OK 0
+# define X_OK 1
+# define W_OK 2
+# define R_OK 4
+#endif
+
+#ifndef HAVE_MEMCPY
+# define memcpy memmove
+#endif
+
+#ifndef HAVE_MEMMOVE
+# define memmove(dest, src, len) bcopy((src), (dest), (len))
+#endif
+
+#ifndef offsetof
+# define offsetof(TYPE, MEM) ((char *)&((TYPE *)0)->MEM - (char *)(TYPE *)0)
+#endif
+
+extern char **environ;
+
+/* These variables are sometimes defined in, *
+ * and needed by, the termcap library.       */
+#if MUST_DEFINE_OSPEED
+extern char PC, *BC, *UP;
+extern short ospeed;
+#endif
+
+#ifndef O_NOCTTY
+# define O_NOCTTY 0
+#endif
diff --git a/Src/text.c b/Src/text.c
new file mode 100644
index 000000000..b7df8012f
--- /dev/null
+++ b/Src/text.c
@@ -0,0 +1,526 @@
+/*
+ * text.c - textual representations of syntax trees
+ *
+ * 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 "text.pro"
+
+static char *tptr, *tbuf, *tlim;
+static int tsiz, tindent, tnewlins;
+
+/* add a character to the text buffer */
+
+/**/
+static void
+taddchr(int c)
+{
+    *tptr++ = c;
+    if (tptr == tlim) {
+	if (!tbuf) {
+	    tptr--;
+	    return;
+	}
+	tbuf = realloc(tbuf, tsiz *= 2);
+	tlim = tbuf + tsiz;
+	tptr = tbuf + tsiz / 2;
+    }
+}
+
+/* add a string to the text buffer */
+
+/**/
+static void
+taddstr(char *s)
+{
+    int sl = strlen(s);
+
+    while (tptr + sl >= tlim) {
+	int x = tptr - tbuf;
+
+	if (!tbuf)
+	    return;
+	tbuf = realloc(tbuf, tsiz *= 2);
+	tlim = tbuf + tsiz;
+	tptr = tbuf + x;
+    }
+    strcpy(tptr, s);
+    tptr += sl;
+}
+
+#if 0
+/* add an integer to the text buffer */
+
+/**/
+void
+taddint(int x)
+{
+    char buf[DIGBUFSIZE];
+
+    sprintf(buf, "%d", x);
+    taddstr(buf);
+}
+#endif
+
+/* add a newline, or something equivalent, to the text buffer */
+
+/**/
+static void
+taddnl(void)
+{
+    int t0;
+
+    if (tnewlins) {
+	taddchr('\n');
+	for (t0 = 0; t0 != tindent; t0++)
+	    taddchr('\t');
+    } else
+	taddstr("; ");
+}
+
+/* get a permanent textual representation of n */
+
+/**/
+char *
+getpermtext(struct node *n)
+{
+    tnewlins = 1;
+    tbuf = (char *)zalloc(tsiz = 32);
+    tptr = tbuf;
+    tlim = tbuf + tsiz;
+    tindent = 1;
+    gettext2(n);
+    *tptr = '\0';
+    untokenize(tbuf);
+    return tbuf;
+}
+
+/* get a representation of n in a job text buffer */
+
+/**/
+char *
+getjobtext(struct node *n)
+{
+    static char jbuf[JOBTEXTSIZE];
+
+    tnewlins = 0;
+    tbuf = NULL;
+    tptr = jbuf;
+    tlim = tptr + JOBTEXTSIZE - 1;
+    tindent = 1;
+    gettext2(n);
+    *tptr = '\0';
+    untokenize(jbuf);
+    return jbuf;
+}
+
+#define gt2(X) gettext2((struct node *) (X))
+
+/*
+	"gettext2" or "type checking and how to avoid it"
+	an epic function by Paul Falstad
+*/
+
+#define _Cond(X) ((Cond) (X))
+#define _Cmd(X) ((Cmd) (X))
+#define _Pline(X) ((Pline) (X))
+#define _Sublist(X) ((Sublist) (X))
+#define _List(X) ((List) (X))
+#define _casecmd(X) ((struct casecmd *) (X))
+#define _ifcmd(X) ((struct ifcmd *) (X))
+#define _whilecmd(X) ((struct whilecmd *) (X))
+
+/**/
+static void
+gettext2(struct node *n)
+{
+    Cmd nn;
+
+    if (!n || ((List) n) == &dummy_list)
+	return;
+    switch (NT_TYPE(n->ntype)) {
+    case N_LIST:
+	gt2(_List(n)->left);
+	if (_List(n)->type & Z_ASYNC) {
+	    taddstr(" &");
+	    if (_List(n)->type & Z_DISOWN)
+		taddstr("|");
+	}
+	simplifyright(_List(n));
+	if (_List(n)->right) {
+	    if (tnewlins)
+		taddnl();
+	    else
+		taddstr((_List(n)->type & Z_ASYNC) ? " " : "; ");
+	    gt2(_List(n)->right);
+	}
+	break;
+    case N_SUBLIST:
+	if (_Sublist(n)->flags & PFLAG_NOT)
+	    taddstr("! ");
+	if (_Sublist(n)->flags & PFLAG_COPROC)
+	    taddstr("coproc ");
+	gt2(_Sublist(n)->left);
+	if (_Sublist(n)->right) {
+	    taddstr((_Sublist(n)->type == ORNEXT) ? " || " : " && ");
+	    gt2(_Sublist(n)->right);
+	}
+	break;
+    case N_PLINE:
+	gt2(_Pline(n)->left);
+	if (_Pline(n)->type == PIPE) {
+	    taddstr(" | ");
+	    gt2(_Pline(n)->right);
+	}
+	break;
+    case N_CMD:
+	nn = _Cmd(n);
+	switch (nn->type) {
+	case SIMPLE:
+	    getsimptext(nn);
+	    break;
+	case SUBSH:
+	    taddstr("( ");
+	    tindent++;
+	    gt2(nn->u.list);
+	    tindent--;
+	    taddstr(" )");
+	    break;
+	case ZCTIME:
+	    taddstr("time ");
+	    tindent++;
+	    gt2(nn->u.pline);
+	    tindent--;
+	    break;
+	case FUNCDEF:
+	    taddlist(nn->args);
+	    taddstr(" () {");
+	    tindent++;
+	    taddnl();
+	    gt2(nn->u.list);
+	    tindent--;
+	    taddnl();
+	    taddstr("}");
+	    break;
+	case CURSH:
+	    taddstr("{ ");
+	    tindent++;
+	    gt2(nn->u.list);
+	    tindent--;
+	    taddstr(" }");
+	    break;
+	case CFOR:
+	case CSELECT:
+	    taddstr((nn->type == CFOR) ? "for " : "select ");
+	    if (nn->u.forcmd->condition) {
+		taddstr("((");
+		taddstr(nn->u.forcmd->name);
+		taddstr("; ");
+		taddstr(nn->u.forcmd->condition);
+		taddstr("; ");
+		taddstr(nn->u.forcmd->advance);
+		taddstr(")) do");
+	    } else {
+		taddstr(nn->u.forcmd->name);
+		if (nn->u.forcmd->inflag) {
+		    taddstr(" in ");
+		    taddlist(nn->args);
+		}
+		taddnl();
+		taddstr("do");
+	    }
+	    tindent++;
+	    taddnl();
+	    gt2(nn->u.forcmd->list);
+	    tindent--;
+	    taddnl();
+	    taddstr("done");
+	    break;
+	case CIF:
+	    gt2(nn->u.ifcmd);
+	    taddstr("fi");
+	    break;
+	case CCASE:
+	    gt2(nn->u.casecmd);
+	    break;
+	case COND:
+	    taddstr("[[ ");
+	    gt2(nn->u.cond);
+	    taddstr(" ]]");
+	    break;
+	case CARITH:
+	    taddstr("((");
+	    taddlist(nn->args);
+	    taddstr("))");
+	    break;
+	case CREPEAT:
+	    taddstr("repeat ");
+	    taddlist(nn->args);
+	    taddnl();
+	    taddstr("do");
+	    tindent++;
+	    taddnl();
+	    gt2(nn->u.list);
+	    tindent--;
+	    taddnl();
+	    taddstr("done");
+	    break;
+	case CWHILE:
+	    gt2(nn->u.whilecmd);
+	    break;
+	}
+	getredirs(nn);
+	break;
+    case N_COND:
+	getcond(_Cond(n), 0);
+	break;
+    case N_CASE:
+	{
+	    List *l;
+	    char **p;
+
+	    l = _casecmd(n)->lists;
+	    p = _casecmd(n)->pats;
+
+	    taddstr("case ");
+	    taddstr(*p++);
+	    taddstr(" in");
+	    tindent++;
+	    for (; *l; p++, l++) {
+		if (tnewlins)
+		    taddnl();
+		else
+		    taddchr(' ');
+		taddstr(*p + 1);
+		taddstr(") ");
+		tindent++;
+		gt2(*l);
+		tindent--;
+		taddstr(" ;");
+		taddchr(**p);
+	    }
+	    tindent--;
+	    if (tnewlins)
+		taddnl();
+	    else
+		taddchr(' ');
+	    taddstr("esac");
+	    break;
+	}
+    case N_IF:
+	{
+	    List *i, *t;
+
+	    taddstr("if ");
+	    for (i = _ifcmd(n)->ifls, t = _ifcmd(n)->thenls; *i; i++, t++) {
+		tindent++;
+		gt2(*i);
+		tindent--;
+		taddnl();
+		taddstr("then");
+		tindent++;
+		taddnl();
+		gt2(*t);
+		tindent--;
+		taddnl();
+		if (i[1]) {
+		    taddstr("elif ");
+		}
+	    }
+	    if (*t) {
+		taddstr("else");
+		tindent++;
+		taddnl();
+		gt2(*t);
+		tindent--;
+		taddnl();
+	    }
+	    break;
+	}
+    case N_WHILE:
+	taddstr((_whilecmd(n)->cond) ? "until " : "while ");
+	tindent++;
+	gt2(_whilecmd(n)->cont);
+	tindent--;
+	taddnl();
+	taddstr("do");
+	tindent++;
+	taddnl();
+	gt2(_whilecmd(n)->loop);
+	tindent--;
+	taddnl();
+	taddstr("done");
+	break;
+    }
+}
+
+/* Print a condition bracketed by [[ ... ]].             *
+ * With addpar non-zero, parenthesise the subexpression. */
+
+/**/
+static void
+getcond(Cond nm, int addpar)
+{
+    static char *c1[] =
+    {
+	"=", "!=", "<", ">", "-nt", "-ot", "-ef", "-eq",
+	"-ne", "-lt", "-gt", "-le", "-ge"
+    };
+
+    if (addpar)
+	taddstr("( ");
+    switch (nm->type) {
+    case COND_NOT:
+	taddstr("! ");
+	getcond(nm->left, _Cond(nm->left)->type <= COND_OR);
+	break;
+    case COND_AND:
+	getcond(nm->left, _Cond(nm->left)->type == COND_OR);
+	taddstr(" && ");
+	getcond(nm->right, _Cond(nm->right)->type == COND_OR);
+	break;
+    case COND_OR:
+	/* This is deliberately over-generous with parentheses: *
+	 * in fact omitting them gives correct precedence.      */
+	getcond(nm->left, _Cond(nm->left)->type == COND_AND);
+	taddstr(" || ");
+	getcond(nm->right, _Cond(nm->right)->type == COND_AND);
+	break;
+    default:
+	if (nm->type <= COND_GE) {
+	    /* Binary test: `a = b' etc. */
+	    taddstr(nm->left);
+	    taddstr(" ");
+	    taddstr(c1[nm->type - COND_STREQ]);
+	    taddstr(" ");
+	    taddstr(nm->right);
+	} else {
+	    /* Unary test: `-f foo' etc. */ 
+	    char c2[4];
+
+	    c2[0] = '-';
+	    c2[1] = nm->type;
+	    c2[2] = ' ';
+	    c2[3] = '\0';
+	    taddstr(c2);
+	    taddstr(nm->left);
+	}
+	break;
+    }
+    if (addpar)
+	taddstr(" )");
+}
+
+/**/
+static void
+getsimptext(Cmd cmd)
+{
+    LinkNode n;
+
+    for (n = firstnode(cmd->vars); n; incnode(n)) {
+	struct varasg *v = (struct varasg *)getdata(n);
+
+	taddstr(v->name);
+	taddchr('=');
+	if (PM_TYPE(v->type) == PM_ARRAY) {
+	    taddchr('(');
+	    taddlist(v->arr);
+	    taddstr(") ");
+	} else {
+	    taddstr(v->str);
+	    taddchr(' ');
+	}
+    }
+    taddlist(cmd->args);
+}
+
+/**/
+void
+getredirs(Cmd cmd)
+{
+    LinkNode n;
+    static char *fstr[] =
+    {
+	">", ">|", ">>", ">>|", "&>", "&>|", "&>>", "&>>|", "<>", "<",
+	"<<", "<<-", "<<<", "<&", ">&", NULL /* >&- */, "<", ">"
+    };
+
+    taddchr(' ');
+    for (n = firstnode(cmd->redir); n; incnode(n)) {
+	struct redir *f = (struct redir *)getdata(n);
+
+	switch (f->type) {
+	case WRITE:
+	case WRITENOW:
+	case APP:
+	case APPNOW:
+	case ERRWRITE:
+	case ERRWRITENOW:
+	case ERRAPP:
+	case ERRAPPNOW:
+	case READ:
+	case READWRITE:
+	case HERESTR:
+	case MERGEIN:
+	case MERGEOUT:
+	case INPIPE:
+	case OUTPIPE:
+	    if (f->fd1 != (IS_READFD(f->type) ? 0 : 1))
+		taddchr('0' + f->fd1);
+	    taddstr(fstr[f->type]);
+	    taddchr(' ');
+	    taddstr(f->name);
+	    taddchr(' ');
+	    break;
+#ifdef DEBUG
+	case CLOSE:
+	    DPUTS(1, "BUG: CLOSE in getredirs()");
+	    taddchr(f->fd1 + '0');
+	    taddstr(">&- ");
+	    break;
+	default:
+	    DPUTS(1, "BUG: unknown redirection in getredirs()");
+#endif
+	}
+    }
+    tptr--;
+}
+
+/**/
+static void
+taddlist(LinkList l)
+{
+    LinkNode n;
+
+    if (!(n = firstnode(l)))
+	return;
+    for (; n; incnode(n)) {
+	taddstr(getdata(n));
+	taddchr(' ');
+    }
+    tptr--;
+}
diff --git a/Src/utils.c b/Src/utils.c
new file mode 100644
index 000000000..3619fa95d
--- /dev/null
+++ b/Src/utils.c
@@ -0,0 +1,3726 @@
+/*
+ * utils.c - miscellaneous utilities
+ *
+ * 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 "utils.pro"
+
+/* Print an error */
+
+/**/
+void
+zwarnnam(const char *cmd, const char *fmt, const char *str, int num)
+{
+    int waserr;
+
+    waserr = errflag;
+    zerrnam(cmd, fmt, str, num);
+    errflag = waserr;
+}
+
+/* name of script being sourced */
+
+/**/
+char *scriptname;
+ 
+/**/
+void
+zerr(const char *fmt, const char *str, int num)
+{
+    if (errflag || noerrs)
+	return;
+    errflag = 1;
+    trashzle();
+    /*
+     * scriptname is set when sourcing scripts, so that we get the
+     * correct name instead of the generic name of whatever
+     * program/script is running.
+     */
+    nicezputs(isset(SHINSTDIN) ? "zsh" :
+	      scriptname ? scriptname : argzero, stderr);
+    fputs(": ", stderr);
+    zerrnam(NULL, fmt, str, num);
+}
+
+/**/
+void
+zerrnam(const char *cmd, const char *fmt, const char *str, int num)
+{
+    if (cmd) {
+	if (errflag || noerrs)
+	    return;
+	errflag = 1;
+	trashzle();
+	if(unset(SHINSTDIN)) {
+	    nicezputs(scriptname ? scriptname : argzero, stderr);
+	    fputs(": ", stderr);
+	}
+	nicezputs(cmd, stderr);
+	fputs(": ", stderr);
+    }
+    while (*fmt)
+	if (*fmt == '%') {
+	    fmt++;
+	    switch (*fmt++) {
+	    case 's':
+		nicezputs(str, stderr);
+		break;
+	    case 'l': {
+		char *s;
+		num = metalen(str, num);
+		s = halloc(num + 1);
+		memcpy(s, str, num);
+		s[num] = '\0';
+		nicezputs(s, stderr);
+		break;
+	    }
+	    case 'd':
+		fprintf(stderr, "%d", num);
+		break;
+	    case '%':
+		putc('%', stderr);
+		break;
+	    case 'c':
+		fputs(nicechar(num), stderr);
+		break;
+	    case 'e':
+		/* print the corresponding message for this errno */
+		if (num == EINTR) {
+		    fputs("interrupt\n", stderr);
+		    errflag = 1;
+		    return;
+		}
+		/* If the message is not about I/O problems, it looks better *
+		 * if we uncapitalize the first letter of the message        */
+		if (num == EIO)
+		    fputs(strerror(num), stderr);
+		else {
+		    char *errmsg = strerror(num);
+		    fputc(tulower(errmsg[0]), stderr);
+		    fputs(errmsg + 1, stderr);
+		}
+		break;
+	    }
+	} else {
+	    putc(*fmt == Meta ? *++fmt ^ 32 : *fmt, stderr);
+	    fmt++;
+	}
+    if (unset(SHINSTDIN) && lineno)
+	fprintf(stderr, " [%ld]\n", lineno);
+    else
+	putc('\n', stderr);
+    fflush(stderr);
+}
+
+/* Output a single character, for the termcap routines.     *
+ * This is used instead of putchar since it can be a macro. */
+
+/**/
+int
+putraw(int c)
+{
+    putc(c, stdout);
+    return 0;
+}
+
+/* Output a single character, for the termcap routines. */
+
+/**/
+int
+putshout(int c)
+{
+    putc(c, shout);
+    return 0;
+}
+
+/* Turn a character into a visible representation thereof.  The visible *
+ * string is put together in a static buffer, and this function returns *
+ * a pointer to it.  Printable characters stand for themselves, DEL is  *
+ * represented as "^?", newline and tab are represented as "\n" and     *
+ * "\t", and normal control characters are represented in "^C" form.    *
+ * Characters with bit 7 set, if unprintable, are represented as "\M-"  *
+ * followed by the visible representation of the character with bit 7   *
+ * stripped off.  Tokens are interpreted, rather than being treated as  *
+ * literal characters.                                                  */
+
+/**/
+char *
+nicechar(int c)
+{
+    static char buf[6];
+    char *s = buf;
+    c &= 0xff;
+    if (isprint(c))
+	goto done;
+    if (c & 0x80) {
+	if (isset(PRINTEIGHTBIT))
+	    goto done;
+	*s++ = '\\';
+	*s++ = 'M';
+	*s++ = '-';
+	c &= 0x7f;
+	if(isprint(c))
+	    goto done;
+    }
+    if (c == 0x7f) {
+	*s++ = '^';
+	c = '?';
+    } else if (c == '\n') {
+	*s++ = '\\';
+	c = 'n';
+    } else if (c == '\t') {
+	*s++ = '\\';
+	c = 't';
+    } else if (c < 0x20) {
+	*s++ = '^';
+	c += 0x40;
+    }
+    done:
+    *s++ = c;
+    *s = 0;
+    return buf;
+}
+
+#if 0
+/* Output a string's visible representation. */
+
+/**/
+void
+nicefputs(char *s, FILE *f)
+{
+    for (; *s; s++)
+	fputs(nicechar(STOUC(*s)), f);
+}
+#endif
+
+/* Return the length of the visible representation of a string. */
+
+/**/
+size_t
+nicestrlen(char *s)
+{
+    size_t l = 0;
+
+    for (; *s; s++)
+	l += strlen(nicechar(STOUC(*s)));
+    return l;
+}
+
+/* get a symlink-free pathname for s relative to PWD */
+
+/**/
+char *
+findpwd(char *s)
+{
+    char *t;
+
+    if (*s == '/')
+	return xsymlink(s);
+    s = tricat((pwd[1]) ? pwd : "", "/", s);
+    t = xsymlink(s);
+    zsfree(s);
+    return t;
+}
+
+/* Check whether a string contains the *
+ * name of the present directory.      */
+
+/**/
+int
+ispwd(char *s)
+{
+    struct stat sbuf, tbuf;
+
+    if (stat(unmeta(s), &sbuf) == 0 && stat(".", &tbuf) == 0)
+	if (sbuf.st_dev == tbuf.st_dev && sbuf.st_ino == tbuf.st_ino)
+	    return 1;
+    return 0;
+}
+
+static char xbuf[PATH_MAX*2];
+
+/**/
+static char **
+slashsplit(char *s)
+{
+    char *t, **r, **q;
+    int t0;
+
+    if (!*s)
+	return (char **) zcalloc(sizeof(char **));
+
+    for (t = s, t0 = 0; *t; t++)
+	if (*t == '/')
+	    t0++;
+    q = r = (char **) zalloc(sizeof(char **) * (t0 + 2));
+
+    while ((t = strchr(s, '/'))) {
+	*q++ = ztrduppfx(s, t - s);
+	while (*t == '/')
+	    t++;
+	if (!*t) {
+	    *q = NULL;
+	    return r;
+	}
+	s = t;
+    }
+    *q++ = ztrdup(s);
+    *q = NULL;
+    return r;
+}
+
+/* expands symlinks and .. or . expressions */
+/* if flag = 0, only expand .. and . expressions */
+
+/**/
+static int
+xsymlinks(char *s, int flag)
+{
+    char **pp, **opp;
+    char xbuf2[PATH_MAX*2], xbuf3[PATH_MAX*2];
+    int t0, ret = 0;
+
+    opp = pp = slashsplit(s);
+    for (; *pp; pp++) {
+	if (!strcmp(*pp, ".")) {
+	    zsfree(*pp);
+	    continue;
+	}
+	if (!strcmp(*pp, "..")) {
+	    char *p;
+
+	    zsfree(*pp);
+	    if (!strcmp(xbuf, "/"))
+		continue;
+	    p = xbuf + strlen(xbuf);
+	    while (*--p != '/');
+	    *p = '\0';
+	    continue;
+	}
+	if (unset(CHASELINKS)) {
+	    strcat(xbuf, "/");
+	    strcat(xbuf, *pp);
+	    zsfree(*pp);
+	    continue;
+	}
+	sprintf(xbuf2, "%s/%s", xbuf, *pp);
+	t0 = readlink(unmeta(xbuf2), xbuf3, PATH_MAX);
+	if (t0 == -1 || !flag) {
+	    strcat(xbuf, "/");
+	    strcat(xbuf, *pp);
+	    zsfree(*pp);
+	} else {
+	    ret = 1;
+	    metafy(xbuf3, t0, META_NOALLOC);
+	    if (*xbuf3 == '/') {
+		strcpy(xbuf, "");
+		xsymlinks(xbuf3 + 1, flag);
+	    } else
+		xsymlinks(xbuf3, flag);
+	    zsfree(*pp);
+	}
+    }
+    free(opp);
+    return ret;
+}
+
+/* expand symlinks in s, and remove other weird things */
+
+/**/
+char *
+xsymlink(char *s)
+{
+    if (unset(CHASELINKS))
+	return ztrdup(s);
+    if (*s != '/')
+	return NULL;
+    *xbuf = '\0';
+    if (!xsymlinks(s + 1, 1))
+	return ztrdup(s);
+    if (!*xbuf)
+	return ztrdup("/");
+    return ztrdup(xbuf);
+}
+
+/**/
+void
+print_if_link(char *s)
+{
+    int chase;
+
+    if (*s == '/') {
+	chase = opts[CHASELINKS];
+	opts[CHASELINKS] = 1;
+	*xbuf = '\0';
+	if (xsymlinks(s + 1, 1))
+	    printf(" -> "), zputs(*xbuf ? xbuf : "/", stdout);
+	opts[CHASELINKS] = chase;
+    }
+}
+
+/* print a directory */
+
+/**/
+void
+fprintdir(char *s, FILE *f)
+{
+    Nameddir d = finddir(s);
+
+    if (!d)
+	fputs(unmeta(s), f);
+    else {
+	putc('~', f);
+	fputs(unmeta(d->nam), f);
+	fputs(unmeta(s + strlen(d->dir)), f);
+    }
+}
+
+/* Returns the current username.  It caches the username *
+ * and uid to try to avoid requerying the password files *
+ * or NIS/NIS+ database.                                 */
+
+/**/
+uid_t cached_uid;
+/**/
+char *cached_username;
+
+/**/
+char *
+get_username(void)
+{
+#ifdef HAVE_GETPWUID
+    struct passwd *pswd;
+    uid_t current_uid;
+ 
+    current_uid = getuid();
+    if (current_uid != cached_uid) {
+	cached_uid = current_uid;
+	zsfree(cached_username);
+	if ((pswd = getpwuid(current_uid)))
+	    cached_username = ztrdup(pswd->pw_name);
+	else
+	    cached_username = ztrdup("");
+    }
+#else /* !HAVE_GETPWUID */
+    cached_uid = current_uid;
+#endif /* !HAVE_GETPWUID */
+    return cached_username;
+}
+
+/* static variables needed by finddir(). */
+
+static char *finddir_full;
+static Nameddir finddir_last;
+static int finddir_best;
+
+/* ScanFunc used by finddir(). */
+
+/**/
+static void
+finddir_scan(HashNode hn, int flags)
+{
+    Nameddir nd = (Nameddir) hn;
+
+    if(nd->diff > finddir_best && !dircmp(nd->dir, finddir_full)) {
+	finddir_last=nd;
+	finddir_best=nd->diff;
+    }
+}
+
+/* See if a path has a named directory as its prefix. *
+ * If passed a NULL argument, it will invalidate any  *
+ * cached information.                                */
+
+/**/
+Nameddir
+finddir(char *s)
+{
+    static struct nameddir homenode = { NULL, "", 0, NULL, 0 };
+    static int ffsz;
+
+    /* Invalidate directory cache if argument is NULL.  This is called *
+     * whenever a node is added to or removed from the hash table, and *
+     * whenever the value of $HOME changes.  (On startup, too.)        */
+    if (!s) {
+	homenode.dir = home;
+	homenode.diff = strlen(home);
+	if(homenode.diff==1)
+	    homenode.diff = 0;
+	if(!finddir_full)
+	    finddir_full = zalloc(ffsz = PATH_MAX);
+	finddir_full[0] = 0;
+	return finddir_last = NULL;
+    }
+
+    if(!strcmp(s, finddir_full) && *finddir_full)
+	return finddir_last;
+
+    if(strlen(s) >= ffsz) {
+	free(finddir_full);
+	finddir_full = zalloc(ffsz = strlen(s) * 2);
+    }
+    strcpy(finddir_full, s);
+    finddir_best=0;
+    finddir_last=NULL;
+    finddir_scan((HashNode)&homenode, 0);
+    scanhashtable(nameddirtab, 0, 0, 0, finddir_scan, 0);
+    return finddir_last;
+}
+
+/* add a named directory */
+
+/**/
+void
+adduserdir(char *s, char *t, int flags, int always)
+{
+    Nameddir nd;
+
+    /* We don't maintain a hash table in non-interactive shells. */
+    if (!interact)
+	return;
+
+    /* The ND_USERNAME flag means that this possible hash table *
+     * entry is derived from a passwd entry.  Such entries are  *
+     * subordinate to explicitly generated entries.             */
+    if ((flags & ND_USERNAME) && nameddirtab->getnode2(nameddirtab, s))
+	return;
+
+    /* Normal parameter assignments generate calls to this function, *
+     * with always==0.  Unless the AUTO_NAME_DIRS option is set, we  *
+     * don't let such assignments actually create directory names.   *
+     * Instead, a reference to the parameter as a directory name can *
+     * cause the actual creation of the hash table entry.            */
+    if (!always && unset(AUTONAMEDIRS) &&
+	    !nameddirtab->getnode2(nameddirtab, s))
+	return;
+
+    if (!t || *t != '/' || strlen(t) >= PATH_MAX) {
+	/* We can't use this value as a directory, so simply remove *
+	 * the corresponding entry in the hash table, if any.       */
+	HashNode hn = nameddirtab->removenode(nameddirtab, s);
+
+	if(hn)
+	    nameddirtab->freenode(hn);
+	return;
+    }
+
+    /* add the name */
+    nd = (Nameddir) zcalloc(sizeof *nd);
+    nd->flags = flags;
+    nd->dir = ztrdup(t);
+    nameddirtab->addnode(nameddirtab, ztrdup(s), nd);
+}
+
+/* Get a named directory: this function can cause a directory name *
+ * to be added to the hash table, if it isn't there already.       */
+
+/**/
+char *
+getnameddir(char *name)
+{
+    Param pm;
+    char *str;
+    Nameddir nd;
+
+    /* Check if it is already in the named directory table */
+    if ((nd = (Nameddir) nameddirtab->getnode(nameddirtab, name)))
+	return dupstring(nd->dir);
+
+    /* Check if there is a scalar parameter with this name whose value *
+     * begins with a `/'.  If there is, add it to the hash table and   *
+     * return the new value.                                           */
+    if ((pm = (Param) paramtab->getnode(paramtab, name)) &&
+	    (PM_TYPE(pm->flags) == PM_SCALAR) &&
+	    (str = getsparam(name)) && *str == '/') {
+	adduserdir(name, str, 0, 1);
+	return str;
+    }
+
+#ifdef HAVE_GETPWNAM
+    {
+	/* Retrieve an entry from the password table/database for this user. */
+	struct passwd *pw;
+	if ((pw = getpwnam(name))) {
+	    char *dir = xsymlink(pw->pw_dir);
+	    adduserdir(name, dir, ND_USERNAME, 1);
+	    str = dupstring(dir);
+	    zsfree(dir);
+	    return str;
+	}
+    }
+#endif /* HAVE_GETPWNAM */
+
+    /* There are no more possible sources of directory names, so give up. */
+    return NULL;
+}
+
+/**/
+static int
+dircmp(char *s, char *t)
+{
+    if (s) {
+	for (; *s == *t; s++, t++)
+	    if (!*s)
+		return 0;
+	if (!*s && *t == '/')
+	    return 0;
+    }
+    return 1;
+}
+
+/* extra functions to call before displaying the prompt */
+
+/**/
+LinkList prepromptfns;
+
+/* the last time we checked mail */
+ 
+/**/
+time_t lastmailcheck;
+ 
+/* the last time we checked the people in the WATCH variable */
+ 
+/**/
+time_t lastwatch;
+
+/* do pre-prompt stuff */
+
+/**/
+void
+preprompt(void)
+{
+    static time_t lastperiodic;
+    LinkNode ln;
+    List list;
+    int period = getiparam("PERIOD");
+    int mailcheck = getiparam("MAILCHECK");
+
+    /* If NOTIFY is not set, then check for completed *
+     * jobs before we print the prompt.               */
+    if (unset(NOTIFY))
+	scanjobs();
+    if (errflag)
+	return;
+
+    /* If a shell function named "precmd" exists, *
+     * then execute it.                           */
+    if ((list = getshfunc("precmd")) != &dummy_list)
+	doshfunc(list, NULL, 0, 1);
+    if (errflag)
+	return;
+
+    /* If 1) the parameter PERIOD exists, 2) the shell function     *
+     * "periodic" exists, 3) it's been greater than PERIOD since we *
+     * executed "periodic", then execute it now.                    */
+    if (period && (time(NULL) > lastperiodic + period) &&
+	(list = getshfunc("periodic")) != &dummy_list) {
+	doshfunc(list, NULL, 0, 1);
+	lastperiodic = time(NULL);
+    }
+    if (errflag)
+	return;
+
+    /* If WATCH is set, then check for the *
+     * specified login/logout events.      */
+    if (watch) {
+	if ((int) difftime(time(NULL), lastwatch) > getiparam("LOGCHECK")) {
+	    dowatch();
+	    lastwatch = time(NULL);
+	}
+    }
+    if (errflag)
+	return;
+
+    /* Check mail */
+    if (mailcheck && (int) difftime(time(NULL), lastmailcheck) > mailcheck) {
+	char *mailfile;
+
+	if (mailpath && *mailpath && **mailpath)
+	    checkmailpath(mailpath);
+	else if ((mailfile = getsparam("MAIL")) && *mailfile) {
+	    char *x[2];
+
+	    x[0] = mailfile;
+	    x[1] = NULL;
+	    checkmailpath(x);
+	}
+	lastmailcheck = time(NULL);
+    }
+
+    /* Some people have claimed that C performs type    *
+     * checking, but they were later found to be lying. */
+    for(ln = firstnode(prepromptfns); ln; ln = nextnode(ln))
+	(**(void (**) _((void)))getdata(ln))();
+}
+
+/**/
+static void
+checkmailpath(char **s)
+{
+    struct stat st;
+    char *v, *u, c;
+
+    while (*s) {
+	for (v = *s; *v && *v != '?'; v++);
+	c = *v;
+	*v = '\0';
+	if (c != '?')
+	    u = NULL;
+	else
+	    u = v + 1;
+	if (**s == 0) {
+	    *v = c;
+	    zerr("empty MAILPATH component: %s", *s, 0);
+	} else if (stat(unmeta(*s), &st) == -1) {
+	    if (errno != ENOENT)
+		zerr("%e: %s", *s, errno);
+	} else if (S_ISDIR(st.st_mode)) {
+	    LinkList l;
+	    DIR *lock = opendir(unmeta(*s));
+	    char buf[PATH_MAX * 2], **arr, **ap;
+	    int ct = 1;
+
+	    if (lock) {
+		char *fn;
+		HEAPALLOC {
+		    pushheap();
+		    l = newlinklist();
+		    while ((fn = zreaddir(lock, 1)) && !errflag) {
+			if (u)
+			    sprintf(buf, "%s/%s?%s", *s, fn, u);
+			else
+			    sprintf(buf, "%s/%s", *s, fn);
+			addlinknode(l, dupstring(buf));
+			ct++;
+		    }
+		    closedir(lock);
+		    ap = arr = (char **) alloc(ct * sizeof(char *));
+
+		    while ((*ap++ = (char *)ugetnode(l)));
+		    checkmailpath(arr);
+		    popheap();
+		} LASTALLOC;
+	    }
+	} else {
+	    if (st.st_size && st.st_atime <= st.st_mtime &&
+		st.st_mtime > lastmailcheck)
+		if (!u) {
+		    fprintf(shout, "You have new mail.\n");
+		    fflush(shout);
+		} else {
+		    char *usav = underscore;
+
+		    underscore = *s;
+		    HEAPALLOC {
+			u = dupstring(u);
+			if (! parsestr(u)) {
+			    singsub(&u);
+			    zputs(u, shout);
+			    fputc('\n', shout);
+			    fflush(shout);
+			}
+			underscore = usav;
+		    } LASTALLOC;
+		}
+	    if (isset(MAILWARNING) && st.st_atime > st.st_mtime &&
+		st.st_atime > lastmailcheck && st.st_size) {
+		fprintf(shout, "The mail in %s has been read.\n", unmeta(*s));
+		fflush(shout);
+	    }
+	}
+	*v = c;
+	s++;
+    }
+}
+
+/**/
+void
+freestr(void *a)
+{
+    zsfree(a);
+}
+
+/**/
+void
+gettyinfo(struct ttyinfo *ti)
+{
+    if (SHTTY != -1) {
+#ifdef HAVE_TERMIOS_H
+# ifdef HAVE_TCGETATTR
+	if (tcgetattr(SHTTY, &ti->tio) == -1)
+# else
+	if (ioctl(SHTTY, TCGETS, &ti->tio) == -1)
+# endif
+	    zerr("bad tcgets: %e", NULL, errno);
+#else
+# ifdef HAVE_TERMIO_H
+	ioctl(SHTTY, TCGETA, &ti->tio);
+# else
+	ioctl(SHTTY, TIOCGETP, &ti->sgttyb);
+	ioctl(SHTTY, TIOCLGET, &ti->lmodes);
+	ioctl(SHTTY, TIOCGETC, &ti->tchars);
+	ioctl(SHTTY, TIOCGLTC, &ti->ltchars);
+# endif
+#endif
+    }
+}
+
+/**/
+void
+settyinfo(struct ttyinfo *ti)
+{
+    if (SHTTY != -1) {
+#ifdef HAVE_TERMIOS_H
+# ifdef HAVE_TCGETATTR
+#  ifndef TCSADRAIN
+#   define TCSADRAIN 1	/* XXX Princeton's include files are screwed up */
+#  endif
+	tcsetattr(SHTTY, TCSADRAIN, &ti->tio);
+    /* if (tcsetattr(SHTTY, TCSADRAIN, &ti->tio) == -1) */
+# else
+	ioctl(SHTTY, TCSETS, &ti->tio);
+    /* if (ioctl(SHTTY, TCSETS, &ti->tio) == -1) */
+# endif
+	/*	zerr("settyinfo: %e",NULL,errno)*/ ;
+#else
+# ifdef HAVE_TERMIO_H
+	ioctl(SHTTY, TCSETA, &ti->tio);
+# else
+	ioctl(SHTTY, TIOCSETN, &ti->sgttyb);
+	ioctl(SHTTY, TIOCLSET, &ti->lmodes);
+	ioctl(SHTTY, TIOCSETC, &ti->tchars);
+	ioctl(SHTTY, TIOCSLTC, &ti->ltchars);
+# endif
+#endif
+    }
+}
+
+/* the default tty state */
+ 
+/**/
+struct ttyinfo shttyinfo;
+
+/* != 0 if we need to call resetvideo() */
+
+/**/
+int resetneeded;
+
+#ifdef TIOCGWINSZ
+/* window size changed */
+
+/**/
+int winchanged;
+#endif
+ 
+/* check the size of the window and adjust if necessary */
+
+/**/
+void
+adjustwinsize(void)
+{
+#ifdef TIOCGWINSZ
+    int oldcols = columns, oldrows = lines;
+
+    if (SHTTY == -1)
+	return;
+
+    ioctl(SHTTY, TIOCGWINSZ, (char *)&shttyinfo.winsize);
+    setiparam("COLUMNS", shttyinfo.winsize.ws_col);
+    setiparam("LINES", shttyinfo.winsize.ws_row);
+    if (zleactive && (oldcols != columns || oldrows != lines)) {
+	resetneeded = winchanged = 1;
+	refresh();
+    }
+#endif   /* TIOCGWINSZ */
+}
+
+/* Move a fd to a place >= 10 and mark the new fd in fdtable.  If the fd *
+ * is already >= 10, it is not moved.  If it is invalid, -1 is returned. */
+
+/**/
+int
+movefd(int fd)
+{
+    if(fd != -1 && fd < 10) {
+#ifdef F_DUPFD
+	int fe = fcntl(fd, F_DUPFD, 10);
+#else
+	int fe = movefd(dup(fd));
+#endif
+	zclose(fd);
+	fd = fe;
+    }
+    if(fd != -1) {
+	if (fd > max_zsh_fd) {
+	    while (fd >= fdtable_size)
+		fdtable = zrealloc(fdtable, (fdtable_size *= 2));
+	    max_zsh_fd = fd;
+	}
+	fdtable[fd] = 1;
+    }
+    return fd;
+}
+
+/* Move fd x to y.  If x == -1, fd y is closed. */
+
+/**/
+void
+redup(int x, int y)
+{
+    if(x < 0)
+	zclose(y);
+    else if (x != y) {
+	while (y >= fdtable_size)
+	    fdtable = zrealloc(fdtable, (fdtable_size *= 2));
+	dup2(x, y);
+	if ((fdtable[y] = fdtable[x]) && y > max_zsh_fd)
+	    max_zsh_fd = y;
+	zclose(x);
+    }
+}
+
+/* Close the given fd, and clear it from fdtable. */
+
+/**/
+int
+zclose(int fd)
+{
+    if (fd >= 0) {
+	fdtable[fd] = 0;
+	while (max_zsh_fd > 0 && !fdtable[max_zsh_fd])
+	    max_zsh_fd--;
+	if (fd == coprocin)
+	    coprocin = -1;
+	if (fd == coprocout)
+	    coprocout = -1;
+    }
+    return close(fd);
+}
+
+/* Get a file name relative to $TMPPREFIX which *
+ * is unique, for use as a temporary file.      */
+ 
+/**/
+char *
+gettempname(void)
+{
+    char *s;
+ 
+    if (!(s = getsparam("TMPPREFIX")))
+	s = DEFAULT_TMPPREFIX;
+ 
+    return ((char *) mktemp(dyncat(unmeta(s), "XXXXXX")));
+}
+
+/* Check if a string contains a token */
+
+/**/
+int
+has_token(const char *s)
+{
+    while(*s)
+	if(itok(*s++))
+	    return 1;
+    return 0;
+}
+
+/* Delete a character in a string */
+ 
+/**/
+void
+chuck(char *str)
+{
+    while ((str[0] = str[1]))
+	str++;
+}
+
+/**/
+int
+tulower(int c)
+{
+    c &= 0xff;
+    return (isupper(c) ? tolower(c) : c);
+}
+
+/**/
+int
+tuupper(int c)
+{
+    c &= 0xff;
+    return (islower(c) ? toupper(c) : c);
+}
+
+/* copy len chars from t into s, and null terminate */
+
+/**/
+void
+ztrncpy(char *s, char *t, int len)
+{
+    while (len--)
+	*s++ = *t++;
+    *s = '\0';
+}
+
+/* copy t into *s and update s */
+
+/**/
+void
+strucpy(char **s, char *t)
+{
+    char *u = *s;
+
+    while ((*u++ = *t++));
+    *s = u - 1;
+}
+
+/**/
+void
+struncpy(char **s, char *t, int n)
+{
+    char *u = *s;
+
+    while (n--)
+	*u++ = *t++;
+    *s = u;
+    *u = '\0';
+}
+
+/* Return the number of elements in an array of pointers. *
+ * It doesn't count the NULL pointer at the end.          */
+
+/**/
+int
+arrlen(char **s)
+{
+    int count;
+
+    for (count = 0; *s; s++, count++);
+    return count;
+}
+
+/* Skip over a balanced pair of parenthesis. */
+
+/**/
+int
+skipparens(char inpar, char outpar, char **s)
+{
+    int level;
+
+    if (**s != inpar)
+	return -1;
+
+    for (level = 1; *++*s && level;)
+	if (**s == inpar)
+	   ++level;
+	else if (**s == outpar)
+	   --level;
+
+   return level;
+}
+
+/* Convert string to long.  This function (without the z) *
+ * is contained in the ANSI standard C library, but a lot *
+ * of them seem to be broken.                             */
+
+/**/
+long
+zstrtol(const char *s, char **t, int base)
+{
+    long ret = 0;
+    int neg;
+
+    while (inblank(*s))
+	s++;
+
+    if ((neg = (*s == '-')))
+	s++;
+    else if (*s == '+')
+	s++;
+
+    if (!base)
+	if (*s != '0')
+	    base = 10;
+	else if (*++s == 'x' || *s == 'X')
+	    base = 16, s++;
+	else
+	    base = 8;
+ 
+    if (base <= 10)
+	for (; *s >= '0' && *s < ('0' + base); s++)
+	    ret = ret * base + *s - '0';
+    else
+	for (; idigit(*s) || (*s >= 'a' && *s < ('a' + base - 10))
+	     || (*s >= 'A' && *s < ('A' + base - 10)); s++)
+	    ret = ret * base + (idigit(*s) ? (*s - '0') : (*s & 0x1f) + 9);
+    if (t)
+	*t = (char *)s;
+    return neg ? -ret : ret;
+}
+
+/**/
+int
+setblock_stdin(void)
+{
+#ifdef O_NDELAY
+# ifdef O_NONBLOCK
+#  define NONBLOCK (O_NDELAY|O_NONBLOCK)
+# else /* !O_NONBLOCK */
+#  define NONBLOCK O_NDELAY
+# endif /* !O_NONBLOCK */
+#else /* !O_NDELAY */
+# ifdef O_NONBLOCK
+#  define NONBLOCK O_NONBLOCK
+# else /* !O_NONBLOCK */
+#  define NONBLOCK 0
+# endif /* !O_NONBLOCK */
+#endif /* !O_NDELAY */
+
+#if NONBLOCK
+    struct stat st;
+    long mode;
+
+    if (!fstat(0, &st) && !S_ISREG(st.st_mode)) {
+	mode = fcntl(0, F_GETFL);
+	if (mode != -1 && (mode & NONBLOCK) &&
+	    !fcntl(0, F_SETFL, mode & ~NONBLOCK))
+	    return 1;
+    }
+#endif /* NONBLOCK */
+    return 0;
+
+#undef NONBLOCK
+}
+
+/**/
+int
+checkrmall(char *s)
+{
+    fprintf(shout, "zsh: sure you want to delete all the files in ");
+    if (*s != '/') {
+	nicezputs(pwd[1] ? unmeta(pwd) : "", shout);
+	fputc('/', shout);
+    }
+    nicezputs(s, shout);
+    if(isset(RMSTARWAIT)) {
+	fputs("? (waiting ten seconds)", shout);
+	fflush(shout);
+	beep();
+	sleep(10);
+	fputc('\n', shout);
+    }
+    fputs(" [yn]? ", shout);
+    fflush(shout);
+    beep();
+    return (getquery("ny", 1) == 'y');
+}
+
+/**/
+int
+getquery(char *valid_chars, int purge)
+{
+    char c, d;
+    int isem = !strcmp(term, "emacs");
+
+#ifdef FIONREAD
+    int val = 0;
+#endif
+
+    attachtty(mypgrp);
+    if (!isem)
+	setcbreak();
+
+#ifdef FIONREAD
+    ioctl(SHTTY, FIONREAD, (char *)&val);
+    if(purge) {
+	while(val--)
+	    read(SHTTY, &c, 1);
+    } else if (val) {
+	if (!isem)
+	    settyinfo(&shttyinfo);
+	write(SHTTY, "n\n", 2);
+	return 'n';
+    }
+#endif
+    while (read(SHTTY, &c, 1) == 1) {
+	if (c == 'Y' || c == '\t')
+	    c = 'y';
+	else if (c == 'N')
+	    c = 'n';
+	if (!valid_chars)
+	    break;
+	if (c == '\n') {
+	    c = *valid_chars;
+	    break;
+	}
+	if (strchr(valid_chars, c)) {
+	    write(SHTTY, "\n", 1);
+	    break;
+	}
+	beep();
+	if (icntrl(c))
+	    write(SHTTY, "\b \b", 3);
+	write(SHTTY, "\b \b", 3);
+    }
+    if (isem) {
+	if (c != '\n')
+	    while (read(SHTTY, &d, 1) == 1 && d != '\n');
+    } else {
+	settyinfo(&shttyinfo);
+	if (c != '\n' && !valid_chars)
+	    write(SHTTY, "\n", 1);
+    }
+    return (int)c;
+}
+
+static int d;
+static char *guess, *best;
+
+/**/
+static void
+spscan(HashNode hn, int scanflags)
+{
+    int nd;
+
+    nd = spdist(hn->nam, guess, (int) strlen(guess) / 4 + 1);
+    if (nd <= d) {
+	best = hn->nam;
+	d = nd;
+    }
+}
+
+/* spellcheck a word */
+/* fix s ; if hist is nonzero, fix the history list too */
+
+/**/
+void
+spckword(char **s, int hist, int cmd, int ask)
+{
+    char *t, *u;
+    int x;
+    char ic = '\0';
+    int ne;
+    int preflen = 0;
+
+    if ((histdone & HISTFLAG_NOEXEC) || **s == '-' || **s == '%')
+	return;
+    if (!strcmp(*s, "in"))
+	return;
+    if (!(*s)[0] || !(*s)[1])
+	return;
+    if (shfunctab->getnode(shfunctab, *s) ||
+	builtintab->getnode(builtintab, *s) ||
+	cmdnamtab->getnode(cmdnamtab, *s) ||
+	aliastab->getnode(aliastab, *s)  ||
+	reswdtab->getnode(reswdtab, *s))
+	return;
+    else if (isset(HASHLISTALL)) {
+	cmdnamtab->filltable(cmdnamtab);
+	if (cmdnamtab->getnode(cmdnamtab, *s))
+	    return;
+    }
+    t = *s;
+    if (*t == Tilde || *t == Equals || *t == String)
+	t++;
+    for (; *t; t++)
+	if (itok(*t))
+	    return;
+    best = NULL;
+    for (t = *s; *t; t++)
+	if (*t == '/')
+	    break;
+    if (**s == Tilde && !*t)
+	return;
+    if (**s == String && !*t) {
+	guess = *s + 1;
+	if (*t || !ialpha(*guess))
+	    return;
+	ic = String;
+	d = 100;
+	scanhashtable(paramtab, 1, 0, 0, spscan, 0);
+    } else if (**s == Equals) {
+	if (*t)
+	    return;
+	if (hashcmd(guess = *s + 1, pathchecked))
+	    return;
+	d = 100;
+	ic = Equals;
+	scanhashtable(aliastab, 1, 0, 0, spscan, 0);
+	scanhashtable(cmdnamtab, 1, 0, 0, spscan, 0);
+    } else {
+	guess = *s;
+	if (*guess == Tilde || *guess == String) {
+	    ic = *guess;
+	    if (!*++t)
+		return;
+	    guess = dupstring(guess);
+	    ne = noerrs;
+	    noerrs = 1;
+	    singsub(&guess);
+	    noerrs = ne;
+	    if (!guess)
+		return;
+	    preflen = strlen(guess) - strlen(t);
+	}
+	if (access(unmeta(guess), F_OK) == 0)
+	    return;
+	if ((u = spname(guess)) != guess)
+	    best = u;
+	if (!*t && cmd) {
+	    if (hashcmd(guess, pathchecked))
+		return;
+	    d = 100;
+	    scanhashtable(reswdtab, 1, 0, 0, spscan, 0);
+	    scanhashtable(aliastab, 1, 0, 0, spscan, 0);
+	    scanhashtable(shfunctab, 1, 0, 0, spscan, 0);
+	    scanhashtable(builtintab, 1, 0, 0, spscan, 0);
+	    scanhashtable(cmdnamtab, 1, 0, 0, spscan, 0);
+	}
+    }
+    if (errflag)
+	return;
+    if (best && (int)strlen(best) > 1 && strcmp(best, guess)) {
+	if (ic) {
+	    if (preflen) {
+		/* do not correct the result of an expansion */
+		if (strncmp(guess, best, preflen))
+		    return;
+		/* replace the temporarily expanded prefix with the original */
+		u = (char *) ncalloc(t - *s + strlen(best + preflen) + 1);
+		strncpy(u, *s, t - *s);
+		strcpy(u + (t - *s), best + preflen);
+	    } else {
+		u = (char *) ncalloc(strlen(best) + 2);
+		strcpy(u + 1, best);
+	    }
+	    best = u;
+	    guess = *s;
+	    *guess = *best = ztokens[ic - Pound];
+	}
+	if (ask) {
+	    char *pptbuf;
+	    pptbuf = promptexpand(sprompt, 0, best, guess);
+	    zputs(pptbuf, shout);
+	    free(pptbuf);
+	    fflush(shout);
+	    beep();
+	    x = getquery("nyae ", 0);
+	} else
+	    x = 'y';
+	if (x == 'y' || x == ' ') {
+	    *s = dupstring(best);
+	    if (hist)
+		hwrep(best);
+	} else if (x == 'a') {
+	    histdone |= HISTFLAG_NOEXEC;
+	} else if (x == 'e') {
+	    histdone |= HISTFLAG_NOEXEC | HISTFLAG_RECALL;
+	}
+	if (ic)
+	    **s = ic;
+    }
+}
+
+/**/
+int
+ztrftime(char *buf, int bufsize, char *fmt, struct tm *tm)
+{
+    int hr12;
+#ifndef HAVE_STRFTIME
+    static char *astr[] =
+    {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+    static char *estr[] =
+    {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
+     "Aug", "Sep", "Oct", "Nov", "Dec"};
+#else
+    char *origbuf = buf;
+#endif
+    char tmp[3];
+
+
+    tmp[0] = '%';
+    tmp[2] = '\0';
+    while (*fmt)
+	if (*fmt == '%') {
+	    fmt++;
+	    switch (*fmt++) {
+	    case 'd':
+		*buf++ = '0' + tm->tm_mday / 10;
+		*buf++ = '0' + tm->tm_mday % 10;
+		break;
+	    case 'e':
+	    case 'f':
+		if (tm->tm_mday > 9)
+		    *buf++ = '0' + tm->tm_mday / 10;
+		else if (fmt[-1] == 'e')
+		    *buf++ = ' ';
+		*buf++ = '0' + tm->tm_mday % 10;
+		break;
+	    case 'k':
+	    case 'K':
+		if (tm->tm_hour > 9)
+		    *buf++ = '0' + tm->tm_hour / 10;
+		else if (fmt[-1] == 'k')
+		    *buf++ = ' ';
+		*buf++ = '0' + tm->tm_hour % 10;
+		break;
+	    case 'l':
+	    case 'L':
+		hr12 = tm->tm_hour % 12;
+		if (hr12 == 0)
+		    hr12 = 12;
+	        if (hr12 > 9)
+		  *buf++ = '1';
+		else if (fmt[-1] == 'l')
+		  *buf++ = ' ';
+		*buf++ = '0' + (hr12 % 10);
+		break;
+	    case 'm':
+		*buf++ = '0' + (tm->tm_mon + 1) / 10;
+		*buf++ = '0' + (tm->tm_mon + 1) % 10;
+		break;
+	    case 'M':
+		*buf++ = '0' + tm->tm_min / 10;
+		*buf++ = '0' + tm->tm_min % 10;
+		break;
+	    case 'S':
+		*buf++ = '0' + tm->tm_sec / 10;
+		*buf++ = '0' + tm->tm_sec % 10;
+		break;
+	    case 'y':
+		*buf++ = '0' + (tm->tm_year / 10) % 10;
+		*buf++ = '0' + tm->tm_year % 10;
+		break;
+#ifndef HAVE_STRFTIME
+	    case 'a':
+		strucpy(&buf, astr[tm->tm_wday]);
+		break;
+	    case 'b':
+		strucpy(&buf, estr[tm->tm_mon]);
+		break;
+	    case 'p':
+		*buf++ = (tm->tm_hour > 11) ? 'p' : 'a';
+		*buf++ = 'm';
+		break;
+	    default:
+		*buf++ = '%';
+		if (fmt[-1] != '%')
+		    *buf++ = fmt[-1];
+#else
+	    default:
+		*buf = '\0';
+		tmp[1] = fmt[-1];
+		strftime(buf, bufsize - strlen(origbuf), tmp, tm);
+		buf += strlen(buf);
+#endif
+		break;
+	    }
+	} else
+	    *buf++ = *fmt++;
+    *buf = '\0';
+    return 0;
+}
+
+/**/
+char *
+zjoin(char **arr, int delim)
+{
+    int len = 0;
+    char **s, *ret, *ptr;
+
+    for (s = arr; *s; s++)
+	len += strlen(*s) + 1;
+    if (!len)
+	return "";
+    ptr = ret = (char *) ncalloc(len);
+    for (s = arr; *s; s++) {
+	strucpy(&ptr, *s);
+	if (delim)
+	    *ptr++ = delim;
+    }
+    ptr[-1] = '\0';
+    return ret;
+}
+
+/* Split a string containing a colon separated list *
+ * of items into an array of strings.               */
+
+/**/
+char **
+colonsplit(char *s, int uniq)
+{
+    int ct;
+    char *t, **ret, **ptr, **p;
+
+    for (t = s, ct = 0; *t; t++) /* count number of colons */
+	if (*t == ':')
+	    ct++;
+    ptr = ret = (char **) zalloc(sizeof(char **) * (ct + 2));
+
+    t = s;
+    do {
+	s = t;
+        /* move t to point at next colon */
+	for (; *t && *t != ':'; t++);
+	if (uniq)
+	    for (p = ret; p < ptr; p++)
+		if (strlen(*p) == t - s && ! strncmp(*p, s, t - s))
+		    goto cont;
+	*ptr = (char *) zalloc((t - s) + 1);
+	ztrncpy(*ptr++, s, t - s);
+      cont: ;
+    }
+    while (*t++);
+    *ptr = NULL;
+    return ret;
+}
+
+/**/
+static int
+skipwsep(char **s)
+{
+    char *t = *s;
+    int i = 0;
+
+    while (*t && iwsep(*t == Meta ? t[1] ^ 32 : *t)) {
+	if (*t == Meta)
+	    t++;
+	t++;
+	i++;
+    }
+    *s = t;
+    return i;
+}
+
+/**/
+char **
+spacesplit(char *s, int allownull)
+{
+    char *t, **ret, **ptr;
+
+    ptr = ret = (char **) ncalloc(sizeof(*ret) * (wordcount(s, NULL, -!allownull) + 1));
+
+    t = s;
+    skipwsep(&s);
+    if (*s && isep(*s == Meta ? s[1] ^ 32 : *s))
+	*ptr++ = dupstring(allownull ? "" : nulstring);
+    else if (!allownull && t != s)
+	*ptr++ = dupstring("");
+    while (*s) {
+	if (isep(*s == Meta ? s[1] ^ 32 : *s)) {
+	    if (*s == Meta)
+		s++;
+	    s++;
+	    skipwsep(&s);
+	}
+	t = s;
+	findsep(&s, NULL);
+	if (s > t || allownull) {
+	    *ptr = (char *) ncalloc((s - t) + 1);
+	    ztrncpy(*ptr++, t, s - t);
+	} else
+	    *ptr++ = dupstring(nulstring);
+	t = s;
+	skipwsep(&s);
+    }
+    if (!allownull && t != s)
+	*ptr++ = dupstring("");
+    *ptr = NULL;
+    return ret;
+}
+
+/**/
+static int
+findsep(char **s, char *sep)
+{
+    int i;
+    char *t, *tt;
+
+    if (!sep) {
+	for (t = *s; *t; t++) {
+	    if (*t == Meta) {
+		if (isep(t[1] ^ 32))
+		    break;
+		t++;
+	    } else if (isep(*t))
+		break;
+	}
+	i = t - *s;
+	*s = t;
+	return i;
+    }
+    if (!sep[0]) {
+	return **s ? ++*s, 1 : -1;
+    }
+    for (i = 0; **s; i++) {
+	for (t = sep, tt = *s; *t && *tt && *t == *tt; t++, tt++);
+	if (!*t)
+	    return i;
+	if (*(*s)++ == Meta) {
+	    (*s)++;
+#ifdef DEBUG
+	    if (! **s)
+		fprintf(stderr, "BUG: unexpected end of string in findsep()\n");
+#endif
+	}
+    }
+    return -1;
+}
+
+/**/
+char *
+findword(char **s, char *sep)
+{
+    char *r, *t;
+    int sl;
+
+    if (!**s)
+	return NULL;
+
+    if (sep) {
+	sl = strlen(sep);
+	r = *s;
+	while (! findsep(s, sep)) {
+	    r = *s += sl;
+	}
+	return r;
+    }
+    for (t = *s; *t; t++) {
+	if (*t == Meta) {
+	    if (! isep(t[1] ^ 32))
+		break;
+	    t++;
+	} else if (! isep(*t))
+	    break;
+    }
+    *s = t;
+    findsep(s, sep);
+    return t;
+}
+
+/**/
+int
+wordcount(char *s, char *sep, int mul)
+{
+    int r, sl, c;
+
+    if (sep) {
+	r = 1;
+	sl = strlen(sep);
+	for (; (c = findsep(&s, sep)) >= 0; s += sl)
+	    if ((c && *(s + sl)) || mul)
+		r++;
+    } else {
+	char *t = s;
+
+	r = 0;
+	if (mul <= 0)
+	    skipwsep(&s);
+	if ((*s && isep(*s == Meta ? s[1] ^ 32 : *s)) ||
+	    (mul < 0 && t != s))
+	    r++;
+	for (; *s; r++) {
+	    if (isep(*s == Meta ? s[1] ^ 32 : *s)) {
+		if (*s == Meta)
+		    s++;
+		s++;
+		if (mul <= 0)
+		    skipwsep(&s);
+	    }
+	    findsep(&s, NULL);
+	    t = s;
+	    if (mul <= 0)
+		skipwsep(&s);
+	}
+	if (mul < 0 && t != s)
+	    r++;
+    }
+    return r;
+}
+
+/**/
+char *
+sepjoin(char **s, char *sep)
+{
+    char *r, *p, **t;
+    int l, sl, elide = 0;
+    char sepbuf[3];
+
+    if (!*s)
+	return "";
+    if (!sep) {
+	elide = 1;
+	sep = sepbuf;
+	sepbuf[0] = *ifs;
+	sepbuf[1] = *ifs == Meta ? ifs[1] ^ 32 : '\0';
+	sepbuf[2] = '\0';
+    }
+    sl = strlen(sep);
+    for (t = s, l = 1 - sl; *t; l += strlen(*t) + sl, t++);
+    r = p = (char *) ncalloc(l);
+    t = s;
+    while (*t) {
+	strucpy(&p, *t);
+	if (*++t)
+	    strucpy(&p, sep);
+    }
+    *p = '\0';
+    return r;
+}
+
+/**/
+char **
+sepsplit(char *s, char *sep, int allownull)
+{
+    int n, sl;
+    char *t, *tt, **r, **p;
+
+    if (!sep)
+	return spacesplit(s, allownull);
+
+    sl = strlen(sep);
+    n = wordcount(s, sep, 1);
+    r = p = (char **) ncalloc((n + 1) * sizeof(char *));
+
+    for (t = s; n--;) {
+	tt = t;
+	findsep(&t, sep);
+	*p = (char *) ncalloc(t - tt + 1);
+	strncpy(*p, tt, t - tt);
+	(*p)[t - tt] = '\0';
+	p++;
+	t += sl;
+    }
+    *p = NULL;
+
+    return r;
+}
+
+/* Get the definition of a shell function */
+
+/**/
+List
+getshfunc(char *nam)
+{
+    Shfunc shf;
+
+    if (!(shf = (Shfunc) shfunctab->getnode(shfunctab, nam)))
+	return &dummy_list;
+
+    return shf->funcdef;
+}
+
+/* allocate a tree element */
+
+static int sizetab[N_COUNT] = {
+    sizeof(struct list),
+    sizeof(struct sublist),
+    sizeof(struct pline),
+    sizeof(struct cmd),
+    sizeof(struct redir),
+    sizeof(struct cond),
+    sizeof(struct forcmd),
+    sizeof(struct casecmd),
+    sizeof(struct ifcmd),
+    sizeof(struct whilecmd),
+    sizeof(struct varasg),
+    sizeof(struct autofn),
+};
+
+static int offstab[N_COUNT] = {
+    offsetof(struct list, left),
+    offsetof(struct sublist, left),
+    offsetof(struct pline, left),
+    offsetof(struct cmd, u),
+    offsetof(struct redir, name),
+    offsetof(struct cond, left),
+    offsetof(struct forcmd, name),
+    offsetof(struct casecmd, pats),
+    offsetof(struct ifcmd, ifls),
+    offsetof(struct whilecmd, cont),
+    offsetof(struct varasg, name),
+    sizeof(struct autofn),
+};
+
+static int flagtab[N_COUNT] = {
+    NT_SET(N_LIST, NT_NODE, NT_NODE, 0, 0),
+    NT_SET(N_SUBLIST, NT_NODE, NT_NODE, 0, 0),
+    NT_SET(N_PLINE, NT_NODE, NT_NODE, 0, 0),
+    NT_SET(N_CMD, NT_NODE, NT_STR | NT_LIST, NT_NODE | NT_LIST, NT_NODE | NT_LIST),
+    NT_SET(N_REDIR, NT_STR, 0, 0, 0),
+    NT_SET(N_COND, NT_NODE, NT_NODE, 0, 0),
+    NT_SET(N_FOR, NT_STR, NT_STR, NT_STR, NT_NODE),
+    NT_SET(N_CASE, NT_STR | NT_ARR, NT_NODE | NT_ARR, 0, 0),
+    NT_SET(N_IF, NT_NODE | NT_ARR, NT_NODE | NT_ARR, 0, 0),
+    NT_SET(N_WHILE, NT_NODE, NT_NODE, 0, 0),
+    NT_SET(N_VARASG, NT_STR, NT_STR, NT_STR | NT_LIST, 0),
+    NT_SET(N_AUTOFN, 0, 0, 0, 0),
+};
+
+/**/
+void *
+allocnode(int type)
+{
+    struct node *n;
+
+    n = (struct node *) alloc(sizetab[type]);
+    memset((void *) n, 0, sizetab[type]);
+    n->ntype = flagtab[type];
+    if (useheap)
+	n->ntype |= NT_HEAP;
+
+    return (void *) n;
+}
+
+/**/
+void *
+dupstruct(void *a)
+{
+    struct node *n, *r;
+
+    n = (struct node *) a;
+    if (!a || ((List) a) == &dummy_list)
+	return (void *) a;
+
+    if ((n->ntype & NT_HEAP) && !useheap) {
+	HEAPALLOC {
+	    n = (struct node *) dupstruct2((void *) n);
+	} LASTALLOC;
+	n = simplifystruct(n);
+    }
+    r = (struct node *)dupstruct2((void *) n);
+
+    if (!(n->ntype & NT_HEAP) && useheap)
+	r = expandstruct(r, N_LIST);
+
+    return (void *) r;
+}
+
+/**/
+static struct node *
+simplifystruct(struct node *n)
+{
+    if (!n || ((List) n) == &dummy_list)
+	return n;
+
+    switch (NT_TYPE(n->ntype)) {
+    case N_LIST:
+	{
+	    List l = (List) n;
+
+	    l->left = (Sublist) simplifystruct((struct node *)l->left);
+	    if ((l->type & Z_SYNC) && !l->right)
+		return (struct node *)l->left;
+	}
+	break;
+    case N_SUBLIST:
+	{
+	    Sublist sl = (Sublist) n;
+
+	    sl->left = (Pline) simplifystruct((struct node *)sl->left);
+	    if (sl->type == END && !sl->flags && !sl->right)
+		return (struct node *)sl->left;
+	}
+	break;
+    case N_PLINE:
+	{
+	    Pline pl = (Pline) n;
+
+	    pl->left = (Cmd) simplifystruct((struct node *)pl->left);
+	    if (pl->type == END && !pl->right)
+		return (struct node *)pl->left;
+	}
+	break;
+    case N_CMD:
+	{
+	    Cmd c = (Cmd) n;
+	    int i = 0;
+
+	    if (empty(c->args))
+		c->args = NULL, i++;
+	    if (empty(c->redir))
+		c->redir = NULL, i++;
+	    if (empty(c->vars))
+		c->vars = NULL, i++;
+
+	    c->u.list = (List) simplifystruct((struct node *)c->u.list);
+	    if (i == 3 && !c->flags &&
+		(c->type == CWHILE || c->type == CIF ||
+		 c->type == COND))
+		return (struct node *)c->u.list;
+	}
+	break;
+    case N_FOR:
+	{
+	    Forcmd f = (Forcmd) n;
+
+	    f->list = (List) simplifystruct((struct node *)f->list);
+	}
+	break;
+    case N_CASE:
+	{
+	    struct casecmd *c = (struct casecmd *)n;
+	    List *l;
+
+	    for (l = c->lists; *l; l++)
+		*l = (List) simplifystruct((struct node *)*l);
+	}
+	break;
+    case N_IF:
+	{
+	    struct ifcmd *i = (struct ifcmd *)n;
+	    List *l;
+
+	    for (l = i->ifls; *l; l++)
+		*l = (List) simplifystruct((struct node *)*l);
+	    for (l = i->thenls; *l; l++)
+		*l = (List) simplifystruct((struct node *)*l);
+	}
+	break;
+    case N_WHILE:
+	{
+	    struct whilecmd *w = (struct whilecmd *)n;
+
+	    w->cont = (List) simplifystruct((struct node *)w->cont);
+	    w->loop = (List) simplifystruct((struct node *)w->loop);
+	}
+    }
+
+    return n;
+}
+
+/**/
+struct node *
+expandstruct(struct node *n, int exp)
+{
+    struct node *m;
+
+    if (!n || ((List) n) == &dummy_list)
+	return n;
+
+    if (exp != N_COUNT && exp != NT_TYPE(n->ntype)) {
+	switch (exp) {
+	case N_LIST:
+	    {
+		List l;
+
+		m = (struct node *) allocnode(N_LIST);
+		l = (List) m;
+		l->type = Z_SYNC;
+		l->left = (Sublist) expandstruct(n, N_SUBLIST);
+
+		return (struct node *)l;
+	    }
+	case N_SUBLIST:
+	    {
+		Sublist sl;
+
+		m = (struct node *) allocnode(N_SUBLIST);
+		sl = (Sublist) m;
+		sl->type = END;
+		sl->left = (Pline) expandstruct(n, N_PLINE);
+
+		return (struct node *)sl;
+	    }
+	case N_PLINE:
+	    {
+		Pline pl;
+
+		m = (struct node *) allocnode(N_PLINE);
+		pl = (Pline) m;
+		pl->type = END;
+		pl->left = (Cmd) expandstruct(n, N_CMD);
+
+		return (struct node *)pl;
+	    }
+	case N_CMD:
+	    {
+		Cmd c;
+
+		m = (struct node *) allocnode(N_CMD);
+		c = (Cmd) m;
+		switch (NT_TYPE(n->ntype)) {
+		case N_WHILE:
+		    c->type = CWHILE;
+		    break;
+		case N_IF:
+		    c->type = CIF;
+		    break;
+		case N_COND:
+		    c->type = COND;
+		}
+		c->u.list = (List) expandstruct(n, NT_TYPE(n->ntype));
+		c->args = newlinklist();
+		c->vars = newlinklist();
+		c->redir = newlinklist();
+
+		return (struct node *)c;
+	    }
+	}
+    } else
+	switch (NT_TYPE(n->ntype)) {
+	case N_LIST:
+	    {
+		List l = (List) n;
+
+		l->left = (Sublist) expandstruct((struct node *)l->left,
+						 N_SUBLIST);
+		l->right = (List) expandstruct((struct node *)l->right,
+					       N_LIST);
+	    }
+	    break;
+	case N_SUBLIST:
+	    {
+		Sublist sl = (Sublist) n;
+
+		sl->left = (Pline) expandstruct((struct node *)sl->left,
+						N_PLINE);
+		sl->right = (Sublist) expandstruct((struct node *)sl->right,
+						   N_SUBLIST);
+	    }
+	    break;
+	case N_PLINE:
+	    {
+		Pline pl = (Pline) n;
+
+		pl->left = (Cmd) expandstruct((struct node *)pl->left,
+					      N_CMD);
+		pl->right = (Pline) expandstruct((struct node *)pl->right,
+						 N_PLINE);
+	    }
+	    break;
+	case N_CMD:
+	    {
+		Cmd c = (Cmd) n;
+
+		if (!c->args)
+		    c->args = newlinklist();
+		if (!c->vars)
+		    c->vars = newlinklist();
+		if (!c->redir)
+		    c->redir = newlinklist();
+
+		switch (c->type) {
+		case CFOR:
+		case CSELECT:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_FOR);
+		    break;
+		case CWHILE:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_WHILE);
+		    break;
+		case CIF:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_IF);
+		    break;
+		case CCASE:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_CASE);
+		    break;
+		case COND:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_COND);
+		    break;
+		case ZCTIME:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_SUBLIST);
+		    break;
+		case AUTOFN:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_AUTOFN);
+		    break;
+		default:
+		    c->u.list = (List) expandstruct((struct node *)c->u.list,
+						    N_LIST);
+		}
+	    }
+	    break;
+	case N_FOR:
+	    {
+		Forcmd f = (Forcmd) n;
+
+		f->list = (List) expandstruct((struct node *)f->list,
+					      N_LIST);
+	    }
+	    break;
+	case N_CASE:
+	    {
+		struct casecmd *c = (struct casecmd *)n;
+		List *l;
+
+		for (l = c->lists; *l; l++)
+		    *l = (List) expandstruct((struct node *)*l, N_LIST);
+	    }
+	    break;
+	case N_IF:
+	    {
+		struct ifcmd *i = (struct ifcmd *)n;
+		List *l;
+
+		for (l = i->ifls; *l; l++)
+		    *l = (List) expandstruct((struct node *)*l, N_LIST);
+		for (l = i->thenls; *l; l++)
+		    *l = (List) expandstruct((struct node *)*l, N_LIST);
+	    }
+	    break;
+	case N_WHILE:
+	    {
+		struct whilecmd *w = (struct whilecmd *)n;
+
+		w->cont = (List) expandstruct((struct node *)w->cont,
+					      N_LIST);
+		w->loop = (List) expandstruct((struct node *)w->loop,
+					      N_LIST);
+	    }
+	}
+
+    return n;
+}
+
+/* duplicate a syntax tree */
+
+/**/
+static void *
+dupstruct2(void *a)
+{
+    void **onodes, **nnodes, *ret, *n, *on;
+    int type, heap;
+    size_t nodeoffs;
+
+    if (!a || ((List) a) == &dummy_list)
+	return a;
+    type = *(int *)a;
+    ret = alloc(sizetab[NT_TYPE(type)]);
+    memcpy(ret, a, nodeoffs = offstab[NT_TYPE(type)]);
+    *(int*)ret = (type & ~NT_HEAP) | (useheap ? NT_HEAP : 0);
+    onodes = (void **) ((char *)a + nodeoffs);
+    nnodes = (void **) ((char *)ret + nodeoffs);
+    heap = type & NT_HEAP;
+    for (type = (type & 0xffff00) >> 4; (type >>= 4); *nnodes++ = n) {
+	if (!(on = *onodes++))
+	    n = NULL;
+	else {
+	    switch (type & 0xf) {
+	    case NT_NODE:
+		n = dupstruct2(on);
+		break;
+	    case NT_STR:
+		n = dupstring(on);
+		break;
+	    case NT_LIST | NT_NODE:
+		if (heap)
+		    if (useheap)
+			n =  duplist(on, (VFunc) dupstruct2);
+		    else
+			n = list2arr(on, (VFunc) dupstruct2);
+		else if (useheap)
+		    n = arr2list(on, (VFunc) dupstruct2);
+		else
+		    n = duparray(on, (VFunc) dupstruct2);
+		break;
+	    case NT_LIST | NT_STR:
+		if (heap)
+		    if (useheap)
+			n = duplist(on, (VFunc) dupstring);
+		    else
+			n = list2arr(on, (VFunc) ztrdup);
+		else if (useheap)
+		    n = arr2list(on, (VFunc) dupstring);
+		else
+		    n = duparray(on, (VFunc) ztrdup);
+		break;
+	    case NT_NODE | NT_ARR:
+		n = duparray(on, (VFunc) dupstruct2);
+		break;
+	    case NT_STR | NT_ARR:
+		n = duparray(on, (VFunc) (useheap ? dupstring : ztrdup));
+		break;
+	    default:
+		DPUTS(1, "BUG: bad node type in dupstruct2()");
+		abort();
+	    }
+	}
+    }
+    return ret;
+}
+
+/* free a syntax tree */
+
+/**/
+void
+freestruct(void *a)
+{
+    void **nodes, *n;
+    int type, size;
+
+    if (!a || ((List) a) == &dummy_list)
+	return;
+
+    type = * (int *) a;
+    nodes = (void **) ((char *)a + offstab[NT_TYPE(type)]);
+    size = sizetab[NT_TYPE(type)];
+    for (type = (type & 0xffff00) >> 4; (type >>= 4);) {
+	if ((n = *nodes++)) {
+	    switch (type & 0xf) {
+	    case NT_NODE:
+		freestruct(n);
+		break;
+	    case NT_STR:
+		zsfree((char *) n);
+		break;
+	    case NT_LIST | NT_NODE:
+	    case NT_NODE | NT_ARR:
+	    {
+		void **p = (void **) n;
+
+		while (*p)
+		    freestruct(*p++);
+		zfree(n, sizeof(void *) * (p + 1 - (void **) n));
+		break;
+	    }
+	    case NT_LIST | NT_STR:
+	    case NT_STR | NT_ARR:
+		freearray((char **) n);
+		break;
+	    default:
+		DPUTS(1, "BUG: bad node type in freenode()");
+		abort();
+	    }
+	}
+    }
+    DPUTS(size != ((char *) nodes) - ((char *) a),
+	"BUG: size wrong in freenode()");
+    zfree(a, size);
+}
+
+/**/
+static LinkList
+duplist(LinkList l, VFunc func)
+{
+    LinkList ret;
+    LinkNode node;
+
+    ret = newlinklist();
+    for (node = firstnode(l); node; incnode(node))
+	addlinknode(ret, func(getdata(node)));
+    return ret;
+}
+
+/**/
+static char **
+duparray(char **arr, VFunc func)
+{
+    char **ret, **rr;
+
+    ret = (char **) alloc((arrlen(arr) + 1) * sizeof(char *));
+    for (rr = ret; *arr;)
+	*rr++ = (char *)func(*arr++);
+    *rr = NULL;
+
+    return ret;
+}
+
+/**/
+static char **
+list2arr(LinkList l, VFunc func)
+{
+    char **arr, **r;
+    LinkNode n;
+
+    arr = r = (char **) alloc((countlinknodes(l) + 1) * sizeof(char *));
+
+    for (n = firstnode(l); n; incnode(n))
+	*r++ = (char *)func(getdata(n));
+    *r = NULL;
+
+    return arr;
+}
+
+/**/
+static LinkList
+arr2list(char **arr, VFunc func)
+{
+    LinkList l = newlinklist();
+
+    while (*arr)
+	addlinknode(l, func(*arr++));
+
+    return l;
+}
+
+/**/
+char **
+mkarray(char *s)
+{
+    char **t = (char **) zalloc((s) ? (2 * sizeof s) : (sizeof s));
+
+    if ((*t = s))
+	t[1] = NULL;
+    return t;
+}
+
+/**/
+void
+beep(void)
+{
+    if (isset(BEEP))
+	write(SHTTY, "\07", 1);
+}
+
+/**/
+void
+freearray(char **s)
+{
+    char **t = s;
+
+    while (*s)
+	zsfree(*s++);
+    free(t);
+}
+
+/**/
+int
+equalsplit(char *s, char **t)
+{
+    for (; *s && *s != '='; s++);
+    if (*s == '=') {
+	*s++ = '\0';
+	*t = s;
+	return 1;
+    }
+    return 0;
+}
+
+/* see if the right side of a list is trivial */
+
+/**/
+void
+simplifyright(List l)
+{
+    Cmd c;
+
+    if (l == &dummy_list || !l->right)
+	return;
+    if (l->right->right || l->right->left->right ||
+	l->right->left->flags || l->right->left->left->right ||
+	l->left->flags)
+	return;
+    c = l->left->left->left;
+    if (c->type != SIMPLE || nonempty(c->args) || nonempty(c->redir)
+	|| nonempty(c->vars))
+	return;
+    l->right = NULL;
+    return;
+}
+
+/* the ztypes table */
+
+/**/
+short int typtab[256];
+
+/* initialize the ztypes table */
+
+/**/
+void
+inittyptab(void)
+{
+    int t0;
+    char *s;
+
+    for (t0 = 0; t0 != 256; t0++)
+	typtab[t0] = 0;
+    for (t0 = 0; t0 != 32; t0++)
+	typtab[t0] = typtab[t0 + 128] = ICNTRL;
+    typtab[127] = ICNTRL;
+    for (t0 = '0'; t0 <= '9'; t0++)
+	typtab[t0] = IDIGIT | IALNUM | IWORD | IIDENT | IUSER;
+    for (t0 = 'a'; t0 <= 'z'; t0++)
+	typtab[t0] = typtab[t0 - 'a' + 'A'] = IALPHA | IALNUM | IIDENT | IUSER | IWORD;
+    for (t0 = 0240; t0 != 0400; t0++)
+	typtab[t0] = IALPHA | IALNUM | IIDENT | IUSER | IWORD;
+    typtab['_'] = IIDENT | IUSER;
+    typtab['-'] = IUSER;
+    typtab[' '] |= IBLANK | INBLANK;
+    typtab['\t'] |= IBLANK | INBLANK;
+    typtab['\n'] |= INBLANK;
+    typtab['\0'] |= IMETA;
+    typtab[STOUC(Meta)  ] |= IMETA;
+    typtab[STOUC(Marker)] |= IMETA;
+    for (t0 = (int)STOUC(Pound); t0 <= (int)STOUC(Nularg); t0++)
+	typtab[t0] |= ITOK | IMETA;
+    for (s = ifs ? ifs : DEFAULT_IFS; *s; s++) {
+	if (inblank(*s))
+	    if (s[1] == *s)
+		s++;
+	    else
+		typtab[STOUC(*s)] |= IWSEP;
+	typtab[STOUC(*s == Meta ? *++s ^ 32 : *s)] |= ISEP;
+    }
+    for (s = wordchars ? wordchars : DEFAULT_WORDCHARS; *s; s++)
+	typtab[STOUC(*s == Meta ? *++s ^ 32 : *s)] |= IWORD;
+    for (s = SPECCHARS; *s; s++)
+	typtab[STOUC(*s)] |= ISPECIAL;
+    if (isset(BANGHIST) && bangchar && interact && isset(SHINSTDIN))
+	typtab[bangchar] |= ISPECIAL;
+}
+
+/**/
+char **
+arrdup(char **s)
+{
+    char **x, **y;
+
+    y = x = (char **) ncalloc(sizeof(char *) * (arrlen(s) + 1));
+
+    while ((*x++ = dupstring(*s++)));
+    return y;
+}
+
+/**/
+static char *
+spname(char *oldname)
+{
+    char *p, spnameguess[PATH_MAX + 1], spnamebest[PATH_MAX + 1];
+    static char newname[PATH_MAX + 1];
+    char *new = newname, *old;
+    int bestdist = 200, thisdist;
+
+    old = oldname;
+    for (;;) {
+	while (*old == '/')
+	    *new++ = *old++;
+	*new = '\0';
+	if (*old == '\0')
+	    return newname;
+	p = spnameguess;
+	for (; *old != '/' && *old != '\0'; old++)
+	    if (p < spnameguess + PATH_MAX)
+		*p++ = *old;
+	*p = '\0';
+	if ((thisdist = mindist(newname, spnameguess, spnamebest)) >= 3) {
+	    if (bestdist < 3) {
+		strcpy(new, spnameguess);
+		strcat(new, old);
+		return newname;
+	    } else
+	    	return NULL;
+	} else
+	    bestdist = thisdist;
+	for (p = spnamebest; (*new = *p++);)
+	    new++;
+    }
+}
+
+/**/
+static int
+mindist(char *dir, char *mindistguess, char *mindistbest)
+{
+    int mindistd, nd;
+    DIR *dd;
+    char *fn;
+    char buf[PATH_MAX];
+
+    if (dir[0] == '\0')
+	dir = ".";
+    mindistd = 100;
+    sprintf(buf, "%s/%s", dir, mindistguess);
+    if (access(unmeta(buf), F_OK) == 0) {
+	strcpy(mindistbest, mindistguess);
+	return 0;
+    }
+    if (!(dd = opendir(unmeta(dir))))
+	return mindistd;
+    while ((fn = zreaddir(dd, 0))) {
+	nd = spdist(fn, mindistguess,
+		    (int)strlen(mindistguess) / 4 + 1);
+	if (nd <= mindistd) {
+	    strcpy(mindistbest, fn);
+	    mindistd = nd;
+	    if (mindistd == 0)
+		break;
+	}
+    }
+    closedir(dd);
+    return mindistd;
+}
+
+/**/
+static int
+spdist(char *s, char *t, int thresh)
+{
+    char *p, *q;
+    char *keymap =
+    "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\
+\t1234567890-=\t\
+\tqwertyuiop[]\t\
+\tasdfghjkl;'\n\t\
+\tzxcvbnm,./\t\t\t\
+\n\n\n\n\n\n\n\n\n\n\n\n\n\n\
+\t!@#$%^&*()_+\t\
+\tQWERTYUIOP{}\t\
+\tASDFGHJKL:\"\n\t\
+\tZXCVBNM<>?\n\n\t\
+\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
+
+    if (!strcmp(s, t))
+	return 0;
+/* any number of upper/lower mistakes allowed (dist = 1) */
+    for (p = s, q = t; *p && tulower(*p) == tulower(*q); p++, q++);
+    if (!*p && !*q)
+	return 1;
+    if (!thresh)
+	return 200;
+    for (p = s, q = t; *p && *q; p++, q++)
+	if (*p == *q)
+	    continue;		/* don't consider "aa" transposed, ash */
+	else if (p[1] == q[0] && q[1] == p[0])	/* transpositions */
+	    return spdist(p + 2, q + 2, thresh - 1) + 1;
+	else if (p[1] == q[0])	/* missing letter */
+	    return spdist(p + 1, q + 0, thresh - 1) + 2;
+	else if (p[0] == q[1])	/* missing letter */
+	    return spdist(p + 0, q + 1, thresh - 1) + 2;
+	else if (*p != *q)
+	    break;
+    if ((!*p && strlen(q) == 1) || (!*q && strlen(p) == 1))
+	return 2;
+    for (p = s, q = t; *p && *q; p++, q++)
+	if (p[0] != q[0] && p[1] == q[1]) {
+	    int t0;
+	    char *z;
+
+	/* mistyped letter */
+
+	    if (!(z = strchr(keymap, p[0])) || *z == '\n' || *z == '\t')
+		return spdist(p + 1, q + 1, thresh - 1) + 1;
+	    t0 = z - keymap;
+	    if (*q == keymap[t0 - 15] || *q == keymap[t0 - 14] ||
+		*q == keymap[t0 - 13] ||
+		*q == keymap[t0 - 1] || *q == keymap[t0 + 1] ||
+		*q == keymap[t0 + 13] || *q == keymap[t0 + 14] ||
+		*q == keymap[t0 + 15])
+		return spdist(p + 1, q + 1, thresh - 1) + 2;
+	    return 200;
+	} else if (*p != *q)
+	    break;
+    return 200;
+}
+
+/* set cbreak mode, or the equivalent */
+
+/**/
+void
+setcbreak(void)
+{
+    struct ttyinfo ti;
+
+    ti = shttyinfo;
+#ifdef HAS_TIO
+    ti.tio.c_lflag &= ~ICANON;
+    ti.tio.c_cc[VMIN] = 1;
+    ti.tio.c_cc[VTIME] = 0;
+#else
+    ti.sgttyb.sg_flags |= CBREAK;
+#endif
+    settyinfo(&ti);
+}
+
+/* give the tty to some process */
+
+/**/
+void
+attachtty(pid_t pgrp)
+{
+    static int ep = 0;
+
+    if (jobbing) {
+#ifdef HAVE_TCSETPGRP
+	if (SHTTY != -1 && tcsetpgrp(SHTTY, pgrp) == -1 && !ep)
+#else
+# if ardent
+	if (SHTTY != -1 && setpgrp() == -1 && !ep)
+# else
+	int arg = pgrp;
+
+	if (SHTTY != -1 && ioctl(SHTTY, TIOCSPGRP, &arg) == -1 && !ep)
+# endif
+#endif
+	{
+	    if (pgrp != mypgrp && kill(pgrp, 0) == -1)
+		attachtty(mypgrp);
+	    else {
+		if (errno != ENOTTY)
+		{
+		    zerr("can't set tty pgrp: %e", NULL, errno);
+		    fflush(stderr);
+		}
+		opts[MONITOR] = 0;
+		ep = 1;
+		errflag = 0;
+	    }
+	}
+    }
+}
+
+/* get the process group associated with the tty */
+
+/**/
+pid_t
+gettygrp(void)
+{
+    pid_t arg;
+
+    if (SHTTY == -1)
+	return -1;
+
+#ifdef HAVE_TCSETPGRP
+    arg = tcgetpgrp(SHTTY);
+#else
+    ioctl(SHTTY, TIOCGPGRP, &arg);
+#endif
+
+    return arg;
+}
+
+/* Return the output baudrate */
+
+#ifdef HAVE_SELECT
+/**/
+long
+getbaudrate(struct ttyinfo *shttyinfo)
+{
+    long speedcode;
+
+#ifdef HAS_TIO
+# if defined(HAVE_TCGETATTR) && defined(HAVE_TERMIOS_H)
+    speedcode = cfgetospeed(&shttyinfo->tio);
+# else
+    speedcode = shttyinfo->tio.c_cflag & CBAUD;
+# endif
+#else
+    speedcode = shttyinfo->sgttyb.sg_ospeed;
+#endif
+
+    switch (speedcode) {
+    case B0:
+	return (0L);
+    case B50:
+	return (50L);
+    case B75:
+	return (75L);
+    case B110:
+	return (110L);
+    case B134:
+	return (134L);
+    case B150:
+	return (150L);
+    case B200:
+	return (200L);
+    case B300:
+	return (300L);
+    case B600:
+	return (600L);
+#ifdef _B900
+    case _B900:
+	return (900L);
+#endif
+    case B1200:
+	return (1200L);
+    case B1800:
+	return (1800L);
+    case B2400:
+	return (2400L);
+#ifdef _B3600
+    case _B3600:
+	return (3600L);
+#endif
+    case B4800:
+	return (4800L);
+#ifdef _B7200
+    case _B7200:
+	return (7200L);
+#endif
+    case B9600:
+	return (9600L);
+#ifdef B19200
+    case B19200:
+	return (19200L);
+#else
+# ifdef EXTA
+    case EXTA:
+	return (19200L);
+# endif
+#endif
+#ifdef B38400
+    case B38400:
+	return (38400L);
+#else
+# ifdef EXTB
+    case EXTB:
+	return (38400L);
+# endif
+#endif
+#ifdef B57600
+    case B57600:
+	return (57600L);
+#endif
+#ifdef B115200
+    case B115200:
+	return (115200L);
+#endif
+#ifdef B230400
+    case B230400:
+	return (230400L);
+#endif
+#ifdef B460800
+    case B460800:
+	return (460800L);
+#endif
+    default:
+	if (speedcode >= 100)
+	    return speedcode;
+	break;
+    }
+    return (0L);
+}
+#endif
+
+/* Escape tokens and null characters.  Buf is the string which should be     *
+ * escaped.  len is the length of the string.  If len is -1, buf should be   *
+ * null terminated.  If len is non-negative and the third paramerer is not   *
+ * META_DUP, buf should point to an at least len+1 long memory area.  The    *
+ * return value points to the quoted string.  If the given string does not   *
+ * contain any special character which should be quoted and the third        *
+ * parameter is not META_(HEAP|)DUP, buf is returned unchanged (a            *
+ * terminating null character is appended to buf if necessary).  Otherwise   *
+ * the third `heap' argument determines the method used to allocate space    *
+ * for the result.  It can have the following values:                        *
+ *   META_REALLOC:  use zrealloc on buf                                      *
+ *   META_HREALLOC: use hrealloc on buf                                      *
+ *   META_USEHEAP:  get memory from the heap.  This leaves buf unchanged.    *
+ *   META_NOALLOC:  buf points to a memory area which is long enough to hold *
+ *                  the quoted form, just quote it and return buf.           *
+ *   META_STATIC:   store the quoted string in a static area.  The original  *
+ *                  sting should be at most PATH_MAX long.                   *
+ *   META_ALLOC:    allocate memory for the new string with zalloc().        *
+ *   META_DUP:      leave buf unchanged and allocate space for the return    *
+ *                  value even if buf does not contains special characters   *
+ *   META_HEAPDUP:  same as META_DUP, but uses the heap                      */
+
+/**/
+char *
+metafy(char *buf, int len, int heap)
+{
+    int meta = 0;
+    char *t, *p, *e;
+    static char mbuf[PATH_MAX*2+1];
+
+    if (len == -1) {
+	for (e = buf, len = 0; *e; len++)
+	    if (imeta(*e++))
+		meta++;
+    } else
+	for (e = buf; e < buf + len;)
+	    if (imeta(*e++))
+		meta++;
+
+    if (meta || heap == META_DUP || heap == META_HEAPDUP) {
+	switch (heap) {
+	case META_REALLOC:
+	    buf = zrealloc(buf, len + meta + 1);
+	    break;
+	case META_HREALLOC:
+	    buf = hrealloc(buf, len, len + meta + 1);
+	    break;
+	case META_ALLOC:
+	case META_DUP:
+	    buf = memcpy(zalloc(len + meta + 1), buf, len);
+	    break;
+	case META_USEHEAP:
+	case META_HEAPDUP:
+	    buf = memcpy(halloc(len + meta + 1), buf, len);
+	    break;
+	case META_STATIC:
+#ifdef DEBUG
+	    if (len > PATH_MAX) {
+		fprintf(stderr, "BUG: len = %d > PATH_MAX in metafy\n", len);
+		fflush(stderr);
+	    }
+#endif
+	    buf = memcpy(mbuf, buf, len);
+	    break;
+#ifdef DEBUG
+	case META_NOALLOC:
+	    break;
+	default:
+	    fprintf(stderr, "BUG: metafy called with invaild heap value\n");
+	    fflush(stderr);
+	    break;
+#endif
+	}
+	p = buf + len;
+	e = t = buf + len + meta;
+	while (meta) {
+	    if (imeta(*--t = *--p)) {
+		*t-- ^= 32;
+		*t = Meta;
+		meta--;
+	    }
+	}
+    }
+    *e = '\0';
+    return buf;
+}
+
+/**/
+char *
+unmetafy(char *s, int *len)
+{
+    char *p, *t;
+
+    for (p = s; *p && *p != Meta; p++);
+    for (t = p; (*t = *p++);)
+	if (*t++ == Meta)
+	    t[-1] = *p++ ^ 32;
+    if (len)
+	*len = t - s;
+    return s;
+}
+
+/* Return the character length of a metafied substring, given the      *
+ * unmetafied substring length.                                        */
+
+/**/
+int
+metalen(const char *s, int len)
+{
+    int mlen = len;
+
+    while (len--) {
+	if (*s++ == Meta) {
+	    mlen++;
+	    s++;
+	}
+    }
+    return mlen;
+}
+
+/* This function converts a zsh internal string to a form which can be *
+ * passed to a system call as a filename.  The result is stored in a   *
+ * single static area.  NULL returned if the result is longer than     *
+ * 4 * PATH_MAX.                                                       */
+
+/**/
+char *
+unmeta(const char *file_name)
+{
+    static char fn[4 * PATH_MAX];
+    char *p;
+    const char *t;
+
+    for (t = file_name, p = fn; *t && p < fn + 4 * PATH_MAX - 1; p++)
+	if ((*p = *t++) == Meta)
+	    *p = *t++ ^ 32;
+    if (*t)
+	return NULL;
+    if (p - fn == t - file_name)
+	return (char *) file_name;
+    *p = '\0';
+    return fn;
+}
+
+/* Unmetafy and compare two strings, with unsigned characters. *
+ * "a\0" sorts after "a".                                      */
+
+/**/
+int
+ztrcmp(unsigned char const *s1, unsigned char const *s2)
+{
+    int c1, c2;
+
+    while(*s1 && *s1 == *s2) {
+	s1++;
+	s2++;
+    }
+
+    if(!(c1 = *s1))
+	c1 = -1;
+    else if(c1 == STOUC(Meta))
+	c1 = *++s1 ^ 32;
+    if(!(c2 = *s2))
+	c2 = -1;
+    else if(c2 == STOUC(Meta))
+	c2 = *++s2 ^ 32;
+
+    if(c1 == c2)
+	return 0;
+    else if(c1 < c2)
+	return -1;
+    else
+	return 1;
+}
+
+/* Return zero if the metafied string s and the non-metafied,  *
+ * len-long string r are the same.  Return -1 if r is a prefix *
+ * of s.  Return 1 if r is the lowercase version of s.  Return *
+ * 2 is r is the lowercase prefix of s and return 3 otherwise. */
+
+/**/
+int
+metadiffer(char const *s, char const *r, int len)
+{
+    int l = len;
+
+    while (l-- && *s && *r++ == (*s == Meta ? *++s ^ 32 : *s))
+	s++;
+    if (*s && l < 0)
+	return -1;
+    if (l < 0)
+	return 0;
+    if (!*s)
+	return 3;
+    s -= len - l - 1;
+    r -= len - l;
+    while (len-- && *s && *r++ == tulower(*s == Meta ? *++s ^ 32 : *s))
+	s++;
+    if (*s && len < 0)
+	return 2;
+    if (len < 0)
+	return 1;
+    return 3;
+}
+
+/* Return the unmetafied length of a metafied string. */
+
+/**/
+int
+ztrlen(char const *s)
+{
+    int l;
+
+    for (l = 0; *s; l++)
+	if (*s++ == Meta) {
+#ifdef DEBUG
+	    if (! *s)
+		fprintf(stderr, "BUG: unexpected end of string in ztrlen()\n");
+	    else
+#endif
+	    s++;
+	}
+    return l;
+}
+
+/* Subtract two pointers in a metafied string. */
+
+/**/
+int
+ztrsub(char const *t, char const *s)
+{
+    int l = t - s;
+
+    while (s != t)
+	if (*s++ == Meta) {
+#ifdef DEBUG
+	    if (! *s || s == t)
+		fprintf(stderr, "BUG: substring ends in the middle of a metachar in ztrsub()\n");
+	    else
+#endif
+	    s++;
+	    l--;
+	}
+    return l;
+}
+
+/**/
+char *
+zreaddir(DIR *dir, int ignoredots)
+{
+    struct dirent *de;
+
+    do {
+	de = readdir(dir);
+	if(!de)
+	    return NULL;
+    } while(ignoredots && de->d_name[0] == '.' &&
+	(!de->d_name[1] || (de->d_name[1] == '.' && !de->d_name[2])));
+
+    return metafy(de->d_name, -1, META_STATIC);
+}
+
+/* Unmetafy and output a string.  Tokens are skipped. */
+
+/**/
+int
+zputs(char const *s, FILE *stream)
+{
+    int c;
+
+    while (*s) {
+	if (*s == Meta)
+	    c = *++s ^ 32;
+	else if(itok(*s)) {
+	    s++;
+	    continue;
+	} else
+	    c = *s;
+	s++;
+	if (fputc(c, stream) < 0)
+	    return EOF;
+    }
+    return 0;
+}
+
+/* Create a visibly-represented duplicate of a string. */
+
+/**/
+char *
+niceztrdup(char const *s)
+{
+    int c, len = strlen(s) * 5;
+    char *buf = zalloc(len);
+    char *p = buf, *n, *ret;
+
+    while ((c = *s++)) {
+	if (itok(c))
+	    if (c <= Comma)
+		c = ztokens[c - Pound];
+	    else 
+		continue;
+	if (c == Meta)
+	    c = *s++ ^ 32;
+	n = nicechar(c);
+	while(*n)
+	    *p++ = *n++;
+    }
+    ret = metafy(buf, p - buf, META_DUP);
+    zfree(buf, len);
+    return ret;
+}
+
+/* Unmetafy and output a string, displaying special characters readably. */
+
+/**/
+int
+nicezputs(char const *s, FILE *stream)
+{
+    int c;
+
+    while ((c = *s++)) {
+	if (itok(c))
+	    if (c <= Comma)
+		c = ztokens[c - Pound];
+	    else 
+		continue;
+	if (c == Meta)
+	    c = *s++ ^ 32;
+	if(fputs(nicechar(c), stream) < 0)
+	    return EOF;
+    }
+    return 0;
+}
+
+/* Return the length of the visible representation of a metafied string. */
+
+/**/
+size_t
+niceztrlen(char const *s)
+{
+    size_t l = 0;
+    int c;
+
+    while ((c = *s++)) {
+	if (itok(c))
+	    if (c <= Comma)
+		c = ztokens[c - Pound];
+	    else 
+		continue;
+	if (c == Meta)
+	    c = *s++ ^ 32;
+	l += strlen(nicechar(STOUC(c)));
+    }
+    return l;
+}
+
+/* check for special characters in the string */
+
+/**/
+int
+hasspecial(char const *s)
+{
+    for (; *s; s++)
+	if (ispecial(*s == Meta ? *++s ^ 32 : *s))
+	    return 1;
+    return 0;
+}
+
+/* Unmetafy and output a string, quoted if it contains special characters. */
+
+/**/
+int
+quotedzputs(char const *s, FILE *stream)
+{
+    int inquote = 0, c;
+
+    /* check for empty string */
+    if(!*s)
+	return fputs("''", stream);
+
+    if (!hasspecial(s))
+	return zputs(s, stream);
+
+    if (isset(RCQUOTES)) {
+	/* use rc-style quotes-within-quotes for the whole string */
+	if(fputc('\'', stream) < 0)
+	    return EOF;
+	while(*s) {
+	    if (*s == Meta)
+		c = *++s ^ 32;
+	    else
+		c = *s;
+	    s++;
+	    if (c == '\'') {
+		if(fputc('\'', stream) < 0)
+		    return EOF;
+	    } else if(c == '\n' && isset(CSHJUNKIEQUOTES)) {
+		if(fputc('\\', stream) < 0)
+		    return EOF;
+	    }
+	    if(fputc(c, stream) < 0)
+		return EOF;
+	}
+	if(fputc('\'', stream) < 0)
+	    return EOF;
+    } else {
+	/* use Bourne-style quoting, avoiding empty quoted strings */
+	while(*s) {
+	    if (*s == Meta)
+		c = *++s ^ 32;
+	    else
+		c = *s;
+	    s++;
+	    if (c == '\'') {
+		if(inquote) {
+		    if(fputc('\'', stream) < 0)
+			return EOF;
+		    inquote=0;
+		}
+		if(fputs("\\'", stream) < 0)
+		    return EOF;
+	    } else {
+		if (!inquote) {
+		    if(fputc('\'', stream) < 0)
+			return EOF;
+		    inquote=1;
+		}
+		if(c == '\n' && isset(CSHJUNKIEQUOTES)) {
+		    if(fputc('\\', stream) < 0)
+			return EOF;
+		}
+		if(fputc(c, stream) < 0)
+		    return EOF;
+	    }
+	}
+	if (inquote) {
+	    if(fputc('\'', stream) < 0)
+		return EOF;
+	}
+    }
+    return 0;
+}
+
+/* Double-quote a metafied string. */
+
+/**/
+char *
+dquotedztrdup(char const *s)
+{
+    int len = strlen(s) * 4 + 2;
+    char *buf = zalloc(len);
+    char *p = buf, *ret;
+
+    if(isset(CSHJUNKIEQUOTES)) {
+	int inquote = 0;
+
+	while(*s) {
+	    int c = *s++;
+
+	    if (c == Meta)
+		c = *s++ ^ 32;
+	    switch(c) {
+		case '"':
+		case '$':
+		case '`':
+		    if(inquote) {
+			*p++ = '"';
+			inquote = 0;
+		    }
+		    *p++ = '\\';
+		    *p++ = c;
+		    break;
+		default:
+		    if(!inquote) {
+			*p++ = '"';
+			inquote = 1;
+		    }
+		    if(c == '\n')
+			*p++ = '\\';
+		    *p++ = c;
+		    break;
+	    }
+	}
+	if (inquote)
+	    *p++ = '"';
+    } else {
+	int pending = 0;
+
+	*p++ = '"';
+	while(*s) {
+	    int c = *s++;
+
+	    if (c == Meta)
+		c = *s++ ^ 32;
+	    switch(c) {
+		case '\\':
+		    if(pending)
+			*p++ = '\\';
+		    *p++ = '\\';
+		    pending = 1;
+		    break;
+		case '"':
+		case '$':
+		case '`':
+		    if(pending)
+			*p++ = '\\';
+		    *p++ = '\\';
+		    /* fall through */
+		default:
+		    *p++ = c;
+		    pending = 0;
+		    break;
+	    }
+	}
+	if(pending)
+	    *p++ = '\\';
+	*p++ = '"';
+    }
+    ret = metafy(buf, p - buf, META_DUP);
+    zfree(buf, len);
+    return ret;
+}
+
+#if 0
+/* Unmetafy and output a string, double quoting it in its entirety. */
+
+/**/
+int
+dquotedzputs(char const *s, FILE *stream)
+{
+    char *d = dquotedztrdup(s);
+    int ret = zputs(d, stream);
+
+    zsfree(d);
+    return ret;
+}
+#endif
+
+/**/
+char *
+getkeystring(char *s, int *len, int fromwhere, int *misc)
+{
+    char *buf;
+    char *t, *u = NULL;
+    char svchar = '\0';
+    int meta = 0, control = 0;
+
+    if (fromwhere != 4)
+	buf = halloc(strlen(s) + 1);
+    else {
+	buf = s;
+	s += 2;
+    }
+    for (t = buf; *s; s++) {
+	if (*s == '\\' && s[1]) {
+	    switch (*++s) {
+	    case 'a':
+#ifdef __STDC__
+		*t++ = '\a';
+#else
+		*t++ = '\07';
+#endif
+		break;
+	    case 'n':
+		*t++ = '\n';
+		break;
+	    case 'b':
+		*t++ = '\b';
+		break;
+	    case 't':
+		*t++ = '\t';
+		break;
+	    case 'v':
+		*t++ = '\v';
+		break;
+	    case 'f':
+		*t++ = '\f';
+		break;
+	    case 'r':
+		*t++ = '\r';
+		break;
+	    case 'E':
+		if (!fromwhere) {
+		    *t++ = '\\', s--;
+		    continue;
+		}
+	    case 'e':
+		*t++ = '\033';
+		break;
+	    case 'M':
+		if (fromwhere) {
+		    if (s[1] == '-')
+			s++;
+		    meta = 1 + control;	/* preserve the order of ^ and meta */
+		} else
+		    *t++ = '\\', s--;
+		continue;
+	    case 'C':
+		if (fromwhere) {
+		    if (s[1] == '-')
+			s++;
+		    control = 1;
+		} else
+		    *t++ = '\\', s--;
+		continue;
+	    case Meta:
+		*t++ = '\\', s--;
+		break;
+	    case 'c':
+		if (fromwhere < 2) {
+		    *misc = 1;
+		    break;
+		}
+	    default:
+		if ((idigit(*s) && *s < '8') || *s == 'x') {
+		    if (!fromwhere)
+			if (*s == '0')
+			    s++;
+			else if (*s != 'x') {
+			    *t++ = '\\', s--;
+			    continue;
+			}
+		    if (s[1] && s[2] && s[3]) {
+			svchar = s[3];
+			s[3] = '\0';
+			u = s;
+		    }
+		    *t++ = zstrtol(s + (*s == 'x'), &s,
+				   (*s == 'x') ? 16 : 8);
+		    if (svchar) {
+			u[3] = svchar;
+			svchar = '\0';
+		    }
+		    s--;
+		} else {
+		    if (!fromwhere && *s != '\\')
+			*t++ = '\\';
+		    *t++ = *s;
+		}
+		break;
+	    }
+	} else if (fromwhere == 4 && *s == Snull) {
+	    for (u = t; (*u++ = *s++););
+	    return t + 1;
+	} else if (*s == '^' && fromwhere == 2) {
+	    control = 1;
+	    continue;
+	} else if (*s == Meta)
+	    *t++ = *++s ^ 32;
+	else
+	    *t++ = *s;
+	if (meta == 2) {
+	    t[-1] |= 0x80;
+	    meta = 0;
+	}
+	if (control) {
+	    if (t[-1] == '?')
+		t[-1] = 0x7f;
+	    else
+		t[-1] &= 0x9f;
+	    control = 0;
+	}
+	if (meta) {
+	    t[-1] |= 0x80;
+	    meta = 0;
+	}
+	if (fromwhere == 4 && imeta(t[-1])) {
+	    *t = t[-1] ^ 32;
+	    t[-1] = Meta;
+	    t++;
+	}
+    }
+    DPUTS(fromwhere == 4, "BUG: unterminated $' substitution");
+    *t = '\0';
+    *len = t - buf;
+    return buf;
+}
+
+/* Return non-zero if s is a prefix of t. */
+
+/**/
+int
+strpfx(char *s, char *t)
+{
+    while (*s && *s == *t)
+	s++, t++;
+    return !*s;
+}
+
+/* Return non-zero if s is a suffix of t. */
+
+/**/
+int
+strsfx(char *s, char *t)
+{
+    int ls = strlen(s), lt = strlen(t);
+
+    if (ls <= lt)
+	return !strcmp(t + lt - ls, s);
+    return 0;
+}
+
+/**/
+char *
+dupstrpfx(const char *s, int len)
+{
+    char *r = ncalloc(len + 1);
+
+    memcpy(r, s, len);
+    r[len] = '\0';
+    return r;
+}
+
+/**/
+char *
+ztrduppfx(const char *s, int len)
+{
+    char *r = zalloc(len + 1);
+
+    memcpy(r, s, len);
+    r[len] = '\0';
+    return r;
+}
+
+/* Append a string to an allocated string, reallocating to make room. */
+
+/**/
+char *
+appstr(char *base, char const *append)
+{
+    return strcat(realloc(base, strlen(base) + strlen(append) + 1), append);
+}
+
+/**/
+static int
+upchdir(int n)
+{
+    char buf[PATH_MAX];
+    char *s;
+    int err = -1;
+
+    while (n > 0) {
+	for (s = buf; s < buf + PATH_MAX - 4 && n--; )
+	    *s++ = '.', *s++ = '.', *s++ = '/';
+	s[-1] = '\0';
+	if (chdir(buf))
+	    return err;
+	err = -2;
+    }
+    return 0;
+}
+
+/* Change directory, without following symlinks.  Returns 0 on success, -1 *
+ * on failure.  Sets errno to ENOTDIR if any symlinks are encountered.  If *
+ * fchdir() fails, or the current directory is unreadable, we might end up *
+ * in an unwanted directory in case of failure.                            */
+
+/**/
+int
+lchdir(char const *path, struct dirsav *d, int hard)
+{
+    char const *pptr;
+    int level;
+    struct stat st1;
+    struct dirsav ds;
+#ifdef HAVE_LSTAT
+    char buf[PATH_MAX + 1], *ptr;
+    int err;
+    struct stat st2;
+#endif
+
+    if (!d) {
+	ds.ino = ds.dev = 0;
+	ds.dirname = NULL;
+	ds.dirfd = -1;
+	d = &ds;
+    }
+#ifdef HAVE_LSTAT
+    if ((*path == '/' || !hard) &&
+	(d != &ds || hard)){
+#else
+    if (*path == '/') {
+#endif
+	level = -1;
+#ifdef HAVE_FCHDIR
+	if (d->dirfd < 0 && (d->dirfd = open(".", O_RDONLY | O_NOCTTY)) < 0 &&
+	    zgetdir(d) && *d->dirname != '/')
+	    d->dirfd = open("..", O_RDONLY | O_NOCTTY);
+#else
+	if (!d->dirname)
+	    zgetdir(d);
+#endif
+    } else {
+	level = 0;
+	if (!d->dev && !d->ino) {
+	    stat(".", &st1);
+	    d->dev = st1.st_dev;
+	    d->ino = st1.st_ino;
+	}
+    }
+
+#ifdef HAVE_LSTAT
+    if (!hard)
+#endif
+    {
+	if (d != &ds) {
+	    for (pptr = path; *pptr; level++) {
+		while (*pptr && *pptr++ != '/');
+		while (*pptr == '/')
+		    pptr++;
+	    }
+	    d->level = level;
+	}
+	return zchdir((char *) path);
+    }
+#ifdef HAVE_LSTAT
+    if (*path == '/')
+	chdir("/");
+    for(;;) {
+	while(*path == '/')
+	    path++;
+	if(!*path) {
+	    if (d == &ds) {
+		zsfree(ds.dirname);
+		if (ds.dirfd >=0)
+		    close(ds.dirfd);
+	    } else
+		d->level = level;
+	    return 0;
+	}
+	for(pptr = path; *++pptr && *pptr != '/'; ) ;
+	if(pptr - path > PATH_MAX) {
+	    err = ENAMETOOLONG;
+	    break;
+	}
+	for(ptr = buf; path != pptr; )
+	    *ptr++ = *path++;
+	*ptr = 0;
+	if(lstat(buf, &st1)) {
+	    err = errno;
+	    break;
+	}
+	if(!S_ISDIR(st1.st_mode)) {
+	    err = ENOTDIR;
+	    break;
+	}
+	if(chdir(buf)) {
+	    err = errno;
+	    break;
+	}
+	if (level >= 0)
+	    level++;
+	if(lstat(".", &st2)) {
+	    err = errno;
+	    break;
+	}
+	if(st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) {
+	    err = ENOTDIR;
+	    break;
+	}
+    }
+    if (restoredir(d)) {
+	if (d == &ds) {
+	    zsfree(ds.dirname);
+	    if (ds.dirfd >=0)
+		close(ds.dirfd);
+	}
+	errno = err;
+	return -2;
+    }
+    if (d == &ds) {
+	zsfree(ds.dirname);
+	if (ds.dirfd >=0)
+	    close(ds.dirfd);
+    }
+    errno = err;
+    return -1;
+#endif /* HAVE_LSTAT */
+}
+
+/**/
+int
+restoredir(struct dirsav *d)
+{
+    int err = 0;
+    struct stat sbuf;
+
+    if (d->dirname && *d->dirname == '/')
+	return chdir(d->dirname);
+#ifdef HAVE_FCHDIR
+    if (d->dirfd >= 0) {
+	if (!fchdir(d->dirfd)) {
+	    if (!d->dirname) {
+		return 0;
+	    } else if (chdir(d->dirname)) {
+		close(d->dirfd);
+		d->dirfd = -1;
+		err = -2;
+	    }
+	} else {
+	    close(d->dirfd);
+	    d->dirfd = err = -1;
+	}
+    } else
+#endif
+    if (d->level > 0)
+	err = upchdir(d->level);
+    else if (d->level < 0)
+	err = -1;
+    if (d->dev || d->ino) {
+	stat(".", &sbuf);
+	if (sbuf.st_ino != d->ino || sbuf.st_dev != d->dev)
+	    err = -2;
+    }
+    return err;
+}
+
+/* Get a signal number from a string */
+
+/**/
+int
+getsignum(char *s)
+{
+    int x, i;
+
+    /* check for a signal specified by number */
+    x = atoi(s);
+    if (idigit(*s) && x >= 0 && x < VSIGCOUNT)
+	return x;
+
+    /* search for signal by name */
+    for (i = 0; i < VSIGCOUNT; i++)
+	if (!strcmp(s, sigs[i]))
+	    return i;
+
+    /* no matching signal */
+    return -1;
+}
+
+/* Check whether the shell is running with privileges in effect.  *
+ * This is the case if EITHER the euid is zero, OR (if the system *
+ * supports POSIX.1e (POSIX.6) capability sets) the process'      *
+ * Effective or Inheritable capability sets are non-empty.        */
+
+/**/
+int
+privasserted(void)
+{
+    if(!geteuid())
+	return 1;
+#ifdef HAVE_CAP_GET_PROC
+    {
+	cap_t caps = cap_get_proc();
+	if(caps) {
+	    /* POSIX doesn't define a way to test whether a capability set *
+	     * is empty or not.  Typical.  I hope this is conforming...    */
+	    cap_flag_value_t val;
+	    cap_value_t n;
+	    for(n = 0; !cap_get_flag(caps, n, CAP_EFFECTIVE, &val); n++)
+		if(val ||
+		   (!cap_get_flag(caps, n, CAP_INHERITABLE, &val) && val)) {
+		    cap_free(&caps);
+		    return 1;
+		}
+	    cap_free(&caps);
+	}
+    }
+#endif /* HAVE_CAP_GET_PROC */
+    return 0;
+}
+
+#ifdef DEBUG
+
+/**/
+void
+dputs(char *message)
+{
+    fprintf(stderr, "%s\n", message);
+    fflush(stderr);
+}
+
+#endif /* DEBUG */
+
+/**/
+int
+mode_to_octal(mode_t mode)
+{
+    int m = 0;
+
+    if(mode & S_ISUID)
+	m |= 04000;
+    if(mode & S_ISGID)
+	m |= 02000;
+    if(mode & S_ISVTX)
+	m |= 01000;
+    if(mode & S_IRUSR)
+	m |= 00400;
+    if(mode & S_IWUSR)
+	m |= 00200;
+    if(mode & S_IXUSR)
+	m |= 00100;
+    if(mode & S_IRGRP)
+	m |= 00040;
+    if(mode & S_IWGRP)
+	m |= 00020;
+    if(mode & S_IXGRP)
+	m |= 00010;
+    if(mode & S_IROTH)
+	m |= 00004;
+    if(mode & S_IWOTH)
+	m |= 00002;
+    if(mode & S_IXOTH)
+	m |= 00001;
+    return m;
+}
diff --git a/Src/watch.c b/Src/watch.c
new file mode 100644
index 000000000..2532e0a63
--- /dev/null
+++ b/Src/watch.c
@@ -0,0 +1,586 @@
+/*
+ * watch.c - login/logout watching
+ *
+ * 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"
+
+/* Headers for utmp/utmpx structures */
+#ifdef HAVE_UTMP_H
+# include <utmp.h>
+#endif
+#ifdef HAVE_UTMPX_H
+# include <utmpx.h>
+#endif
+
+/* Find utmp file */
+#if !defined(REAL_UTMP_FILE) && defined(UTMP_FILE)
+# define REAL_UTMP_FILE UTMP_FILE
+#endif
+#if !defined(REAL_UTMP_FILE) && defined(_PATH_UTMP)
+# define REAL_UTMP_FILE _PATH_UTMP
+#endif
+#if !defined(REAL_UTMP_FILE) && defined(PATH_UTMP_FILE)
+# define REAL_UTMP_FILE PATH_UTMP_FILE
+#endif
+
+/* Find wtmp file */
+#if !defined(REAL_WTMP_FILE) && defined(WTMP_FILE)
+# define REAL_WTMP_FILE WTMP_FILE
+#endif
+#if !defined(REAL_WTMP_FILE) && defined(_PATH_WTMP)
+# define REAL_WTMP_FILE _PATH_WTMP
+#endif
+#if !defined(REAL_WTMP_FILE) && defined(PATH_WTMP_FILE)
+# define REAL_WTMP_FILE PATH_WTMP_FILE
+#endif
+
+/* Find utmpx file */
+#if !defined(REAL_UTMPX_FILE) && defined(UTMPX_FILE)
+# define REAL_UTMPX_FILE UTMPX_FILE
+#endif
+#if !defined(REAL_UTMPX_FILE) && defined(_PATH_UTMPX)
+# define REAL_UTMPX_FILE _PATH_UTMPX
+#endif
+#if !defined(REAL_UTMPX_FILE) && defined(PATH_UTMPX_FILE)
+# define REAL_UTMPX_FILE PATH_UTMPX_FILE
+#endif
+
+/* Find wtmpx file */
+#if !defined(REAL_WTMPX_FILE) && defined(WTMPX_FILE)
+# define REAL_WTMPX_FILE WTMPX_FILE
+#endif
+#if !defined(REAL_WTMPX_FILE) && defined(_PATH_WTMPX)
+# define REAL_WTMPX_FILE _PATH_WTMPX
+#endif
+#if !defined(REAL_WTMPX_FILE) && defined(PATH_WTMPX_FILE)
+# define REAL_WTMPX_FILE PATH_WTMPX_FILE
+#endif
+
+/* Decide which structure to use.  We use a structure that exists in *
+ * the headers, and require that its corresponding utmp file exist.  *
+ * (wtmp is less important.)                                         */
+
+#if !defined(WATCH_STRUCT_UTMP) && defined(HAVE_STRUCT_UTMPX) && defined(REAL_UTMPX_FILE)
+# define WATCH_STRUCT_UTMP struct utmpx
+# ifdef HAVE_STRUCT_UTMPX_UT_XTIME
+#  undef ut_time
+#  define ut_time ut_xtime
+# else /* !HAVE_STRUCT_UTMPX_UT_XTIME */
+#  ifdef HAVE_STRUCT_UTMPX_UT_TV
+#   undef ut_time
+#   define ut_time ut_tv.tv_sec
+#  endif /* HAVE_STRUCT_UTMPX_UT_TV */
+# endif /* !HAVE_STRUCT_UTMPX_UT_XTIME */
+# define WATCH_UTMP_FILE REAL_UTMPX_FILE
+# ifdef REAL_WTMPX_FILE
+#  define WATCH_WTMP_FILE REAL_WTMPX_FILE
+# endif
+# ifdef HAVE_STRUCT_UTMPX_UT_HOST
+#  define WATCH_UTMP_UT_HOST 1
+# endif
+#endif
+
+#if !defined(WATCH_STRUCT_UTMP) && defined(HAVE_STRUCT_UTMP) && defined(REAL_UTMP_FILE)
+# define WATCH_STRUCT_UTMP struct utmp
+# define WATCH_UTMP_FILE REAL_UTMP_FILE
+# ifdef REAL_WTMP_FILE
+#  define WATCH_WTMP_FILE REAL_WTMP_FILE
+# endif
+# ifdef HAVE_STRUCT_UTMP_UT_HOST
+#  define WATCH_UTMP_UT_HOST 1
+# endif
+#endif
+
+#ifdef WATCH_UTMP_UT_HOST
+# define DEFAULT_WATCHFMT "%n has %a %l from %m."
+#else /* !WATCH_UTMP_UT_HOST */
+# define DEFAULT_WATCHFMT "%n has %a %l."
+#endif /* !WATCH_UTMP_UT_HOST */
+
+/**/
+char const * const default_watchfmt = DEFAULT_WATCHFMT;
+
+#ifdef WATCH_STRUCT_UTMP
+
+# include "watch.pro"
+
+# ifndef WATCH_WTMP_FILE
+#  define WATCH_WTMP_FILE "/dev/null"
+# endif
+
+static int wtabsz;
+static WATCH_STRUCT_UTMP *wtab;
+static time_t lastutmpcheck;
+
+/* get the time of login/logout for WATCH */
+
+/**/
+static time_t
+getlogtime(WATCH_STRUCT_UTMP *u, int inout)
+{
+    FILE *in;
+    WATCH_STRUCT_UTMP uu;
+    int first = 1;
+    int srchlimit = 50;		/* max number of wtmp records to search */
+
+    if (inout)
+	return u->ut_time;
+    if (!(in = fopen(WATCH_WTMP_FILE, "r")))
+	return time(NULL);
+    fseek(in, 0, 2);
+    do {
+	if (fseek(in, ((first) ? -1 : -2) * sizeof(WATCH_STRUCT_UTMP), 1)) {
+	    fclose(in);
+	    return time(NULL);
+	}
+	first = 0;
+	if (!fread(&uu, sizeof(WATCH_STRUCT_UTMP), 1, in)) {
+	    fclose(in);
+	    return time(NULL);
+	}
+	if (uu.ut_time < lastwatch || !srchlimit--) {
+	    fclose(in);
+	    return time(NULL);
+	}
+    }
+    while (memcmp(&uu, u, sizeof(uu)));
+
+    do
+	if (!fread(&uu, sizeof(WATCH_STRUCT_UTMP), 1, in)) {
+	    fclose(in);
+	    return time(NULL);
+	}
+    while (strncmp(uu.ut_line, u->ut_line, sizeof(u->ut_line)));
+    fclose(in);
+    return uu.ut_time;
+}
+
+/* Mutually recursive call to handle ternaries in $WATCHFMT */
+
+# define BEGIN3 '('
+# define END3 ')'
+
+/**/
+static char *
+watch3ary(int inout, WATCH_STRUCT_UTMP *u, char *fmt, int prnt)
+{
+    int truth = 1, sep;
+
+    switch (*fmt++) {
+    case 'n':
+	truth = (u->ut_name[0] != 0);
+	break;
+    case 'a':
+	truth = inout;
+	break;
+    case 'l':
+	if (!strncmp(u->ut_line, "tty", 3))
+	    truth = (u->ut_line[3] != 0);
+	else
+	    truth = (u->ut_line[0] != 0);
+	break;
+# ifdef WATCH_UTMP_UT_HOST
+    case 'm':
+    case 'M':
+	truth = (u->ut_host[0] != 0);
+	break;
+# endif /* WATCH_UTMP_UT_HOST */
+    default:
+	prnt = 0;		/* Skip unknown conditionals entirely */
+	break;
+    }
+    sep = *fmt++;
+    fmt = watchlog2(inout, u, fmt, (truth && prnt), sep);
+    return watchlog2(inout, u, fmt, (!truth && prnt), END3);
+}
+
+/* print a login/logout event */
+
+/**/
+static char *
+watchlog2(int inout, WATCH_STRUCT_UTMP *u, char *fmt, int prnt, int fini)
+{
+    char buf[40], buf2[80];
+    time_t timet;
+    struct tm *tm;
+    char *fm2;
+# ifdef WATCH_UTMP_UT_HOST
+    char *p;
+    int i;
+# endif /* WATCH_UTMP_UT_HOST */
+
+    while (*fmt)
+	if (*fmt == '\\')
+	    if (*++fmt) {
+		if (prnt)
+		    putchar(*fmt);
+		++fmt;
+	    } else if (fini)
+		return fmt;
+	    else
+		break;
+	else if (*fmt == fini)
+	    return ++fmt;
+	else if (*fmt != '%') {
+	    if (prnt)
+		putchar(*fmt);
+	    ++fmt;
+	} else {
+	    if (*++fmt == BEGIN3)
+		fmt = watch3ary(inout, u, ++fmt, prnt);
+	    else if (!prnt)
+		++fmt;
+	    else
+		switch (*(fm2 = fmt++)) {
+		case 'n':
+		    printf("%.*s", (int)sizeof(u->ut_name), u->ut_name);
+		    break;
+		case 'a':
+		    printf("%s", (!inout) ? "logged off" : "logged on");
+		    break;
+		case 'l':
+		    if (!strncmp(u->ut_line, "tty", 3))
+			printf("%.*s", (int)sizeof(u->ut_line) - 3, u->ut_line + 3);
+		    else
+			printf("%.*s", (int)sizeof(u->ut_line), u->ut_line);
+		    break;
+# ifdef WATCH_UTMP_UT_HOST
+		case 'm':
+		    for (p = u->ut_host, i = sizeof(u->ut_host); i && *p; i--, p++) {
+			if (*p == '.' && !idigit(p[1]))
+			    break;
+			putchar(*p);
+		    }
+		    break;
+		case 'M':
+		    printf("%.*s", (int)sizeof(u->ut_host), u->ut_host);
+		    break;
+# endif /* WATCH_UTMP_UT_HOST */
+		case 'T':
+		case 't':
+		case '@':
+		case 'W':
+		case 'w':
+		case 'D':
+		    switch (*fm2) {
+		    case '@':
+		    case 't':
+			fm2 = "%l:%M%p";
+			break;
+		    case 'T':
+			fm2 = "%K:%M";
+			break;
+		    case 'w':
+			fm2 = "%a %f";
+			break;
+		    case 'W':
+			fm2 = "%m/%d/%y";
+			break;
+		    case 'D':
+			if (fm2[1] == '{') {
+			    char *dd, *ss;
+			    int n = 79;
+
+			    for (ss = fm2 + 2, dd = buf2;
+				 n-- && *ss && *ss != '}'; ++ss, ++dd)
+				*dd = *((*ss == '\\' && ss[1]) ? ++ss : ss);
+			    if (*ss == '}') {
+				*dd = '\0';
+				fmt = ss + 1;
+				fm2 = buf2;
+			    }
+			    else fm2 = "%y-%m-%d";
+			}
+			else fm2 = "%y-%m-%d";
+			break;
+		    }
+		    timet = getlogtime(u, inout);
+		    tm = localtime(&timet);
+		    ztrftime(buf, 40, fm2, tm);
+		    printf("%s", (*buf == ' ') ? buf + 1 : buf);
+		    break;
+		case '%':
+		    putchar('%');
+		    break;
+		case 'S':
+		    txtset(TXTSTANDOUT);
+		    tsetcap(TCSTANDOUTBEG, -1);
+		    break;
+		case 's':
+		    txtset(TXTDIRTY);
+		    txtunset(TXTSTANDOUT);
+		    tsetcap(TCSTANDOUTEND, -1);
+		    break;
+		case 'B':
+		    txtset(TXTDIRTY);
+		    txtset(TXTBOLDFACE);
+		    tsetcap(TCBOLDFACEBEG, -1);
+		    break;
+		case 'b':
+		    txtset(TXTDIRTY);
+		    txtunset(TXTBOLDFACE);
+		    tsetcap(TCALLATTRSOFF, -1);
+		    break;
+		case 'U':
+		    txtset(TXTUNDERLINE);
+		    tsetcap(TCUNDERLINEBEG, -1);
+		    break;
+		case 'u':
+		    txtset(TXTDIRTY);
+		    txtunset(TXTUNDERLINE);
+		    tsetcap(TCUNDERLINEEND, -1);
+		    break;
+		default:
+		    putchar('%');
+		    putchar(*fm2);
+		    break;
+		}
+	}
+    if (prnt)
+	putchar('\n');
+
+    return fmt;
+}
+
+/* check the List for login/logouts */
+
+/**/
+static void
+watchlog(int inout, WATCH_STRUCT_UTMP *u, char **w, char *fmt)
+{
+    char *v, *vv, sav;
+    int bad;
+
+    if (!*u->ut_name)
+	return;
+
+    if (*w && !strcmp(*w, "all")) {
+	(void)watchlog2(inout, u, fmt, 1, 0);
+	return;
+    }
+    if (*w && !strcmp(*w, "notme") &&
+	strncmp(u->ut_name, get_username(), sizeof(u->ut_name))) {
+	(void)watchlog2(inout, u, fmt, 1, 0);
+	return;
+    }
+    for (; *w; w++) {
+	bad = 0;
+	v = *w;
+	if (*v != '@' && *v != '%') {
+	    for (vv = v; *vv && *vv != '@' && *vv != '%'; vv++);
+	    sav = *vv;
+	    *vv = '\0';
+	    if (strncmp(u->ut_name, v, sizeof(u->ut_name)))
+		bad = 1;
+	    *vv = sav;
+	    v = vv;
+	}
+	for (;;)
+	    if (*v == '%') {
+		for (vv = ++v; *vv && *vv != '@'; vv++);
+		sav = *vv;
+		*vv = '\0';
+		if (strncmp(u->ut_line, v, sizeof(u->ut_line)))
+		    bad = 1;
+		*vv = sav;
+		v = vv;
+	    }
+# ifdef WATCH_UTMP_UT_HOST
+	    else if (*v == '@') {
+		for (vv = ++v; *vv && *vv != '%'; vv++);
+		sav = *vv;
+		*vv = '\0';
+		if (strncmp(u->ut_host, v, strlen(v)))
+		    bad = 1;
+		*vv = sav;
+		v = vv;
+	    }
+# endif /* WATCH_UTMP_UT_HOST */
+	    else
+		break;
+	if (!bad) {
+	    (void)watchlog2(inout, u, fmt, 1, 0);
+	    return;
+	}
+    }
+}
+
+/* compare 2 utmp entries */
+
+/**/
+static int
+ucmp(WATCH_STRUCT_UTMP *u, WATCH_STRUCT_UTMP *v)
+{
+    if (u->ut_time == v->ut_time)
+	return strncmp(u->ut_line, v->ut_line, sizeof(u->ut_line));
+    return u->ut_time - v->ut_time;
+}
+
+/* initialize the user List */
+
+/**/
+static void
+readwtab(void)
+{
+    WATCH_STRUCT_UTMP *uptr;
+    int wtabmax = 32;
+    FILE *in;
+
+    wtabsz = 0;
+    if (!(in = fopen(WATCH_UTMP_FILE, "r")))
+	return;
+    uptr = wtab = (WATCH_STRUCT_UTMP *)zalloc(wtabmax * sizeof(WATCH_STRUCT_UTMP));
+    while (fread(uptr, sizeof(WATCH_STRUCT_UTMP), 1, in))
+# ifdef USER_PROCESS
+	if   (uptr->ut_type == USER_PROCESS)
+# else /* !USER_PROCESS */
+	if   (uptr->ut_name[0])
+# endif /* !USER_PROCESS */
+	{
+	    uptr++;
+	    if (++wtabsz == wtabmax)
+		uptr = (wtab = (WATCH_STRUCT_UTMP *)realloc((void *) wtab, (wtabmax *= 2) *
+						      sizeof(WATCH_STRUCT_UTMP))) + wtabsz;
+	}
+    fclose(in);
+
+    if (wtabsz)
+	qsort((void *) wtab, wtabsz, sizeof(WATCH_STRUCT_UTMP),
+	           (int (*) _((const void *, const void *)))ucmp);
+}
+
+/* Check for login/logout events; executed before *
+ * each prompt if WATCH is set                    */
+
+/**/
+void
+dowatch(void)
+{
+    FILE *in;
+    WATCH_STRUCT_UTMP *utab, *uptr, *wptr;
+    struct stat st;
+    char **s;
+    char *fmt;
+    int utabsz = 0, utabmax = wtabsz + 4;
+    int uct, wct;
+
+    s = watch;
+    if (!(fmt = getsparam("WATCHFMT")))
+	fmt = DEFAULT_WATCHFMT;
+
+    holdintr();
+    if (!wtab) {
+	readwtab();
+	noholdintr();
+	return;
+    }
+    if ((stat(WATCH_UTMP_FILE, &st) == -1) || (st.st_mtime <= lastutmpcheck)) {
+	noholdintr();
+	return;
+    }
+    lastutmpcheck = st.st_mtime;
+    uptr = utab = (WATCH_STRUCT_UTMP *) zalloc(utabmax * sizeof(WATCH_STRUCT_UTMP));
+
+    if (!(in = fopen(WATCH_UTMP_FILE, "r"))) {
+	free(utab);
+	noholdintr();
+	return;
+    }
+    while (fread(uptr, sizeof *uptr, 1, in))
+# ifdef USER_PROCESS
+	if (uptr->ut_type == USER_PROCESS)
+# else /* !USER_PROCESS */
+	if (uptr->ut_name[0])
+# endif /* !USER_PROCESS */
+	{
+	    uptr++;
+	    if (++utabsz == utabmax)
+		uptr = (utab = (WATCH_STRUCT_UTMP *)realloc((void *) utab, (utabmax *= 2) *
+						      sizeof(WATCH_STRUCT_UTMP))) + utabsz;
+	}
+    fclose(in);
+    noholdintr();
+    if (errflag) {
+	free(utab);
+	return;
+    }
+    if (utabsz)
+	qsort((void *) utab, utabsz, sizeof(WATCH_STRUCT_UTMP),
+	           (int (*) _((const void *, const void *)))ucmp);
+
+    wct = wtabsz;
+    uct = utabsz;
+    uptr = utab;
+    wptr = wtab;
+    if (errflag) {
+	free(utab);
+	return;
+    }
+    while ((uct || wct) && !errflag)
+	if (!uct || (wct && ucmp(uptr, wptr) > 0))
+	    wct--, watchlog(0, wptr++, s, fmt);
+	else if (!wct || (uct && ucmp(uptr, wptr) < 0))
+	    uct--, watchlog(1, uptr++, s, fmt);
+	else
+	    uptr++, wptr++, wct--, uct--;
+    free(wtab);
+    wtab = utab;
+    wtabsz = utabsz;
+    fflush(stdout);
+}
+
+/**/
+int
+bin_log(char *nam, char **argv, char *ops, int func)
+{
+    if (!watch)
+	return 1;
+    if (wtab)
+	free(wtab);
+    wtab = (WATCH_STRUCT_UTMP *)zalloc(1);
+    wtabsz = 0;
+    lastutmpcheck = 0;
+    dowatch();
+    return 0;
+}
+
+#else /* !WATCH_STRUCT_UTMP */
+
+/**/
+void dowatch(void)
+{
+}
+
+/**/
+int
+bin_log(char *nam, char **argv, char *ops, int func)
+{
+    return bin_notavail(nam, argv, ops, func);
+}
+
+#endif /* !WATCH_STRUCT_UTMP */
diff --git a/Src/xmods.conf b/Src/xmods.conf
new file mode 100644
index 000000000..c36105721
--- /dev/null
+++ b/Src/xmods.conf
@@ -0,0 +1,5 @@
+rlimits
+comp1
+zle
+compctl
+sched
diff --git a/Src/zsh.h b/Src/zsh.h
new file mode 100644
index 000000000..e96fc6e86
--- /dev/null
+++ b/Src/zsh.h
@@ -0,0 +1,1293 @@
+/*
+ * zsh.h - standard header file
+ *
+ * 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.
+ *
+ */
+
+#define trashzle()      trashzleptr()
+#define zleread(X,Y,H)  zlereadptr(X,Y,H)
+#define spaceinline(X)  spaceinlineptr(X)
+#define gotword()       gotwordptr()
+#define refresh()       refreshptr()
+
+#define compctlread(N,A,O,R) compctlreadptr(N,A,O,R)
+
+/* A few typical macros */
+#define minimum(a,b)  ((a) < (b) ? (a) : (b))
+
+/* math.c */
+typedef int LV;
+
+/* Character tokens are sometimes casted to (unsigned char)'s.         * 
+ * Unfortunately, some compilers don't correctly cast signed to        * 
+ * unsigned promotions; i.e. (int)(unsigned char)((char) -1) evaluates * 
+ * to -1, instead of 255 like it should.  We circumvent the troubles   * 
+ * of such shameful delinquency by casting to a larger unsigned type   * 
+ * then back down to unsigned char.                                    */
+
+#ifdef BROKEN_SIGNED_TO_UNSIGNED_CASTING
+# define STOUC(X)	((unsigned char)(unsigned short)(X))
+#else
+# define STOUC(X)	((unsigned char)(X))
+#endif
+
+/* Meta together with the character following Meta denotes the character *
+ * which is the exclusive or of 32 and the character following Meta.     *
+ * This is used to represent characters which otherwise has special      *
+ * meaning for zsh.  These are the characters for which the imeta() test *
+ * is true: the null character, and the characters from Meta to Marker.  */
+
+#define Meta		((char) 0x83)
+
+/* Note that the fourth character in DEFAULT_IFS is Meta *
+ * followed by a space which denotes the null character. */
+
+#define DEFAULT_IFS	" \t\n\203 "
+
+/* Character tokens */
+#define Pound		((char) 0x84)
+#define String		((char) 0x85)
+#define Hat		((char) 0x86)
+#define Star		((char) 0x87)
+#define Inpar		((char) 0x88)
+#define Outpar		((char) 0x89)
+#define Qstring	        ((char) 0x8a)
+#define Equals		((char) 0x8b)
+#define Bar	      	((char) 0x8c)
+#define Inbrace	        ((char) 0x8d)
+#define Outbrace	((char) 0x8e)
+#define Inbrack	        ((char) 0x8f)
+#define Outbrack	((char) 0x90)
+#define Tick		((char) 0x91)
+#define Inang		((char) 0x92)
+#define Outang		((char) 0x93)
+#define Quest		((char) 0x94)
+#define Tilde		((char) 0x95)
+#define Qtick		((char) 0x96)
+#define Comma		((char) 0x97)
+#define Snull		((char) 0x98)
+#define Dnull		((char) 0x99)
+#define Bnull		((char) 0x9a)
+#define Nularg		((char) 0x9b)
+
+#define INULL(x)	(((x) & 0xfc) == 0x98)
+
+/* Marker used in paramsubst for rc_expand_param */
+#define Marker		((char) 0x9c)
+
+/* chars that need to be quoted if meant literally */
+
+#define SPECCHARS "#$^*()=|{}[]`<>?~;&\n\t \\\'\""
+
+enum {
+    NULLTOK,		/* 0  */
+    SEPER,
+    NEWLIN,
+    SEMI,
+    DSEMI,
+    AMPER,		/* 5  */
+    INPAR,
+    OUTPAR,
+    DBAR,
+    DAMPER,
+    OUTANG,		/* 10 */
+    OUTANGBANG,
+    DOUTANG,
+    DOUTANGBANG,
+    INANG,
+    INOUTANG,		/* 15 */
+    DINANG,
+    DINANGDASH,
+    INANGAMP,
+    OUTANGAMP,
+    AMPOUTANG,		/* 20 */
+    OUTANGAMPBANG,
+    DOUTANGAMP,
+    DOUTANGAMPBANG,
+    TRINANG,
+    BAR,		/* 25 */
+    BARAMP,
+    INOUTPAR,
+    DINPAR,
+    DOUTPAR,
+    AMPERBANG,		/* 30 */
+    SEMIAMP,
+    DOUTBRACK,
+    STRING,
+    ENVSTRING,
+    ENVARRAY,		/* 35 */
+    ENDINPUT,
+    LEXERR,
+
+    /* Tokens for reserved words */
+    BANG,	/* !         */
+    DINBRACK,	/* [[        */
+    INBRACE,    /* {         */	/* 40 */
+    OUTBRACE,   /* }         */
+    CASE,	/* case      */
+    COPROC,	/* coproc    */
+    DO,		/* do        */
+    DONE,	/* done      */ /* 45 */
+    ELIF,	/* elif      */
+    ELSE,	/* else      */
+    ZEND,	/* end       */
+    ESAC,	/* esac      */
+    FI,		/* fi        */ /* 50 */
+    FOR,	/* for       */
+    FOREACH,	/* foreach   */
+    FUNC,	/* function  */
+    IF,		/* if        */
+    NOCORRECT,	/* nocorrect */ /* 55 */
+    REPEAT,	/* repeat    */
+    SELECT,	/* select    */
+    THEN,	/* then      */
+    TIME,	/* time      */
+    UNTIL,	/* until     */ /* 60 */
+    WHILE	/* while     */
+};
+
+/* Redirection types.  If you modify this, you may also have to modify *
+ * redirtab in parse.c and getredirs() in text.c and the IS_* macros   *
+ * below.                                                              */
+
+enum {
+    WRITE,		/* > */
+    WRITENOW,		/* >| */
+    APP,		/* >> */
+    APPNOW,		/* >>| */
+    ERRWRITE,		/* &>, >& */
+    ERRWRITENOW,	/* >&| */
+    ERRAPP,		/* >>& */
+    ERRAPPNOW,		/* >>&| */
+    READWRITE,		/* <> */
+    READ,		/* < */
+    HEREDOC,		/* << */
+    HEREDOCDASH,	/* <<- */
+    HERESTR,		/* <<< */
+    MERGEIN,		/* <&n */
+    MERGEOUT,		/* >&n */
+    CLOSE,		/* >&-, <&- */
+    INPIPE,		/* < <(...) */
+    OUTPIPE		/* > >(...) */
+};
+
+#define IS_WRITE_FILE(X)      ((X)>=WRITE && (X)<=READWRITE)
+#define IS_APPEND_REDIR(X)    (IS_WRITE_FILE(X) && ((X) & 2))
+#define IS_CLOBBER_REDIR(X)   (IS_WRITE_FILE(X) && ((X) & 1))
+#define IS_ERROR_REDIR(X)     ((X)>=ERRWRITE && (X)<=ERRAPPNOW)
+#define IS_READFD(X)          (((X)>=READWRITE && (X)<=MERGEIN) || (X)==INPIPE)
+#define IS_REDIROP(X)         ((X)>=OUTANG && (X)<=TRINANG)
+
+/* Flags for input stack */
+#define INP_FREE      (1<<0)	/* current buffer can be free'd            */
+#define INP_ALIAS     (1<<1)	/* expanding alias or history              */
+#define INP_HIST      (1<<2)	/* expanding history                       */
+#define INP_CONT      (1<<3)	/* continue onto previously stacked input  */
+#define INP_ALCONT    (1<<4)	/* stack is continued from alias expn.     */
+
+/* Flags for metafy */
+#define META_REALLOC	0
+#define META_USEHEAP	1
+#define META_STATIC	2
+#define META_DUP	3
+#define META_ALLOC	4
+#define META_NOALLOC	5
+#define META_HEAPDUP	6
+#define META_HREALLOC	7
+
+
+/**************************/
+/* Abstract types for zsh */
+/**************************/
+
+typedef struct linknode  *LinkNode;
+typedef struct linklist  *LinkList;
+typedef struct hashnode  *HashNode;
+typedef struct hashtable *HashTable;
+
+typedef struct reswd     *Reswd;
+typedef struct alias     *Alias;
+typedef struct param     *Param;
+typedef struct cmdnam    *Cmdnam;
+typedef struct shfunc    *Shfunc;
+typedef struct builtin   *Builtin;
+typedef struct nameddir  *Nameddir;
+typedef struct module    *Module;
+
+typedef struct process   *Process;
+typedef struct job       *Job;
+typedef struct value     *Value;
+typedef struct varasg    *Varasg;
+typedef struct cond      *Cond;
+typedef struct cmd       *Cmd;
+typedef struct pline     *Pline;
+typedef struct sublist   *Sublist;
+typedef struct list      *List;
+typedef struct comp      *Comp;
+typedef struct redir     *Redir;
+typedef struct complist  *Complist;
+typedef struct heap      *Heap;
+typedef struct heapstack *Heapstack;
+typedef struct histent   *Histent;
+typedef struct forcmd    *Forcmd;
+typedef struct autofn    *AutoFn;
+
+typedef struct asgment  *Asgment;
+
+
+/********************************/
+/* Definitions for linked lists */
+/********************************/
+
+/* linked list abstract data type */
+
+struct linknode {
+    LinkNode next;
+    LinkNode last;
+    void *dat;
+};
+
+struct linklist {
+    LinkNode first;
+    LinkNode last;
+};
+
+/* Macros for manipulating link lists */
+
+#define addlinknode(X,Y) insertlinknode(X,(X)->last,Y)
+#define uaddlinknode(X,Y) uinsertlinknode(X,(X)->last,Y)
+#define empty(X)     ((X)->first == NULL)
+#define nonempty(X)  ((X)->first != NULL)
+#define firstnode(X) ((X)->first)
+#define getaddrdata(X) (&((X)->dat))
+#define getdata(X)   ((X)->dat)
+#define setdata(X,Y) ((X)->dat = (Y))
+#define lastnode(X)  ((X)->last)
+#define nextnode(X)  ((X)->next)
+#define prevnode(X)  ((X)->last)
+#define peekfirst(X) ((X)->first->dat)
+#define pushnode(X,Y) insertlinknode(X,(LinkNode) X,Y)
+#define incnode(X) (X = nextnode(X))
+#define gethistent(X) (histentarr+((X)%histentct))
+
+
+/********************************/
+/* Definitions for syntax trees */
+/********************************/
+
+/* struct list, struct sublist, struct pline, etc.  all fit the form *
+ * of this structure and are used interchangably. The ptrs may hold  *
+ * integers or pointers, depending on the type of the node.          */
+
+/* Generic node structure for syntax trees */
+struct node {
+    int ntype;			/* node type */
+};
+
+#define N_LIST    0
+#define N_SUBLIST 1
+#define N_PLINE   2
+#define N_CMD     3
+#define N_REDIR   4
+#define N_COND    5
+#define N_FOR     6
+#define N_CASE    7
+#define N_IF      8
+#define N_WHILE   9
+#define N_VARASG 10
+#define N_AUTOFN 11
+#define N_COUNT  12
+
+/* values for types[4] */
+
+#define NT_EMPTY 0
+#define NT_NODE  1
+#define NT_STR   2
+#define NT_LIST  4
+#define NT_ARR   8
+
+#define NT_TYPE(T) ((T) & 0xff)
+#define NT_N(T, N) (((T) >> (8 + (N) * 4)) & 0xf)
+#define NT_SET(T0, T1, T2, T3, T4) \
+    ((T0) | ((T1) << 8) | ((T2) << 12) | ((T3) << 16) | ((T4) << 20))
+#define NT_HEAP   (1 << 30)
+
+/* tree element for lists */
+
+struct list {
+    int ntype;			/* node type */
+    int type;
+    Sublist left;
+    List right;
+};
+
+/* These are control flags that are passed *
+ * down the execution pipeline.            */
+#define Z_TIMED	(1<<0)	/* pipeline is being timed                   */
+#define Z_SYNC	(1<<1)	/* run this sublist synchronously       (;)  */
+#define Z_ASYNC	(1<<2)	/* run this sublist asynchronously      (&)  */
+#define Z_DISOWN (1<<3)	/* run this sublist without job control (&|) */
+
+/* tree element for sublists */
+
+struct sublist {
+    int ntype;			/* node type */
+    int type;
+    int flags;			/* see PFLAGs below */
+    Pline left;
+    Sublist right;
+};
+
+#define ORNEXT  10		/* || */
+#define ANDNEXT 11		/* && */
+
+#define PFLAG_NOT     1		/* ! ... */
+#define PFLAG_COPROC 32		/* coproc ... */
+
+/* tree element for pipes */
+
+struct pline {
+    int ntype;			/* node type */
+    int type;
+    Cmd left;
+    Pline right;
+};
+
+#define END	0		/* pnode *right is null                     */
+#define PIPE	1		/* pnode *right is the rest of the pipeline */
+
+/* tree element for commands */
+
+struct cmd {
+    int ntype;			/* node type                    */
+    int type;
+    int flags;			/* see CFLAGs below             */
+    int lineno;			/* lineno of script for command */
+    union {
+	List list;		/* for SUBSH/CURSH/SHFUNC       */
+	Forcmd forcmd;
+	struct casecmd *casecmd;
+	struct ifcmd *ifcmd;
+	struct whilecmd *whilecmd;
+	Sublist pline;
+	Cond cond;
+	AutoFn autofn;
+	void *generic;
+    } u;
+    LinkList args;		/* command & argmument List (char *'s)   */
+    LinkList redir;		/* i/o redirections (struct redir *'s)   */
+    LinkList vars;		/* param assignments (struct varasg *'s) */
+};
+
+/* cmd types */
+#define SIMPLE   0
+#define SUBSH    1
+#define CURSH    2
+#define ZCTIME   3
+#define FUNCDEF  4
+#define CFOR     5
+#define CWHILE   6
+#define CREPEAT  7
+#define CIF      8
+#define CCASE    9
+#define CSELECT 10
+#define COND    11
+#define CARITH  12
+#define AUTOFN  13
+
+/* flags for command modifiers */
+#define CFLAG_EXEC	(1<<0)	/* exec ...    */
+
+/* tree element for redirection lists */
+
+struct redir {
+    int ntype;			/* node type */
+    int type;
+    int fd1, fd2;
+    char *name;
+};
+
+/* tree element for conditionals */
+
+struct cond {
+    int ntype;		/* node type                     */
+    int type;		/* can be cond_type, or a single */
+			/* letter (-a, -b, ...)          */
+    void *left, *right;
+};
+
+#define COND_NOT    0
+#define COND_AND    1
+#define COND_OR     2
+#define COND_STREQ  3
+#define COND_STRNEQ 4
+#define COND_STRLT  5
+#define COND_STRGTR 6
+#define COND_NT     7
+#define COND_OT     8
+#define COND_EF     9
+#define COND_EQ    10
+#define COND_NE    11
+#define COND_LT    12
+#define COND_GT    13
+#define COND_LE    14
+#define COND_GE    15
+
+struct forcmd {			/* for/select */
+/* Cmd->args contains list of words to loop thru */
+    int ntype;			/* node type                          */
+    int inflag;			/* if there is an in ... clause       */
+    char *name;			/* initializer or parameter name      */
+    char *condition;		/* arithmetic terminating condition   */
+    char *advance;		/* evaluated after each loop          */
+    List list;			/* list to look through for each name */
+};
+
+struct casecmd {
+/* Cmd->args contains word to test */
+    int ntype;			/* node type       */
+    char **pats;
+    List *lists;		/* list to execute */
+};
+
+
+/*  A command like "if foo then bar elif baz then fubar else fooble"  */
+/*  generates a tree like:                                            */
+/*                                                                    */
+/*  struct ifcmd a = { next =  &b,  ifl = "foo", thenl = "bar" }      */
+/*  struct ifcmd b = { next =  &c,  ifl = "baz", thenl = "fubar" }    */
+/*  struct ifcmd c = { next = NULL, ifl = NULL, thenl = "fooble" }    */
+
+struct ifcmd {
+    int ntype;			/* node type */
+    List *ifls;
+    List *thenls;
+};
+
+struct whilecmd {
+    int ntype;			/* node type                           */
+    int cond;			/* 0 for while, 1 for until            */
+    List cont;			/* condition                           */
+    List loop;			/* list to execute until condition met */
+};
+
+/* node for autoloading functions */
+
+struct autofn {
+    int ntype;			/* node type                             */
+    Shfunc shf;			/* the shell function to define	         */
+};
+
+/* The number of fds space is allocated for  *
+ * each time a multio must increase in size. */
+#define MULTIOUNIT 8
+
+/* A multio is a list of fds associated with a certain fd.       *
+ * Thus if you do "foo >bar >ble", the multio for fd 1 will have *
+ * two fds, the result of open("bar",...), and the result of     *
+ * open("ble",....).                                             */
+
+/* structure used for multiple i/o redirection */
+/* one for each fd open                        */
+
+struct multio {
+    int ct;			/* # of redirections on this fd                 */
+    int rflag;			/* 0 if open for reading, 1 if open for writing */
+    int pipe;			/* fd of pipe if ct > 1                         */
+    int fds[MULTIOUNIT];	/* list of src/dests redirected to/from this fd */
+};
+
+/* variable assignment tree element */
+
+struct varasg {
+    int ntype;			/* node type                             */
+    int type;			/* nonzero means array                   */
+    char *name;
+    char *str;			/* should've been a union here.  oh well */
+    LinkList arr;
+};
+
+/* lvalue for variable assignment/expansion */
+
+struct value {
+    int isarr;
+    Param pm;		/* parameter node                      */
+    int inv;		/* should we return the index ?        */
+    int a;		/* first element of array slice, or -1 */
+    int b;		/* last element of array slice, or -1  */
+};
+
+/* structure for foo=bar assignments */
+
+struct asgment {
+    struct asgment *next;
+    char *name;
+    char *value;
+};
+
+#define MAX_ARRLEN    262144
+
+
+/********************************************/
+/* Defintions for job table and job control */
+/********************************************/
+
+/* size of job table */
+#define MAXJOB 50
+
+/* entry in the job table */
+
+struct job {
+    pid_t gleader;		/* process group leader of this job  */
+    pid_t other;		/* subjob id or subshell pid         */
+    int stat;                   /* see STATs below                   */
+    char *pwd;			/* current working dir of shell when *
+				 * this job was spawned              */
+    struct process *procs;	/* list of processes                 */
+    LinkList filelist;		/* list of files to delete when done */
+    int stty_in_env;		/* if STTY=... is present            */
+    struct ttyinfo *ty;		/* the modes specified by STTY       */
+};
+
+#define STAT_CHANGED	(1<<0)	/* status changed and not reported      */
+#define STAT_STOPPED	(1<<1)	/* all procs stopped or exited          */
+#define STAT_TIMED	(1<<2)	/* job is being timed                   */
+#define STAT_DONE	(1<<3)	/* job is done                          */
+#define STAT_LOCKED	(1<<4)	/* shell is finished creating this job, */
+                                /*   may be deleted from job table      */
+#define STAT_NOPRINT	(1<<5)	/* job was killed internally,           */
+                                /*   we don't want to show that         */
+#define STAT_INUSE	(1<<6)	/* this job entry is in use             */
+#define STAT_SUPERJOB	(1<<7)	/* job has a subjob                     */
+#define STAT_SUBJOB	(1<<8)	/* job is a subjob                      */
+#define STAT_CURSH	(1<<9)	/* last command is in current shell     */
+#define STAT_NOSTTY	(1<<10)	/* the tty settings are not inherited   */
+				/* from this job when it exits.         */
+
+#define SP_RUNNING -1		/* fake status for jobs currently running */
+
+struct timeinfo {
+    long ut;                    /* user space time   */
+    long st;                    /* system space time */
+};
+
+#define JOBTEXTSIZE 80
+
+/* node in job process lists */
+
+struct process {
+    struct process *next;
+    pid_t pid;                  /* process id                       */
+    char text[JOBTEXTSIZE];	/* text to print when 'jobs' is run */
+    int status;			/* return code from waitpid/wait3() */
+    struct timeinfo ti;
+    struct timeval bgtime;	/* time job was spawned             */
+    struct timeval endtime;	/* time job exited                  */
+};
+
+struct execstack {
+    struct execstack *next;
+
+    LinkList args;
+    pid_t list_pipe_pid;
+    int nowait;
+    int pline_level;
+    int list_pipe_child;
+    int list_pipe_job;
+    char list_pipe_text[JOBTEXTSIZE];
+    int lastval;
+    int noeval;
+    int badcshglob;
+    pid_t cmdoutpid;
+    int cmdoutval;
+    int trapreturn;
+    int noerrs;
+    int subsh_close;
+    char *underscore;
+};
+
+struct heredocs {
+    struct heredocs *next;
+    Redir rd;
+};
+
+struct dirsav {
+    int dirfd, level;
+    char *dirname;
+    dev_t dev;
+    ino_t ino;
+};
+
+/*******************************/
+/* Definitions for Hash Tables */
+/*******************************/
+
+typedef void *(*VFunc) _((void *));
+typedef void (*FreeFunc) _((void *));
+
+typedef unsigned (*HashFunc)       _((char *));
+typedef void     (*TableFunc)      _((HashTable));
+typedef void     (*AddNodeFunc)    _((HashTable, char *, void *));
+typedef HashNode (*GetNodeFunc)    _((HashTable, char *));
+typedef HashNode (*RemoveNodeFunc) _((HashTable, char *));
+typedef void     (*FreeNodeFunc)   _((HashNode));
+
+/* type of function that is passed to *
+ * scanhashtable or scanmatchtable    */
+typedef void     (*ScanFunc)       _((HashNode, int));
+
+typedef void (*PrintTableStats) _((HashTable));
+
+/* hash table for standard open hashing */
+
+struct hashtable {
+    /* HASHTABLE DATA */
+    int hsize;			/* size of nodes[]  (number of hash values)   */
+    int ct;			/* number of elements                         */
+    HashNode *nodes;		/* array of size hsize                        */
+
+    /* HASHTABLE METHODS */
+    HashFunc hash;		/* pointer to hash function for this table    */
+    TableFunc emptytable;	/* pointer to function to empty table         */
+    TableFunc filltable;	/* pointer to function to fill table          */
+    AddNodeFunc addnode;	/* pointer to function to add new node        */
+    GetNodeFunc getnode;	/* pointer to function to get an enabled node */
+    GetNodeFunc getnode2;	/* pointer to function to get node            */
+				/* (getnode2 will ignore DISABLED flag)       */
+    RemoveNodeFunc removenode;	/* pointer to function to delete a node       */
+    ScanFunc disablenode;	/* pointer to function to disable a node      */
+    ScanFunc enablenode;	/* pointer to function to enable a node       */
+    FreeNodeFunc freenode;	/* pointer to function to free a node         */
+    ScanFunc printnode;		/* pointer to function to print a node        */
+
+#ifdef HASHTABLE_INTERNAL_MEMBERS
+    HASHTABLE_INTERNAL_MEMBERS	/* internal use in hashtable.c                */
+#endif
+};
+
+/* generic hash table node */
+
+struct hashnode {
+    HashNode next;		/* next in hash chain */
+    char *nam;			/* hash key           */
+    int flags;			/* various flags      */
+};
+
+/* The flag to disable nodes in a hash table.  Currently  *
+ * you can disable builtins, shell functions, aliases and *
+ * reserved words.                                        */
+#define DISABLED	(1<<0)
+
+/* node in shell reserved word hash table (reswdtab) */
+
+struct reswd {
+    HashNode next;		/* next in hash chain        */
+    char *nam;			/* name of reserved word     */
+    int flags;			/* flags                     */
+    int token;			/* corresponding lexer token */
+};
+
+/* node in alias hash table (aliastab) */
+
+struct alias {
+    HashNode next;		/* next in hash chain       */
+    char *nam;			/* hash data                */
+    int flags;			/* flags for alias types    */
+    char *text;			/* expansion of alias       */
+    int inuse;			/* alias is being expanded  */
+};
+
+/* is this alias global */
+#define ALIAS_GLOBAL	(1<<1)
+
+/* node in command path hash table (cmdnamtab) */
+
+struct cmdnam {
+    HashNode next;		/* next in hash chain */
+    char *nam;			/* hash data          */
+    int flags;
+    union {
+	char **name;		/* full pathname for external commands */
+	char *cmd;		/* file name for hashed commands       */
+    }
+    u;
+};
+
+/* flag for nodes explicitly added to *
+ * cmdnamtab with hash builtin        */
+#define HASHED		(1<<1)
+
+/* node in shell function hash table (shfunctab) */
+
+struct shfunc {
+    HashNode next;		/* next in hash chain     */
+    char *nam;			/* name of shell function */
+    int flags;			/* various flags          */
+    List funcdef;		/* function definition    */
+};
+
+/* node in builtin command hash table (builtintab) */
+
+typedef int (*HandlerFunc) _((char *, char **, char *, int));
+#define NULLBINCMD ((HandlerFunc) 0)
+
+struct builtin {
+    HashNode next;		/* next in hash chain                                 */
+    char *nam;			/* name of builtin                                    */
+    int flags;			/* various flags                                      */
+    HandlerFunc handlerfunc;	/* pointer to function that executes this builtin     */
+    int minargs;		/* minimum number of arguments                        */
+    int maxargs;		/* maximum number of arguments, or -1 for no limit    */
+    int funcid;			/* xbins (see above) for overloaded handlerfuncs      */
+    char *optstr;		/* string of legal options                            */
+    char *defopts;		/* options set by default for overloaded handlerfuncs */
+};
+
+#define BUILTIN(name, flags, handler, min, max, funcid, optstr, defopts) \
+    { NULL, name, flags, handler, min, max, funcid, optstr, defopts }
+#define BIN_PREFIX(name, flags) \
+    BUILTIN(name, flags | BINF_PREFIX, NULLBINCMD, 0, 0, 0, NULL, NULL)
+
+/* builtin flags */
+/* DISABLE IS DEFINED AS (1<<0) */
+#define BINF_PLUSOPTS		(1<<1)	/* +xyz legal */
+#define BINF_R			(1<<2)	/* this is the builtin `r' (fc -e -) */
+#define BINF_PRINTOPTS		(1<<3)
+#define BINF_ADDED		(1<<4)	/* is in the builtins hash table */
+#define BINF_FCOPTS		(1<<5)
+#define BINF_TYPEOPT		(1<<6)
+#define BINF_ECHOPTS		(1<<7)
+#define BINF_MAGICEQUALS	(1<<8)  /* needs automatic MAGIC_EQUAL_SUBST substitution */
+#define BINF_PREFIX		(1<<9)
+#define BINF_DASH		(1<<10)
+#define BINF_BUILTIN		(1<<11)
+#define BINF_COMMAND		(1<<12)
+#define BINF_EXEC		(1<<13)
+#define BINF_NOGLOB		(1<<14)
+#define BINF_PSPECIAL		(1<<15)
+
+#define BINF_TYPEOPTS   (BINF_TYPEOPT|BINF_PLUSOPTS)
+
+struct module {
+    char *nam;
+    int flags;
+    void *handle;
+    LinkList deps;
+};
+
+#define MOD_BUSY    (1<<0)
+
+/* node used in parameter hash table (paramtab) */
+
+struct param {
+    HashNode next;		/* next in hash chain */
+    char *nam;			/* hash data          */
+    int flags;			/* PM_* flags         */
+
+    /* the value of this parameter */
+    union {
+	void *data;		/* used by special parameter functions    */
+	char **arr;		/* value if declared array   (PM_ARRAY)   */
+	char *str;		/* value if declared string  (PM_SCALAR)  */
+	long val;		/* value if declared integer (PM_INTEGER) */
+    } u;
+
+    /* pointer to function to set value of this parameter */
+    union {
+	void (*cfn) _((Param, char *));
+	void (*ifn) _((Param, long));
+	void (*afn) _((Param, char **));
+    } sets;
+
+    /* pointer to function to get value of this parameter */
+    union {
+	char *(*cfn) _((Param));
+	long (*ifn) _((Param));
+	char **(*afn) _((Param));
+    } gets;
+
+    /* pointer to function to unset this parameter */
+    void (*unsetfn) _((Param, int));
+
+    int ct;			/* output base or field width            */
+    char *env;			/* location in environment, if exported  */
+    char *ename;		/* name of corresponding environment var */
+    Param old;			/* old struct for use with local         */
+    int level;			/* if (old != NULL), level of localness  */
+};
+
+/* flags for parameters */
+
+/* parameter types */
+#define PM_SCALAR	0	/* scalar                                     */
+#define PM_ARRAY	(1<<0)	/* array                                      */
+#define PM_INTEGER	(1<<1)	/* integer                                    */
+
+#define PM_TYPE(X) (X & (PM_SCALAR|PM_INTEGER|PM_ARRAY))
+
+#define PM_LEFT		(1<<2)	/* left justify and remove leading blanks     */
+#define PM_RIGHT_B	(1<<3)	/* right justify and fill with leading blanks */
+#define PM_RIGHT_Z	(1<<4)	/* right justify and fill with leading zeros  */
+#define PM_LOWER	(1<<5)	/* all lower case                             */
+
+/* The following are the same since they *
+ * both represent -u option to typeset   */
+#define PM_UPPER	(1<<6)	/* all upper case                             */
+#define PM_UNDEFINED	(1<<6)	/* undefined (autoloaded) shell function      */
+
+#define PM_READONLY	(1<<7)	/* readonly                                   */
+#define PM_TAGGED	(1<<8)	/* tagged                                     */
+#define PM_EXPORTED	(1<<9)	/* exported                                   */
+#define PM_UNIQUE	(1<<10)	/* remove duplicates                          */
+#define PM_SPECIAL	(1<<11) /* special builtin parameter                  */
+#define PM_DONTIMPORT	(1<<12)	/* do not import this variable                */
+#define PM_RESTRICTED	(1<<13) /* cannot be changed in restricted mode       */
+#define PM_UNSET	(1<<14)	/* has null value                             */
+
+/* node for named directory hash table (nameddirtab) */
+
+struct nameddir {
+    HashNode next;		/* next in hash chain               */
+    char *nam;			/* directory name                   */
+    int flags;			/* see below                        */
+    char *dir;			/* the directory in full            */
+    int diff;			/* strlen(.dir) - strlen(.nam)      */
+};
+
+/* flags for named directories */
+/* DISABLED is defined (1<<0) */
+#define ND_USERNAME	(1<<1)	/* nam is actually a username       */
+
+
+/* flags for controlling printing of hash table nodes */
+#define PRINT_NAMEONLY		(1<<0)
+#define PRINT_TYPE		(1<<1)
+#define PRINT_LIST		(1<<2)
+
+/* flags for printing for the whence builtin */
+#define PRINT_WHENCE_CSH	(1<<3)
+#define PRINT_WHENCE_VERBOSE	(1<<4)
+#define PRINT_WHENCE_SIMPLE	(1<<5)
+#define PRINT_WHENCE_FUNCDEF	(1<<6)
+#define PRINT_WHENCE_WORD	(1<<7)
+
+/***********************************/
+/* Definitions for history control */
+/***********************************/
+
+/* history entry */
+
+struct histent {
+    char *text;			/* the history line itself          */
+    char *zle_text;		/* the edited history line          */
+    time_t stim;		/* command started time (datestamp) */
+    time_t ftim;		/* command finished time            */
+    short *words;		/* Position of words in history     */
+				/*   line:  as pairs of start, end  */
+    int nwords;			/* Number of words in history line  */
+    int flags;			/* Misc flags                       */
+};
+
+#define HIST_OLD	0x00000001	/* Command is already written to disk*/
+#define HIST_READ	0x00000002	/* Command was read back from disk*/
+
+/* Parts of the code where history expansion is disabled *
+ * should be within a pair of STOPHIST ... ALLOWHIST     */
+
+#define STOPHIST (stophist += 4);
+#define ALLOWHIST (stophist -= 4);
+
+#define HISTFLAG_DONE   1
+#define HISTFLAG_NOEXEC 2
+#define HISTFLAG_RECALL 4
+
+
+/******************************************/
+/* Definitions for programable completion */
+/******************************************/
+
+/* Nothing special. */
+#define IN_NOTHING 0
+/* In command position. */
+#define IN_CMD     1
+/* In a mathematical environment. */
+#define IN_MATH    2
+/* In a condition. */
+#define IN_COND    3
+/* In a parameter assignment (e.g. `foo=bar'). */
+#define IN_ENV     4
+
+
+/******************************/
+/* Definition for zsh options */
+/******************************/
+
+/* Possible values of emulation */
+
+#define EMULATE_CSH  (1<<1) /* C shell */
+#define EMULATE_KSH  (1<<2) /* Korn shell */
+#define EMULATE_SH   (1<<3) /* Bourne shell */
+#define EMULATE_ZSH  (1<<4) /* `native' mode */
+
+/* option indices */
+
+enum {
+    OPT_INVALID,
+    ALLEXPORT,
+    ALWAYSLASTPROMPT,
+    ALWAYSTOEND,
+    APPENDHISTORY,
+    AUTOCD,
+    AUTOLIST,
+    AUTOMENU,
+    AUTONAMEDIRS,
+    AUTOPARAMKEYS,
+    AUTOPARAMSLASH,
+    AUTOPUSHD,
+    AUTOREMOVESLASH,
+    AUTORESUME,
+    BADPATTERN,
+    BANGHIST,
+    BAREGLOBQUAL,
+    BEEP,
+    BGNICE,
+    BRACECCL,
+    BSDECHO,
+    CDABLEVARS,
+    CHASELINKS,
+    CLOBBER,
+    COMPLETEALIASES,
+    COMPLETEINWORD,
+    CORRECT,
+    CORRECTALL,
+    CSHJUNKIEHISTORY,
+    CSHJUNKIELOOPS,
+    CSHJUNKIEQUOTES,
+    CSHNULLGLOB,
+    EQUALS,
+    ERREXIT,
+    EXECOPT,
+    EXTENDEDGLOB,
+    EXTENDEDHISTORY,
+    FLOWCONTROL,
+    FUNCTIONARGZERO,
+    GLOBOPT,
+    GLOBASSIGN,
+    GLOBCOMPLETE,
+    GLOBDOTS,
+    GLOBSUBST,
+    HASHCMDS,
+    HASHDIRS,
+    HASHLISTALL,
+    HISTALLOWCLOBBER,
+    HISTBEEP,
+    HISTIGNOREDUPS,
+    HISTIGNORESPACE,
+    HISTNOFUNCTIONS,
+    HISTNOSTORE,
+    HISTREDUCEBLANKS,
+    HISTVERIFY,
+    HUP,
+    IGNOREBRACES,
+    IGNOREEOF,
+    INTERACTIVE,
+    INTERACTIVECOMMENTS,
+    KSHARRAYS,
+    KSHAUTOLOAD,
+    KSHGLOB,
+    KSHOPTIONPRINT,
+    LISTAMBIGUOUS,
+    LISTBEEP,
+    LISTTYPES,
+    LOCALOPTIONS,
+    LOGINSHELL,
+    LONGLISTJOBS,
+    MAGICEQUALSUBST,
+    MAILWARNING,
+    MARKDIRS,
+    MENUCOMPLETE,
+    MONITOR,
+    MULTIOS,
+    NOMATCH,
+    NOTIFY,
+    NULLGLOB,
+    NUMERICGLOBSORT,
+    OVERSTRIKE,
+    PATHDIRS,
+    POSIXBUILTINS,
+    PRINTEIGHTBIT,
+    PRINTEXITVALUE,
+    PRIVILEGED,
+    PROMPTBANG,
+    PROMPTCR,
+    PROMPTPERCENT,
+    PROMPTSUBST,
+    PUSHDIGNOREDUPS,
+    PUSHDMINUS,
+    PUSHDSILENT,
+    PUSHDTOHOME,
+    RCEXPANDPARAM,
+    RCQUOTES,
+    RCS,
+    RECEXACT,
+    RESTRICTED,
+    RMSTARSILENT,
+    RMSTARWAIT,
+    SHFILEEXPANSION,
+    SHGLOB,
+    SHINSTDIN,
+    SHOPTIONLETTERS,
+    SHORTLOOPS,
+    SHWORDSPLIT,
+    SINGLECOMMAND,
+    SINGLELINEZLE,
+    SUNKEYBOARDHACK,
+    UNSET,
+    VERBOSE,
+    XTRACE,
+    USEZLE,
+    OPT_SIZE
+};
+
+#undef isset
+#define isset(X) (opts[X])
+#define unset(X) (!opts[X])
+
+#define interact (isset(INTERACTIVE))
+#define jobbing  (isset(MONITOR))
+#define islogin  (isset(LOGINSHELL))
+
+/***********************************************/
+/* Defintions for terminal and display control */
+/***********************************************/
+
+/* tty state structure */
+
+struct ttyinfo {
+#ifdef HAVE_TERMIOS_H
+    struct termios tio;
+#else
+# ifdef HAVE_TERMIO_H
+    struct termio tio;
+# else
+    struct sgttyb sgttyb;
+    int lmodes;
+    struct tchars tchars;
+    struct ltchars ltchars;
+# endif
+#endif
+#ifdef TIOCGWINSZ
+    struct winsize winsize;
+#endif
+};
+
+/* defines for whether tabs expand to spaces */
+#if defined(HAVE_TERMIOS_H) || defined(HAVE_TERMIO_H)
+#define SGTTYFLAG       shttyinfo.tio.c_oflag
+#else   /* we're using sgtty */
+#define SGTTYFLAG       shttyinfo.sgttyb.sg_flags
+#endif
+# ifdef TAB3
+#define SGTABTYPE       TAB3
+# else
+#  ifdef OXTABS
+#define SGTABTYPE       OXTABS
+#  else
+#define SGTABTYPE       XTABS
+#  endif
+# endif
+
+/* flags for termflags */
+
+#define TERM_BAD	0x01	/* terminal has extremely basic capabilities */
+#define TERM_UNKNOWN	0x02	/* unknown terminal type */
+#define TERM_NOUP	0x04	/* terminal has no up capability */
+#define TERM_SHORT	0x08	/* terminal is < 3 lines high */
+#define TERM_NARROW	0x10	/* terminal is < 3 columns wide */
+
+/* interesting termcap strings */
+
+#define TCCLEARSCREEN   0
+#define TCLEFT          1
+#define TCMULTLEFT      2
+#define TCRIGHT         3
+#define TCMULTRIGHT     4
+#define TCUP            5
+#define TCMULTUP        6
+#define TCDOWN          7
+#define TCMULTDOWN      8
+#define TCDEL           9
+#define TCMULTDEL      10
+#define TCINS          11
+#define TCMULTINS      12
+#define TCCLEAREOD     13
+#define TCCLEAREOL     14
+#define TCINSLINE      15
+#define TCDELLINE      16
+#define TCNEXTTAB      17
+#define TCBOLDFACEBEG  18
+#define TCSTANDOUTBEG  19
+#define TCUNDERLINEBEG 20
+#define TCALLATTRSOFF  21
+#define TCSTANDOUTEND  22
+#define TCUNDERLINEEND 23
+#define TC_COUNT       24
+
+#define tccan(X) (tclen[X])
+
+#define TXTBOLDFACE   0x01
+#define TXTSTANDOUT   0x02
+#define TXTUNDERLINE  0x04
+#define TXTDIRTY      0x80
+
+#define txtisset(X)  (txtattrmask & (X))
+#define txtset(X)    (txtattrmask |= (X))
+#define txtunset(X)  (txtattrmask &= ~(X))
+
+#define TXTNOBOLDFACE	0x10
+#define TXTNOSTANDOUT	0x20
+#define TXTNOUNDERLINE	0x40
+
+#define txtchangeisset(X)	(txtchange & (X))
+#define txtchangeset(X, Y)	(txtchange |= (X), txtchange &= ~(Y))
+
+/****************************************/
+/* Definitions for the %_ prompt escape */
+/****************************************/
+
+#define cmdpush(X) if (!(cmdsp >= 0 && cmdsp < 256)) {;} else cmdstack[cmdsp++]=(X)
+#ifdef DEBUG
+# define cmdpop()  if (cmdsp <= 0) { \
+			fputs("BUG: cmdstack empty\n", stderr); \
+			fflush(stderr); \
+		   } else cmdsp--
+#else
+# define cmdpop()   if (cmdsp <= 0) {;} else cmdsp--
+#endif
+
+#define CS_FOR          0
+#define CS_WHILE        1
+#define CS_REPEAT       2
+#define CS_SELECT       3
+#define CS_UNTIL        4
+#define CS_IF           5
+#define CS_IFTHEN       6
+#define CS_ELSE         7
+#define CS_ELIF         8
+#define CS_MATH         9
+#define CS_COND        10
+#define CS_CMDOR       11
+#define CS_CMDAND      12
+#define CS_PIPE        13
+#define CS_ERRPIPE     14
+#define CS_FOREACH     15
+#define CS_CASE        16
+#define CS_FUNCDEF     17
+#define CS_SUBSH       18
+#define CS_CURSH       19
+#define CS_ARRAY       20
+#define CS_QUOTE       21
+#define CS_DQUOTE      22
+#define CS_BQUOTE      23
+#define CS_CMDSUBST    24
+#define CS_MATHSUBST   25
+#define CS_ELIFTHEN    26
+#define CS_HEREDOC     27
+#define CS_HEREDOCD    28
+#define CS_BRACE       29
+#define CS_BRACEPAR    30
+
+/*********************
+ * Memory management *
+ *********************/
+
+#ifndef DEBUG
+# define HEAPALLOC	do { int nonlocal_useheap = global_heapalloc(); do
+
+# define PERMALLOC	do { int nonlocal_useheap = global_permalloc(); do
+
+# define LASTALLOC	while (0); \
+			if (nonlocal_useheap) global_heapalloc(); \
+			else global_permalloc(); \
+		} while(0)
+
+# define LASTALLOC_RETURN \
+			if ((nonlocal_useheap ? global_heapalloc() : \
+			     global_permalloc()), 0) {;} else return
+#else
+# define HEAPALLOC	do { int nonlocal_useheap = global_heapalloc(); \
+			alloc_stackp++; do
+
+# define PERMALLOC	do { int nonlocal_useheap = global_permalloc(); \
+			alloc_stackp++; do
+
+# define LASTALLOC	while (0); alloc_stackp--; \
+			if (nonlocal_useheap) global_heapalloc(); \
+			else global_permalloc(); \
+		} while(0)
+
+# define LASTALLOC_RETURN \
+			if ((nonlocal_useheap ? global_heapalloc() : \
+			    global_permalloc()),alloc_stackp--,0){;}else return
+#endif
+
+/****************/
+/* Debug macros */
+/****************/
+
+#ifdef DEBUG
+# define DPUTS(X,Y) if (!(X)) {;} else dputs(Y)
+# define MUSTUSEHEAP(X) if (useheap) {;} else \
+		fprintf(stderr, "BUG: permanent allocation in %s\n", X), \
+		fflush(stderr)
+#else
+# define DPUTS(X,Y)
+# define MUSTUSEHEAP(X)
+#endif
+
+/**************************/
+/* Signal handling macros */
+/**************************/
+
+/* These used in the sigtrapped[] array */
+
+#define ZSIG_TRAPPED	(1<<0)
+#define ZSIG_IGNORED	(1<<1)
+#define ZSIG_FUNC	(1<<2)
+
+/****************/
+/* Entry points */
+/****************/
+
+/* compctl entry point pointers */
+
+typedef int (*CompctlReadFn) _((char *, char **, char *, char *));
+
+/* ZLE entry point pointers */
+
+typedef void (*ZleVoidFn) _((void));
+typedef void (*ZleVoidIntFn) _((int));
+typedef unsigned char * (*ZleReadFn) _((char *, char *, int));
diff --git a/Src/zsh.mdd b/Src/zsh.mdd
new file mode 100644
index 000000000..244029d65
--- /dev/null
+++ b/Src/zsh.mdd
@@ -0,0 +1,71 @@
+nozshdep=1
+alwayslink=1
+
+# autobins not specified because of alwayslink
+
+objects="builtin.o compat.o cond.o exec.o glob.o hashtable.o \
+hist.o init.o input.o jobs.o lex.o linklist.o loop.o math.o \
+mem.o module.o options.o params.o parse.o prompt.o signals.o \
+signames.o subst.o text.o utils.o watch.o"
+
+headers="../config.h system.h zsh.h sigcount.h signals.h \
+prototypes.h hashtable.h ztype.h"
+
+:<<\Make
+signames.c: signames.awk @SIGNAL_H@
+	$(AWK) -f $(sdir)/signames.awk @SIGNAL_H@ > $@
+
+sigcount.h: signames.c
+	grep 'define.*SIGCOUNT' signames.c > $@
+
+init.o: bltinmods.list zshpaths.h zshxmods.h
+
+params.o: version.h
+
+version.h: $(sdir_top)/Config/version.mk
+	echo '#define ZSH_VERSION "'$(VERSION)'"' > $@
+
+zshpaths.h: FORCE
+	@echo '#define MODULE_DIR "'$(MODDIR)'"' > zshpaths.h.tmp
+	@if cmp -s zshpaths.h zshpaths.h.tmp; then \
+	    rm -f zshpaths.h.tmp; \
+	    echo "\`zshpaths.h' is up to date." ; \
+	else \
+	    mv -f zshpaths.h.tmp zshpaths.h; \
+	    echo "Updated \`zshpaths.h'." ; \
+	fi
+
+bltinmods.list: modules.stamp modules-bltin xmods.conf mkbltnmlst.sh
+	srcdir='$(sdir)' MODBINS='modules-bltin' \
+	XMODCF='$(sdir)/xmods.conf' $(SHELL) $(sdir)/mkbltnmlst.sh $@
+
+zshxmods.h: modules-bltin xmods.conf
+	@echo "Creating \`$@'."
+	@( \
+	    binmods=`sed 's/^/ /;s/$$/ /' modules-bltin`; \
+	    for mod in `cat $(sdir_src)/xmods.conf`; do \
+		case $$binmods in \
+		    *" $$mod "*) \
+			echo "#define    LINKED_XMOD_$$mod 1" ;; \
+		    *)  echo "#ifdef DYNAMIC"; \
+			echo "# define UNLINKED_XMOD_$$mod 1"; \
+			echo "#endif" ;; \
+		esac; \
+	    done; \
+	    echo; \
+	    for mod in $$binmods; do \
+		echo "int boot_$$mod _((Module));"; \
+	    done; \
+	) > $@
+
+clean-here: clean.zsh
+clean.zsh:
+	rm -f sigcount.h signames.c bltinmods.list version.h zshpaths.h zshxmods.h
+
+# This is not properly part of this module, but it is built as if it were.
+main.o: main.c zsh.mdh main.pro
+	$(CC) -c -I. $(CPPFLAGS) $(DEFS) $(CFLAGS) -o $@ $(sdir)/main.c
+
+main.pro: $(PROTODEPS)
+proto.zsh: main.pro
+Make
diff --git a/Src/ztype.h b/Src/ztype.h
new file mode 100644
index 000000000..595ff0588
--- /dev/null
+++ b/Src/ztype.h
@@ -0,0 +1,58 @@
+/*
+ * ztype.h - character classification macros
+ *
+ * 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.
+ *
+ */
+
+#define IDIGIT   (1 <<  0)
+#define IALNUM   (1 <<  1)
+#define IBLANK   (1 <<  2)
+#define INBLANK  (1 <<  3)
+#define ITOK     (1 <<  4)
+#define ISEP     (1 <<  5)
+#define IALPHA   (1 <<  6)
+#define IIDENT   (1 <<  7)
+#define IUSER    (1 <<  8)
+#define ICNTRL   (1 <<  9)
+#define IWORD    (1 << 10)
+#define ISPECIAL (1 << 11)
+#define IMETA    (1 << 12)
+#define IWSEP    (1 << 13)
+#define _icom(X,Y) (typtab[STOUC(X)] & Y)
+#define idigit(X) _icom(X,IDIGIT)
+#define ialnum(X) _icom(X,IALNUM)
+#define iblank(X) _icom(X,IBLANK)	/* blank, not including \n */
+#define inblank(X) _icom(X,INBLANK)	/* blank or \n */
+#define itok(X) _icom(X,ITOK)
+#define isep(X) _icom(X,ISEP)
+#define ialpha(X) _icom(X,IALPHA)
+#define iident(X) _icom(X,IIDENT)
+#define iuser(X) _icom(X,IUSER)	/* username char */
+#define icntrl(X) _icom(X,ICNTRL)
+#define iword(X) _icom(X,IWORD)
+#define ispecial(X) _icom(X,ISPECIAL)
+#define imeta(X) _icom(X,IMETA)
+#define iwsep(X) _icom(X,IWSEP)