xref: /macosx-10.9.5/zsh-60/zsh/Src/Zle/computil.c

/*
 * 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 `_describe'. */

typedef struct cdset *Cdset;
typedef struct cdstr *Cdstr;
typedef struct cdrun *Cdrun;

struct cdstate {
    int showd;			/* != 0 if descriptions should be shown */
    char *sep;			/* the separator string */
    int slen;			/* its metafied length */
    int swidth;			/* its screen width */
    int maxmlen;                /* maximum length to allow for the matches */
    Cdset sets;			/* the sets of matches */
    int pre;                    /* longest prefix length (before description) */
    int premaxw;		/* ... and its screen width */
    int suf;                    /* longest suffix (description) */
    int maxg;                   /* size of largest group */
    int maxglen;                /* columns for matches of largest group */
    int groups;                 /* number of groups */
    int descs;                  /* number of non-group matches with desc */
    int gprew;                   /* prefix screen width for group display */
    Cdrun runs;                 /* runs to report to shell code */
};

struct cdstr {
    Cdstr next;                 /* the next one in this set */
    char *str;                  /* the string to display */
    char *desc;                 /* the description or NULL */
    char *match;                /* the match to add */
    char *sortstr;		/* unmetafied string used to sort matches */
    int len;                    /* length of str or match */
    int width;			/* ... and its screen width */
    Cdstr other;                /* next string with the same description */
    int kind;                   /* 0: not in a group, 1: the first, 2: other */
    Cdset set;                  /* the set this string is in */
    Cdstr run;                  /* next in this run */
};

struct cdrun {
    Cdrun next;                 /* ... */
    int type;                   /* see CRT_* below */
    Cdstr strs;                 /* strings in this run */
    int count;                  /* number of strings in this run */
};

#define CRT_SIMPLE 0
#define CRT_DESC   1
#define CRT_SPEC   2
#define CRT_DUMMY  3
#define CRT_EXPL   4

struct cdset {
    Cdset next;			/* guess what */
    char **opts;		/* the compadd-options */
    Cdstr strs;                 /* the strings/matches */
    int count;                  /* number of matches in this set */
    int desc;                   /* number of matches with description */
};

static struct cdstate cd_state;
static int cd_parsed = 0;

static void
freecdsets(Cdset p)
{
    Cdset n;
    Cdstr s, sn;
    Cdrun r, rn;

    for (; p; p = n) {
	n = p->next;
	if (p->opts)
	    freearray(p->opts);
        for (s = p->strs; s; s = sn) {
            sn = s->next;
	    zfree(s->sortstr, strlen(s->str) + 1);
            zsfree(s->str);
            zsfree(s->desc);
            if (s->match != s->str)
                zsfree(s->match);
            zfree(s, sizeof(*s));
        }
        for (r = cd_state.runs; r; r = rn) {
            rn = r->next;
            zfree(r, sizeof(*r));
        }
	zfree(p, sizeof(*p));
    }
}

/* Find matches with same descriptions and group them. */

static void
cd_group(int maxg)
{
    Cdset set1, set2;
    Cdstr str1, str2, *strp;
    int num, width;

    cd_state.groups = cd_state.descs = cd_state.maxglen = 0;
    cd_state.maxg = 0;

    for (set1 = cd_state.sets; set1; set1 = set1->next)
        for (str1 = set1->strs; str1; str1 = str1->next) {
            str1->kind = 0;
            str1->other = NULL;
        }

    for (set1 = cd_state.sets; set1; set1 = set1->next) {
        for (str1 = set1->strs; str1; str1 = str1->next) {
            if (!str1->desc || str1->kind != 0)
                continue;

            num = 1;
            width = str1->width + cd_state.swidth;
            if (width > cd_state.maxglen)
                cd_state.maxglen = width;
            strp = &(str1->other);

            for (set2 = set1; set2; set2 = set2->next) {
                for (str2 = (set2 == set1 ? str1->next : set2->strs);
                     str2; str2 = str2->next)
                    if (str2->desc && !strcmp(str1->desc, str2->desc)) {
                        width += CM_SPACE + str2->width;
                        if (width > cd_state.maxmlen || num == maxg)
                            break;
                        if (width > cd_state.maxglen)
                            cd_state.maxglen = width;
                        str1->kind = 1;
                        str2->kind = 2;
                        num++;
                        *strp = str2;
                        strp = &(str2->other);
                    }
                if (str2)
                    break;
            }
            *strp = NULL;

            if (num > 1)
                cd_state.groups++;
            else
                cd_state.descs++;

            if (num > cd_state.maxg)
                cd_state.maxg = num;
        }
    }
}

/* Calculate longest prefix and suffix and count the strings with
 * descriptions. */

static void
cd_calc()
{
    Cdset set;
    Cdstr str;
    int l;

    cd_state.pre = cd_state.suf = 0;

    for (set = cd_state.sets; set; set = set->next) {
        set->count = set->desc = 0;
        for (str = set->strs; str; str = str->next) {
            set->count++;
            if ((l = strlen(str->str)) > cd_state.pre)
                cd_state.pre = l;
            if ((l = MB_METASTRWIDTH(str->str)) > cd_state.premaxw)
                cd_state.premaxw = l;
            if (str->desc) {
                set->desc++;
                if ((l = strlen(str->desc)) > cd_state.suf)
                    cd_state.suf = l;
            }
        }
    }
}

static int
cd_sort(const void *a, const void *b)
{
    return zstrcmp((*((Cdstr *) a))->sortstr, (*((Cdstr *) b))->sortstr, 0);
}

static int
cd_prep()
{
    Cdrun run, *runp;
    Cdset set;
    Cdstr str, *strp;

    runp = &(cd_state.runs);

    if (cd_state.groups) {
        int preplines = cd_state.groups + cd_state.descs;
        VARARR(Cdstr, grps, preplines);
        VARARR(int, wids, cd_state.maxg);
        Cdstr gs, gp, gn, *gpp;
        int i, j, d;
        Cdrun expl;
        Cdstr *strp2;

        memset(wids, 0, cd_state.maxg * sizeof(int));
        strp = grps;

        for (set = cd_state.sets; set; set = set->next)
            for (str = set->strs; str; str = str->next) {
                if (str->kind != 1) {
                    if (!str->kind && str->desc) {
                        if (str->width > wids[0])
                            wids[0] = str->width;
                        str->other = NULL;
                        *strp++ = str;
                    }
                    continue;
                }
                gs = str;
                gs->kind = 2;
                gp = str->other;
                gs->other = NULL;
                for (; gp; gp = gn) {
                    gn = gp->other;
                    gp->other = NULL;
                    for (gpp = &gs; *gpp && (*gpp)->width > gp->width;
                         gpp = &((*gpp)->other));
                    gp->other = *gpp;
                    *gpp = gp;
                }
                for (gp = gs, i = 0; gp; gp = gp->other, i++)
                    if (gp->width > wids[i])
                        wids[i] = gp->width;

                *strp++ = gs;
            }

        cd_state.gprew = 0;
        for (i = 0; i < cd_state.maxg; i++) {
            cd_state.gprew += wids[i] + CM_SPACE;
	}

        if (cd_state.gprew > cd_state.maxmlen && cd_state.maxglen > 1)
            return 1;

	for (i = 0; i < preplines; i++) {
	    Cdstr s = grps[i];
	    int dummy;

	    s->sortstr = ztrdup(s->str);
	    unmetafy(s->sortstr, &dummy);
	}

        qsort(grps, preplines, sizeof(Cdstr), cd_sort);

        for (i = preplines, strp = grps; i > 1; i--, strp++) {
            strp2 = strp + 1;
            if (!strcmp((*strp)->desc, (*strp2)->desc))
                continue;
            for (j = i - 2, strp2++; j > 0; j--, strp2++)
                if (!strcmp((*strp)->desc, (*strp2)->desc)) {
                    Cdstr tmp = *strp2;

                    memmove(strp + 2, strp + 1,
                            (strp2 - strp - 1) * sizeof(Cdstr));

                    *++strp = tmp;
                    i--;
                }
        }
        expl =  (Cdrun) zalloc(sizeof(*run));
        expl->type = CRT_EXPL;
        expl->strs = grps[0];
        expl->count = preplines;

        for (i = preplines, strp = grps, strp2 = NULL; i; i--, strp++) {
            str = *strp;
            *strp = str->other;
            if (strp2)
                *strp2 = str;
            strp2 = &(str->run);

            *runp = run = (Cdrun) zalloc(sizeof(*run));
            runp = &(run->next);
            run->type = CRT_SPEC;
            run->strs = str;
            run->count = 1;
        }
        *strp2 = NULL;

        for (i = cd_state.maxg - 1; i; i--) {
            for (d = 0, j = preplines, strp = grps; j; j--, strp++) {
                if ((str = *strp)) {
                    if (d) {
                        *runp = run = (Cdrun) zalloc(sizeof(*run));
                        runp = &(run->next);
                        run->type = CRT_DUMMY;
                        run->strs = expl->strs;
                        run->count = d;
                        d = 0;
                    }
                    *runp = run = (Cdrun) zalloc(sizeof(*run));
                    runp = &(run->next);
                    run->type = CRT_SPEC;
                    run->strs = str;
                    run->strs->run = NULL;
                    run->count = 1;

                    *strp = str->other;
                } else
                    d++;
            }
            if (d) {
                *runp = run = (Cdrun) zalloc(sizeof(*run));
                runp = &(run->next);
                run->type = CRT_DUMMY;
                run->strs = expl->strs;
                run->count = d;
            }
        }
        *runp = expl;
        runp = &(expl->next);

        for (set = cd_state.sets; set; set = set->next) {
            for (i = 0, gs = NULL, gpp = &gs, str = set->strs;
                 str; str = str->next) {
                if (str->kind || str->desc)
                    continue;

                i++;
                *gpp = str;
                gpp = &(str->run);
            }
            *gpp = NULL;
            if (i) {
                *runp = run = (Cdrun) zalloc(sizeof(*run));
                runp = &(run->next);
                run->type = CRT_SIMPLE;
                run->strs = gs;
                run->count = i;
            }
        }
    } else if (cd_state.showd) {
        for (set = cd_state.sets; set; set = set->next) {
            if (set->desc) {
                *runp = run = (Cdrun) zalloc(sizeof(*run));
                runp = &(run->next);
                run->type = CRT_DESC;
                strp = &(run->strs);
                for (str = set->strs; str; str = str->next)
                    if (str->desc) {
                        *strp = str;
                        strp = &(str->run);
                    }
                *strp = NULL;
                run->count = set->desc;
            }
            if (set->desc != set->count) {
                *runp = run = (Cdrun) zalloc(sizeof(*run));
                runp = &(run->next);
                run->type = CRT_SIMPLE;
                strp = &(run->strs);
                for (str = set->strs; str; str = str->next)
                    if (!str->desc) {
                        *strp = str;
                        strp = &(str->run);
                    }
                *strp = NULL;
                run->count = set->count - set->desc;
            }
        }
    } else {
        for (set = cd_state.sets; set; set = set->next)
            if (set->count) {
                *runp = run = (Cdrun) zalloc(sizeof(*run));
                runp = &(run->next);
                run->type = CRT_SIMPLE;
                run->strs = set->strs;
                for (str = set->strs; str; str = str->next)
                    str->run = str->next;
                run->count = set->count;
            }
    }
    *runp = NULL;

    return 0;
}

/* Duplicate and concatenate two arrays.  Return the result. */

static char **
cd_arrcat(char **a, char **b)
{
    if (!b)
        return zarrdup(a);
    else {
        char **r = (char **) zalloc((arrlen(a) + arrlen(b) + 1) *
                                    sizeof(char *));
        char **p = r;

        for (; *a; a++)
            *p++ = ztrdup(*a);
        for (; *b; b++)
            *p++ = ztrdup(*b);

        *p = NULL;

        return r;
    }
}

/* Initialisation. Store and calculate the string and matches and so on. */

static int
cd_init(char *nam, char *hide, char *mlen, char *sep,
        char **opts, char **args, int disp)
{
    Cdset *setp, set;
    Cdstr *strp, str;
    char **ap, *tmp;
    int grp = 0, itmp;

    if (cd_parsed) {
	zsfree(cd_state.sep);
	freecdsets(cd_state.sets);
	cd_parsed = 0;
    }
    setp = &(cd_state.sets);
    cd_state.sep = ztrdup(sep);
    cd_state.slen = strlen(sep);
    cd_state.swidth = MB_METASTRWIDTH(sep);
    cd_state.sets = NULL;
    cd_state.showd = disp;
    cd_state.maxg = cd_state.groups = cd_state.descs = 0;
    cd_state.maxmlen = atoi(mlen);
    itmp = zterm_columns - cd_state.swidth - 4;
    if (cd_state.maxmlen > itmp)
        cd_state.maxmlen = itmp;
    if (cd_state.maxmlen < 4)
        cd_state.maxmlen = 4;
    if (*args && !strcmp(*args, "-g")) {
        args++;
        grp = 1;
    }
    while (*args) {
	*setp = set = (Cdset) zshcalloc(sizeof(*set));
	setp = &(set->next);
        *setp = NULL;
        set->opts = NULL;
        set->strs = NULL;

	if (!(ap = get_user_var(*args))) {
	    zwarnnam(nam, "invalid argument: %s", *args);
            zsfree(cd_state.sep);
            freecdsets(cd_state.sets);
	    return 1;
	}
        for (str = NULL, strp = &(set->strs); *ap; ap++) {
            *strp = str = (Cdstr) zalloc(sizeof(*str));
            strp = &(str->next);

            str->kind = 0;
            str->other = NULL;
            str->set = set;

            for (tmp = *ap; *tmp && *tmp != ':'; tmp++)
                if (*tmp == '\\' && tmp[1])
                    tmp++;

            if (*tmp)
                str->desc = ztrdup(rembslash(tmp + 1));
            else
                str->desc = NULL;
            *tmp = '\0';
            str->str = str->match = ztrdup(rembslash(*ap));
            str->len = strlen(str->str);
            str->width = MB_METASTRWIDTH(str->str);
	    str->sortstr = NULL;
        }
        if (str)
            str->next = NULL;

	if (*++args && **args != '-') {
	    if (!(ap = get_user_var(*args))) {
		zwarnnam(nam, "invalid argument: %s", *args);
                zsfree(cd_state.sep);
                freecdsets(cd_state.sets);
		return 1;
	    }
            for (str = set->strs; str && *ap; str = str->next, ap++)
                str->match = ztrdup(*ap);

	    args++;
	}
        if (hide && *hide) {
            for (str = set->strs; str; str = str->next) {
                if (str->str == str->match)
                    str->str = ztrdup(str->str);
                if (hide[1] && str->str[0] == '-' && str->str[1] == '-')
                    strcpy(str->str, str->str + 2);
                else if (str->str[0] == '-' || str->str[0] == '+')
                    strcpy(str->str, str->str + 1);
            }
        }
	for (ap = args; *args &&
		 (args[0][0] != '-' || args[0][1] != '-' || args[0][2]);
	     args++);

	tmp = *args;
	*args = NULL;
	set->opts = cd_arrcat(ap, opts);
	if ((*args = tmp))
	    args++;
    }
    if (disp && grp) {
        int mg = zterm_columns;

        do {
            cd_group(mg);
            mg = cd_state.maxg - 1;
            cd_calc();
        } while (cd_prep());

    } else {
        cd_calc();
        cd_prep();
    }
    cd_parsed = 1;
    return 0;
}

/* Copy an array with one element in reserve (at the beginning). */

static char **
cd_arrdup(char **a)
{
    char **r = (char **) zalloc((arrlen(a) + 2) * sizeof(char *));
    char **p = r + 1;

    while (*a)
        *p++ = ztrdup(*a++);
    *p = NULL;

    return r;
}

/* Get the next set. */

static int
cd_get(char **params)
{
    Cdrun run;

    if ((run = cd_state.runs)) {
        Cdstr str;
        char **mats, **mp, **dpys, **dp, **opts, *csl = "";

        cd_state.runs = run->next;

        switch (run->type) {
        case CRT_SIMPLE:
            mats = mp = (char **) zalloc((run->count + 1) * sizeof(char *));
            dpys = dp = (char **) zalloc((run->count + 1) * sizeof(char *));

            for (str = run->strs; str; str = str->run) {
                *mp++ = ztrdup(str->match);
                *dp++ = ztrdup(str->str ? str->str : str->match);
            }
            *mp = *dp = NULL;
            opts = zarrdup(run->strs->set->opts);
            if (cd_state.groups) {
                /* We are building a columnised list with dummy matches
                 * but there are also matches without descriptions.
                 * Those end up in a different group, so make sure that
                 * group doesn't have an explanation. */

                for (mp = dp = opts; *mp; mp++) {
                    if (dp[0][0] == '-' && dp[0][1] == 'X') {
                        if (!dp[0][2] && dp[1])
                            mp++;
                    } else
                        *dp++ = *mp;
                }
                *dp = NULL;
            }
            break;

        case CRT_DESC:
            {
		/*
		 * The buffer size:
		 *     max prefix length (cd_state.pre) +
		 *     max padding (cd_state.premaxw generously :) +
		 *     separator length (cd_state.slen) +
		 *     inter matches gap (CM_SPACE) +
		 *     max description length (cd_state.suf) +
		 *     trailing \0
		 */
                VARARR(char, buf,
                       cd_state.pre + cd_state.suf +
		       cd_state.premaxw + cd_state.slen + 3);
                mats = mp = (char **) zalloc((run->count + 1) * sizeof(char *));
                dpys = dp = (char **) zalloc((run->count + 1) * sizeof(char *));

                for (str = run->strs; str; str = str->run) {
		    char *p = buf, *pp, *d;
		    int l, remw, w;

                    *mp++ = ztrdup(str->match);
		    strcpy(p, str->str);
		    p += str->len;
                    memset(p, ' ', (l = (cd_state.premaxw - str->width + CM_SPACE)));
		    p += l;
		    strcpy(p, cd_state.sep);
		    p += cd_state.slen;

		    /*
		     * copy a character at once until no more screen width
		     * is available. Leave 1 character at the end of screen
		     * as safety margin
		     */
		    remw = zterm_columns - cd_state.premaxw -
			cd_state.swidth - 3;
		    d = str->desc;
		    w = MB_METASTRWIDTH(d);
		    if (w <= remw)
			strcpy(p, d);
		    else {
			pp = p;
			while (remw > 0 && *d) {
			    l = MB_METACHARLEN(d);
			    memcpy(pp, d, l);
			    pp[l] = '\0';
			    w = MB_METASTRWIDTH(pp);
			    if (w > remw) {
				*pp = '\0';
				break;
			    }

			    pp += l;
			    d += l;
			    remw -= w;
			}
		    }

                    *dp++ = ztrdup(buf);
                }
                *mp = *dp = NULL;
                opts = cd_arrdup(run->strs->set->opts);
                opts[0] = ztrdup("-l");
                break;
            }

        case CRT_SPEC:
            mats = (char **) zalloc(2 * sizeof(char *));
            dpys = (char **) zalloc(2 * sizeof(char *));
            mats[0] = ztrdup(run->strs->match);
            dpys[0] = ztrdup(run->strs->str);
            mats[1] = dpys[1] = NULL;
            opts = cd_arrdup(run->strs->set->opts);
            for (dp = opts + 1; *dp; dp++)
                if (dp[0][0] == '-' && dp[0][1] == 'J')
                    break;
            if (*dp) {
                char *s = tricat("-2V", "", dp[0] + 2);

                zsfree(*dp);
                *dp = s;

                memmove(opts, opts + 1,
                        (arrlen(opts + 1) + 1) * sizeof(char *));

            } else
                opts[0] = ztrdup("-2V-default-");
            csl = "packed";
            break;

        case CRT_DUMMY:
            {
                char buf[20];

                sprintf(buf, "-E%d", run->count);

                mats = (char **) zalloc(sizeof(char *));
                dpys = (char **) zalloc(sizeof(char *));
                mats[0] = dpys[0] = NULL;

                opts = cd_arrdup(run->strs->set->opts);
                opts[0] = ztrdup(buf);

                csl = "packed";
            }
            break;

	default: /* This silences the "might be used uninitialized" warnings */
        case CRT_EXPL:
            {
		/* add columns as safety margin */
                VARARR(char, dbuf, cd_state.suf + cd_state.slen +
		       zterm_columns);
                char buf[20], *p, *pp, *d;
                int i = run->count, remw, w, l;

                sprintf(buf, "-E%d", i);

                mats = (char **) zalloc(sizeof(char *));
                dpys = (char **) zalloc((i + 1) * sizeof(char *));

                for (dp = dpys, str = run->strs; str; str = str->run) {
                    if (str->run && !strcmp(str->desc, str->run->desc)) {
                        *dp++ = ztrdup("");
                        continue;
                    }

                    strcpy(dbuf, cd_state.sep);
		    remw = zterm_columns - cd_state.gprew -
			cd_state.swidth - CM_SPACE;
		    p = pp = dbuf + cd_state.slen;
		    d = str->desc;
		    w = MB_METASTRWIDTH(d);
		    if (w <= remw) {
			strcpy(p, d);
			remw -= w;
			pp += strlen(d);
		    } else
			while (remw > 0 && *d) {
			    l = MB_METACHARLEN(d);
			    memcpy(pp, d, l);
			    pp[l] = '\0';
			    w = MB_METASTRWIDTH(pp);
			    if (w > remw) {
				*pp = '\0';
				break;
			    }

			    pp += l;
			    d += l;
			    remw -= w;
			}

		    while (remw-- > 0)
			*pp++ = ' ';
		    *pp = '\0';

                    *dp++ = ztrdup(dbuf);
                }
                mats[0] = *dp = NULL;

                opts = cd_arrdup(run->strs->set->opts);
                opts[0] = ztrdup(buf);

                csl = "packed";
            }
            break;
        }
        setsparam(params[0], ztrdup(csl));
        setaparam(params[1], opts);
        setaparam(params[2], mats);
        setaparam(params[3], dpys);

        zfree(run, sizeof(*run));

        return 0;
    }
    return 1;
}

/**/
static int
bin_compdescribe(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    int n = arrlen(args);

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (!args[0][0] || !args[0][1] || args[0][2]) {
	zwarnnam(nam, "invalid argument: %s", args[0]);
	return 1;
    }
    switch (args[0][1]) {
    case 'i':
        if (n < 3) {
            zwarnnam(nam, "not enough arguments");

            return 1;
        }
	return cd_init(nam, args[1], args[2], "", NULL, args + 3, 0);
    case 'I':
        if (n < 6) {
            zwarnnam(nam, "not enough arguments");

            return 1;
        } else {
            char **opts;

            if (!(opts = getaparam(args[4]))) {
		zwarnnam(nam, "unknown parameter: %s", args[4]);
		return 1;
            }
            return cd_init(nam, args[1], args[2], args[3], opts, args + 5, 1);
        }
    case 'g':
	if (cd_parsed) {
	    if (n != 5) {
		zwarnnam(nam, (n < 5 ? "not enough arguments" :
			      "too many arguments"));
		return 1;
	    }
	    return cd_get(args + 1);
	} else {
	    zwarnnam(nam, "no parsed state");
	    return 1;
	}
    }
    zwarnnam(nam, "invalid option: %s", args[0]);
    return 1;
}

/* Help for `_arguments'. */

typedef struct cadef *Cadef;
typedef struct caopt *Caopt;
typedef struct caarg *Caarg;

/* Cache for a set of _arguments-definitions. */

struct cadef {
    Cadef next;			/* next in cache */
    Cadef snext;		/* next set */
    Caopt opts;			/* the options */
    int nopts, ndopts, nodopts;	/* number of options/direct/optional direct */
    Caarg args;			/* the normal arguments */
    Caarg rest;			/* the rest-argument */
    char **defs;		/* the original strings */
    int ndefs;			/* number of ... */
    int lastt;			/* last time this was used */
    Caopt *single;		/* array of single-letter options */
    char *match;		/* -M spec to use */
    int argsactive;		/* if arguments are still allowed */
				/* used while parsing a command line */
    char *set;			/* set name prefix (<name>-), shared */
    char *sname;		/* set name */
    int flags;			/* see CDF_* below */
    char *nonarg;		/* pattern for non-args (-A argument) */
};

#define CDF_SEP 1

/* Description for an option. */

struct caopt {
    Caopt next;
    char *name;			/* option name */
    char *descr;		/* the description */
    char **xor;			/* if this, then not ... */
    int type;			/* type, CAO_* */
    Caarg args;			/* option arguments */
    int active;			/* still allowed on command line */
    int num;			/* it's the num'th option */
    char *set;			/* set name, shared */
    int not;			/* don't complete this option (`!...') */
};

#define CAO_NEXT    1
#define CAO_DIRECT  2
#define CAO_ODIRECT 3
#define CAO_EQUAL   4
#define CAO_OEQUAL  5

/* Description for an argument */

struct caarg {
    Caarg next;
    char *descr;		/* description */
    char **xor;			/* if this, then not ... */
    char *action;		/* what to do for it */
    int type;			/* CAA_* below */
    char *end;			/* end-pattern for ::<pat>:... */
    char *opt;			/* option name if for an option */
    int num;			/* it's the num'th argument */
    int min;			/* it's also this argument, using opt. args */
    int direct;			/* number was given directly */
    int active;			/* still allowed on command line */
    char *set;			/* set name, shared */
};

#define CAA_NORMAL 1
#define CAA_OPT    2
#define CAA_REST   3
#define CAA_RARGS  4
#define CAA_RREST  5

/* The cache of parsed descriptons. */

#define MAX_CACACHE 8
static Cadef cadef_cache[MAX_CACACHE];

/* Compare two arrays of strings for equality. */

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);
    }
}

/* Memory stuff. Obviously. */

static void
freecaargs(Caarg a)
{
    Caarg n;

    for (; a; a = n) {
	n = a->next;
	zsfree(a->descr);
	if (a->xor)
	    freearray(a->xor);
	zsfree(a->action);
	zsfree(a->end);
	zsfree(a->opt);
	zfree(a, sizeof(*a));
    }
}

static void
freecadef(Cadef d)
{
    Cadef s;
    Caopt p, n;

    while (d) {
	s = d->snext;
	zsfree(d->match);
	zsfree(d->set);
	zsfree(d->sname);
	if (d->defs)
	    freearray(d->defs);

	for (p = d->opts; p; p = n) {
	    n = p->next;
	    zsfree(p->name);
	    zsfree(p->descr);
	    if (p->xor)
		freearray(p->xor);
	    freecaargs(p->args);
	    zfree(p, sizeof(*p));
	}
	freecaargs(d->args);
	freecaargs(d->rest);
	zsfree(d->nonarg);
	if (d->single)
	    zfree(d->single, 256 * sizeof(Caopt));
	zfree(d, sizeof(*d));
	d = s;
    }
}

/* Remove backslashes before colons. */

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;
}

/* Add backslashes before colons. */

static char *
bslashcolon(char *s)
{
    char *p, *r;

    r = p = zhalloc((2 * strlen(s)) + 1);

    while (*s) {
	if (*s == ':')
	    *p++ = '\\';
	*p++ = *s++;
    }
    *p = '\0';

    return r;
}

/* Parse an argument definition. */

static Caarg
parse_caarg(int mult, int type, int num, int opt, char *oname, char **def,
	    char *set)
{
    Caarg ret = (Caarg) zalloc(sizeof(*ret));
    char *p = *def, *d, sav;

    ret->next = NULL;
    ret->descr = ret->action = ret->end = NULL;
    ret->xor = NULL;
    ret->num = num;
    ret->min = num - opt;
    ret->type = type;
    ret->opt = ztrdup(oname);
    ret->direct = 0;
    ret->set = set;

    /* Get the description. */

    for (d = p; *p && *p != ':'; p++)
	if (*p == '\\' && p[1])
	    p++;
    sav = *p;
    *p = '\0';
    ret->descr = ztrdup(rembslashcolon(d));

    /* Get the action if there is one. */

    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));
    } else
	ret->action = ztrdup("");
    *def = p;

    return ret;
}

static Cadef
alloc_cadef(char **args, int single, char *match, char *nonarg, int flags)
{
    Cadef ret;

    ret = (Cadef) zalloc(sizeof(*ret));
    ret->next = ret->snext = NULL;
    ret->opts = NULL;
    ret->args = ret->rest = NULL;
    ret->nonarg = ztrdup(nonarg);
    if (args) {
	ret->defs = zarrdup(args);
	ret->ndefs = arrlen(args);
    } else {
	ret->defs = NULL;
	ret->ndefs = 0;
    }
    ret->lastt = time(0);
    ret->set = ret->sname = NULL;
    if (single) {
	ret->single = (Caopt *) zalloc(256 * sizeof(Caopt));
	memset(ret->single, 0, 256 * sizeof(Caopt));
    } else
	ret->single = NULL;
    ret->match = ztrdup(match);
    ret->flags = flags;

    return ret;
}

static void
set_cadef_opts(Cadef def)
{
    Caarg argp;
    int xnum;

    for (argp = def->args, xnum = 0; argp; argp = argp->next) {
	if (!argp->direct)
	    argp->min = argp->num - xnum;
	if (argp->type == CAA_OPT)
	    xnum++;
    }
}

/* Parse an array of definitions. */

static Cadef
parse_cadef(char *nam, char **args)
{
    Cadef all, ret;
    Caopt *optp;
    char **orig_args = args, *p, *q, *match = "r:|[_-]=* r:|=*", **xor, **sargs;
    char *adpre, *adsuf, *axor = NULL, *doset = NULL, **setp = NULL;
    char *nonarg = NULL;
    int single = 0, anum = 1, xnum, nopts, ndopts, nodopts, flags = 0;
    int state = 0, not = 0;

    nopts = ndopts = nodopts = 0;

    /* First string is the auto-description definition. */

    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;

    /* Now get the -s, -A, -S and -M options. */

    args++;
    while ((p = *args) && *p == '-' && p[1]) {
	for (q = ++p; *q; q++)
	    if (*q == 'M' || *q == 'A') {
		q = "";
		break;
	    } else if (*q != 's' && *q != 'S')
		break;

	if (*q)
	    break;

	for (; *p; p++) {
	    if (*p == 's')
		single = 1;
	    else if (*p == 'S')
		flags |= CDF_SEP;
	    else if (*p == 'A') {
		if (p[1]) {
		    nonarg = p + 1;
		    p = "" - 1;
		} else if (args[1])
		    nonarg = *++args;
		else
		    break;
	    } else if (*p == 'M') {
		if (p[1]) {
		    match = p + 1;
		    p = "" - 1;
		} else if (args[1])
		    match = *++args;
		else
		    break;
	    }
	}
	if (*p)
	    break;

	args++;
    }
    if (*args && !strcmp(*args, ":"))
        args++;
    if (!*args)
	return NULL;

    if (nonarg)
	tokenize(nonarg = dupstring(nonarg));

    /* Looks good. Optimistically allocate the cadef structure. */

    all = ret = alloc_cadef(orig_args, single, match, nonarg, flags);
    optp = &(ret->opts);
    anum = 1;

    sargs = args;

    /* Get the definitions. */

    for (; *args; args++) {
        if (args[0][0] == '-' && !args[0][1] && args[1]) {
	    if (!state) {
		char *p;
		int l;

		if (setp)
		    args = setp;
		p = *++args;
		l = strlen(p) - 1;
		if (*p == '(' && p[l] == ')') {
		    axor = p = dupstring(p + 1);
		    p[l - 1] = '\0';
		} else
		    axor = NULL;
		ret->set = doset = tricat(p, "-", "");
		ret->sname = ztrdup(p);
		state = 1;
	    } else {
		setp = args;
		state = 0;
		args = sargs - 1;
		doset = NULL;
		ret->nopts = nopts;
		ret->ndopts = ndopts;
		ret->nodopts = nodopts;
		set_cadef_opts(ret);
		ret = ret->snext = alloc_cadef(NULL, single, NULL, nonarg, flags);
		optp = &(ret->opts);
		nopts = ndopts = nodopts = 0;
		anum = 1;
	    }
	    continue;
	}
	p = dupstring(*args);
	xnum = 0;
	if ((not = (*p == '!')))
	    p++;
	if (*p == '(') {
	    /* There is a xor list, get it. */

	    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;
	    }
	    /* Oops, end-of-string. */
	    if (*p != ')') {
		freecadef(all);
		zwarnnam(nam, "invalid argument: %s", *args);
		return NULL;
	    }
	    if (doset && axor)
		xnum++;
	    xor = (char **) zalloc((xnum + 2) * sizeof(char *));
	    for (node = firstnode(list), xp = xor; node; incnode(node), xp++)
		*xp = ztrdup((char *) getdata(node));
	    if (doset && axor)
		*xp++ = ztrdup(axor);
	    xp[0] = xp[1] = NULL;

	    p++;
	} else if (doset && axor) {
	    xnum = 1;
	    xor = (char **) zalloc(3 * sizeof(char *));
	    xor[0] = ztrdup(axor);
	    xor[1] = xor[2] = NULL;
	} else
	    xor = NULL;

	if (*p == '-' || *p == '+' ||
	    (*p == '*' && (p[1] == '-' || p[1] == '+'))) {
	    /* It's an option. */
	    Caopt opt;
	    Caarg oargs = NULL;
	    int multi, otype = CAO_NEXT, again = 0;
	    char *name, *descr, c, *againp = NULL;

	    rec:

	    /* Allowed more than once? */
	    if ((multi = (*p == '*')))
		p++;

	    if (((p[0] == '-' && p[1] == '+') ||
		 (p[0] == '+' && p[1] == '-')) &&
		p[2] && p[2] != ':' && p[2] != '[' &&
		p[2] != '=' && p[2] != '-' && p[2] != '+') {
		/* It's a -+ or +- definition. We just execute the whole
		 * stuff twice for such things. */
		againp = dupstring(p);
		name = ++p;
		*p = (again ? '-' : '+');
		again++;
	    } else {
		name = p;
		/* If it's a long option skip over the first `-'. */
		if (p[0] == '-' && p[1] == '-')
		    p++;
	    }
	    if (!p[1]) {
		freecadef(all);
		zwarnnam(nam, "invalid argument: %s", *args);
		return NULL;
	    }

	    /* Skip over the name. */
	    for (p++; *p && *p != ':' && *p != '[' &&
		     ((*p != '-' && *p != '+') ||
		      (p[1] != ':' && p[1] != '[')) &&
		     (*p != '=' ||
		      (p[1] != ':' && p[1] != '[' && p[1] != '-')); p++)
		if (*p == '\\' && p[1])
		    p++;

	    /* The character after the option name specifies the type. */
	    c = *p;
	    *p = '\0';
	    if (c == '-') {
		otype = CAO_DIRECT;
		c = *++p;
	    } else if (c == '+') {
		otype = CAO_ODIRECT;
		c = *++p;
	    } else if (c == '=') {
		otype = CAO_OEQUAL;
		if ((c = *++p) == '-') {
		    otype = CAO_EQUAL;
		    c = *++p;
		}
	    }
	    /* Get the optional description, if any. */
	    if (c == '[') {
		for (descr = ++p; *p && *p != ']'; p++)
		    if (*p == '\\' && p[1])
			p++;

		if (!*p) {
		    freecadef(all);
		    zwarnnam(nam, "invalid option definition: %s", *args);
		    return NULL;
		}
		*p++ = '\0';
		c = *p;
	    } else
		descr = NULL;

	    if (c && c != ':') {
		freecadef(all);
		zwarnnam(nam, "invalid option definition: %s", *args);
		return NULL;
	    }
	    /* Add the option name to the xor list if not `*-...'. */
	    if (!multi) {
		if (!xor) {
		    xor = (char **) zalloc(2 * sizeof(char *));
		    xor[0] = xor[1] = NULL;
		}
                zsfree(xor[xnum]);
		xor[xnum] = ztrdup(rembslashcolon(name));
	    }
	    if (c == ':') {
		/* There's at least one argument. */

		Caarg *oargp = &oargs;
		int atype, rest, oanum = 1, onum = 0;
		char *end;

		/* Loop over the arguments. */

		while (c == ':') {
		    rest = 0;
		    end = NULL;

		    /* Get the argument type. */
		    if (*++p == ':') {
			atype = CAA_OPT;
			p++;
		    } else if (*p == '*') {
			if (*++p != ':') {
			    char sav;

			    for (end = p++; *p && *p != ':'; p++)
				if (*p == '\\' && p[1])
				    p++;
			    sav = *p;
			    *p = '\0';
			    end = dupstring(end);
			    tokenize(end);
			    *p = sav;
			}
			if (*p != ':') {
			    freecadef(all);
			    freecaargs(oargs);
			    zwarnnam(nam, "invalid option definition: %s",
				    *args);
			    return NULL;
			}
			if (*++p == ':') {
			    if (*++p == ':') {
				atype = CAA_RREST;
				p++;
			    } else
				atype = CAA_RARGS;
			} else
			    atype = CAA_REST;
			rest = 1;
		    } else
			atype = CAA_NORMAL;

		    /* And the definition. */

		    *oargp = parse_caarg(!rest, atype, oanum++, onum,
					 name, &p, doset);
		    if (atype == CAA_OPT)
			onum++;
		    if (end)
			(*oargp)->end = ztrdup(end);
		    oargp = &((*oargp)->next);
		    if (rest)
			break;
		    c = *p;
		}
	    }
	    /* Store the option definition. */

	    *optp = opt = (Caopt) zalloc(sizeof(*opt));
	    optp = &((*optp)->next);

	    opt->next = NULL;
	    opt->set = doset;
	    opt->name = ztrdup(rembslashcolon(name));
	    if (descr)
		opt->descr = ztrdup(descr);
	    else if (adpre && oargs && !oargs->next) {
		char *d;

		for (d = oargs->descr; *d; d++)
		    if (!iblank(*d))
			break;

		if (*d)
		    opt->descr = tricat(adpre, oargs->descr, adsuf);
		else
		    opt->descr = NULL;
	    } else
		opt->descr = NULL;
	    opt->xor = (again == 1 && xor ? zarrdup(xor) : xor);
	    opt->type = otype;
	    opt->args = oargs;
	    opt->num = nopts++;
	    opt->not = not;

	    if (otype == CAO_DIRECT || otype == CAO_EQUAL)
		ndopts++;
	    else if (otype == CAO_ODIRECT || otype == CAO_OEQUAL)
		nodopts++;

	    /* If this is for single-letter option we also store a
	     * pointer for the definition in the array for fast lookup. */

	    if (single && name[1] && !name[2])
		ret->single[STOUC(name[1])] = opt;

	    if (again == 1) {
		/* Do it all again for `*-...'. */
		p = againp;
		goto rec;
	    }
	} else if (*p == '*') {
	    /* It's a rest-argument definition. */

	    int type = CAA_REST;

	    if (not)
		continue;

	    if (*++p != ':') {
		freecadef(all);
		zwarnnam(nam, "invalid rest argument definition: %s", *args);
		return NULL;
	    }
	    if (ret->rest) {
		freecadef(all);
		zwarnnam(nam, "doubled rest argument definition: %s", *args);
		return NULL;
	    }
	    if (*++p == ':') {
		if (*++p == ':') {
		    type = CAA_RREST;
		    p++;
		} else
		    type = CAA_RARGS;
	    }
	    ret->rest = parse_caarg(0, type, -1, 0, NULL, &p, doset);
	    ret->rest->xor = xor;
	} else {
	    /* It's a normal argument definition. */

	    int type = CAA_NORMAL, direct;
	    Caarg arg, tmp, pre;

	    if (not)
		continue;

	    if ((direct = idigit(*p))) {
		/* Argment number is given. */
		int num = 0;

		while (*p && idigit(*p))
		    num = (num * 10) + (((int) *p++) - '0');

		anum = num + 1;
	    } else
		/* Default number. */
		anum++;

	    if (*p != ':') {
		freecadef(all);
		zwarnnam(nam, "invalid argument: %s", *args);
		if (xor)
		    free(xor);
		return NULL;
	    }
	    if (*++p == ':') {
		/* Optional argument. */
		type = CAA_OPT;
		p++;
	    }
	    arg = parse_caarg(0, type, anum - 1, 0, NULL, &p, doset);
	    arg->xor = xor;
	    arg->direct = direct;

	    /* Sort the new definition into the existing list. */

	    for (tmp = ret->args, pre = NULL;
		 tmp && tmp->num < anum - 1;
		 pre = tmp, tmp = tmp->next);

	    if (tmp && tmp->num == anum - 1) {
		freecadef(all);
		freecaargs(arg);
		zwarnnam(nam, "doubled argument definition: %s", *args);
		return NULL;
	    }
	    arg->next = tmp;
	    if (pre)
		pre->next = arg;
	    else
		ret->args = arg;
	}
    }
    ret->nopts = nopts;
    ret->ndopts = ndopts;
    ret->nodopts = nodopts;
    set_cadef_opts(ret);

    return all;
}

/* Given an array of definitions, return the cadef for it. From the cache
 * are newly built. */

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; i && *p; p++, i--)
	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))) {
	freecadef(*min);
	*min = new;
    }
    return new;
}

/*
 * Get the option used in a word from the line, if any.
 *
 * "d" is a complete set of argument/option definitions to scan.
 * "line" is the word we are scanning.
 * "full" indicates that the option must match a full word; otherwise
 *   we look for "=" arguments or prefixes.
 * *"end" is set to point to the end of the option, in some cases
 *   leaving an option argument after it.
 */

static Caopt
ca_get_opt(Cadef d, char *line, int full, char **end)
{
    Caopt p;

    /* The full string may be an option. */

    for (p = d->opts; p; p = p->next)
	if (p->active && !strcmp(p->name, line)) {
	    if (end)
		*end = line + strlen(line);

	    return p;
	}

    if (!full) {
	/* The string from the line probably only begins with an option. */
	for (p = d->opts; p; p = p->next)
	    if (p->active && ((!p->args || p->type == CAO_NEXT) ?
			      !strcmp(p->name, line) : strpfx(p->name, line))) {
		if (end) {
		    /* Return a pointer to the end of the option. */
		    int l = strlen(p->name);

		    if ((p->type == CAO_OEQUAL || p->type == CAO_EQUAL) &&
			line[l] == '=')
			l++;

		    *end = line + l;
		}
		return p;
	    }
    }
    return NULL;
}

/* Same as above, only for single-letter-style. */

static Caopt
ca_get_sopt(Cadef d, char *line, char **end, LinkList *lp)
{
    Caopt p, pp = NULL;
    char pre = *line++;
    LinkList l = NULL;

    *lp = NULL;
    for (p = NULL; *line; line++) {
	if ((p = d->single[STOUC(*line)]) && p->active &&
	    p->args && p->name[0] == pre) {
	    if (p->type == CAO_NEXT) {
		if (!l)
		    *lp = l = newlinklist();
		addlinknode(l, p);
	    } else {
		if (end) {
		    line++;
		    if ((p->type == CAO_OEQUAL || p->type == CAO_EQUAL) &&
			*line == '=')
			line++;
		    *end = line;
		}
		pp = p;
		break;
	    }
	} else if (!p || (p && !p->active))
	    return NULL;
	pp = (p->name[0] == pre ? p : NULL);
	p = NULL;
    }
    if (pp && end)
	*end = line;
    return pp;
}

/* Return the n'th argument definition. */

static Caarg
ca_get_arg(Cadef d, int n)
{
    if (d->argsactive) {
	Caarg a = d->args;

	while (a && (!a->active || n < a->min || n > a->num)) {
            if (!a->active)
                n++;
	    a = a->next;
        }
	if (a && a->min <= n && a->num >= n && a->active)
	    return a;

	return (d->rest && d->rest->active ? d->rest : NULL);
    }
    return NULL;
}

/* Use a xor list, marking options as inactive. */

static LinkList ca_xor;

static int
ca_inactive(Cadef d, char **xor, int cur, int opts, char *optname)
{
    if ((xor || opts) && cur <= compcurrent) {
	Caopt opt;
	char *x;
	int sl = (d->set ? (int)strlen(d->set) : -1), set = 0;

	for (; (x = (opts ? "-" : *xor)); xor++) {
            if (optname && optname[0] == x[0] && strcmp(optname, x))
                continue;
	    if (ca_xor)
		addlinknode(ca_xor, x);
	    set = 0;
	    if (sl > 0) {
		if (strpfx(d->set, x)) {
		    x += sl;
		    set = 1;
		} else if (!strncmp(d->set, x, sl - 1)) {
		    Caopt p;

		    for (p = d->opts; p; p = p->next)
			if (p->set)
			    p->active = 0;

		    x = ":";
		    set = 1;
		}
	    }
	    if (x[0] == ':' && !x[1]) {
		if (set) {
		    Caarg a;

		    for (a = d->args; a; a = a->next)
			if (a->set)
			    a->active = 0;
		    if (d->rest && (!set || d->rest->set))
			d->rest->active = 0;
		} else
		    d->argsactive = 0;
	    } else if (x[0] == '-' && !x[1]) {
		Caopt p;

		for (p = d->opts; p; p = p->next)
		    if (!set || p->set)
			p->active = 0;
	    } else if (x[0] == '*' && !x[1]) {
		if (d->rest && (!set || d->rest->set))
		    d->rest->active = 0;
	    } else if (idigit(x[0])) {
		int n = atoi(x);
		Caarg a = d->args;

		while (a && a->num < n)
		    a = a->next;

		if (a && a->num == n && (!set || a->set))
		    a->active = 0;
	    } else if ((opt = ca_get_opt(d, x, 1, NULL)) && (!set || opt->set))
		opt->active = 0;

	    if (opts)
		break;
	}
    }
    return 0;
}

/* State when parsing a command line. */

typedef struct castate *Castate;

/*
 *           **** DOCUMENT ME ****
 *
 * This structure and its use are a nightmare.
 */

struct castate {
    Castate snext;
    Cadef d;
    int nopts;
    Caarg def, ddef;
    Caopt curopt, dopt;
    int opt, arg, argbeg, optbeg, nargbeg, restbeg, curpos, argend;
    int inopt, inrest, inarg, nth, doff, singles, oopt, actopts;
    LinkList args;
    LinkList *oargs;
};

static struct castate ca_laststate;
static int ca_parsed = 0, ca_alloced = 0;

static void
freecastate(Castate s)
{
    int i;
    LinkList *p;

    freelinklist(s->args, freestr);
    for (i = s->nopts, p = s->oargs; i--; p++)
	if (*p)
	    freelinklist(*p, freestr);
    zfree(s->oargs, s->d->nopts * sizeof(LinkList));
}

/* Return a copy of an option's argument, ignoring possible quoting
 * in the option name. */

static char *
ca_opt_arg(Caopt opt, char *line)
{
    char *o = opt->name;

    while (1) {
        if (*o == '\\')
            o++;
        if (*line == '\\' || *line == '\'' || *line == '"')
            line++;
        if (!*o || *o != *line)
            break;
        o++;
        line++;
    }
    if (*line && (opt->type == CAO_EQUAL || opt->type == CAO_OEQUAL)) {
        if (*line == '\\')
            line++;
        if (*line == '=')
            line++;
    }
    return ztrdup(line);
}

/* Parse a command line. */

static int
ca_parse_line(Cadef d, int multi, int first)
{
    Caarg adef, ddef;
    Caopt ptr, wasopt = NULL, dopt;
    struct castate state;
    char *line, *oline, *pe, **argxor = NULL;
    int cur, doff, argend, arglast;
    Patprog endpat = NULL, napat = NULL;
    LinkList sopts = NULL;
#if 0
    int ne;
#endif

    /* Free old state. */

    if (first && ca_alloced) {
	Castate s = &ca_laststate, ss;

	while (s) {
	    ss = s->snext;
	    freecastate(s);
	    s = ss;
	}
    }
    /* Mark everything as active. */

    for (ptr = d->opts; ptr; ptr = ptr->next)
	ptr->active = 1;
    d->argsactive = 1;
    if (d->rest)
	d->rest->active = 1;
    for (adef = d->args; adef; adef = adef->next)
	adef->active = 1;

    /* Default values for the state. */

    state.snext = NULL;
    state.d = d;
    state.nopts = d->nopts;
    state.def = state.ddef = NULL;
    state.curopt = state.dopt = NULL;
    state.argbeg = state.optbeg = state.nargbeg = state.restbeg = state.actopts =
	state.nth = state.inopt = state.inarg = state.opt = state.arg = 1;
    state.argend = argend = arrlen(compwords) - 1;
    state.inrest = state.doff = state.singles = state.oopt = 0;
    state.curpos = compcurrent;
    state.args = znewlinklist();
    state.oargs = (LinkList *) zalloc(d->nopts * sizeof(LinkList));
    memset(state.oargs, 0, d->nopts * sizeof(LinkList));

    ca_alloced = 1;

    memcpy(&ca_laststate, &state, sizeof(state));

    if (!compwords[1]) {
	ca_laststate.opt = ca_laststate.arg = 0;

	goto end;
    }
    if (d->nonarg)
	napat = patcompile(d->nonarg, 0, NULL);

    /* Loop over the words from the line. */

    for (line = compwords[1], cur = 2, state.curopt = NULL, state.def = NULL;
	 line; line = compwords[cur++]) {
	ddef = adef = NULL;
	dopt = NULL;
	doff = state.singles = arglast = 0;

        oline = line;
#if 0
        /*
	 * remove quotes.
	 * This is commented out:  it doesn't allow you to discriminate
	 * between command line values that can be expanded and those
	 * that can't, and in some cases this generates inconsistency;
	 * for example, ~/foo\[bar unqotes to ~/foo[bar which doesn't
	 * work either way---it's wrong if the ~ is quoted, and
	 * wrong if the [ isn't quoted..  So it's now up to the caller to
	 * unquote.
	 */
        line = dupstring(line);
        ne = noerrs;
        noerrs = 2;
        parse_subst_string(line);
        noerrs = ne;
#endif
        remnulargs(line);
        untokenize(line);

	if (ca_inactive(d, argxor, cur, 0, NULL) ||
	    ((d->flags & CDF_SEP) && cur != compcurrent && !strcmp(line, "--"))) {
	    if (ca_inactive(d, NULL, cur, 1, NULL))
		return 1;
	    continue;
	}
	/* We've got a definition for an argument, skip to the next. */

	if (state.def) {
	    state.arg = 0;
	    if (state.curopt)
		zaddlinknode(state.oargs[state.curopt->num], ztrdup(oline));

	    if ((state.opt = (state.def->type == CAA_OPT)) && state.def->opt)
		state.oopt++;

	    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;
		    state.opt = state.arg = 1;
		    state.argend = ca_laststate.argend = cur - 1;
		    goto cont;
		}
	    } else if ((state.def = state.def->next)) {
		state.argbeg = cur;
		state.argend = argend;
	    } else if (sopts && nonempty(sopts)) {
		state.curopt = (Caopt) uremnode(sopts, firstnode(sopts));
		state.def = state.curopt->args;
		state.opt = 0;
		state.argbeg = state.optbeg = state.inopt = cur;
		state.argend = argend;
		doff = state.doff = 0;
		state.singles = 1;
		if (!state.oargs[state.curopt->num])
		    state.oargs[state.curopt->num] = znewlinklist();
		goto cont;
	    } else {
		state.curopt = NULL;
		state.opt = 1;
	    }
	} else {
	    state.opt = state.arg = 1;
	    state.curopt = NULL;
	}
	if (state.opt)
	    state.opt = (line[0] ? (line[1] ? 2 : 1) : 0);

	pe = NULL;

	wasopt = NULL;

	/* See if it's an option. */

	if (state.opt == 2 && (state.curopt = ca_get_opt(d, line, 0, &pe)) &&
	    (state.curopt->type == CAO_OEQUAL ?
	     (compwords[cur] || pe[-1] == '=') :
	     (state.curopt->type == CAO_EQUAL ?
	      (pe[-1] == '=' || !pe[0]) : 1))) {

	    if ((ddef = state.def = ((state.curopt->type != CAO_EQUAL ||
				      pe[-1] == '=') ?
				     state.curopt->args : NULL)))
		dopt = state.curopt;

	    doff = pe - line;
	    state.optbeg = state.argbeg = state.inopt = cur;
	    state.argend = argend;
	    state.singles = (d->single && (!pe || !*pe) &&
			     state.curopt->name[1] && !state.curopt->name[2]);

	    if (!state.oargs[state.curopt->num])
		state.oargs[state.curopt->num] = znewlinklist();

	    if (ca_inactive(d, state.curopt->xor, cur, 0,
                            (cur == compcurrent ? state.curopt->name : NULL)))
		return 1;

	    /* Collect the argument strings. Maybe. */

	    if (state.def &&
		(state.curopt->type == CAO_DIRECT ||
		 state.curopt->type == CAO_EQUAL ||
		 (state.curopt->type == CAO_ODIRECT && pe[0]) ||
		 (state.curopt->type == CAO_OEQUAL &&
		  (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;

		zaddlinknode(state.oargs[state.curopt->num],
                             ca_opt_arg(state.curopt, oline));
	    }
	    if (state.def)
		state.opt = 0;
	    else {
		if (!d->single || (state.curopt->name[1] && state.curopt->name[2]))
		    wasopt = state.curopt;
		state.curopt = NULL;
	    }
	} else if (state.opt == 2 && d->single &&
		   ((state.curopt = ca_get_sopt(d, line, &pe, &sopts)) ||
		    (cur != compcurrent && sopts && nonempty(sopts)))) {
	    /* Or maybe it's a single-letter option? */

	    char *p;
	    Caopt tmpopt;

	    if (cur != compcurrent && sopts && nonempty(sopts))
		state.curopt = (Caopt) uremnode(sopts, firstnode(sopts));

	    if (!state.oargs[state.curopt->num])
		state.oargs[state.curopt->num] = znewlinklist();

	    state.def = state.curopt->args;
	    ddef = (state.curopt->type == CAO_NEXT && cur == compcurrent ?
		    NULL : state.def);
	    dopt = state.curopt;
	    doff = pe - line;
	    state.optbeg = state.argbeg = state.inopt = cur;
	    state.argend = argend;
	    state.singles = (!pe || !*pe);

	    for (p = line + 1; p < pe; p++) {
		if ((tmpopt = d->single[STOUC(*p)])) {
		    if (!state.oargs[tmpopt->num])
			state.oargs[tmpopt->num] = znewlinklist();

		    if (ca_inactive(d, tmpopt->xor, cur, 0,
                                    (cur == compcurrent ? tmpopt->name : NULL)))
			return 1;
		}
	    }
	    if (state.def &&
		(state.curopt->type == CAO_DIRECT ||
		 state.curopt->type == CAO_EQUAL ||
		 (state.curopt->type == CAO_ODIRECT && pe[0]) ||
		 (state.curopt->type == CAO_OEQUAL &&
		  (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;

		zaddlinknode(state.oargs[state.curopt->num],
                             ca_opt_arg(state.curopt, line));
	    }
	    if (state.def)
		state.opt = 0;
	    else
		state.curopt = NULL;
	} else if (multi && (*line == '-' || *line == '+') && cur != compcurrent
#if 0
		   /**** Ouch. Using this will disable the mutual exclusion
			 of different sets. Not using it will make the -A
			 pattern be effectively ignored with multiple sets. */
		   && (!napat || !pattry(napat, line))
#endif
		   )
	    return 1;
	else if (state.arg && (!napat || !pattry(napat, line))) {
	    /* Otherwise it's a normal argument. */
	    if (napat && ca_inactive(d, NULL, cur + 1, 1, NULL))
		return 1;

	    arglast = 1;
	    if (state.inopt) {
		state.inopt = 0;
		state.nargbeg = cur - 1;
		state.argend = argend;
	    }
	    if (!d->args && !d->rest && *line && *line != '-' && *line != '+') {
		if (!multi && cur > compcurrent)
		    break;
		return 1;
	    }
	    if ((adef = state.def = ca_get_arg(d, state.nth)) &&
		(state.def->type == CAA_RREST ||
		 state.def->type == CAA_RARGS)) {

		/* Bart 2009/11/17:
		 * We've reached the "rest" definition.  If at this point
		 * we already found another definition that describes the
		 * current word, use that instead.  If not, prep for the
		 * "narrowing" of scope to only the remaining words.
		 *
		 * We can't test ca_laststate.def in the loop conditions
		 * at the top because this same loop also handles the
		 * ':*PATTERN:MESSAGE:ACTION' form for multiple arguments
		 * after an option, which may need to continue scanning.
		 * There might be an earlier point at which this test can
		 * be made but tracking it down is not worth the effort.
		 */
		if (ca_laststate.def)
		    break;

		state.inrest = 0;
		state.opt = (cur == state.nargbeg + 1 &&
			     (!multi || !*line ||
			      *line == '-' || *line == '+'));
		state.optbeg = state.nargbeg;
		state.argbeg = cur - 1;
		state.argend = argend;

		for (; line; line = compwords[cur++])
		    zaddlinknode(state.args, ztrdup(line));

		memcpy(&ca_laststate, &state, sizeof(state));
		ca_laststate.ddef = NULL;
		ca_laststate.dopt = NULL;
		ca_laststate.doff = 0;
		break;
	    }
	    zaddlinknode(state.args, ztrdup(line));
            if (adef)
                state.oopt = adef->num - state.nth;

	    if (state.def)
		argxor = state.def->xor;

	    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;
	}
	/* Do the end-pattern test if needed. */

	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];

		if (cur < compcurrent)
		    memcpy(&ca_laststate, &state, sizeof(state));

		for (; line; line = compwords[cur++])
		    zaddlinknode(l, ztrdup(line));

		ca_laststate.ddef = NULL;
		ca_laststate.dopt = NULL;
		ca_laststate.doff = 0;
		break;
	    }
	} else if (state.def && state.def->end)
	    endpat = patcompile(state.def->end, 0, NULL);

	/* Copy the state into the global one. */

    cont:

	if (cur + 1 == compcurrent) {
	    memcpy(&ca_laststate, &state, sizeof(state));
	    ca_laststate.ddef = NULL;
	    ca_laststate.dopt = NULL;
	    ca_laststate.doff = 0;
	} else if (cur == compcurrent && !ca_laststate.def) {
	    if ((ca_laststate.def = ddef)) {
		ca_laststate.singles = state.singles;
		if (state.curopt && state.curopt->type == CAO_NEXT) {
		    ca_laststate.ddef = ddef;
		    ca_laststate.dopt = dopt;
		    ca_laststate.def = NULL;
		    ca_laststate.opt = 1;
		    state.curopt->active = 1;
		} else {
		    ca_laststate.doff = doff;
		    ca_laststate.opt = 0;
		}
	    } else {
		ca_laststate.def = adef;
		ca_laststate.opt = (!arglast || !multi || !*line ||
				    *line == '-' || *line == '+');
		ca_laststate.ddef = NULL;
		ca_laststate.dopt = NULL;
		ca_laststate.optbeg = state.nargbeg;
		ca_laststate.argbeg = state.restbeg;
		ca_laststate.argend = state.argend;
		ca_laststate.singles = state.singles;
		ca_laststate.oopt = state.oopt;
		if (wasopt)
		    wasopt->active = 1;
	    }
	}
    }
 end:

    ca_laststate.actopts = 0;
    for (ptr = d->opts; ptr; ptr = ptr->next)
	if (ptr->active)
	    ca_laststate.actopts++;

    return 0;
}

/* Build a colon-list from a list. */

static char *
ca_colonlist(LinkList l)
{
    if (l) {
	LinkNode n;
	int len = 0;
	char *p, *ret, *q;

	for (n = firstnode(l); n; incnode(n)) {
	    len++;
	    for (p = (char *) getdata(n); *p; p++)
		len += (*p == ':' ? 2 : 1);
	}
	ret = q = (char *) zalloc(len);

	for (n = firstnode(l); n;) {
	    for (p = (char *) getdata(n); *p; p++) {
		if (*p == ':')
		    *q++ = '\\';
		*q++ = *p;
	    }
	    incnode(n);
	    if (n)
		*q++ = ':';
	}
	*q = '\0';

	return ret;
    } else
	return ztrdup("");
}

/*
 * This function adds the current set of descriptions, actions,
 * and subcontext descriptions to the given linked list for passing
 * up in comparguments -D and comparguments -L.  opt is the
 * option string (may be NULL if this isn't an option argument) and arg the
 * argument structure (either an option argument or a normal argument
 * as determined by arg->type).
 */

static void
ca_set_data(LinkList descr, LinkList act, LinkList subc,
	    char *opt, Caarg arg, Caopt optdef, int single)
{
    LinkNode dnode, anode;
    char nbuf[40], *buf;
    int restr = 0, onum, miss = 0, rest, oopt = 1, lopt = 0, addopt;

 rec:

    addopt = (opt ? 0 : ca_laststate.oopt);

    for (; arg && (opt || (arg->num < 0 ||
			   (arg->min <= ca_laststate.nth + addopt &&
			    arg->num >= ca_laststate.nth)));) {
	lopt = (arg->type == CAA_OPT);
	if (!opt && !lopt && oopt > 0)
	    oopt = 0;

	for (dnode = firstnode(descr), anode = firstnode(act);
	     dnode; incnode(dnode), incnode(anode))
	    if (!strcmp((char *) getdata(dnode), arg->descr) &&
		!strcmp((char *) getdata(anode), arg->action))
		break;

	if (!dnode) {
	    addlinknode(descr, arg->descr);
	    addlinknode(act, arg->action);

	    if (!restr) {
		if ((restr = (arg->type == CAA_RARGS)))
		    restrict_range(ca_laststate.optbeg, ca_laststate.argend);
		else if ((restr = (arg->type == CAA_RREST)))
		    restrict_range(ca_laststate.argbeg, ca_laststate.argend);
	    }
	    if (arg->opt) {
		buf = (char *) zhalloc((arg->set ? strlen(arg->set) : 0) +
				       strlen(arg->opt) + 40);
		if (arg->num > 0 && arg->type < CAA_REST)
		    sprintf(buf, "%soption%s-%d",
			    (arg->set ? arg->set : ""), arg->opt, arg->num);
		else
		    sprintf(buf, "%soption%s-rest",
			    (arg->set ? arg->set : ""), arg->opt);
	    } else if (arg->num > 0) {
		sprintf(nbuf, "argument-%d", arg->num);
		buf = (arg->set ? dyncat(arg->set, nbuf) : dupstring(nbuf));
	    } else
		buf = (arg->set ? dyncat(arg->set, "argument-rest") :
		       dupstring("argument-rest"));

	    addlinknode(subc, buf);
	}
	/*
	 * If this is an argument to an option, and the option definition says
	 * the argument to the option is required and in the following
	 * (i.e. this) word, then it must match what we've just told it to
	 * match---don't try to match normal arguments.
	 *
	 * This test may be too stringent for what we need, or it
	 * may be too loose; I've simply tweaked it until it gets
	 * the case above right.
	 */
	if (arg->type == CAA_NORMAL &&
	    opt && optdef && optdef->type == CAO_NEXT)
	    return;
	if (single)
	    break;

	if (!opt) {
	    if (arg->num >= 0 && !arg->next && miss)
		arg = (ca_laststate.d->rest && ca_laststate.d->rest->active ?
		       ca_laststate.d->rest : NULL);
	    else {
		onum = arg->num;
		rest = (onum != arg->min && onum == ca_laststate.nth);
		if ((arg = arg->next)) {
		    if (arg->num != onum + 1)
			miss = 1;
		} else if (rest || (oopt > 0 && !opt)) {
		    arg = (ca_laststate.d->rest && ca_laststate.d->rest->active ?
			   ca_laststate.d->rest : NULL);
		    oopt = -1;
		}
	    }
	} else {
	    if (!lopt)
		break;
	    arg = arg->next;
	}
    }
    if (!single && opt && (lopt || ca_laststate.oopt)) {
	opt = NULL;
	arg = ca_get_arg(ca_laststate.d, ca_laststate.nth);

	goto rec;
    }
    if (!opt && oopt > 0) {
	oopt = -1;
	arg = (ca_laststate.d->rest && ca_laststate.d->rest->active ?
	       ca_laststate.d->rest : NULL);

	goto rec;
    }
}

static int
bin_comparguments(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    int min, max, n;
    Castate lstate = &ca_laststate;

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (args[0][0] != '-' || !args[0][1] || args[0][2]) {
	zwarnnam(nam, "invalid argument: %s", args[0]);
	return 1;
    }
    if (args[0][1] != 'i' && args[0][1] != 'I' && !ca_parsed) {
	zwarnnam(nam, "no parsed state");
	return 1;
    }
    switch (args[0][1]) {
    case 'i': min = 2; max = -1; break;
    case 'D': min = 3; max =  3; break;
    case 'O': min = 4; max =  4; break;
    case 'L': min = 3; max =  4; 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;
    case 'n': min = 1; max =  1; break;
    default:
	zwarnnam(nam, "invalid option: %s", args[0]);
	return 1;
    }
    n = arrlen(args) - 1;
    if (n < min) {
	zwarnnam(nam, "not enough arguments");
	return 1;
    } else if (max >= 0 && n > max) {
	zwarnnam(nam, "too many arguments");
	return 1;
    }
    switch (args[0][1]) {
    case 'i':
        /* This initialises the internal data structures. Arguments are the
         * auto-description string, the optional -s, -S, -A and -M options
         * given to _arguments and the specs. */
	if (compcurrent > 1 && compwords[0]) {
	    Cadef def;
	    int cap = ca_parsed, multi, first = 1, use, ret = 0;
	    LinkList cax = ca_xor, nx;
	    LinkNode node;
	    Castate states = NULL, sp;
	    char *xor[2];

	    ca_parsed = 0;
	    xor[1] = NULL;

	    if (!(def = get_cadef(nam, args + 1)))
		return 1;

	    multi = !!def->snext;
	    ca_parsed = cap;
	    ca_xor = (multi ? newlinklist() : NULL);

	    while (def) {
		use = !ca_parse_line(def, multi, first);
		nx = ca_xor;
		ca_xor = NULL;
		while ((def = def->snext)) {
		    if (nx) {
			for (node = firstnode(nx); node; incnode(node)) {
			    xor[0] = (char *) getdata(node);
			    if (!strcmp(xor[0], def->sname) ||
				ca_inactive(def, xor, compcurrent, 0, NULL))
				break;
			}
			if (!node)
			    break;
		    }
		}
		ca_xor = nx;
		if (use && def) {
		    sp = (Castate) zalloc(sizeof(*sp));
		    memcpy(sp, &ca_laststate, sizeof(*sp));
		    sp->snext = states;
		    states = sp;
		} else if (!use && !def) {
		    if (states) {
			freecastate(&ca_laststate);
			memcpy(&ca_laststate, states, sizeof(*sp));
			sp = states->snext;
			zfree(states, sizeof(*states));
			states = sp;
		    } else
			ret = 1;
		}
		first = 0;
	    }
	    ca_xor = cax;
	    ca_parsed = 1;
	    ca_laststate.snext = states;

	    return ret;
	}
	return 1;

    case 'D':
        /* This returns the descriptions, actions and sub-contexts for the
         * things _arguments has to execute at this place on the line (the
         * sub-contexts are used as tags).
         * The return value is particularly important here, it says if
         * there are arguments to completely at all. */
	{
	    LinkList descr, act, subc;
	    Caarg arg;
	    int ign = 0, ret = 1;

	    descr = newlinklist();
	    act = newlinklist();
	    subc = newlinklist();

	    while (lstate) {
		arg = lstate->def;

		if (arg) {
		    ret = 0;
		    if (!ign && lstate->doff > 0) {
			ign = 1;
			ignore_prefix(lstate->doff);
		    }
		    ca_set_data(descr, act, subc, arg->opt, arg,
				lstate->curopt, (lstate->doff > 0));
		}
		lstate = lstate->snext;
	    }
	    if (!ret) {
		set_list_array(args[1], descr);
		set_list_array(args[2], act);
		set_list_array(args[3], subc);
	    }
	    return ret;
	}
    case 'O':
        /* This returns the descriptions for the options in the arrays whose
         * names are given as arguments.  The descriptions are strings in a
         * form usable by _describe.  The return value says if there are any
         * options to be completed. */
	{
	    LinkList next = newlinklist();
	    LinkList direct = newlinklist();
	    LinkList odirect = newlinklist();
	    LinkList equal = newlinklist(), l;
            LinkNode node;
	    Caopt p;
	    char *str;
	    int ret = 1;

	    for (; lstate; lstate = lstate->snext) {
		if (lstate->actopts &&
		    (lstate->opt || (lstate->doff && lstate->def) ||
		     (lstate->def && lstate->def->opt &&
		      (lstate->def->type == CAA_OPT ||
		       (lstate->def->type >= CAA_RARGS &&
			lstate->def->num < 0)))) &&
		    (!lstate->def || lstate->def->type < CAA_RARGS ||
		     (lstate->def->type == CAA_RARGS ?
		      (lstate->curpos == lstate->argbeg + 1) :
		      (compcurrent == 1)))) {
		    ret = 0;
		    for (p = lstate->d->opts; p; p = p->next) {
			if (p->active && !p->not) {
			    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) {
				char *n = bslashcolon(p->name);
				int len = strlen(n) + strlen(p->descr) + 2;

				str = (char *) zhalloc(len);
				strcpy(str, n);
				strcat(str, ":");
				strcat(str, p->descr);
			    } else
				str = bslashcolon(p->name);

                            for (node = firstnode(l); node; incnode(node))
                                if (!strcmp(str, (char *) getdata(node)))
                                    break;

                            if (!node)
                                addlinknode(l, str);
			}
		    }
		}
	    }
	    if (!ret) {
		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;
	    }
	    return (ca_laststate.singles ? 2 : 1);
	}
    case 'L':
        /* This tests if the beginning of the current word matches an option.
         * It is for cases like `./configure --pre=/<TAB>' which should
         * complete to `--prefix=/...'.  The options name isn't fully typed
         * and _arguments finds out that there is no option `--pre' and that
         * it should complete some argument to an option.  It then uses -L
         * to find the option the argument is for. */
	{
	    LinkList descr, act, subc;
	    Caopt opt;
	    int ret = 1;

	    descr = newlinklist();
	    act = newlinklist();
	    subc = newlinklist();

	    while (lstate) {
		opt = ca_get_opt(lstate->d, args[1], 1, NULL);

		if (opt && opt->args) {
		    ret = 0;
		    ca_set_data(descr, act, subc, opt->name, opt->args, opt, 1);
		}
		lstate = lstate->snext;
	    }
	    if (!ret) {
		set_list_array(args[2], descr);
		set_list_array(args[3], act);
		set_list_array(args[4], subc);
	    }
	    return ret;
	}
    case 's':
        /* This returns zero if we are completing single letter options.
         * It also uses its argument as the name of a parameter and sets
         * that to a string describing the argument behaviour of the last
         * option in the current word so that we can get the auto-suffix
         * right. */
	for (; lstate; lstate = lstate->snext)
	    if (lstate->d->single && lstate->singles &&
		lstate->actopts
#if 0
                /* let's try without, for the -W option of _arguments */
                && lstate->opt
#endif
                ) {
		setsparam(args[1],
			  ztrdup((lstate->ddef && lstate->dopt) ?
				 (lstate->dopt->type == CAO_DIRECT ?
				  "direct" :
				  ((lstate->dopt->type == CAO_OEQUAL ||
				    lstate->dopt->type == CAO_EQUAL) ?
				   "equal" : "next")) : ""));
		return 0;
	    }
	return 1;
    case 'M':
        /* This returns the match specs defined for the set of specs we are
         * using.  Returned, as usual in a parameter whose name is given as
         * the argument. */
	setsparam(args[1], ztrdup(ca_laststate.d->match));
	return 0;
    case 'a':
        /* This just sets the return value.  To zero if there would be or
         * were any normal arguments to be completed.  Used to decide if
         * _arguments should say `no arguments' or `no more arguments'. */
	for (; lstate; lstate = lstate->snext)
	    if (lstate->d->args || lstate->d->rest)
		return 0;
	return 1;
    case 'W':
        /* This gets two parameter names as arguments.  The first is set to
         * the current word sans any option prefixes handled by comparguments.
         * The second parameter is set to an array containing the options on
         * the line and their arguments.  I.e. the stuff _arguments returns
         * to its caller in the `line' and `opt_args' parameters. */
	{
	    Castate s;
	    char **ret, **p;
	    LinkNode n;
	    LinkList *a;
	    Caopt o;
	    int num;

	    for (num = 0, s = lstate; s; s = s->snext)
		num += countlinknodes(s->args);

	    ret = p = zalloc((num + 1) * sizeof(char *));

	    for (s = lstate; s; s = s->snext)
		for (n = firstnode(s->args); n; incnode(n))
		    *p++ = ztrdup((char *) getdata(n));
	    *p = NULL;

	    setaparam(args[1], ret);

	    for (num = 0, s = lstate; s; s = s->snext)
		for (o = s->d->opts, a = s->oargs; o; o = o->next, a++)
		    if (*a)
			num += 2;

	    ret = p = zalloc((num + 1) * sizeof(char *));

	    for (s = lstate; s; s = s->snext)
		for (o = s->d->opts, a = s->oargs; o; o = o->next, a++)
		    if (*a) {
			*p++ = (o->set ? tricat(o->set, o->name, "") :
				ztrdup(o->name));
			*p++ = ca_colonlist(*a);
		    }
	    *p = NULL;

	    sethparam(args[2], ret);
	}
	return 0;
    case 'n':
	/*
	 * This returns the array index of the word where normal
	 * arguments began.  It uses optbeg rather than nargbeg
	 * (the value used when parsing) because nargbeg is assigned
	 * to optbeg in the returned value and nargbeg isn't
	 * used.
	 *
	 * -->PLEASE DON'T ASK<--
	 *
	 * Thank you.
	 */
	setiparam(args[1], (zlong)ca_laststate.optbeg + !isset(KSHARRAYS));
	return 0;
    }
    return 1;
}

/* Help for `_values'. */

typedef struct cvdef *Cvdef;
typedef struct cvval *Cvval;

/* Definitions for _values. */

struct cvdef {
    char *descr;		/* global description */
    int hassep;			/* multiple values allowed */
    char sep;			/* separator character */
    char argsep;                /* argument separator */
    Cvdef next;			/* next in cache */
    Cvval vals;			/* value definitions */
    char **defs;		/* original strings */
    int ndefs;			/* number of ... */
    int lastt;			/* last time used */
    int words;                  /* if to look at other words */
};

/* One value definition. */

struct cvval {
    Cvval next;
    char *name;			/* value name */
    char *descr;		/* description */
    char **xor;			/* xor-list */
    int type;			/* CVV_* below */
    Caarg arg;			/* argument definition */
    int active;			/* still allowed */
};

#define CVV_NOARG 0
#define CVV_ARG   1
#define CVV_OPT   2

/* Cache. */

#define MAX_CVCACHE 8
static Cvdef cvdef_cache[MAX_CVCACHE];

/* Memory stuff. */

static void
freecvdef(Cvdef d)
{
    if (d) {
	Cvval p, n;

	zsfree(d->descr);
	if (d->defs)
	    freearray(d->defs);

	for (p = d->vals; p; p = n) {
	    n = p->next;
	    zsfree(p->name);
	    zsfree(p->descr);
	    if (p->xor)
		freearray(p->xor);
	    freecaargs(p->arg);
	    zfree(p, sizeof(*p));
	}
	zfree(d, sizeof(*d));
    }
}

/* Parse option definitions. */

static Cvdef
parse_cvdef(char *nam, char **args)
{
    Cvdef ret;
    Cvval val, *valp;
    Caarg arg;
    char **oargs = args, sep = '\0', asep = '=', *name, *descr, *p, *q, **xor, c;
    int xnum, multi, vtype, hassep = 0, words = 0;

    while (args && args[0] && args[1] &&
           args[0][0] == '-' &&
           (args[0][1] == 's' || args[0][1] == 'S' || args[0][1] == 'w') &&
           !args[0][2]) {

        if (args[0][1] == 's') {
            hassep = 1;
            sep = args[1][0];
            args += 2;
        } else if (args[0][1] == 'S') {
            asep = args[1][0];
            args += 2;
        } else {
            words = 1;
            args++;
        }
    }
    if (!args[0] || !args[1]) {
	zwarnnam(nam, "not enough arguments");
	return NULL;
    }
    descr = *args++;

    ret = (Cvdef) zalloc(sizeof(*ret));
    ret->descr = ztrdup(descr);
    ret->hassep = hassep;
    ret->sep = sep;
    ret->argsep = asep;
    ret->next = NULL;
    ret->vals = NULL;
    ret->defs = zarrdup(oargs);
    ret->ndefs = arrlen(oargs);
    ret->lastt = time(0);
    ret->words = words;

    for (valp = &(ret->vals); *args; args++) {
	int bs = 0;
	p = dupstring(*args);
	xnum = 0;

	/* xor list? */
	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 != ')') {
		freecvdef(ret);
		zwarnnam(nam, "invalid argument: %s", *args);
		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;

	/* More than once allowed? */
	if ((multi = (*p == '*')))
	    p++;

	/* Skip option name. */

	for (name = p; *p && *p != ':' && *p != '['; p++)
	    if (*p == '\\' && p[1])
		p++, bs = 1;

	if (hassep && !sep && name + bs + 1 < p) {
	    freecvdef(ret);
	    zwarnnam(nam, "no multi-letter values with empty separator allowed");
	    return NULL;
	}
	/* Optional description? */

	if ((c = *p) == '[') {
	    *p = '\0';
	    for (descr = ++p; *p && *p != ']'; p++)
		if (*p == '\\' && p[1])
		    p++;

	    if (!*p) {
		freecvdef(ret);
		zwarnnam(nam, "invalid value definition: %s", *args);
		return NULL;
	    }
	    *p++ = '\0';
	    c = *p;
	} else {
	    *p = '\0';
	    descr = NULL;
	}
	if (c && c != ':') {
	    freecvdef(ret);
	    zwarnnam(nam, "invalid value definition: %s", *args);
	    return NULL;
	}
	/* Get argument? */

	if (c == ':') {
	    if (hassep && !sep) {
		freecvdef(ret);
		zwarnnam(nam, "no value with argument with empty separator allowed");
		return NULL;
	    }
	    if (*++p == ':') {
		p++;
		vtype = CVV_OPT;
	    } else
		vtype = CVV_ARG;
	    arg = parse_caarg(0, 0, 0, 0, name, &p, NULL);
	} else {
	    vtype = CVV_NOARG;
	    arg = NULL;
	}
	if (!multi) {
	    if (!xor) {
		xor = (char **) zalloc(2 * sizeof(char *));
		xor[1] = NULL;
	    }
	    xor[xnum] = ztrdup(name);
	}
	*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;
    }
    return ret;
}

/* Get the definition from the cache or newly built. */

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))) {
	freecvdef(*min);
	*min = new;
    }
    return new;
}

/* Get the definition for a value. */

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 Cvval
cv_quote_get_val(Cvdef d, char *name)
{
    int ne;

    /* remove quotes */
    name = dupstring(name);
    ne = noerrs;
    noerrs = 2;
    parse_subst_string(name);
    noerrs = ne;
    remnulargs(name);
    untokenize(name);

    return cv_get_val(d, name);
}

/* Handle a xor list. */

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;
    }
}

/* Parse state. */

struct cvstate {
    Cvdef d;
    Caarg def;
    Cvval val;
    LinkList vals;
};

static struct cvstate cv_laststate;
static int cv_parsed = 0, cv_alloced = 0;

/* Get the next value in the string.  Return it's definition and update the
 * sp pointer to point to the end of the value (plus argument, if any).
 * If there is no next value, the string pointer is set to null.  In any
 * case ap will point to the beginning of the argument or will be a null
 * pointer if there is no argument.
 */

static Cvval
cv_next(Cvdef d, char **sp, char **ap)
{
    Cvval r = NULL;
    char *s = *sp;

    if (!*s) {
        *sp = *ap = NULL;

        return NULL;
    }
    if ((d->hassep && !d->sep) || !d->argsep) {
        char sav, ec, *v = s, *os;

        ec = ((d->hassep && d->sep) ? d->sep : d->argsep);

        do {
            sav = *++s;
            *s = '\0';
            if ((r = cv_quote_get_val(d, v))) {
                *s = sav;

                break;
            }
            *s = sav;
        } while (*s && *s != ec);

        os = s;

        if (d->hassep && d->sep) {
            if ((s = strchr(s, d->sep)))
                *sp = s + 1;
            else
                *sp = NULL;
        } else
            *sp = s;
        if (d->argsep && *os == d->argsep) {
            *ap = os + 1;
            *sp = NULL;
        } else if (r && r->type != CVV_NOARG)
            *ap = os;
        else
            *ap = NULL;

        return r;

    } else if (d->hassep) {
        char *ns = strchr(s, d->sep), *as = 0, *sap, sav = 0;
        int skip = 0;

        if (d->argsep && (as = strchr(s, d->argsep)) && (!ns || as <= ns)) {
            *ap = as + 1;
            ns = strchr(as + 1, d->sep);
            skip = 1;
            sap = as;
        } else {
            *ap = NULL;
            sap = ns;
        }
        if (sap) {
            sav = *sap;
            *sap = '\0';
        }
        if ((!(r = cv_quote_get_val(d, s)) || r->type == CVV_NOARG) && skip)
            ns = as;

        if (sap)
            *sap = sav;

        *sp = ((!ns || (ns == as && r && r->type != CVV_NOARG)) ? NULL : ns + 1);

        return r;
    } else {
        char *as = strchr(s, d->argsep), *sap, sav = 0;

        *sp = NULL;

        if (as) {
            *ap = as + 1;
            sap = as;
            sav = *as;
            *sap = '\0';
        } else
            *ap = sap = NULL;

        r = cv_quote_get_val(d, s);

        if (sap)
            *sap = sav;

        return r;
    }
}

/* Parse the current word. */

static void
cv_parse_word(Cvdef d)
{
    Cvval val;
    struct cvstate state;
    char *str, *arg = NULL, *pign = compprefix;
    int nosfx = 0;

    if (cv_alloced)
	freelinklist(cv_laststate.vals, freestr);

    for (val = d->vals; val; val = val->next)
	val->active = 1;

    state.d = d;
    state.def = NULL;
    state.val = NULL;
    state.vals = (LinkList) znewlinklist();

    cv_alloced = 1;

    if (d->words && compwords[0]) {
        int i;

        for (i = 1; compwords[i]; i++)
            if (i != compcurrent - 1)
                for (str = compwords[i]; str && *str; ) {
                    if ((val = cv_next(d, &str, &arg))) {
                        zaddlinknode(state.vals, ztrdup(val->name));
                        if (arg) {
                            char sav = '\0';

                            if (str) {
                                sav = str[-1];
                                str[-1] = '\0';
                            }
                            zaddlinknode(state.vals, ztrdup(arg));
                            if (str)
                                str[-1] = sav;
                        } else
                            zaddlinknode(state.vals, ztrdup(""));

                        if (i + 1 < compcurrent)
                            cv_inactive(d, val->xor);
                    }
                }

        val = NULL;
        arg = NULL;
    }
    for (str = compprefix; str && *str; ) {
        if ((val = cv_next(d, &str, &arg))) {
            zaddlinknode(state.vals, ztrdup(val->name));
            if (arg) {
                if (str) {
                    char sav = str[-1];

                    str[-1] = '\0';
                    zaddlinknode(state.vals, ztrdup(arg));
                    str[-1] = sav;
                } else {
                    zaddlinknode(state.vals, tricat(arg, compsuffix, ""));
                    nosfx = 1;
                }
            } else
                zaddlinknode(state.vals, ztrdup(""));

            cv_inactive(d, val->xor);

            if (str)
                pign = str;
            else
                val->active = 1;
        }
    }
    state.val = val;
    if (val && arg && !str)
        state.def = val->arg;

    if (!nosfx && d->hassep) {
        int ign = 0;
        char *more = NULL;

        ignore_prefix(pign - compprefix);

        if (!d->sep && (!val || val->type == CVV_NOARG)) {
            ign = strlen(compsuffix);
            more = compsuffix;
        } else {
            if (d->sep) {
                char *ns = strchr(compsuffix, d->sep), *as;

                if (d->argsep && (as = strchr(compsuffix, d->argsep)) &&
                    (!ns || as <= ns)) {
                    ign = strlen(as);
                } else
                    ign = (ns ? strlen(ns) : 0);

                more = (ns ? ns + 1 : NULL);
            } else if (d->argsep) {
                char *as;

                if ((as = strchr(compsuffix, d->argsep)))
                    ign = strlen(as);
            }
        }
        more = dupstring(more);

        if (ign)
            ignore_suffix(ign);

        while (more && *more) {
            if ((val = cv_next(d, &more, &arg))) {
                zaddlinknode(state.vals, ztrdup(val->name));
                if (arg) {
                    if (more) {
                        char sav = more[-1];

                        more[-1] = '\0';
                        zaddlinknode(state.vals, ztrdup(arg));
                        more[-1] = sav;
                    } else {
                        zaddlinknode(state.vals, tricat(arg, compsuffix, ""));
                        nosfx = 1;
                    }
                } else
                    zaddlinknode(state.vals, ztrdup(""));

                cv_inactive(d, val->xor);
            }
        }
    } else if (arg)
        ignore_prefix(arg - compprefix);
    else
        ignore_prefix(pign - compprefix);

    memcpy(&cv_laststate, &state, sizeof(state));
}

static int
bin_compvalues(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    int min, max, n;

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (args[0][0] != '-' || !args[0][1] || args[0][2]) {
	zwarnnam(nam, "invalid argument: %s", args[0]);
	return 1;
    }
    if (args[0][1] != 'i' && !cv_parsed) {
	zwarnnam(nam, "no parsed state");
	return 1;
    }
    switch (args[0][1]) {
    case 'i': min = 2; max = -1; break;
    case 'D': min = 2; max =  2; break;
    case 'C': min = 1; max =  1; break;
    case 'V': min = 3; max =  3; break;
    case 's': min = 1; max =  1; break;
    case 'S': min = 1; max =  1; break;
    case 'd': min = 1; max =  1; break;
    case 'L': min = 3; max =  4; break;
    case 'v': min = 1; max =  1; break;
    default:
	zwarnnam(nam, "invalid option: %s", args[0]);
	return 1;
    }
    n = arrlen(args) - 1;
    if (n < min) {
	zwarnnam(nam, "not enough arguments");
	return 1;
    } else if (max >= 0 && n > max) {
	zwarnnam(nam, "too many arguments");
	return 1;
    }
    switch (args[0][1]) {
    case 'i':
        /* This initialises the internal data structures.  The arguments are
         * just the arguments that were given to _values itself. */
	{
	    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;
	}

    case 'D':
        /* This returns the description and action to use if we are at
         * a place where some action has to be used at all.  In that case
         * zero is returned and non-zero otherwise. */
	{
	    Caarg arg = cv_laststate.def;

	    if (arg) {
		setsparam(args[1], ztrdup(arg->descr));
		setsparam(args[2], ztrdup(arg->action));

		return 0;
	    }
	    return 1;
	}
    case 'C':
        /* This returns the sub-context (i.e.: the tag) to use when executing
         * an action. */
	{
	    Caarg arg = cv_laststate.def;

	    if (arg) {
		setsparam(args[1], ztrdup(arg->opt));

		return 0;
	    }
	    return 1;
	}
    case 'V':
        /* This is what -O is for comparguments: it returns (in three arrays)
         * the values for values without arguments, with arguments and with
         * optional arguments (so that we can get the auto-suffixes right).
         * As for comparguments, the strings returned are usable for _describe. */
	{
	    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':
        /* This returns the value separator, if any, and sets the return
         * value to say if there is such a separator. */
	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 'S':
        /* Like -s, but for the separator between values and their arguments. */
	{
	    char tmp[2];

	    tmp[0] = cv_laststate.d->argsep;
	    tmp[1] = '\0';
	    setsparam(args[1], ztrdup(tmp));
	}
	return 0;
    case 'd':
        /* This returns the description string (first argument to _values)
         * which is passed down to _describe. */
	setsparam(args[1], ztrdup(cv_laststate.d->descr));
	return 0;
    case 'L':
        /* Almost the same as for comparguments.  This gets a value name
         * and returns the description and action of its first argument, if
         * any.  The rest (prefix matching) is in _values.  Return non-zero
         * if there is no such option. */
	{
	    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);

		if (args[4])
		    setsparam(args[4], ztrdup(val->name));

		return 0;
	    }
	    return 1;
	}
    case 'v':
        /* Again, as for comparguments.  This returns the values and their
         * arguments as an array which will be stored in val_args in _values. */
	if (cv_laststate.vals) {
	    char **ret;

	    ret = zlinklist2array(cv_laststate.vals);
	    sethparam(args[1], ret);

	    return 0;
	}
	return 1;
    }
    return 1;
}

static char *
comp_quote(char *str, int prefix)
{
    int x;
    char *ret;

    if ((x = (prefix && *str == '=')))
	*str = 'x';

    ret = quotestring(str, NULL, *compqstack);

    if (x)
	*str = *ret = '=';

    return ret;
}

static int
bin_compquote(char *nam, char **args, Options ops, UNUSED(int func))
{
    char *name;
    struct value vbuf;
    Value v;

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    /* Anything to do? */

    if (!compqstack || !*compqstack)
	return 0;

    /* For all parameters given... */

    while ((name = *args++)) {
	name = dupstring(name);
	queue_signals();
	if ((v = getvalue(&vbuf, &name, 0))) {
	    switch (PM_TYPE(v->pm->node.flags)) {
	    case PM_SCALAR:
		setstrvalue(v, ztrdup(comp_quote(getstrvalue(v),
						 OPT_ISSET(ops,'p'))));
		break;
	    case PM_ARRAY:
		{
		    char **val = v->pm->gsu.a->getfn(v->pm);
		    char **new = (char **) zalloc((arrlen(val) + 1) *
						  sizeof(char *));
		    char **p = new;

		    for (; *val; val++, p++)
			*p = ztrdup(comp_quote(*val, OPT_ISSET(ops,'p')));
		    *p = NULL;

		    setarrvalue(v, new);
		}
		break;
	    default:
		zwarnnam(nam, "invalid parameter type: %s", args[-1]);
	    }
	} else
	    zwarnnam(nam, "unknown parameter: %s", args[-1]);
	unqueue_signals();
    }
    return 0;
}

/* Tags stuff. */

typedef struct ctags *Ctags;
typedef struct ctset *Ctset;

/* A bunch of tag sets. */

struct ctags {
    char **all;			/* all tags offered */
    char *context;		/* the current context */
    int init;			/* not yet used */
    Ctset sets;			/* the tag sets */
};

/* A tag set. */

struct ctset {
    Ctset next;
    char **tags;		/* the tags */
    char *tag;			/* last tag checked for -A */
    char **ptr;			/* ptr into tags for -A */
};

/* Array of tag-set infos. Index is the locallevel. */

#define MAX_TAGS 256
static Ctags comptags[MAX_TAGS];

/* locallevel at last comptags -i */

static int lasttaglevel;

static void
freectset(Ctset s)
{
    Ctset n;

    while (s) {
	n = s->next;

	if (s->tags)
	    freearray(s->tags);
	zsfree(s->tag);
	zfree(s, sizeof(*s));

	s = n;
    }
}

static void
freectags(Ctags t)
{
    if (t) {
	if (t->all)
	    freearray(t->all);
	zsfree(t->context);
	freectset(t->sets);
	zfree(t, sizeof(*t));
    }
}

/* Set the tags for the current local level. */

static void
settags(int level, char **tags)
{
    Ctags t;

    if (comptags[level])
	freectags(comptags[level]);

    comptags[level] = t = (Ctags) zalloc(sizeof(*t));

    t->all = zarrdup(tags + 1);
    t->context = ztrdup(*tags);
    t->sets = NULL;
    t->init = 1;
}

/* Check if an array contains a string. */

/**/
static int
arrcontains(char **a, char *s, int colon)
{
    char *p, *q;

    while (*a) {
	if (colon) {
	    for (p = s, q = *a++; *p && *q && *p != ':' && *q != ':'; p++, q++)
		if (*p != *q)
		    break;
	    if ((!*p || *p == ':') && (!*q || *q == ':'))
		return 1;
	} else if (!strcmp(*a++, s))
	    return 1;
    }
    return 0;
}

static int
bin_comptags(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    int min, max, n, level;

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (args[0][0] != '-' || !args[0][1] ||
	(args[0][2] && (args[0][2] != '-' || args[0][3]))) {
	zwarnnam(nam, "invalid argument: %s", args[0]);
	return 1;
    }
    level = locallevel - (args[0][2] ? 1 : 0);
    if (level >= MAX_TAGS) {
	zwarnnam(nam, "nesting level too deep");
	return 1;
    }
    if (args[0][1] != 'i' && args[0][1] != 'I' && !comptags[level]) {
	zwarnnam(nam, "no tags registered");
	return 1;
    }
    switch (args[0][1]) {
    case 'i': min = 2; max = -1; break;
    case 'C': min = 1; max =  1; break;
    case 'T': min = 0; max =  0; break;
    case 'N': min = 0; max =  0; break;
    case 'R': min = 1; max =  1; break;
    case 'S': min = 1; max =  1; break;
    case 'A': min = 2; max =  3; break;
    default:
	zwarnnam(nam, "invalid option: %s", args[0]);
	return 1;
    }
    n = arrlen(args) - 1;
    if (n < min) {
	zwarnnam(nam, "not enough arguments");
	return 1;
    } else if (max >= 0 && n > max) {
	zwarnnam(nam, "too many arguments");
	return 1;
    }
    switch (args[0][1]) {
    case 'i':
	settags(level, args + 1);
	lasttaglevel = level;
	break;
    case 'C':
	setsparam(args[1], ztrdup(comptags[level]->context));
	break;
    case 'T':
	return !comptags[level]->sets;
    case 'N':
	{
	    Ctset s;

	    if (comptags[level]->init)
		comptags[level]->init = 0;
	    else if ((s = comptags[level]->sets)) {
		comptags[level]->sets = s->next;
		s->next = NULL;
		freectset(s);
	    }
	    return !comptags[level]->sets;
	}
    case 'R':
	{
	    Ctset s;

	    return !((s = comptags[level]->sets) &&
		     arrcontains(s->tags, args[1], 1));
	}
    case 'A':
	{
	    Ctset s;

	    if (comptags[level] && (s = comptags[level]->sets)) {
		char **q, *v = NULL;
		int l = strlen(args[1]);

		if (!s->tag || strcmp(s->tag, args[1])) {
		    zsfree(s->tag);
		    s->tag = ztrdup(args[1]);
		    s->ptr = s->tags;
		}
		for (q = s->ptr; *q; q++) {
		    if (strpfx(args[1], *q)) {
			if (!(*q)[l]) {
			    v = *q;
			    break;
			} else if ((*q)[l] == ':') {
			    v = (*q) + l + 1;
			    break;
			}
		    }
		}
		if (!v) {
		    zsfree(s->tag);
		    s->tag = NULL;
		    return 1;
		}
		s->ptr = q + 1;
		setsparam(args[2], ztrdup(*v == '-' ? dyncat(args[1], v) : v));
		if (args[3]) {
		    char *r = dupstring(*q), *p;

		    for (p = r + (v - *q); *p && *p != ':'; p++);
		    *p = '\0';

		    setsparam(args[3], ztrdup(r));
		}
		return 0;
	    }
	    return 1;
	}
    case 'S':
	if (comptags[level]->sets) {
	    char **ret;

	    ret = zarrdup(comptags[level]->sets->tags);
	    setaparam(args[1], ret);
	} else
	    return 1;

	break;
    }
    return 0;
}

static int
bin_comptry(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (!lasttaglevel || !comptags[lasttaglevel]) {
	zwarnnam(nam, "no tags registered");
	return 1;
    }
    if (*args) {
	if (!strcmp(*args, "-m")) {
	    char *s, *p, *q, *c, **all = comptags[lasttaglevel]->all;
	    LinkList list = newlinklist();
	    int num = 0;
	    Ctset set;

	    while ((s = *++args)) {
		while (*s) {
		    while (*s && iblank(*s))
			s++;
		    for (p = q = s, c = NULL; *s && !inblank(*s); s++) {
			if (!c && *s == ':')
			    c = p;
			if (*s == '\\' && s[1])
			    s++;
			*p++ = *s;
		    }
		    if (*s)
			s++;
		    *p = '\0';
		    if (*q) {
			char *qq, *qqq;

			if (c)
			    *c = '\0';

			qqq = qq = dupstring(q);
			while (*qqq) {
			    if (*qqq == '\\' && qqq[1])
				qqq++;
			    else if (*qqq == '{')
				*qqq = Inbrace;
			    else if (*qqq == '}')
				*qqq = Outbrace;
			    else if (*qqq == ',')
				*qqq = Comma;
			    qqq++;
			}
			tokenize(qq);
			if (haswilds(qq) || hasbraces(qq)) {
			    Patprog prog;
			    LinkNode bnode, node;
			    LinkList blist = newlinklist();

			    addlinknode(blist, qq);
			    for (bnode = firstnode(blist); bnode; incnode(bnode))
				while (hasbraces(getdata(bnode)))
				    xpandbraces(blist, &bnode);

			    for (bnode = firstnode(blist); bnode; incnode(bnode)) {
				qq = (char *) getdata(bnode);
				if ((prog = patcompile(qq, PAT_STATIC, NULL))) {
				    char **a, *n;
				    int l = (c ? strlen(c + 1) + 2 : 1), al;

				    for (a = all; *a; a++) {
					for (node = firstnode(list); node;
					     incnode(node)) {
					    char *as, *ls;

					    for (as = *a, ls = (char *) getdata(node);
						 *as && *ls && *ls != ':'; as++, ls++)
						if (*as != *ls)
						    break;
					    if (!*as && (!*ls || *ls == ':'))
						break;
					}
					if (node)
					    continue;
					if (pattry(prog, *a)) {
					    n = (char *) zhalloc((al = strlen(*a)) + l);
					    strcpy(n, *a);
					    if (c) {
						n[al] = ':';
						strcpy(n + al + 1, c + 1);
					    }
					    addlinknode(list, n);
					    num++;
					}
				    }
				}
			    }
			} else if (arrcontains(all, q, 0)) {
			    for (set = comptags[lasttaglevel]->sets; set;
				 set = set->next)
				if (arrcontains(set->tags, q, 0))
				    break;
			    if (!set) {
				addlinknode(list, q);
				num++;
			    }
			}
			if (c)
			    *c = ':';
		    }
		}
		if (num) {
		    Ctset l;

		    set = (Ctset) zalloc(sizeof(*set));

		    set->tags = zlinklist2array(list);
		    set->next = NULL;
		    set->ptr = NULL;
		    set->tag = NULL;

		    if ((l = comptags[lasttaglevel]->sets)) {
			while (l->next)
			    l = l->next;

			l->next = set;
		    } else
			comptags[lasttaglevel]->sets = set;
		}
	    }
	} else {
	    char **p, **q, **all;
	    int sep = 0;

	    if ((sep = !strcmp(*args, "-s")))
		args++;

	    for (p = q = args, all = comptags[lasttaglevel]->all; *p; p++)
		if (arrcontains(all, *p, 1)) {
		    Ctset s;

		    for (s = comptags[lasttaglevel]->sets; s; s = s->next)
			if (arrcontains(s->tags, *p, 0))
			    break;

		    if (!s)
			*q++ = *p;
		}
	    *q = NULL;

	    if (*args) {
		char *dummy[2];

		do {
		    Ctset s = (Ctset) zalloc(sizeof(*s)), l;

		    if (sep) {
			dummy[0] = *args++;
			dummy[1] = NULL;
			s->tags = zarrdup(dummy);
		    } else
			s->tags = zarrdup(args);
		    s->next = NULL;
		    s->ptr = NULL;
		    s->tag = NULL;

		    if ((l = comptags[lasttaglevel]->sets)) {
			while (l->next)
			    l = l->next;

			l->next = s;
		    } else
			comptags[lasttaglevel]->sets = s;
		} while (sep && *args);
	    }
	}
    }
    return 0;
}

#define PATH_MAX2 (PATH_MAX * 2)

/*
 * Return a list of files we should accept exactly, without
 * trying pattern matching.
 *
 * This is based on the accept-exact style, which may be
 * an array so is passed in via "accept".  The trial files
 * are input in "names".  "skipped" is passed down straight
 * from the file completion function:  it's got something to
 * do with other components in the path but it's hard to work out
 * quite what.
 *
 * There is one extra trick here for Cygwin.  Regardless of the style,
 * if the file ends in a colon it has to be a drive or a special device
 * file and we always accept it exactly because treating it as a pattern
 * won't work.
 */
static LinkList
cfp_test_exact(LinkList names, char **accept, char *skipped)
{
    char buf[PATH_MAX2 + 1], *suf, *p;
    int l, sl, found = 0;
    struct stat st;
    LinkNode node;
    LinkList ret = newlinklist(), alist = NULL;
#ifdef __CYGWIN__
    int accept_off = 0;
#endif

    /*
     * Don't do this unless completion has provided either a
     * prefix or suffix from the command line.
     */
    if (!(compprefix && *compprefix) && !(compsuffix && *compsuffix))
	return NULL;

    /*
     * See if accept-exact is off, implicitly or explicitly.
     */
    if (!accept || !*accept ||
	((!strcmp(*accept, "false") || !strcmp(*accept, "no") ||
	  !strcmp(*accept, "off") || !strcmp(*accept, "0")) && !accept[1])) {
#ifdef __CYGWIN__
	accept_off = 1;
#else
	/* If not Cygwin, nothing to do here. */
	return NULL;
#endif
    }

    /*
     * See if the style is something other than just a boolean.
     */
    if (
#ifdef __CYGWIN__
	!accept_off &&
#endif
	(accept[1] ||
	 (strcmp(*accept, "true") && strcmp(*accept, "yes") &&
	  strcmp(*accept, "on") && strcmp(*accept, "1")))) {
	Patprog prog;

	alist = newlinklist();

	for (; (p = *accept); accept++) {
	    if (*p == '*' && !p[1]) {
		alist = NULL;
		break;
	    }
	    tokenize(p = dupstring(p));
	    if ((prog = patcompile(p, 0, NULL)))
		addlinknode(alist, prog);
	}
    }
    /*
     * Assemble the bits other than the set of file names:
     * the other components, and the prefix and suffix.
     */
    sl = strlen(skipped) + (compprefix ? strlen(compprefix) : 0) +
	(compsuffix ? strlen(compsuffix) : 0);

    if (sl > PATH_MAX2)
	return NULL;

    suf = dyncat(skipped, rembslash(dyncat(compprefix, compsuffix)));

    for (node = firstnode(names); node; incnode(node)) {
	l = strlen(p = (char *) getdata(node));
	if (l + sl < PATH_MAX2) {
#ifdef __CYGWIN__
	    char *testbuf;
#define TESTBUF testbuf
#else
#define TESTBUF buf
#endif
	    strcpy(buf, p);
	    strcpy(buf + l, suf);
#ifdef __CYGWIN__
	    if (accept_off) {
		int sl = strlen(buf);
		/*
		 * If accept-exact is not set, accept this only if
		 * it looks like a special file such as a drive.
		 * We still test if it exists.
		 */
		if (!sl || strchr(buf, '/') || buf[sl-1] != ':')
		    continue;
		if (sl == 2) {
		    /*
		     * Recent versions of Cygwin only recognise "c:/",
		     * but not "c:", as special directories.  So
		     * we have to append the slash for the purpose of
		     * the test.
		     */
		    testbuf = zhalloc(sl + 2);
		    strcpy(testbuf, buf);
		    testbuf[sl] = '/';
		    testbuf[sl+1] = '\0';
		} else {
		    /* Don't do this with stuff like PRN: */
		    testbuf = buf;
		}
	    } else {
		testbuf = buf;
	    }
#endif
	    if (!ztat(TESTBUF, &st, 0)) {
		/*
		 * File exists; if accept-exact contained non-boolean
		 * values it must match those, too.
		 */
		if (alist) {
		    LinkNode anode;

		    for (anode = firstnode(alist); anode; incnode(anode))
			if (pattry((Patprog) getdata(anode), buf))
			    break;

		    if (!anode)
			continue;
		}
		found = 1;
		addlinknode(ret, dupstring(buf));
	    }
	}
    }
    return (found ? ret : NULL);
}


/*
 * This code constructs (from heap) and returns a string that
 * corresponds to a series of matches; when compiled as a pattern, at
 * each position it matches either the character from the string "add"
 * or the corresponding single-character match from the set of matchers.
 * To take a simple case, if add is "a" and the single matcher for the
 * character position matches "[0-9]", the pattern returned is "[0-9a]".
 * We take account of equivalences between the word and line, too.
 *
 * As there are virtually no comments in this file, I don't really
 * know why we're doing this, but it's to do with a matcher which
 * is passed as an argument to the utility compfiles -p/-P.
 */
static char *
cfp_matcher_range(Cmatcher *ms, char *add)
{
    Cmatcher *mp, m;
    int len = 0, mt;
    char *ret = NULL, *p = NULL, *adds = add;

    /*
     * Do this twice:  once to work out the length of the
     * string in len, the second time to build it in ret.
     * This is probably worthwhile because otherwise memory
     * management is difficult.
     */
    for (;;) {
	MB_METACHARINIT();
	for (mp = ms; *add; ) {
	    convchar_t addc;
	    int addlen;

	    addlen = MB_METACHARLENCONV(add, &addc);
#ifdef MULTIBYTE_SUPPORT
	    if (addc == WEOF)
		addc = (wchar_t)(*p == Meta ? p[1] ^ 32 : *p);
#endif

	    if (!(m = *mp)) {
		/*
		 * No matcher, so just match the character
		 * itself.
		 *
		 * TODO: surely this needs quoting if it's a
		 * metacharacter?
		 */
		if (ret) {
		    memcpy(p, add, addlen);
		    p += addlen;
		} else
		    len += addlen;
	    } else if (m->flags & CMF_RIGHT) {
		/*
		 * Right-anchored:  match anything followed
		 * by the character itself.
		 */
		if (ret) {
		    *p++ = '*';
		    /* TODO: quote again? */
		    memcpy(p, add, addlen);
		    p += addlen;
		} else
		    len += addlen + 1;
	    } else {
		/* The usual set of matcher possibilities. */
		convchar_t ind;
		if (m->line->tp == CPAT_EQUIV &&
		    m->word->tp == CPAT_EQUIV) {
		    /*
		     * Genuine equivalence.  Add the character to match
		     * and the equivalent character from the word
		     * pattern.
		     *
		     * TODO: we could be more careful here with special
		     * cases as we are in the basic character class
		     * code below.
		     */
		    if (ret) {
			*p++ = '[';
			memcpy(p, add, addlen);
			p += addlen;
		    } else
			len += addlen + 1;
		    if (PATMATCHRANGE(m->line->u.str, addc, &ind, &mt)) {
			/*
			 * Find the equivalent match for ind in the
			 * word pattern.
			 */
			if ((ind = pattern_match_equivalence
			     (m->word, ind, mt, addc)) != CHR_INVALID) {
			    if (ret) {
				if (imeta(ind)) {
				    *p++ = Meta;
				    *p++ = ind ^ 32;
				} else
				    *p++ = ind;
			    } else
				len += imeta(ind) ? 2 : 1;
			}
		    }
		    if (ret)
			*p++ = ']';
		    else
			len++;
		} else {
		    int newlen, addadd;

		    switch (m->word->tp) {
		    case CPAT_NCLASS:
			/*
			 * TODO: the old logic implies that we need to
			 * match *add, i.e. it should be deleted from
			 * the set of character's we're not allowed to
			 * match.  That's too much like hard work for
			 * now.  Indeed, in general it's impossible
			 * without trickery.  Consider *add == 'A',
			 * range == "[^[:upper:]]": we would have to
			 * resort to something like "(A|[^[:upper:]])";
			 * and in an expression like that *add may or
			 * may not need backslashing.  So we're deep
			 * into see-if-we-can-get-away-without
			 * territory.
			 */
			if (ret) {
			    *p++ = '[';
			    *p++ = '^';
			} else
			    len += 2;
			/*
			 * Convert the compiled range string back
			 * to an ordinary string.
			 */
			newlen =
			    pattern_range_to_string(m->word->u.str, p);
			DPUTS(!newlen, "empty character range");
			if (ret) {
			    p += newlen;
			    *p++ = ']';
			} else
			    len += newlen + 1;
			break;

		    case CPAT_CCLASS:
			/*
			 * If there is an equivalence only on one
			 * side it's not equivalent to anything.
			 * Treat it as an ordinary character class.
			 */
		    case CPAT_EQUIV:
		    case CPAT_CHAR:
			if (ret)
			    *p++ = '[';
			else
			    len++;
			/*
			 * We needed to add *add specially only if
			 * it is not covered by the range.  This
			 * is necessary for correct syntax---consider
			 * if *add is ] and ] is also the first
			 * character in the range.
			 */
			addadd = !pattern_match1(m->word, addc, &mt);
			if (addadd && *add == ']') {
			    if (ret)
				*p++ = *add;
			    else
				len++;
			}
			if (m->word->tp == CPAT_CHAR) {
			    /*
			     * The matcher just matches a single
			     * character, but we need to be able
			     * to match *add, too, hence we do
			     * this as a [...].
			     */
			    if (ret) {
				if (imeta(m->word->u.chr)) {
				    *p++ = Meta;
				    *p++ = m->word->u.chr ^ 32;
				} else
				    *p++ = m->word->u.chr;
			    } else
				len += imeta(m->word->u.chr) ? 2 : 1;
			} else {
			    /*
			     * Convert the compiled range string back
			     * to an ordinary string.
			     */
			    newlen =
				pattern_range_to_string(m->word->u.str, p);
			    DPUTS(!newlen, "empty character range");
			    if (ret)
				p += newlen;
			    else
				len += newlen;
			}
			if (addadd && *add != ']') {
			    if (ret) {
				memcpy(p, add, addlen);
				p += addlen;
			    } else
				len += addlen;
			}
			if (ret)
			    *p++ = ']';
			else
			    len++;
			break;

		    case CPAT_ANY:
			if (ret)
			    *p++ = '?';
			else
			    len++;
			break;
		    }
		}
	    }
	    add += addlen;
	    mp++;
	}
	if (ret) {
	    *p = '\0';
	    return ret;
	}
	p = ret = zhalloc(len + 1);
	add = adds;
    }
}


static char *
cfp_matcher_pats(char *matcher, char *add)
{
    Cmatcher m = parse_cmatcher(NULL, matcher);

    if (m && m != pcm_err) {
	char *tmp;
	int al = strlen(add), zl = ztrlen(add), tl, cl;
	VARARR(Cmatcher, ms, zl);
	Cmatcher *mp;
	Cpattern stopp;
	int stopl = 0;

	memset(ms, 0, zl * sizeof(Cmatcher));

	for (; m && *add; m = m->next) {
	    stopp = NULL;
	    if (!(m->flags & (CMF_LEFT|CMF_RIGHT))) {
		if (m->llen == 1 && m->wlen == 1) {
		    for (tmp = add, tl = al, mp = ms; tl; ) {
			if (pattern_match(m->line, tmp, NULL, NULL)) {
			    if (*mp) {
				*tmp = '\0';
				al = tmp - add;
				break;
			    } else
				*mp = m;
			}
			cl = (*tmp == Meta) ? 2 : 1;
			tl -= cl;
			tmp += cl;
			mp += cl;
		    }
		} else {
		    stopp = m->line;
		    stopl = m->llen;
		}
	    } else if (m->flags & CMF_RIGHT) {
		if (m->wlen < 0 && !m->llen && m->ralen == 1) {
		    for (tmp = add, tl = al, mp = ms; tl; ) {
			if (pattern_match(m->right, tmp, NULL, NULL)) {
			    if (*mp || (tmp == add && *tmp == '.')) {
				*tmp = '\0';
				al = tmp - add;
				break;
			    } else
				*mp = m;
			}
			cl = (*tmp == Meta) ? 2 : 1;
			tl -= cl;
			tmp += cl;
			mp += cl;
		    }
		} else if (m->llen) {
		    stopp = m->line;
		    stopl = m->llen;
		} else {
		    stopp = m->right;
		    stopl = m->ralen;
		}
	    } else {
		if (!m->lalen)
		    return "";

		stopp = m->left;
		stopl = m->lalen;
	    }
	    if (stopp)
		for (tmp = add, tl = al; tl >= stopl; ) {
		    if (pattern_match(stopp, tmp, NULL, NULL)) {
			*tmp = '\0';
			al = tmp - add;
			break;
		    }
		    cl = (*tmp == Meta) ? 2 : 1;
		    tl -= cl;
		    tmp += cl;
		}
	}
	if (*add)
	    return cfp_matcher_range(ms, add);
    }
    return add;
}

static void
cfp_opt_pats(char **pats, char *matcher)
{
    char *add, **p, *q, *t, *s;

    if (!compprefix || !*compprefix)
	return;

    if (comppatmatch && *comppatmatch) {
	tokenize(t = rembslash(dyncat(compprefix, compsuffix)));
	remnulargs(t);
	if (haswilds(t))
	    return;
    }
    add = (char *) zhalloc(strlen(compprefix) * 2 + 1);
    for (s = compprefix, t = add; *s; s++) {
	if (*s != '\\' || !s[1] || s[1] == '*' || s[1] == '?' ||
	    s[1] == '<' || s[1] == '>' || s[1] == '(' || s[1] == ')' ||
	    s[1] == '[' || s[1] == ']' || s[1] == '|' || s[1] == '#' ||
	    s[1] == '^' || s[1] == '~' || s[1] == '=') {
	    if ((s == compprefix || s[-1] != '\\') &&
		(*s == '*' || *s == '?' || *s == '<' || *s == '>' ||
		 *s == '(' || *s == ')' || *s == '[' || *s == ']' ||
		 *s == '|' || *s == '#' || *s == '^' || *s == '~' ||
		 *s == '='))
		*t++ = '\\';
	    *t++ = *s;
	}
    }
    *t = '\0';
    for (p = pats; *add && (q = *p); p++) {
	if (*q) {
	    q = dupstring(q);
	    t = q + strlen(q) - 1;
	    if (*t == ')') {
		for (s = t--; t > q; t--)
		    if (*t == ')' || *t == '|' || *t == '~' || *t == '(')
			break;
		if (t != q && *t == '(')
		    *t = '\0';
	    }
	    for (; *q && *add; q++) {
		if (*q == '\\' && q[1]) {
		    for (s = add, q++; *s && *s != *q; s++);
		    *s = '\0';
		} else if (*q == '<') {
		    for (s = add; *s && !idigit(*s); s++);
		    *s = '\0';
		} else if (*q == '[') {
		    int not;
		    char *x = ++q;

		    if ((not = (*x == '!' || *x == '^')))
			x++;
		    for (; *x; x++) {
			if (x[1] == '-' && x[2]) {
			    char c1 = *x, c2 = x[2];

			    for (s = add; *s && (*x < c1 || *x > c2); s++);
			    *s = '\0';
			} else {
			    for (s = add; *s && *s != *x; s++);
			    *s = '\0';
			}
		    }
		} else if (*q != '?' && *q != '*' && *q != '(' && *q != ')' &&
			   *q != '|' && *q != '~' && *q != '#') {
		    for (s = add; *s && *s != *q; s++);
		    *s = '\0';
		}
	    }
	}
    }
    if (*add) {
	if (*matcher && !(add = cfp_matcher_pats(matcher, add)))
	    return;

	for (p = pats; *p; p++)
	    if (**p == '*')
		*p = dyncat(add, *p);
    }
}

static LinkList
cfp_bld_pats(UNUSED(int dirs), LinkList names, char *skipped, char **pats)
{
    LinkList ret = newlinklist();
    LinkNode node;
    int ol, sl = strlen(skipped), pl, dot;
    char **p, *o, *str;

    dot = (unset(GLOBDOTS) && compprefix && *compprefix == '.');
    for (node = firstnode(names); node; incnode(node)) {
	ol = strlen(o = (char *) getdata(node));
	for (p = pats; *p; p++) {
	    pl = strlen(*p);
	    str = (char *) zhalloc(ol + sl + pl + 1);
	    strcpy(str, o);
	    strcpy(str + ol, skipped);
	    strcpy(str + ol + sl, *p);
	    addlinknode(ret, str);
	    if (dot && **p != '.') {
		str = (char *) zhalloc(ol + sl + pl + 2);
		strcpy(str, o);
		strcpy(str + ol, skipped);
		str[ol + sl] = '.';
		strcpy(str + ol + sl + 1, *p);
		addlinknode(ret, str);
	    }
	}
    }
    return ret;
}

static LinkList
cfp_add_sdirs(LinkList final, LinkList orig, char *skipped,
	      char *sdirs, char **fake)
{
    int add = 0;

    if (*sdirs && (isset(GLOBDOTS) || (compprefix && *compprefix == '.'))) {
	if (!strcmp(sdirs, "yes") || !strcmp(sdirs, "true") ||
	    !strcmp(sdirs, "on") || !strcmp(sdirs, "1"))
	    add = 2;
	else if (!strcmp(sdirs, ".."))
	    add = 1;
    }
    if (add) {
	LinkNode node;
	char *s1 = dyncat(skipped, "..");
	char *s2 = (add == 2 ? dyncat(skipped, ".") : NULL), *m;

	for (node = firstnode(orig); node; incnode(node)) {
	    if ((m = (char *) getdata(node))) {
		addlinknode(final, dyncat(m, s1));
		if (s2)
		    addlinknode(final, dyncat(m, s2));
	    }
	}
    }
    if (fake && *fake) {
	LinkNode node;
	char *m, *f, *p, *t, *a, c;
	int sl = strlen(skipped) + 1;
	struct stat st1, st2;
	Patprog pprog;

	for (; (f = *fake); fake++) {
	    f = dupstring(f);
	    for (p = t = f; *p; p++) {
		if (*p == ':')
		    break;
		else if (*p == '\\' && p[1] == ':') {
		    /*
		     * strip quoted colons here; rely
		     * on tokenization to strip other backslashes
		     */
		    p++;
		}
		*t++ = *p;
	    }
	    if (*p) {
		*t = *p++ = '\0';
		if (!*p)
		    continue;

		tokenize(f);
		pprog = patcompile(f, PAT_STATIC, NULL);
		untokenize(f);
		for (node = firstnode(orig); node; incnode(node)) {
		    if ((m = (char *) getdata(node)) &&
			((pprog ? pattry(pprog, m) : !strcmp(f, m)) ||
			 (!stat(f, &st1) && !stat((*m ? m : "."), &st2) &&
			  st1.st_dev == st2.st_dev &&
			  st1.st_ino == st2.st_ino))) {
			while (*p) {
			    while (*p && inblank(*p))
				p++;
			    if (!*p)
				break;
			    for (f = t = p; *p; p++) {
				if (inblank(*p))
				    break;
				else if (*p == '\\' && p[1])
				    p++;
				*t++ = *p;
			    }
			    c = *t;
			    *t = '\0';
			    a = (char *) zhalloc(strlen(m) + sl + strlen(f));
			    strcpy(a, m);
			    strcat(a, skipped);
			    strcat(a, f);
			    addlinknode(final, a);
			    *t = c;
			}
		    }
		}
	    }
	}
    }
    return final;
}

static LinkList
cf_pats(int dirs, int noopt, LinkList names, char **accept, char *skipped,
	char *matcher, char *sdirs, char **fake, char **pats)
{
    LinkList ret;
    char *dpats[2];

    if ((ret = cfp_test_exact(names, accept, skipped)))
	return cfp_add_sdirs(ret, names, skipped, sdirs, fake);

    if (dirs) {
	dpats[0] = "*(-/)";
	dpats[1] = NULL;
	pats = dpats;
    }
    if (!noopt)
	cfp_opt_pats(pats, matcher);

    return cfp_add_sdirs(cfp_bld_pats(dirs, names, skipped, pats),
			 names, skipped, sdirs, fake);
}

/*
 * This function looks at device/inode pairs to determine if
 * a file is one we should ignore because of its relationship
 * to the current or parent directory.
 *
 * We don't follow symbolic links here, because typically
 * a user will not want an explicit link to the current or parent
 * directory ignored.
 */
static void
cf_ignore(char **names, LinkList ign, char *style, char *path)
{
    int pl = strlen(path), tpar, tpwd, found;
    struct stat nst, est, st;
    char *n, *c, *e;

    tpar = !!strstr(style, "parent");
    if ((tpwd = !!strstr(style, "pwd")) && lstat(pwd, &est))
	tpwd = 0;

    if (!tpar && !tpwd)
	return;

    for (; (n = *names); names++) {
	if (!ztat(n, &nst, 1) && S_ISDIR(nst.st_mode)) {
	    if (tpwd && nst.st_dev == est.st_dev && nst.st_ino == est.st_ino) {
		addlinknode(ign, quotestring(n, NULL, QT_BACKSLASH));
		continue;
	    }
	    if (tpar && !strncmp((c = dupstring(n)), path, pl)) {
		found = 0;
		while ((e = strrchr(c, '/')) && e > c + pl) {
		    *e = '\0';
		    if (!ztat(c, &st, 0) &&
			st.st_dev == nst.st_dev && st.st_ino == nst.st_ino) {
			found = 1;
			break;
		    }
		}
		if (found || ((e = strrchr(c, '/')) && e > c + pl &&
			      !ztat(c, &st, 1) && st.st_dev == nst.st_dev &&
			      st.st_ino == nst.st_ino))
		    addlinknode(ign, quotestring(n, NULL, QT_BACKSLASH));
	    }
	}
    }
}

static LinkList
cf_remove_other(char **names, char *pre, int *amb)
{
    char *p;

    if ((p = strchr(pre, '/'))) {
	char **n;

	*p = '\0';
	pre = dyncat(pre, "/");
	*p = '/';

	for (n = names; *n; n++)
	    if (strpfx(pre, *n))
		break;

	if (*n) {
	    LinkList ret = newlinklist();

	    for (; *names; names++)
		if (strpfx(pre, *names))
		    addlinknode(ret, dupstring(*names));

	    *amb = 0;

	    return ret;
	} else {
	    if (!(p = *names++))
		*amb = 0;
	    else {
		char *q;

		if ((q = strchr((p = dupstring(p)), '/')))
		    *q = '\0';

                p = dyncat(p, "/");

		for (; *names; names++)
		    if (!strpfx(p, *names)) {
			*amb = 1;
			return NULL;
		    }
	    }
	}
    } else {
	if (!(p = *names++))
	    *amb = 0;
	else
	    for (; *names; names++)
		if (strcmp(p, *names)) {
		    *amb = 1;
		    return NULL;
		}
    }
    return NULL;
}

static int
bin_compfiles(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    if (**args != '-') {
	zwarnnam(nam, "missing option: %s", *args);
	return 1;
    }
    switch (args[0][1]) {
    case 'p':
    case 'P':
	if (args[0][2] && (args[0][2] != '-' || args[0][3])) {
	    zwarnnam(nam, "invalid option: %s", *args);
	    return 1;
	} else {
	    char **tmp;
	    LinkList l;

	    if (!args[1] || !args[2] || !args[3] || !args[4] || !args[5] ||
		!args[6] || (args[0][1] == 'p' && !args[7])) {
		zwarnnam(nam, "too few arguments");
		return 1;
	    }
	    queue_signals();
	    if (!(tmp = getaparam(args[1]))) {
		zwarnnam(nam, "unknown parameter: %s", args[1]);
		return 0;
	    }
	    for (l = newlinklist(); *tmp; tmp++)
		addlinknode(l, *tmp);
	    set_list_array(args[1], cf_pats((args[0][1] == 'P'), !!args[0][2],
					    l, getaparam(args[2]), args[3],
					    args[4], args[5],
					    getaparam(args[6]), args + 7));
	    unqueue_signals();
	    return 0;
	}
    case 'i':
	if (args[0][2]) {
	    zwarnnam(nam, "invalid option: %s", *args);
	    return 1;
	} else {
	    char **tmp;
	    LinkList l;

	    if (!args[1] || !args[2] || !args[3] || !args[4]) {
		zwarnnam(nam, "too few arguments");
		return 1;
	    }
	    if (args[5]) {
		zwarnnam(nam, "too many arguments");
		return 1;
	    }
	    queue_signals();
	    tmp = getaparam(args[2]);
	    l = newlinklist();
	    if (tmp)
		for (; *tmp; tmp++)
		    addlinknode(l, *tmp);
	    if (!(tmp = getaparam(args[1]))) {
		unqueue_signals();
		zwarnnam(nam, "unknown parameter: %s", args[1]);
		return 0;
	    }
	    cf_ignore(tmp, l, args[3], args[4]);
	    unqueue_signals();
	    set_list_array(args[2], l);
	    return 0;
	}
    case 'r':
	{
	    char **tmp;
	    LinkList l;
	    int ret = 0;

	    if (!args[1] || !args[2]) {
		zwarnnam(nam, "too few arguments");
		return 1;
	    }
	    if (args[3]) {
		zwarnnam(nam, "too many arguments");
		return 1;
	    }
	    queue_signals();
	    if (!(tmp = getaparam(args[1]))) {
		unqueue_signals();
		zwarnnam(nam, "unknown parameter: %s", args[1]);
		return 0;
	    }
	    if ((l = cf_remove_other(tmp, args[2], &ret)))
		set_list_array(args[1], l);
	    unqueue_signals();
	    return ret;
	}
    }
    zwarnnam(nam, "invalid option: %s", *args);
    return 1;
}

static int
bin_compgroups(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
    Heap oldheap;
    char *n;

    if (incompfunc != 1) {
	zwarnnam(nam, "can only be called from completion function");
	return 1;
    }
    SWITCHHEAPS(oldheap, compheap) {
	while ((n = *args++)) {
	    endcmgroup(NULL);
	    begcmgroup(n, CGF_NOSORT|CGF_UNIQCON);
	    endcmgroup(NULL);
	    begcmgroup(n, CGF_UNIQALL);
	    endcmgroup(NULL);
	    begcmgroup(n, CGF_NOSORT|CGF_UNIQCON);
	    endcmgroup(NULL);
	    begcmgroup(n, CGF_UNIQALL);
	    endcmgroup(NULL);
	    begcmgroup(n, CGF_NOSORT);
	    endcmgroup(NULL);
	    begcmgroup(n, 0);
	}
    } SWITCHBACKHEAPS(oldheap);

    return 0;
}

static struct builtin bintab[] = {
    BUILTIN("comparguments", 0, bin_comparguments, 1, -1, 0, NULL, NULL),
    BUILTIN("compdescribe", 0, bin_compdescribe, 3, -1, 0, NULL, NULL),
    BUILTIN("compfiles", 0, bin_compfiles, 1, -1, 0, NULL, NULL),
    BUILTIN("compgroups", 0, bin_compgroups, 1, -1, 0, NULL, NULL),
    BUILTIN("compquote", 0, bin_compquote, 1, -1, 0, "p", NULL),
    BUILTIN("comptags", 0, bin_comptags, 1, -1, 0, NULL, NULL),
    BUILTIN("comptry", 0, bin_comptry, 0, -1, 0, NULL, NULL),
    BUILTIN("compvalues", 0, bin_compvalues, 1, -1, 0, NULL, NULL)
};

static struct features module_features = {
    bintab, sizeof(bintab)/sizeof(*bintab),
    NULL, 0,
    NULL, 0,
    NULL, 0,
    0
};


/**/
int
setup_(UNUSED(Module m))
{
    memset(cadef_cache, 0, sizeof(cadef_cache));
    memset(cvdef_cache, 0, sizeof(cvdef_cache));

    memset(comptags, 0, sizeof(comptags));

    lasttaglevel = 0;

    return 0;
}

/**/
int
features_(Module m, char ***features)
{
    *features = featuresarray(m, &module_features);
    return 0;
}

/**/
int
enables_(Module m, int **enables)
{
    return handlefeatures(m, &module_features, enables);
}

/**/
int
boot_(Module m)
{
    return 0;
}

/**/
int
cleanup_(Module m)
{
    return setfeatureenables(m, &module_features, NULL);
}

/**/
int
finish_(UNUSED(Module m))
{
    int i;

    for (i = 0; i < MAX_CACACHE; i++)
	freecadef(cadef_cache[i]);
    for (i = 0; i < MAX_CVCACHE; i++)
	freecvdef(cvdef_cache[i]);

    for (i = 0; i < MAX_TAGS; i++)
	freectags(comptags[i]);

    return 0;
}