Initial revision

1 files changed, 1891 insertions, 0 deletions

diff --git a/Src/Zle/computil.c b/Src/Zle/computil.c
new file mode 100644
index 000000000..aed3d9808
--- /dev/null
+++ b/Src/Zle/computil.c
@@ -0,0 +1,1891 @@
+/*
+ * computil.c - completion utilities
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1999 Sven Wischnowsky
+ * 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 Sven Wischnowsky 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 Sven Wischnowsky and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Sven Wischnowsky 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 Sven Wischnowsky and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "computil.mdh"
+#include "computil.pro"
+
+
+/* Help for `_display'. */
+
+typedef struct cdisp *Cdisp;
+
+struct cdisp {
+    int pre, suf, colon;
+};
+
+static void
+cdisp_calc(Cdisp disp, char **args)
+{
+    char *cp;
+    int i;
+
+    for (; *args; args++) {
+	if ((cp = strchr(*args, ':')) && cp[1]) {
+	    disp->colon++;
+	    if ((i = cp - *args) > disp->pre)
+		disp->pre = i;
+	    if ((i = strlen(cp + 1)) > disp->suf)
+		disp->suf = i;
+	}
+    }
+}
+
+static char **
+cdisp_build(Cdisp disp, char *sep, char **args)
+{
+    int sl = strlen(sep), pre = disp->pre, suf;
+    VARARR(char, buf, disp->pre + disp->suf + sl + 1);
+    char **ret, **rp, *cp;
+
+    ret = (char **) zalloc((arrlen(args) + 1) * sizeof(char *));
+
+    memcpy(buf + pre, sep, sl);
+    suf = pre + sl;
+
+    for (rp = ret; *args; args++) {
+	if ((cp = strchr(*args, ':')) && cp[1]) {
+	    memset(buf, ' ', pre);
+	    memcpy(buf, *args, (cp - *args));
+	    strcpy(buf + suf, cp + 1);
+	    *rp++ = ztrdup(buf);
+	} else {
+	    if (cp)
+		*cp = '\0';
+	    *rp++ = ztrdup(*args);
+	    if (cp)
+		*cp = ':';
+	}
+    }
+    *rp = NULL;
+
+    return ret;
+}
+
+/**/
+static int
+bin_compdisplay(char *nam, char **args, char *ops, int func)
+{
+    struct cdisp disp;
+
+    if (incompfunc != 1) {
+	zerrnam(nam, "can only be called from completion function", NULL, 0);
+	return 1;
+    }
+    disp.pre = disp.suf = disp.colon = 0;
+
+    cdisp_calc(&disp, args + 2);
+    setaparam(args[0], cdisp_build(&disp, args[1], args + 2));
+
+    return !disp.colon;
+}
+
+/* Help fuer `_describe'. */
+
+typedef struct cdset *Cdset;
+
+struct cdstate {
+    int showd;
+    char *sep;
+    Cdset sets;
+    struct cdisp disp;
+};
+
+struct cdset {
+    Cdset next;
+    char **opts;
+    char **strs;
+    char **matches;
+};
+
+static struct cdstate cd_state;
+static int cd_parsed = 0;
+
+static void
+free_cdsets(Cdset p)
+{
+    Cdset n;
+
+    for (; p; p = n) {
+	n = p->next;
+	if (p->opts)
+	    freearray(p->opts);
+	if (p->strs)
+	    freearray(p->strs);
+	if (p->matches)
+	    freearray(p->matches);
+	zfree(p, sizeof(*p));
+    }
+}
+
+static int
+cd_init(char *nam, char *sep, char **args, int disp)
+{
+    Cdset *setp, set;
+    char **ap, *tmp;
+
+    if (cd_parsed) {
+	zsfree(cd_state.sep);
+	free_cdsets(cd_state.sets);
+    }
+    setp = &(cd_state.sets);
+    cd_state.sep = ztrdup(sep);
+    cd_state.sets = NULL;
+    cd_state.disp.pre = cd_state.disp.suf = cd_state.disp.colon = 0;
+    cd_state.showd = disp;
+
+    while (*args) {
+	*setp = set = (Cdset) zcalloc(sizeof(*set));
+	setp = &(set->next);
+
+	if (!(ap = get_user_var(*args))) {
+	    zerrnam(nam, "invalid argument: %s", *args, 0);
+	    return 1;
+	}
+	PERMALLOC {
+	    set->strs = arrdup(ap);
+	} LASTALLOC;
+
+	if (disp)
+	    cdisp_calc(&(cd_state.disp), set->strs);
+
+	if (*++args && **args != '-') {
+	    if (!(ap = get_user_var(*args))) {
+		zerrnam(nam, "invalid argument: %s", *args, 0);
+		return 1;
+	    }
+	    PERMALLOC {
+		set->matches = arrdup(ap);
+	    } LASTALLOC;
+	    args++;
+	}
+	for (ap = args; *args &&
+		 (args[0][0] != '-' || args[0][1] != '-' || args[0][2]);
+	     args++);
+
+	tmp = *args;
+	*args = NULL;
+	PERMALLOC {
+	    set->opts = arrdup(ap);
+	} LASTALLOC;
+	if ((*args = tmp))
+	    args++;
+    }
+    return 0;
+}
+
+static int
+cd_get(char **params)
+{
+    Cdset set;
+
+    if ((set = cd_state.sets)) {
+	char **sd, **sdp, **md, **mdp, **ss, **ssp, **ms, **msp;
+	char **p, **mp, *cp;
+	int dl = 1, sl = 1, sepl = strlen(cd_state.sep);
+	int pre = cd_state.disp.pre, suf = cd_state.disp.suf;
+	VARARR(char, buf, pre + suf + sepl + 1);
+
+	for (p = set->strs; *p; p++)
+	    if (cd_state.showd && (cp = strchr(*p, ':')) && cp[1])
+		dl++;
+	    else
+		sl++;
+
+	sd = (char **) zalloc(dl * sizeof(char *));
+	ss = (char **) zalloc(sl * sizeof(char *));
+	md = (char **) zalloc(dl * sizeof(char *));
+	ms = (char **) zalloc(sl * sizeof(char *));
+
+	if (cd_state.showd) {
+	    memcpy(buf + pre, cd_state.sep, sepl);
+	    suf = pre + sepl;
+	}
+	for (sdp = sd, ssp = ss, mdp = md, msp = ms,
+		 p = set->strs, mp = set->matches; *p; p++) {
+	    if ((cp = strchr(*p, ':')) && cp[1] && cd_state.showd) {
+		memset(buf, ' ', pre);
+		memcpy(buf, *p, (cp - *p));
+		strcpy(buf + suf, cp + 1);
+		*sdp++ = ztrdup(buf);
+		if (mp) {
+		    *mdp++ = ztrdup(*mp);
+		    if (*mp)
+			mp++;
+		} else {
+		    *cp = '\0';
+		    *mdp++ = ztrdup(*p);
+		    *cp = ':';
+		}
+	    } else {
+		if (cp)
+		    *cp = '\0';
+		*ssp++ = ztrdup(*p);
+		if (mp) {
+		    *msp++ = ztrdup(*mp);
+		    if (*mp)
+			mp++;
+		} else
+		    *msp++ = ztrdup(*p);
+		if (cp)
+		    *cp = ':';
+	    }
+	}
+	*sdp = *ssp = *mdp = *msp = NULL;
+
+	PERMALLOC {
+	    p = arrdup(set->opts);
+	} LASTALLOC;
+
+	setaparam(params[0], p);
+	setaparam(params[1], sd);
+	setaparam(params[2], md);
+	setaparam(params[3], ss);
+	setaparam(params[4], ms);
+
+	cd_state.sets = set->next;
+	set->next = NULL;
+	free_cdsets(set);
+
+	return 0;
+    }
+    return 1;
+}
+
+/**/
+static int
+bin_compdescribe(char *nam, char **args, char *ops, int func)
+{
+    if (incompfunc != 1) {
+	zerrnam(nam, "can only be called from completion function", NULL, 0);
+	return 1;
+    }
+    if (!args[0][0] || !args[0][1] || args[0][2]) {
+	zerrnam(nam, "invalid argument: %s", args[0], 0);
+	return 1;
+    }
+    switch (args[0][1]) {
+    case 'i':
+    case 'I':
+	cd_parsed = 1;
+	return cd_init(nam, args[1], args + 2, (args[0][1] == 'I'));
+    case 'g':
+	if (cd_parsed) {
+	    int n = arrlen(args);
+
+	    if (n != 6) {
+		zerrnam(nam, (n < 6 ? "not enough arguments" :
+			      "too many arguments"), NULL, 0);
+		return 1;
+	    }
+	    return cd_get(args + 1);
+	} else {
+	    zerrnam(nam, "no parsed state", NULL, 0);
+	    return 1;
+	}
+    }
+    zerrnam(nam, "invalid option: %s", args[0], 0);
+    return 1;
+}
+
+/* Help for `_arguments'. */
+
+typedef struct cadef *Cadef;
+typedef struct caopt *Caopt;
+typedef struct caarg *Caarg;
+
+struct cadef {
+    Cadef next;
+    Caopt opts;
+    int nopts, ndopts, nodopts;
+    Caarg args;
+    Caarg rest;
+    char **defs;
+    int ndefs;
+    int lastt;
+    Caopt *single;
+    char *match;
+    int argsactive;
+};
+
+struct caopt {
+    Caopt next;
+    char *name;
+    char *descr;
+    char **xor;
+    int type;
+    Caarg args;
+    int active;
+    int num;
+};
+
+#define CAO_NEXT    1
+#define CAO_DIRECT  2
+#define CAO_ODIRECT 3
+#define CAO_EQUAL   4
+
+struct caarg {
+    Caarg next;
+    char *descr;
+    char *action;
+    int type;
+    char *end;
+    int num;
+};
+
+#define CAA_NORMAL 1
+#define CAA_OPT    2
+#define CAA_REST   3
+#define CAA_RARGS  4
+#define CAA_RREST  5
+
+#define MAX_CACACHE 8
+static Cadef cadef_cache[MAX_CACACHE];
+
+static int
+arrcmp(char **a, char **b)
+{
+    if (!a && !b)
+	return 1;
+    else if (!a || !b)
+	return 0;
+    else {
+	while (*a && *b)
+	    if (strcmp(*a++, *b++))
+		return 0;
+
+	return (!*a && !*b);
+    }
+}
+
+static void
+free_caargs(Caarg a)
+{
+    Caarg n;
+
+    for (; a; a = n) {
+	n = a->next;
+	zsfree(a->descr);
+	zsfree(a->action);
+	zsfree(a->end);
+	zfree(a, sizeof(*a));
+    }
+}
+
+static void
+free_cadef(Cadef d)
+{
+    if (d) {
+	Caopt p, n;
+
+	zsfree(d->match);
+	freearray(d->defs);
+
+	for (p = d->opts; p; p = n) {
+	    n = p->next;
+	    zsfree(p->name);
+	    zsfree(p->descr);
+	    freearray(p->xor);
+	    free_caargs(p->args);
+	    zfree(p, sizeof(*p));
+	}
+	free_caargs(d->args);
+	free_caargs(d->rest);
+	if (d->single)
+	    zfree(d->single, 256 * sizeof(Caopt));
+	zfree(d, sizeof(*d));
+    }
+}
+
+static char *
+rembslashcolon(char *s)
+{
+    char *p, *r;
+
+    r = p = s = dupstring(s);
+
+    while (*s) {
+	if (s[0] != '\\' || s[1] != ':')
+	    *p++ = *s;
+	s++;
+    }
+    *p = '\0';
+
+    return r;
+}
+
+static Caarg
+parse_caarg(int mult, int type, int num, char **def)
+{
+    Caarg ret = (Caarg) zalloc(sizeof(*ret));
+    char *p = *def, *d, sav;
+
+    ret->next = NULL;
+    ret->descr = ret->action = ret->end = NULL;
+    ret->num = num;
+    ret->type = type;
+
+    for (d = p; *p && *p != ':'; p++)
+	if (*p == '\\' && p[1])
+	    p++;
+    sav = *p;
+    *p = '\0';
+    ret->descr = ztrdup(rembslashcolon(d));
+    if (sav) {
+	if (mult) {
+	    for (d = ++p; *p && *p != ':'; p++)
+		if (*p == '\\' && p[1])
+		    p++;
+	    sav = *p;
+	    *p = '\0';
+	    ret->action = ztrdup(rembslashcolon(d));
+	    if (sav)
+		*p = ':';
+	} else
+	    ret->action = ztrdup(rembslashcolon(p + 1));
+    }
+    *def = p;
+
+    return ret;
+}
+
+static Cadef
+parse_cadef(char *nam, char **args)
+{
+    Cadef ret;
+    Caopt *optp;
+    char **oargs = args, *p, *q, *match = "r:|[_-]=* r:|=*", **xor;
+    char *adpre, *adsuf;
+    int single = 0, anum = 1, xnum, nopts, ndopts, nodopts;
+
+    nopts = ndopts = nodopts = 0;
+
+    for (p = args[0]; *p && (p[0] != '%' || p[1] != 'd'); p++);
+
+    if (*p) {
+	*p = '\0';
+	adpre = dupstring(args[0]);
+	*p = '%';
+	adsuf = dupstring(p + 2);
+    } else
+	adpre = adsuf = NULL;
+
+    args++;
+    while ((p = *args)) {
+	if (!strcmp(p, "-s"))
+	    single = 1;
+	else if (p[0] == '-' && p[1] == 'M') {
+	    if (p[2])
+		match = p + 2;
+	    else if (args[1])
+		match = *++args;
+	    else {
+		args++;
+		break;
+	    }
+	} else
+	    break;
+	args++;
+    }
+    if (!*args)
+	return NULL;
+
+    PERMALLOC {
+	ret = (Cadef) zalloc(sizeof(*ret));
+	ret->next = NULL;
+	ret->opts = NULL;
+	ret->args = ret->rest = NULL;
+	ret->defs = arrdup(oargs);
+	ret->ndefs = arrlen(oargs);
+	ret->lastt = time(0);
+	if (single) {
+	    ret->single = (Caopt *) zalloc(256 * sizeof(Caopt));
+	    memset(ret->single, 0, 256 * sizeof(Caopt));
+	} else
+	    ret->single = NULL;
+	ret->match = ztrdup(match);
+    } LASTALLOC;
+
+    for (optp = &(ret->opts); *args; args++) {
+	p = dupstring(*args);
+	xnum = 0;
+	if (*p == '(') {
+	    LinkList list = newlinklist();
+	    LinkNode node;
+	    char **xp, sav;
+
+	    while (*p && *p != ')') {
+		for (p++; inblank(*p); p++);
+
+		if (*p == ')')
+		    break;
+		for (q = p++; *p && *p != ')' && !inblank(*p); p++);
+
+		if (!*p)
+		    break;
+
+		sav = *p;
+		*p = '\0';
+		addlinknode(list, dupstring(q));
+		xnum++;
+		*p = sav;
+	    }
+	    if (*p != ')') {
+		free_cadef(ret);
+		zerrnam(nam, "invalid argument: %s", *args, 0);
+		return NULL;
+	    }
+	    xor = (char **) zalloc((xnum + 2) * sizeof(char *));
+	    for (node = firstnode(list), xp = xor; node; incnode(node), xp++)
+		*xp = ztrdup((char *) getdata(node));
+	    xp[0] = xp[1] = NULL;
+
+	    p++;
+	} else
+	    xor = NULL;
+	
+	if (*p == '-' || *p == '+' ||
+	    (*p == '*' && (p[1] == '-' || p[1] == '+'))) {
+	    Caopt opt;
+	    Caarg oargs = NULL;
+	    int multi, otype = CAO_NEXT, again = 0;
+	    char *name, *descr, c;
+
+	    rec:
+
+	    if ((multi = (*p == '*')))
+		p++;
+
+	    if ((p[0] == '-' && p[1] == '+') ||
+		(p[0] == '+' && p[1] == '-')) {
+		name = ++p;
+		*p = (again ? '-' : '+');
+		again = 1 - again;
+	    } else {
+		name = p;
+		if (p[0] == '-' && p[1] == '-')
+		    p++;
+	    }
+	    for (p++; *p && *p != ':' && *p != '[' &&
+		     ((*p != '-' && *p != '+' && *p != '=') ||
+		      (p[1] != ':' && p[1] != '[')); p++)
+		if (*p == '\\' && p[1])
+		    p++;
+
+	    c = *p;
+	    *p = '\0';
+	    if (c == '-') {
+		otype = CAO_DIRECT;
+		c = *++p;
+	    } else if (c == '+') {
+		otype = CAO_ODIRECT;
+		c = *++p;
+	    } else if (c == '=') {
+		otype = CAO_EQUAL;
+		c = *++p;
+	    }
+	    if (c == '[') {
+		for (descr = ++p; *p && *p != ']'; p++)
+		    if (*p == '\\' && p[1])
+			p++;
+
+		if (!*p) {
+		    free_cadef(ret);
+		    zerrnam(nam, "invalid option definition: %s", *args, 0);
+		    return NULL;
+		}
+		*p++ = '\0';
+		c = *p;
+	    } else
+		descr = NULL;
+
+	    if (c && c != ':') {
+		free_cadef(ret);
+		zerrnam(nam, "invalid option definition: %s", *args, 0);
+		return NULL;
+	    }
+	    if (!multi) {
+		if (!xor) {
+		    xor = (char **) zalloc(2 * sizeof(char *));
+		    xor[1] = NULL;
+		}
+		xor[xnum] = ztrdup(name);
+	    }
+	    if (c == ':') {
+		Caarg *oargp = &oargs;
+		int atype, rest;
+		char *end;
+
+		while (c == ':') {
+		    rest = 0;
+		    end = NULL;
+
+		    if (*++p == ':') {
+			atype = CAA_OPT;
+			p++;
+		    } else if (*p == '*') {
+			if (*++p != ':') {
+			    for (end = ++p; *p && *p != ':'; p++)
+				if (*p == '\\' && p[1])
+				    p++;
+			}
+			if (*p != ':') {
+			    free_cadef(ret);
+			    free_caargs(oargs);
+			    zerrnam(nam, "invalid option definition: %s",
+				    *args, 0);
+			    return NULL;
+			}
+			if (*++p == ':') {
+			    if (*++p == ':') {
+				atype = CAA_RREST;
+				p++;
+			    } else
+				atype = CAA_RARGS;
+			} else
+			    atype = CAA_REST;
+			rest = 1;
+		    } else
+			atype = CAA_NORMAL;
+		    *oargp = parse_caarg(!rest, atype, 0, &p);
+		    oargp = &((*oargp)->next);
+		    if (rest)
+			break;
+		    c = *p;
+		}
+	    }
+	    PERMALLOC {
+		*optp = opt = (Caopt) zalloc(sizeof(*opt));
+		optp = &((*optp)->next);
+
+		opt->next = NULL;
+		opt->name = ztrdup(name);
+		if (descr)
+		    opt->descr = ztrdup(descr);
+		else if (adpre && oargs && !oargs->next)
+		    opt->descr = tricat(adpre, oargs->descr, adsuf);
+		else
+		    opt->descr = NULL;
+		opt->xor = xor;
+		opt->type = otype;
+		opt->args = oargs;
+		opt->num = nopts++;
+	    } LASTALLOC;
+
+	    if (otype == CAO_DIRECT)
+		ndopts++;
+	    else if (otype == CAO_ODIRECT || otype == CAO_EQUAL)
+		nodopts++;
+
+	    if (single && name[1] && !name[2])
+		ret->single[STOUC(name[1])] = opt;
+
+	    if (again) {
+		p = dupstring(*args);
+		goto rec;
+	    }
+	} else if (*p == '*') {
+	    int type = CAA_REST;
+
+	    if (*++p != ':') {
+		free_cadef(ret);
+		zerrnam(nam, "invalid rest argument definition: %s", *args, 0);
+		return NULL;
+	    }
+	    if (ret->rest) {
+		free_cadef(ret);
+		zerrnam(nam, "doubled rest argument definition: %s", *args, 0);
+		return NULL;
+	    }
+	    if (*++p == ':') {
+		if (*++p == ':') {
+		    type = CAA_RREST;
+		    p++;
+		} else
+		    type = CAA_RARGS;
+	    }
+	    ret->rest = parse_caarg(0, type, -1, &p);
+	} else {
+	    int type = CAA_NORMAL;
+	    Caarg arg, tmp, pre;
+
+	    if (idigit(*p)) {
+		int num = 0;
+
+		while (*p && idigit(*p))
+		    num = (num * 10) + ((int) *p++);
+
+		anum = num + 1;
+	    } else
+		anum++;
+
+	    if (*p != ':') {
+		free_cadef(ret);
+		zerrnam(nam, "invalid argument: %s", *args, 0);
+		return NULL;
+	    }
+	    if (*++p == ':') {
+		type = CAA_OPT;
+		p++;
+	    }
+	    arg = parse_caarg(0, type, anum - 1, &p);
+
+	    for (tmp = ret->args, pre = NULL;
+		 tmp && tmp->num < anum - 1;
+		 pre = tmp, tmp = tmp->next);
+
+	    if (tmp && tmp->num == anum - 1) {
+		free_cadef(ret);
+		free_caargs(arg);
+		zerrnam(nam, "doubled argument definition: %s", *args, 0);
+		return NULL;
+	    }
+	    arg->next = tmp;
+	    if (pre)
+		pre->next = arg;
+	    else
+		ret->args = arg;
+	}
+    }
+    ret->nopts = nopts;
+    ret->ndopts = ndopts;
+    ret->nodopts = nodopts;
+    
+    return ret;
+}
+
+static Cadef
+get_cadef(char *nam, char **args)
+{
+    Cadef *p, *min, new;
+    int i, na = arrlen(args);
+
+    for (i = MAX_CACACHE, p = cadef_cache, min = NULL; *p && i--; p++)
+	if (*p && na == (*p)->ndefs && arrcmp(args, (*p)->defs)) {
+	    (*p)->lastt = time(0);
+
+	    return *p;
+	} else if (!min || !*p || (*p)->lastt < (*min)->lastt)
+	    min = p;
+    if (i)
+	min = p;
+    if ((new = parse_cadef(nam, args))) {
+	free_cadef(*min);
+	*min = new;
+    }
+    return new;
+}
+
+static Caopt
+ca_get_opt(Cadef d, char *line, int full, char **end)
+{
+    Caopt p;
+
+    if (full) {
+	for (p = d->opts; p; p = p->next)
+	    if (p->active && !strcmp(p->name, line))
+		return p;
+    } else {
+	for (p = d->opts; p; p = p->next)
+	    if (p->active && p->args && p->type != CAO_NEXT &&
+		strpfx(p->name, line)) {
+		if (end) {
+		    int l = strlen(p->name);
+
+		    if (p->type == CAO_EQUAL && line[l] == '=')
+			l++;
+
+		    *end = line + l;
+		}
+		return p;
+	    }
+    }
+    return NULL;
+}
+
+static Caopt
+ca_get_sopt(Cadef d, char *line, int full, char **end)
+{
+    Caopt p;
+
+    line++;
+
+    if (full) {
+	for (p = NULL; *line; line++)
+	    if (!(p = d->single[STOUC(*line)]) || !p->active ||
+		(line[1] && p->args))
+		return NULL;
+	return p;
+    } else {
+	for (p = NULL; *line; line++)
+	    if ((p = d->single[STOUC(*line)]) && p->active &&
+		p->args && p->type != CAO_NEXT) {
+		if (end) {
+		    line++;
+		    if (p->type == CAO_EQUAL && *line == '=')
+			line++;
+		    *end = line;
+		}
+		break;
+	    } else if (!p || !p->active || (line[1] && p->args))
+		return NULL;
+	return p;
+    }
+    return NULL;
+}
+
+static Caarg
+ca_get_arg(Cadef d, int n)
+{
+    if (d->argsactive) {
+	Caarg a = d->args;
+
+	while (a && a->num < n)
+	    a = a->next;
+
+	if (a && a->num == n)
+	    return a;
+
+	return d->rest;
+    }
+    return NULL;
+}
+
+static void
+ca_inactive(Cadef d, char **xor)
+{
+    if (xor) {
+	Caopt opt;
+
+	for (; *xor; xor++) {
+	    if (xor[0][0] == ':' && !xor[0][1])
+		d->argsactive = 0;
+	    else if ((opt = ca_get_opt(d, *xor, 1, NULL)))
+		opt->active = 0;
+	}
+    }
+}
+
+struct castate {
+    Cadef d;
+    Caarg def, ddef;
+    Caopt curopt;
+    int opt, arg, argbeg, optbeg, nargbeg, restbeg;
+    int inopt, inrest, inarg, nth, doff, singles;
+    LinkList args;
+    LinkList *oargs;
+};
+
+static struct castate ca_laststate;
+static int ca_parsed = 0, ca_alloced = 0;
+
+static void
+ca_parse_line(Cadef d)
+{
+    Caarg adef, ddef;
+    Caopt ptr;
+    struct castate state;
+    char *line, *pe;
+    int cur, doff;
+    Patprog endpat = NULL;
+
+    if (ca_alloced) {
+	int i = ca_laststate.d->nopts;
+	LinkList *p = ca_laststate.oargs;
+
+	freelinklist(ca_laststate.args, freestr);
+	while (i--)
+	    if (*p++)
+		freelinklist(p[-1], freestr);
+    }
+    for (ptr = d->opts; ptr; ptr = ptr->next)
+	ptr->active = 1;
+    d->argsactive = 1;
+
+    state.d = d;
+    state.def = state.ddef = NULL;
+    state.curopt = NULL;
+    state.argbeg = state.optbeg = state.nargbeg = state.restbeg =
+	state.nth = state.inopt = state.inarg = state.opt = state.arg = 1;
+    state.inrest = state.doff = state.singles = state.doff = 0;
+    PERMALLOC {
+	state.args = newlinklist();
+	state.oargs = (LinkList *) zalloc(d->nopts * sizeof(LinkList));
+	memset(state.oargs, 0, d->nopts * sizeof(LinkList));
+    } LASTALLOC;
+    ca_alloced = 1;
+
+    memcpy(&ca_laststate, &state, sizeof(state));
+
+    if (!compwords[1]) {
+	ca_laststate.opt = ca_laststate.arg = 0;
+
+	return;
+    }
+    for (line = compwords[1], cur = 2, state.curopt = NULL, state.def = NULL;
+	 line; line = compwords[cur++]) {
+	ddef = adef = NULL;
+	doff = state.singles = 0;
+	if (state.def) {
+	    state.arg = 0;
+	    if (state.curopt) {
+		PERMALLOC {
+		    addlinknode(state.oargs[state.curopt->num], ztrdup(line));
+		} LASTALLOC;
+	    }
+	    state.opt = (state.def->type == CAA_OPT && line[0] && line[1]);
+
+	    if (state.def->type == CAA_REST || state.def->type == CAA_RARGS ||
+		state.def->type == CAA_RREST) {
+		if (state.def->end && pattry(endpat, line)) {
+		    state.def = NULL;
+		    state.curopt = NULL;
+		    continue;
+		}
+	    } else if ((state.def = state.def->next))
+		state.argbeg = cur;
+	    else
+		state.curopt = NULL;
+	} else {
+	    state.opt = (line[0] && line[1]);
+	    state.arg = 1;
+	    state.curopt = NULL;
+	}
+	pe = NULL;
+
+	if (state.opt && (state.curopt = ca_get_opt(d, line, 0, &pe))) {
+	    ddef = state.def = state.curopt->args;
+	    doff = pe - line;
+	    state.optbeg = state.argbeg = state.inopt = cur;
+	    PERMALLOC {
+		state.oargs[state.curopt->num] = newlinklist();
+	    } LASTALLOC;
+	    ca_inactive(d, state.curopt->xor);
+
+	    if (state.def &&
+		(state.curopt->type == CAO_DIRECT ||
+		 (state.curopt->type == CAO_ODIRECT && pe[0]) ||
+		 (state.curopt->type == CAO_EQUAL &&
+		  (pe[0] || pe[-1] == '=')))) {
+		if (state.def->type != CAA_REST &&
+		    state.def->type != CAA_RARGS &&
+		    state.def->type != CAA_RREST)
+		    state.def = state.def->next;
+		PERMALLOC {
+		    addlinknode(state.oargs[state.curopt->num], ztrdup(pe));
+		} LASTALLOC;
+	    }
+	    if (!state.def)
+		state.curopt = NULL;
+	} else if (state.opt && d->single &&
+		   (state.curopt = ca_get_sopt(d, line, 0, &pe))) {
+	    char *p;
+	    Caopt tmpopt;
+
+	    ddef = state.def = state.curopt->args;
+	    doff = pe - line;
+	    state.optbeg = state.argbeg = state.inopt = cur;
+	    state.singles = !*pe;
+
+	    for (p = line + 1; p <= pe; p++) {
+		if ((tmpopt = d->single[STOUC(*p)])) {
+		    PERMALLOC {
+			state.oargs[tmpopt->num] = newlinklist();
+		    } LASTALLOC;
+		    ca_inactive(d, tmpopt->xor);
+		}
+	    }
+	    if (state.def &&
+		(state.curopt->type == CAO_DIRECT ||
+		 (state.curopt->type == CAO_ODIRECT && pe[0]) ||
+		 (state.curopt->type == CAO_EQUAL &&
+		  (pe[0] || pe[-1] == '=')))) {
+		if (state.def->type != CAA_REST &&
+		    state.def->type != CAA_RARGS &&
+		    state.def->type != CAA_RREST)
+		    state.def = state.def->next;
+		PERMALLOC {
+		    addlinknode(state.oargs[state.curopt->num], ztrdup(pe));
+		} LASTALLOC;
+	    }
+	    if (!state.def)
+		state.curopt = NULL;
+	} else if (state.arg) {
+	    PERMALLOC {
+		addlinknode(state.args, ztrdup(line));
+	    } LASTALLOC;
+	    if ((adef = state.def = ca_get_arg(d, state.nth)) &&
+		(state.def->type == CAA_RREST ||
+		 state.def->type == CAA_RARGS)) {
+		state.inrest = 0;
+		for (; line; line = compwords[cur++]) {
+		    PERMALLOC {
+			addlinknode(state.args, ztrdup(line));
+		    } LASTALLOC;
+		}
+		break;
+	    }
+	    if (state.inopt) {
+		state.inopt = 0;
+		state.nargbeg = cur - 1;
+	    }
+	    if (state.def && state.def->type != CAA_NORMAL &&
+		state.def->type != CAA_OPT && state.inarg) {
+		state.restbeg = cur;
+		state.inarg = 0;
+	    } else if (!state.def || state.def->type == CAA_NORMAL ||
+		       state.def->type == CAA_OPT)
+		state.inarg = 1;
+	    state.nth++;
+	    state.def = NULL;
+	}
+	if (state.def && state.curopt &&
+	    (state.def->type == CAA_RREST || state.def->type == CAA_RARGS)) {
+	    if (state.def->end)
+		endpat = patcompile(state.def->end, 0, NULL);
+	    else {
+		LinkList l = state.oargs[state.curopt->num];
+
+		for (; line; line = compwords[cur++]) {
+		    PERMALLOC {
+			addlinknode(l, line);
+		    } LASTALLOC;
+		}
+		break;
+	    }
+	}
+	if (cur + 1 == compcurrent) {
+	    memcpy(&ca_laststate, &state, sizeof(state));
+	    ca_laststate.ddef = NULL;
+	    ca_laststate.doff = 0;
+	} else if (cur == compcurrent && !ca_laststate.def) {
+	    if ((ca_laststate.def = ddef))
+		ca_laststate.doff = doff;
+	    else {
+		ca_laststate.def = adef;
+		ca_laststate.ddef = NULL;
+		ca_laststate.argbeg = state.nargbeg;
+		ca_laststate.optbeg = state.restbeg;
+		ca_laststate.singles = state.singles;
+	    }
+	}
+    }
+}
+
+static char *
+ca_colonlist(LinkList l)
+{
+    if (l) {
+	LinkNode n;
+	int len = 1;
+	char *p, *ret, *q;
+
+	for (n = firstnode(l); n; incnode(n))
+	    for (p = (char *) getdata(n); *p; p++)
+		len += (*p == ':' ? 2 : 1);
+
+	ret = q = (char *) zalloc(len);
+
+	for (n = firstnode(l); n; incnode(n))
+	    for (p = (char *) getdata(n); *p; p++) {
+		if (*p == ':')
+		    *q++ = '\\';
+		*q++ = *p;
+	    }
+	*q = '\0';
+
+	return ret;
+    } else
+	return ztrdup("");
+}
+
+static int
+bin_comparguments(char *nam, char **args, char *ops, int func)
+{
+    int min, max, n;
+
+    if (incompfunc != 1) {
+	zerrnam(nam, "can only be called from completion function", NULL, 0);
+	return 1;
+    }
+    if (args[0][0] != '-' || !args[0][1] || args[0][2]) {
+	zerrnam(nam, "invalid argument: %s", args[0], 0);
+	return 1;
+    }
+    if (args[0][1] != 'i' && !ca_parsed) {
+	zerrnam(nam, "no parsed state", NULL, 0);
+	return 1;
+    }
+    switch (args[0][1]) {
+    case 'i': min = 2; max = -1; break;
+    case 'D': min = 2; max =  2; break;
+    case 'O': min = 4; max =  4; break;
+    case 'L': min = 3; max =  3; break;
+    case 's': min = 1; max =  1; break;
+    case 'M': min = 1; max =  1; break;
+    case 'a': min = 0; max =  0; break;
+    case 'W': min = 2; max =  2; break;
+    default:
+	zerrnam(nam, "invalid option: %s", args[0], 0);
+	return 1;
+    }
+    n = arrlen(args) - 1;
+    if (n < min) {
+	zerrnam(nam, "not enough arguments", NULL, 0);
+	return 1;
+    } else if (max >= 0 && n > max) {
+	zerrnam(nam, "too many arguments", NULL, 0);
+	return 1;
+    }
+    switch (args[0][1]) {
+    case 'i':
+	if (compcurrent > 1 && compwords[0]) {
+	    Cadef def = get_cadef(nam, args + 1);
+	    int cap = ca_parsed;
+
+	    ca_parsed = 0;
+
+	    if (!def)
+		return 1;
+
+	    ca_parsed = cap;
+	    ca_parse_line(def);
+	    ca_parsed = 1;
+
+	    return 0;
+	}
+	return 1;
+
+    case 'D':
+	{
+	    Caarg arg = ca_laststate.def;
+
+	    if (arg) {
+		setsparam(args[1], ztrdup(arg->descr));
+		setsparam(args[2], ztrdup(arg->action));
+
+		ignore_prefix(ca_laststate.doff);
+		if (arg->type == CAA_RARGS)
+		    restrict_range(ca_laststate.argbeg - 1,
+				   arrlen(compwords) - 1);
+		else if (arg->type == CAA_RREST)
+		    restrict_range(ca_laststate.optbeg - 1,
+				   arrlen(compwords) - 1);
+		return 0;
+	    }
+	    return 1;
+	}
+    case 'O':
+	if (ca_laststate.opt) {
+	    LinkList next = newlinklist();
+	    LinkList direct = newlinklist();
+	    LinkList odirect = newlinklist();
+	    LinkList equal = newlinklist(), l;
+	    Caopt p;
+	    char *str;
+
+	    for (p = ca_laststate.d->opts; p; p = p->next) {
+		if (p->active) {
+		    switch (p->type) {
+		    case CAO_NEXT:    l = next;    break;
+		    case CAO_DIRECT:  l = direct;  break;
+		    case CAO_ODIRECT: l = odirect; break;
+		    default:          l = equal;   break;
+		    }
+		    if (p->descr) {
+			int len = strlen(p->name) + strlen(p->descr) + 2;
+
+			str = (char *) zhalloc(len);
+			strcpy(str, p->name);
+			strcat(str, ":");
+			strcat(str, p->descr);
+		    } else
+			str = p->name;
+		    addlinknode(l, str);
+		}
+	    }
+	    set_list_array(args[1], next);
+	    set_list_array(args[2], direct);
+	    set_list_array(args[3], odirect);
+	    set_list_array(args[4], equal);
+
+	    return 0;
+	} else
+	    return 1;
+    case 'L':
+	{
+	    Caopt opt = ca_get_opt(ca_laststate.d, args[1], 1, NULL);
+
+	    if (opt && opt->args) {
+		setsparam(args[2], ztrdup(opt->args->descr));
+		setsparam(args[3], ztrdup(opt->args->action));
+
+		return 0;
+	    }
+	    return 1;
+	}
+    case 's':
+	if (ca_laststate.d->single && ca_laststate.singles) {
+	    setsparam(args[1],
+		      ztrdup(ca_laststate.ddef ?
+			     (ca_laststate.ddef->type == CAO_DIRECT ?
+			      "direct" :
+			      (ca_laststate.ddef->type == CAO_EQUAL ?
+			       "equal" : "next")) : ""));
+	    return 0;
+	} else
+	    return 1;
+    case 'M':
+	setsparam(args[1], ztrdup(ca_laststate.d->match));
+	return 0;
+    case 'a':
+	return !(ca_laststate.d->args || ca_laststate.d->rest);
+    case 'W':
+	{
+	    char **ret, **p;
+	    LinkNode n;
+	    LinkList *a;
+	    Caopt o;
+	    int num;
+
+	    ret = p = zalloc((countlinknodes(ca_laststate.args) + 1) *
+			     sizeof(char *));
+
+	    for (n = firstnode(ca_laststate.args); n; incnode(n))
+		*p++ = ztrdup((char *) getdata(n));
+	    *p = NULL;
+
+	    setaparam(args[1], ret);
+
+	    for (num = 0, o = ca_laststate.d->opts, a = ca_laststate.oargs; o;
+		 o = o->next, a++)
+		if (*a)
+		    num += 2;
+
+	    ret = p = zalloc((num + 1) * sizeof(char *));
+
+	    for (o = ca_laststate.d->opts, a = ca_laststate.oargs; o;
+		 o = o->next, a++) {
+		if (*a) {
+		    *p++ = ztrdup(o->name);
+		    *p++ = ca_colonlist(*a);
+		}
+	    }
+	    *p = NULL;
+
+	    sethparam(args[2], ret);
+	}
+	return 0;
+    }
+    return 1;
+}
+
+/* Help for `_values'. */
+
+typedef struct cvdef *Cvdef;
+typedef struct cvval *Cvval;
+
+struct cvdef {
+    char *descr;
+    int hassep;
+    char sep;
+    Cvdef next;
+    Cvval vals;
+    char **defs;
+    int ndefs;
+    int lastt;
+};
+
+struct cvval {
+    Cvval next;
+    char *name;
+    char *descr;
+    char **xor;
+    int type;
+    Caarg arg;
+    int active;
+};
+
+#define CVV_NOARG 0
+#define CVV_ARG   1
+#define CVV_OPT   2
+
+#define MAX_CVCACHE 8
+static Cvdef cvdef_cache[MAX_CVCACHE];
+
+static void
+free_cvdef(Cvdef d)
+{
+    if (d) {
+	Cvval p, n;
+
+	zsfree(d->descr);
+	freearray(d->defs);
+
+	for (p = d->vals; p; p = n) {
+	    n = p->next;
+	    zsfree(p->name);
+	    zsfree(p->descr);
+	    freearray(p->xor);
+	    free_caargs(p->arg);
+	    zfree(p, sizeof(*p));
+	}
+	zfree(d, sizeof(*d));
+    }
+}
+
+static Cvdef
+parse_cvdef(char *nam, char **args)
+{
+    Cvdef ret;
+    Cvval val, *valp;
+    Caarg arg;
+    char **oargs = args, sep, *name, *descr, *p, *q, **xor, c;
+    int xnum, multi, vtype, hassep;
+
+    if (args[0][0] == '-' && args[0][1] == 's' && !args[0][2]) {
+	if (args[1][0] && args[1][1]) {
+	    zerrnam(nam, "invalid separator: %s", args[1], 0);
+	    return NULL;
+	}
+	hassep = 1;
+	sep = args[1][0];
+	args += 2;
+    }
+    if (!args[0] || !args[1]) {
+	zerrnam(nam, "not enough arguments", NULL, 0);
+	return NULL;
+    }
+    descr = *args++;
+
+    PERMALLOC {
+	ret = (Cvdef) zalloc(sizeof(*ret));
+	ret->descr = ztrdup(descr);
+	ret->hassep = hassep;
+	ret->sep = sep;
+	ret->next = NULL;
+	ret->vals = NULL;
+	ret->defs = arrdup(oargs);
+	ret->ndefs = arrlen(oargs);
+	ret->lastt = time(0);
+    } LASTALLOC;
+
+    for (valp = &(ret->vals); *args; args++) {
+	p = dupstring(*args);
+	xnum = 0;
+	if (*p == '(') {
+	    LinkList list = newlinklist();
+	    LinkNode node;
+	    char **xp, sav;
+
+	    while (*p && *p != ')') {
+		for (p++; inblank(*p); p++);
+
+		if (*p == ')')
+		    break;
+		for (q = p++; *p && *p != ')' && !inblank(*p); p++);
+
+		if (!*p)
+		    break;
+
+		sav = *p;
+		*p = '\0';
+		addlinknode(list, dupstring(q));
+		xnum++;
+		*p = sav;
+	    }
+	    if (*p != ')') {
+		free_cvdef(ret);
+		zerrnam(nam, "invalid argument: %s", *args, 0);
+		return NULL;
+	    }
+	    xor = (char **) zalloc((xnum + 2) * sizeof(char *));
+	    for (node = firstnode(list), xp = xor; node; incnode(node), xp++)
+		*xp = ztrdup((char *) getdata(node));
+	    xp[0] = xp[1] = NULL;
+
+	    p++;
+	} else
+	    xor = NULL;
+
+	if ((multi = (*p == '*')))
+	    p++;
+
+	for (name = p; *p && *p != ':' && *p != '['; p++)
+	    if (*p == '\\' && p[1])
+		p++;
+
+	if (hassep && !sep && name + 1 != p) {
+	    free_cvdef(ret);
+	    zerrnam(nam, "no multi-letter values with empty separator allowed", NULL, 0);
+	    return NULL;
+	}
+	if ((c = *p) == '[') {
+	    *p = '\0';
+	    for (descr = ++p; *p && *p != ']'; p++)
+		if (*p == '\\' && p[1])
+		    p++;
+
+	    if (!*p) {
+		free_cvdef(ret);
+		zerrnam(nam, "invalid value definition: %s", *args, 0);
+		return NULL;
+	    }
+	    *p++ = '\0';
+	    c = *p;
+	} else {
+	    *p = '\0';
+	    descr = NULL;
+	}
+	if (c && c != ':') {
+	    free_cvdef(ret);
+	    zerrnam(nam, "invalid value definition: %s", *args, 0);
+	    return NULL;
+	}
+	if (!multi) {
+	    if (!xor) {
+		xor = (char **) zalloc(2 * sizeof(char *));
+		xor[1] = NULL;
+	    }
+	    xor[xnum] = ztrdup(name);
+	}
+	if (c == ':') {
+	    if (hassep && !sep) {
+		free_cvdef(ret);
+		zerrnam(nam, "no value with argument with empty separator allowed", NULL, 0);
+		return NULL;
+	    }
+	    if (*++p == ':') {
+		p++;
+		vtype = CVV_OPT;
+	    } else
+		vtype = CVV_ARG;
+	    arg = parse_caarg(0, 0, 0, &p);
+	} else {
+	    vtype = CVV_NOARG;
+	    arg = NULL;
+	}
+	PERMALLOC {
+	    *valp = val = (Cvval) zalloc(sizeof(*val));
+	    valp = &((*valp)->next);
+
+	    val->next = NULL;
+	    val->name = ztrdup(name);
+	    val->descr = ztrdup(descr);
+	    val->xor = xor;
+	    val->type = vtype;
+	    val->arg = arg;
+	} LASTALLOC;
+    }
+    return ret;
+}
+
+static Cvdef
+get_cvdef(char *nam, char **args)
+{
+    Cvdef *p, *min, new;
+    int i, na = arrlen(args);
+
+    for (i = MAX_CVCACHE, p = cvdef_cache, min = NULL; *p && i--; p++)
+	if (*p && na == (*p)->ndefs && arrcmp(args, (*p)->defs)) {
+	    (*p)->lastt = time(0);
+
+	    return *p;
+	} else if (!min || !*p || (*p)->lastt < (*min)->lastt)
+	    min = p;
+    if (i)
+	min = p;
+    if ((new = parse_cvdef(nam, args))) {
+	free_cvdef(*min);
+	*min = new;
+    }
+    return new;
+}
+
+static Cvval
+cv_get_val(Cvdef d, char *name)
+{
+    Cvval p;
+
+    for (p = d->vals; p; p = p->next)
+	if (!strcmp(name, p->name))
+	    return p;
+
+    return NULL;
+}
+
+static void
+cv_inactive(Cvdef d, char **xor)
+{
+    if (xor) {
+	Cvval val;
+
+	for (; *xor; xor++)
+	    if ((val = cv_get_val(d, *xor)))
+		val->active = 0;
+    }
+}
+
+struct cvstate {
+    Cvdef d;
+    Caarg def;
+    Cvval val;
+    LinkList vals;
+};
+
+static struct cvstate cv_laststate;
+static int cv_parsed = 0, cv_alloced = 0;
+
+static void
+cv_parse_word(Cvdef d)
+{
+    Cvval ptr;
+    struct cvstate state;
+    char *str, *eq;
+
+    if (cv_alloced)
+	freelinklist(cv_laststate.vals, freestr);
+
+    for (ptr = d->vals; ptr; ptr = ptr->next)
+	ptr->active = 1;
+
+    state.d = d;
+    state.def = NULL;
+    state.val = NULL;
+    PERMALLOC {
+	state.vals = (LinkList) newlinklist();
+    } LASTALLOC;
+    cv_alloced = 1;
+
+    if (d->hassep) {
+	if (d->sep) {
+	    char *end;
+	    int heq;
+
+	    for (str = compprefix, end = strchr(str, d->sep); end;) {
+		*end = '\0';
+
+		if ((heq = !!(eq = strchr(str, '='))))
+		    *eq++ = '\0';
+		else
+		    eq = "";
+
+		if ((ptr = cv_get_val(d, str))) {
+		    PERMALLOC {
+			addlinknode(state.vals, ztrdup(str));
+			addlinknode(state.vals, ztrdup(eq));
+		    } LASTALLOC;
+
+		    cv_inactive(d, ptr->xor);
+		}
+		if (heq)
+		    eq[-1] = '=';
+
+		*end = d->sep;
+		str = end + 1;
+		end = strchr(str, d->sep);
+	    }
+	    ignore_prefix(str - compprefix);
+
+	    if ((str = strchr(compsuffix, d->sep))) {
+		char *beg = str;
+
+		for (str++; str; str = end) {
+		    if ((end = strchr(str, d->sep)))
+			*end = '\0';
+
+		    if ((heq = !!(eq = strchr(str, '='))))
+			*eq++ = '\0';
+		    else
+			eq = "";
+
+		    if ((ptr = cv_get_val(d, str))) {
+			PERMALLOC {
+			    addlinknode(state.vals, ztrdup(str));
+			    addlinknode(state.vals, ztrdup(eq));
+			} LASTALLOC;
+
+			cv_inactive(d, ptr->xor);
+		    }
+		    if (heq)
+			eq[-1] = '=';
+		    if (end)
+			*end++ = d->sep;
+		}
+		ignore_suffix(strlen(beg));
+	    }
+	} else {
+	    char tmp[2];
+
+	    tmp[1] = '\0';
+
+	    for (str = compprefix; *str; str++) {
+		tmp[0] = *str;
+		if ((ptr = cv_get_val(d, tmp))) {
+		    PERMALLOC {
+			addlinknode(state.vals, ztrdup(tmp));
+			addlinknode(state.vals, ztrdup(""));
+		    } LASTALLOC;
+
+		    cv_inactive(d, ptr->xor);
+		}
+	    }
+	    for (str = compsuffix; *str; str++) {
+		tmp[0] = *str;
+		if ((ptr = cv_get_val(d, tmp))) {
+		    PERMALLOC {
+			addlinknode(state.vals, ztrdup(tmp));
+			addlinknode(state.vals, ztrdup(""));
+		    } LASTALLOC;
+
+		    cv_inactive(d, ptr->xor);
+		}
+	    }
+	    ignore_prefix(strlen(compprefix));
+	    ignore_suffix(strlen(compsuffix));
+	}
+    }
+    str = tricat(compprefix, compsuffix, "");
+    zsfree(compprefix);
+    zsfree(compsuffix);
+    compprefix = str;
+    compsuffix = ztrdup("");
+
+    if ((eq = strchr(str, '='))) {
+	*eq++ = '\0';
+
+	if ((ptr = cv_get_val(d, str)) && ptr->type != CVV_NOARG) {
+	    eq[-1] = '=';
+	    ignore_prefix(eq - str);
+	    state.def = ptr->arg;
+	    state.val = ptr;
+	} else
+	    eq[-1] = '=';
+    }
+    memcpy(&cv_laststate, &state, sizeof(state));
+}
+
+static int
+bin_compvalues(char *nam, char **args, char *ops, int func)
+{
+    int min, max, n;
+
+    if (incompfunc != 1) {
+	zerrnam(nam, "can only be called from completion function", NULL, 0);
+	return 1;
+    }
+    if (args[0][0] != '-' || !args[0][1] || args[0][2]) {
+	zerrnam(nam, "invalid argument: %s", args[0], 0);
+	return 1;
+    }
+    if (args[0][1] != 'i' && !cv_parsed) {
+	zerrnam(nam, "no parsed state", NULL, 0);
+	return 1;
+    }
+    switch (args[0][1]) {
+    case 'i': min = 2; max = -1; break;
+    case 'D': min = 2; max =  2; break;
+    case 'V': min = 3; max =  3; break;
+    case 's': min = 1; max =  1; break;
+    case 'd': min = 1; max =  1; break;
+    case 'L': min = 3; max =  3; break;
+    case 'v': min = 1; max =  1; break;
+    default:
+	zerrnam(nam, "invalid option: %s", args[0], 0);
+	return 1;
+    }
+    n = arrlen(args) - 1;
+    if (n < min) {
+	zerrnam(nam, "not enough arguments", NULL, 0);
+	return 1;
+    } else if (max >= 0 && n > max) {
+	zerrnam(nam, "too many arguments", NULL, 0);
+	return 1;
+    }
+    switch (args[0][1]) {
+    case 'i':
+	{
+	    Cvdef def = get_cvdef(nam, args + 1);
+	    int cvp = cv_parsed;
+
+	    cv_parsed = 0;
+
+	    if (!def)
+		return 1;
+
+	    cv_parsed = cvp;
+	    cv_parse_word(def);
+	    cv_parsed = 1;
+
+	    return 0;
+	}
+	return 1;
+
+    case 'D':
+	{
+	    Caarg arg = cv_laststate.def;
+
+	    if (arg) {
+		setsparam(args[1], ztrdup(arg->descr));
+		setsparam(args[2], ztrdup(arg->action));
+
+		return 0;
+	    }
+	    return 1;
+	}
+    case 'V':
+	{
+	    LinkList noarg = newlinklist();
+	    LinkList arg = newlinklist();
+	    LinkList opt = newlinklist(), l;
+	    Cvval p;
+	    char *str;
+
+	    for (p = cv_laststate.d->vals; p; p = p->next) {
+		if (p->active) {
+		    switch (p->type) {
+		    case CVV_NOARG: l = noarg; break;
+		    case CVV_ARG:   l = arg;   break;
+		    default:        l = opt;   break;
+		    }
+		    if (p->descr) {
+			int len = strlen(p->name) + strlen(p->descr) + 2;
+
+			str = (char *) zhalloc(len);
+			strcpy(str, p->name);
+			strcat(str, ":");
+			strcat(str, p->descr);
+		    } else
+			str = p->name;
+		    addlinknode(l, str);
+		}
+	    }
+	    set_list_array(args[1], noarg);
+	    set_list_array(args[2], arg);
+	    set_list_array(args[3], opt);
+
+	    return 0;
+	}
+    case 's':
+	if (cv_laststate.d->hassep) {
+	    char tmp[2];
+
+	    tmp[0] = cv_laststate.d->sep;
+	    tmp[1] = '\0';
+	    setsparam(args[1], ztrdup(tmp));
+
+	    return 0;
+	}
+	return 1;
+    case 'd':
+	setsparam(args[1], ztrdup(cv_laststate.d->descr));
+	return 0;
+    case 'L':
+	{
+	    Cvval val = cv_get_val(cv_laststate.d, args[1]);
+
+	    if (val && val->arg) {
+		setsparam(args[2], val->arg->descr);
+		setsparam(args[3], val->arg->action);
+
+		return 0;
+	    }
+	    return 1;
+	}
+    case 'v':
+	if (cv_laststate.vals) {
+	    char **ret, **p;
+	    LinkNode n;
+
+	    ret = (char **) zalloc((countlinknodes(cv_laststate.vals) + 1) *
+				   sizeof(char *));
+
+	    for (n = firstnode(cv_laststate.vals), p = ret; n; incnode(n), p++)
+		*p = ztrdup((char *) getdata(n));
+	    *p = NULL;
+
+	    sethparam(args[1], ret);
+
+	    return 0;
+	}
+	return 1;
+    }
+    return 1;
+}
+
+
+static struct builtin bintab[] = {
+    BUILTIN("compdisplay", 0, bin_compdisplay, 2, -1, 0, NULL, NULL),
+    BUILTIN("compdescribe", 0, bin_compdescribe, 3, -1, 0, NULL, NULL),
+    BUILTIN("comparguments", 0, bin_comparguments, 1, -1, 0, NULL, NULL),
+    BUILTIN("compvalues", 0, bin_compvalues, 1, -1, 0, NULL, NULL),
+};
+
+
+/**/
+int
+setup_computil(Module m)
+{
+    memset(cadef_cache, 0, sizeof(cadef_cache));
+    memset(cvdef_cache, 0, sizeof(cvdef_cache));
+
+    return 0;
+}
+
+/**/
+int
+boot_computil(Module m)
+{
+    return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+}
+
+#ifdef MODULE
+
+/**/
+int
+cleanup_computil(Module m)
+{
+    deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+    return 0;
+}
+
+/**/
+int
+finish_computil(Module m)
+{
+    int i;
+
+    for (i = 0; i < MAX_CACACHE; i++)
+	free_cadef(cadef_cache[i]);
+    for (i = 0; i < MAX_CVCACHE; i++)
+	free_cvdef(cvdef_cache[i]);
+
+    return 0;
+}
+
+#endif