manual/8478

13 files changed, 6858 insertions, 6310 deletions

diff --git a/Src/Zle/comp.h b/Src/Zle/comp.h
index 68575cff4..6097f256c 100644
--- a/Src/Zle/comp.h
+++ b/Src/Zle/comp.h
@@ -238,7 +238,6 @@ struct cadata {
     char *pre;			/* prefix to insert (-P) */
     char *suf;			/* suffix to insert (-S) */
     char *group;		/* name of the group (-[JV]) */
-    char *ylist;		/* display list (-y) */
     char *rems;			/* remove suffix on chars... (-r) */
     char *remf;			/* function to remove suffix (-R) */
     char *ign;			/* ignored suffixes (-F) */
@@ -270,28 +269,10 @@ struct cldata {
 typedef void (*CLPrintFunc)(Cmgroup, Cmatch *, int, int, int, int,
 			    char *, struct stat *);
 
-/* Information about one brace run. */
+/* Flags for fromcomp. */
 
-typedef struct brinfo *Brinfo;
-
-struct brinfo {
-    Brinfo next;		/* next in list */
-    Brinfo prev;		/* previous (only for closing braces) */
-    char *str;			/* the string to insert */
-    int pos;			/* original position */
-    int qpos;			/* original position, with quoting */
-    int curpos;			/* position for current match */
-};
-
-/* Data given to hooks. */
-
-typedef struct chdata *Chdata;
-
-struct chdata {
-    Cmgroup matches;		/* the matches generated */
-    int num;			/* the number of matches */
-    Cmatch cur;			/* current match or NULL */
-};
+#define FC_LINE   1
+#define FC_INWORD 2
 
 /* Flags for special parameters. */
 
@@ -376,12 +357,30 @@ struct chdata {
 #define CP_KEYPARAMS   27
 #define CP_ALLKEYS     ((unsigned int) 0x7ffffff)
 
-/* Types of completion. */
+/* Hooks. */
+
+#define INSERTMATCHHOOK     (comphooks + 0)
+#define MENUSTARTHOOK       (comphooks + 1)
+#define COMPCTLMAKEHOOK     (comphooks + 2)
+#define COMPCTLBEFOREHOOK   (comphooks + 3)
+#define COMPCTLAFTERHOOK    (comphooks + 4)
+#define COMPLISTMATCHESHOOK (comphooks + 5)
+
+/* compctl hook data struct */
+
+struct ccmakedat {
+    char *str;
+    int incmd;
+    int lst;
+};
+
+/* Data given to offered hooks. */
+
+typedef struct chdata *Chdata;
+
+struct chdata {
+    Cmgroup matches;		/* the matches generated */
+    int num;			/* the number of matches */
+    Cmatch cur;			/* current match or NULL */
+};
 
-#define COMP_COMPLETE        0
-#define COMP_LIST_COMPLETE   1
-#define COMP_SPELL           2
-#define COMP_EXPAND          3
-#define COMP_EXPAND_COMPLETE 4
-#define COMP_LIST_EXPAND     5
-#define COMP_ISEXPAND(X) ((X) >= COMP_EXPAND)
diff --git a/Src/Zle/compcore.c b/Src/Zle/compcore.c
new file mode 100644
index 000000000..ea9ff5b20
--- /dev/null
+++ b/Src/Zle/compcore.c
@@ -0,0 +1,2530 @@
+/*
+ * compcore.c - the complete module, completion core code
+ *
+ * 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 "complete.mdh"
+#define GLOBAL_PROTOTYPES
+#include "zle_tricky.pro"
+#undef GLOBAL_PROTOTYPES
+#include "compcore.pro"
+
+/* The last completion widget called. */
+
+static Widget lastcompwidget;
+
+/* Flags saying what we have to do with the result. */
+
+/**/
+int useexact, useline, uselist;
+
+/* Non-zero if we should keep an old list. */
+
+/**/
+int oldlist, oldins;
+
+/* This is used to decide when the cursor should be moved to the end of    *
+ * the inserted word: 0 - never, 1 - only when a single match is inserted, *
+ * 2 - when a full match is inserted (single or menu), 3 - always.         */
+
+/**/
+int movetoend;
+
+/* The match and group number to insert when starting menucompletion.   */
+
+/**/
+int insmnum, insgnum, insgroup, insspace;
+
+/* Information about menucompletion. */
+
+/**/
+struct menuinfo minfo;
+
+/* Number of matches accepted with accept-and-menu-complete */
+
+/**/
+int menuacc;
+
+/* Brace insertion stuff. */
+
+/**/
+int hasunqu, useqbr, brpcs, brscs;
+
+/* Flags saying in what kind of string we are. */
+
+/**/
+int ispar, linwhat;
+
+/* A parameter expansion prefix (like ${). */
+
+/**/
+char *parpre;
+
+/* Flags for parameter expansions for new style completion. */
+
+/**/
+int parflags;
+
+/* Match flags for all matches in this group. */
+
+/**/
+int mflags;
+
+/* Flags saying how the parameter expression we are in is quoted. */
+
+/**/
+int parq, eparq;
+
+/* We store the following prefixes/suffixes:                               *
+ * ipre,ripre  -- the ignored prefix (quoted and unquoted)                 *
+ * isuf        -- the ignored suffix                                       *
+ * autoq       -- quotes to automatically insert                           */
+
+/**/
+char *ipre, *ripre, *isuf;
+
+/* The list of matches.  fmatches contains the matches we first ignore *
+ * because of fignore.                                                 */
+
+/**/
+LinkList matches, fmatches;
+
+/* This holds the list of matches-groups. lastmatches holds the last list of 
+ * permanently allocated matches, pmatches is the same for the list
+ * currently built, amatches is the heap allocated stuff during completion
+ * (after all matches have been generated it is an alias for pmatches), and
+ * lmatches/lastlmatches is a pointer to the last element in the lists. */
+
+/**/
+Cmgroup lastmatches, pmatches, amatches, lmatches, lastlmatches;
+
+/* Non-zero if we have permanently allocated matches (old and new). */
+
+/**/
+int hasoldlist, hasperm;
+
+/* Non-zero if we have newly added matches. */
+
+/**/
+int newmatches;
+
+/* Number of permanently allocated matches and groups. */
+
+/**/
+int permmnum, permgnum, lastpermmnum, lastpermgnum;
+
+/* The total number of matches and the number of matches to be listed. */
+
+/**/
+int nmatches, smatches;
+
+/* != 0 if only explanation strings should be printed */
+
+/**/
+int onlyexpl;
+
+/* Information about the matches for listing. */
+
+/**/
+struct cldata listdat;
+
+/* This flag is non-zero if we are completing a pattern (with globcomplete) */
+
+/**/
+int ispattern, haspattern;
+
+/* Non-zero if at least one match was added without -U. */
+
+/**/
+int hasmatched;
+
+/* The current group of matches. */
+
+/**/
+Cmgroup mgroup;
+
+/* Match counter: all matches. */
+
+/**/
+int mnum;
+
+/* The match counter when unambig_data() was called. */
+
+/**/
+int unambig_mnum;
+
+/* Length of longest/shortest match. */
+
+/**/
+int maxmlen, minmlen;
+
+/* This holds the explanation strings we have to print in this group and *
+ * a pointer to the current cexpl structure. */
+
+/**/
+LinkList expls;
+
+/**/
+Cexpl curexpl;
+
+/* A stack of completion matchers to be used. */
+
+/**/
+Cmlist mstack;
+
+/* The completion matchers used when building new stuff for the line. */
+
+/**/
+Cmlist bmatchers;
+
+/* A list with references to all matchers we used. */
+
+/**/
+LinkList matchers;
+
+/* A heap of free Cline structures. */
+
+/**/
+Cline freecl;
+
+/* Ambiguous information. */
+
+/**/
+Aminfo ainfo, fainfo;
+
+/* The memory heap to use for new style completion generation. */
+
+/**/
+Heap compheap;
+
+/* A list of some data.
+ *
+ * Well, actually, it's the list of all compctls used so far, but since
+ * conceptually we don't know anything about compctls here... */
+
+/**/
+LinkList allccs;
+
+/* This says what of the state the line is in when completion is started *
+ * came from a previous completion. If the FC_LINE bit is set, the       *
+ * string was inserted. If FC_INWORD is set, the last completion moved   *
+ * the cursor into the word although it was at the end of it when the    *
+ * last completion was invoked.                                          *
+ * This is used to detect if the string should be taken as an exact      *
+ * match (see do_ambiguous()) and if the cursor has to be moved to the   *
+ * end of the word before generating the completions.                    */
+
+/**/
+int fromcomp;
+
+/* This holds the end-position of the last string inserted into the line. */
+
+/**/
+int lastend;
+
+/* Convenience macro for calling bslashquote() (formerly quotename()). */
+
+#define quotename(s, e) bslashquote(s, e, instring)
+
+#define inststr(X) inststrlen((X),1,-1)
+
+/* Main completion entry point, called from zle. */
+
+/**/
+int
+do_completion(Hookdef dummy, Compldat dat)
+{
+    int ret = 0, lst = dat->lst, incmd = dat->incmd;
+    char *s = dat->s;
+
+    HEAPALLOC {
+	char *opm;
+	LinkNode n;
+
+	pushheap();
+
+	ainfo = fainfo = NULL;
+	matchers = newlinklist();
+
+	hasunqu = 0;
+	useline = (lst != COMP_LIST_COMPLETE);
+	useexact = isset(RECEXACT);
+	uselist = (useline ?
+		   ((isset(AUTOLIST) && !isset(BASHAUTOLIST)) ? 
+		    (isset(LISTAMBIGUOUS) ? 3 : 2) : 0) : 1);
+	zsfree(comppatmatch);
+	opm = comppatmatch = ztrdup(useglob ? "*" : "");
+	zsfree(comppatinsert);
+	comppatinsert = ztrdup("menu");
+	zsfree(compforcelist);
+	compforcelist = ztrdup("");
+	haspattern = 0;
+	complistmax = getiparam("LISTMAX");
+	zsfree(complastprompt);
+	complastprompt = ztrdup(((isset(ALWAYSLASTPROMPT) && zmult == 1) ||
+				(unset(ALWAYSLASTPROMPT) && zmult != 1)) ?
+				"yes" : "");
+	movetoend = ((cs == we || isset(ALWAYSTOEND)) ? 2 : 1);
+	showinglist = 0;
+	hasmatched = 0;
+	minmlen = 1000000;
+	maxmlen = -1;
+
+	/* Make sure we have the completion list and compctl. */
+	if (makecomplist(s, incmd, lst)) {
+	    /* Error condition: feeeeeeeeeeeeep(). */
+	    cs = 0;
+	    foredel(ll);
+	    inststr(origline);
+	    cs = origcs;
+	    clearlist = 1;
+	    ret = 1;
+	    minfo.cur = NULL;
+	    goto compend;
+	}
+	zsfree(lastprebr);
+	zsfree(lastpostbr);
+	lastprebr = lastpostbr = NULL;
+
+	if (comppatmatch && *comppatmatch && comppatmatch != opm)
+	    haspattern = 1;
+	if (!useline && uselist) {
+	    /* All this and the guy only wants to see the list, sigh. */
+	    cs = 0;
+	    foredel(ll);
+	    inststr(origline);
+	    cs = origcs;
+	    showinglist = -2;
+	} else if (useline == 2 && nmatches > 1) {
+	    int first = 1, nm = nmatches;
+	    Cmatch *mc;
+
+	    menucmp = 1;
+	    menuacc = 0;
+
+	    for (minfo.group = amatches;
+		 minfo.group && !(minfo.group)->mcount;
+		 minfo.group = (minfo.group)->next);
+
+	    mc = (minfo.group)->matches;
+
+	    while (1) {
+		if (!first)
+		    acceptlast();
+		first = 0;
+
+		if (!--nm)
+		    menucmp = 0;
+
+		do_single(*mc);
+		minfo.cur = mc;
+
+		if (!*++(minfo.cur)) {
+		    do {
+			if (!(minfo.group = (minfo.group)->next))
+			    break;
+		    } while (!(minfo.group)->mcount);
+		    if (!minfo.group)
+			break;
+		    minfo.cur = minfo.group->matches;
+		}
+		mc = minfo.cur;
+	    }
+	    menucmp = 0;
+	    minfo.cur = NULL;
+
+	    if (compforcelist && *compforcelist && uselist)
+		showinglist = -2;
+	    else
+		invalidatelist();
+	} else if (useline) {
+	    /* We have matches. */
+	    if (nmatches > 1) {
+		/* There is more than one match. */
+		ret = do_ambiguous();
+	    } else if (nmatches == 1) {
+		/* Only one match. */
+		Cmgroup m = amatches;
+
+		while (!m->mcount)
+		    m = m->next;
+		minfo.cur = NULL;
+		minfo.asked = 0;
+		do_single(m->matches[0]);
+		if (compforcelist && *compforcelist) {
+		    if (uselist)
+			showinglist = -2;
+		    else
+			clearlist = 1;
+		} else
+		    invalidatelist();
+	    }
+	} else {
+	    invalidatelist();
+	    if (compforcelist && *compforcelist)
+		clearlist = 1;
+	    cs = 0;
+	    foredel(ll);
+	    inststr(origline);
+	    cs = origcs;
+	}
+	/* Print the explanation strings if needed. */
+	if (!showinglist && validlist && usemenu != 2 && nmatches != 1 &&
+	    useline != 2 && (!oldlist || !listshown)) {
+	    onlyexpl = 1;
+	    showinglist = -2;
+	}
+      compend:
+	for (n = firstnode(matchers); n; incnode(n))
+	    freecmatcher((Cmatcher) getdata(n));
+
+	ll = strlen((char *)line);
+	if (cs > ll)
+	    cs = ll;
+	popheap();
+    } LASTALLOC;
+
+    return ret;
+}
+
+/* Before and after hooks called by zle. */
+
+static int oldmenucmp;
+
+/**/
+int
+before_complete(Hookdef dummy, int *lst)
+{
+    oldmenucmp = menucmp;
+
+    if (showagain && validlist)
+	showinglist = -2;
+    showagain = 0;
+
+    /* If we are doing a menu-completion... */
+
+    if (menucmp && *lst != COMP_LIST_EXPAND && 
+	(!compwidget || compwidget == lastcompwidget)) {
+	do_menucmp(*lst);
+	return 1;
+    }
+    if (menucmp && validlist && *lst == COMP_LIST_COMPLETE) {
+	showinglist = -2;
+	onlyexpl = listdat.valid = 0;
+	return 1;
+    }
+    lastcompwidget = compwidget;
+
+    /* We may have to reset the cursor to its position after the   *
+     * string inserted by the last completion. */
+
+    if (fromcomp & FC_INWORD)
+	if ((cs = lastend) > ll)
+	    cs = ll;
+
+    /* Check if we have to start a menu-completion (via automenu). */
+
+    if (isset(AUTOMENU) && lastambig &&
+	(!isset(BASHAUTOLIST) || lastambig == 2))
+	usemenu = 2;
+
+    return 0;
+}
+
+/**/
+int
+after_complete(Hookdef dummy, Compldat dat)
+{
+    if (menucmp && !oldmenucmp) {
+	struct chdata dat;
+
+	dat.matches = amatches;
+	dat.num = nmatches;
+	dat.cur = NULL;
+	if (runhookdef(MENUSTARTHOOK, (void *) &dat))
+	    menucmp = menuacc = 0;
+    }
+    return 0;
+}
+
+/* This calls the given completion widget function. */
+
+/**/
+static void
+callcompfunc(char *s, char *fn)
+{
+    List list;
+    int lv = lastval;
+    char buf[20];
+
+    if ((list = getshfunc(fn)) != &dummy_list) {
+	char **p, *tmp;
+	int aadd = 0, usea = 1, icf = incompfunc, osc = sfcontext;
+	unsigned int rset, kset;
+	Param *ocrpms = comprpms, *ockpms = compkpms;
+
+	comprpms = (Param *) zalloc(CP_REALPARAMS * sizeof(Param));
+	compkpms = (Param *) zalloc(CP_KEYPARAMS * sizeof(Param));
+
+	rset = CP_ALLREALS;
+	kset = CP_ALLKEYS &
+	    ~(CP_PARAMETER | CP_REDIRECT | CP_QUOTE | CP_QUOTING |
+	      CP_EXACTSTR | CP_FORCELIST | CP_OLDLIST | CP_OLDINS |
+	      (useglob ? 0 : CP_PATMATCH));
+	zsfree(compvared);
+	if (varedarg) {
+	    compvared = ztrdup(varedarg);
+	    kset |= CP_VARED;
+	} else
+	    compvared = ztrdup("");
+	if (!*complastprompt)
+	    kset &= ~CP_LASTPROMPT;
+	zsfree(compcontext);
+	zsfree(compparameter);
+	zsfree(compredirect);
+	compparameter = compredirect = "";
+	if (ispar)
+	    compcontext = (ispar == 2 ? "brace_parameter" : "parameter");
+	else if (linwhat == IN_MATH) {
+	    if (insubscr) {
+		compcontext = "subscript";
+		if (varname) {
+		    compparameter = varname;
+		    kset |= CP_PARAMETER;
+		}
+	    } else
+		compcontext = "math";
+	    usea = 0;
+	} else if (lincmd) {
+	    if (insubscr) {
+		compcontext = "subscript";
+		kset |= CP_PARAMETER;
+	    } else
+		compcontext = "command";
+	} else if (linredir) {
+	    compcontext = "redirect";
+	    if (rdstr)
+		compredirect = rdstr;
+	    kset |= CP_REDIRECT;
+	} else
+	    switch (linwhat) {
+	    case IN_ENV:
+		compcontext = (linarr ? "array_value" : "value");
+		compparameter = varname;
+		kset |= CP_PARAMETER;
+		if (!clwpos) {
+		    clwpos = 1;
+		    clwnum = 2;
+		    zsfree(clwords[1]);
+		    clwords[1] = ztrdup(s);
+		    zsfree(clwords[2]);
+		    clwords[2] = NULL;
+		}
+		aadd = 1;
+		break;
+	    case IN_COND:
+		compcontext = "condition";
+		break;
+	    default:
+		if (cmdstr)
+		    compcontext = "command";
+		else {
+		    compcontext = "value";
+		    kset |= CP_PARAMETER;
+		    if (clwords[0])
+			compparameter = clwords[0];
+		    aadd = 1;
+		}
+	    }
+	compcontext = ztrdup(compcontext);
+	if (compwords)
+	    freearray(compwords);
+	if (usea && (!aadd || clwords[0])) {
+	    char **q;
+
+	    PERMALLOC {
+		q = compwords = (char **)
+		    zalloc((clwnum + 1) * sizeof(char *));
+		for (p = clwords + aadd; *p; p++, q++) {
+		    tmp = dupstring(*p);
+		    untokenize(tmp);
+		    *q = ztrdup(tmp);
+		}
+		*q = NULL;
+	    } LASTALLOC;
+	} else
+	    compwords = (char **) zcalloc(sizeof(char *));
+
+	compparameter = ztrdup(compparameter);
+	compredirect = ztrdup(compredirect);
+	zsfree(compquote);
+	zsfree(compquoting);
+	if (instring) {
+	    if (instring == 1) {
+		compquote = ztrdup("\'");
+		compquoting = ztrdup("single");
+	    } else {
+		compquote = ztrdup("\"");
+		compquoting = ztrdup("double");
+	    }
+	    kset |= CP_QUOTE | CP_QUOTING;
+	} else if (inbackt) {
+	    compquote = ztrdup("`");
+	    compquoting = ztrdup("backtick");
+	    kset |= CP_QUOTE | CP_QUOTING;
+	} else {
+	    compquote = ztrdup("");
+	    compquoting = ztrdup("");
+	}
+	zsfree(compprefix);
+	zsfree(compsuffix);
+	if (unset(COMPLETEINWORD)) {
+	    tmp = quotename(s, NULL);
+	    untokenize(tmp);
+	    compprefix = ztrdup(tmp);
+	    compsuffix = ztrdup("");
+	} else {
+	    char *ss, sav;
+	    
+	    ss = s + offs;
+
+	    sav = *ss;
+	    *ss = '\0';
+	    tmp = quotename(s, NULL);
+	    untokenize(tmp);
+	    compprefix = ztrdup(tmp);
+	    *ss = sav;
+	    ss = quotename(ss, NULL);
+	    untokenize(ss);
+	    compsuffix = ztrdup(ss);
+	}
+	zsfree(compiprefix);
+	compiprefix = ztrdup("");
+	zsfree(compisuffix);
+	compisuffix = ztrdup("");
+	zsfree(compqiprefix);
+	compqiprefix = ztrdup(qipre ? qipre : "");
+	zsfree(compqisuffix);
+	compqisuffix = ztrdup(qisuf ? qisuf : "");
+	compcurrent = (usea ? (clwpos + 1 - aadd) : 0);
+
+	zsfree(complist);
+	switch (uselist) {
+	case 0: complist = ""; kset &= ~CP_LIST; break;
+	case 1: complist = "list"; break;
+	case 2: complist = "autolist"; break;
+	case 3: complist = "ambiguous"; break;
+	}
+	complist = ztrdup(complist);
+	zsfree(compinsert);
+	if (useline) {
+	    switch (usemenu) {
+	    case 0: compinsert = "unambiguous"; break;
+	    case 1: compinsert = "menu"; break;
+	    case 2: compinsert = "automenu"; break;
+	    }
+	} else {
+	    compinsert = "";
+	    kset &= ~CP_INSERT;
+	}
+	compinsert = ztrdup(compinsert);
+	if (useexact)
+	    compexact = ztrdup("accept");
+	else {
+	    compexact = ztrdup("");
+	    kset &= ~CP_EXACT;
+	}
+	zsfree(comptoend);
+	if (movetoend == 1)
+	    comptoend = ztrdup("single");
+	else
+	    comptoend = ztrdup("match");
+	zsfree(compoldlist);
+	zsfree(compoldins);
+	if (hasoldlist && lastpermmnum) {
+	    if (listshown)
+		compoldlist = "shown";
+	    else
+		compoldlist = "yes";
+	    kset |= CP_OLDLIST;
+	    if (minfo.cur) {
+		sprintf(buf, "%d", (*(minfo.cur))->gnum);
+		compoldins = buf;
+		kset |= CP_OLDINS;
+	    } else
+		compoldins = "";
+	} else
+	    compoldlist = compoldins = "";
+	compoldlist = ztrdup(compoldlist);
+	compoldins = ztrdup(compoldins);
+
+	incompfunc = 1;
+	startparamscope();
+	makecompparams();
+	comp_setunset(rset, (~rset & CP_ALLREALS),
+		      kset, (~kset & CP_ALLKEYS));
+	makezleparams(1);
+	sfcontext = SFC_CWIDGET;
+	NEWHEAPS(compheap) {
+	    LinkList largs = NULL;
+	    int olv = lastval;
+
+	    if (*cfargs) {
+		char **p = cfargs;
+
+		largs = newlinklist();
+		addlinknode(largs, dupstring(fn));
+		while (*p)
+		    addlinknode(largs, dupstring(*p++));
+	    }
+	    doshfunc(fn, list, largs, 0, 0);
+	    cfret = lastval;
+	    lastval = olv;
+	} OLDHEAPS;
+	sfcontext = osc;
+	endparamscope();
+	lastcmd = 0;
+	incompfunc = icf;
+
+	if (!complist)
+	    uselist = 0;
+	else if (!strncmp(complist, "list", 4))
+	    uselist = 1;
+	else if (!strncmp(complist, "auto", 4))
+	    uselist = 2;
+	else if (!strncmp(complist, "ambig", 5))
+	    uselist = 3;
+	else
+	    uselist = 0;
+
+	onlyexpl = (complist && strstr(complist, "expl"));
+
+	if (!compinsert)
+	    useline = 0;
+	else if (!strcmp(compinsert, "unambig") ||
+		 !strcmp(compinsert, "unambiguous"))
+	    useline = 1, usemenu = 0;
+	else if (!strcmp(compinsert, "menu"))
+	    useline = 1, usemenu = 1;
+	else if (!strcmp(compinsert, "auto") ||
+		 !strcmp(compinsert, "automenu"))
+	    useline = 1, usemenu = 2;
+	else if (!strcmp(compinsert, "all"))
+	    useline = 2, usemenu = 0;
+	else if (idigit(*compinsert)) {
+	    char *m;
+
+	    useline = 1; usemenu = 3;
+	    insmnum = atoi(compinsert);
+	    if ((m = strchr(compinsert, ':'))) {
+		insgroup = 1;
+		insgnum = atoi(m + 1);
+	    }
+	    insspace = (compinsert[strlen(compinsert) - 1] == ' ');
+	} else
+	    useline = usemenu = 0;
+	useexact = (compexact && !strcmp(compexact, "accept"));
+
+	if (!comptoend || !*comptoend)
+	    movetoend = 0;
+	else if (!strcmp(comptoend, "single"))
+	    movetoend = 1;
+	else if (!strcmp(comptoend, "always"))
+	    movetoend = 3;
+	else
+	    movetoend = 2;
+
+	oldlist = (hasoldlist && compoldlist && !strcmp(compoldlist, "keep"));
+	oldins = (hasoldlist && minfo.cur &&
+		  compoldins && !strcmp(compoldins, "keep"));
+
+	zfree(comprpms, CP_REALPARAMS * sizeof(Param));
+	zfree(compkpms, CP_KEYPARAMS * sizeof(Param));
+	comprpms = ocrpms;
+	compkpms = ockpms;
+    }
+    lastval = lv;
+}
+
+/* Create the completion list.  This is called whenever some bit of   *
+ * completion code needs the list.                                    *
+ * Along with the list is maintained the prefixes/suffixes etc.  When *
+ * any of this becomes invalid -- e.g. if some text is changed on the *
+ * command line -- invalidatelist() should be called, to set          *
+ * validlist to zero and free up the memory used.  This function      *
+ * returns non-zero on error.                                         */
+
+/**/
+static int
+makecomplist(char *s, int incmd, int lst)
+{
+    struct cmlist ms;
+    Cmlist m;
+    char *p, *os = s;
+    int onm = nmatches, osi = movefd(0);
+
+    /* Inside $... ? */
+    if (compfunc && (p = check_param(s, 0, 0)))
+	os = s = p;
+
+    /* We build a copy of the list of matchers to use to make sure that this
+     * works even if a shell function called from the completion code changes
+     * the global matchers. */
+
+    if ((m = cmatcher)) {
+	Cmlist mm, *mp = &mm;
+	int n;
+
+	for (n = 0; m; m = m->next, n++) {
+	    if (m->matcher) {
+		*mp = (Cmlist) zhalloc(sizeof(struct cmlist));
+		(*mp)->matcher = m->matcher;
+		(*mp)->next = NULL;
+		(*mp)->str = dupstring(m->str);
+		mp = &((*mp)->next);
+		addlinknode(matchers, m->matcher);
+		m->matcher->refc++;
+	    }
+	}
+	m = mm;
+	compmatcher = 1;
+	compmatchertot = n;
+    } else
+	compmatcher = 0;
+
+    linwhat = inwhat;
+
+    /* Walk through the global matchers. */
+    for (;;) {
+	bmatchers = NULL;
+	zsfree(compmatcherstr);
+	if (m) {
+	    ms.next = NULL;
+	    ms.matcher = m->matcher;
+	    mstack = &ms;
+
+	    /* Store the matchers used in the bmatchers list which is used
+	     * when building new parts for the string to insert into the 
+	     * line. */
+	    add_bmatchers(m->matcher);
+	    compmatcherstr = ztrdup(m->str);
+	} else {
+	    mstack = NULL;
+	    compmatcherstr = ztrdup("");
+	}
+	ainfo = (Aminfo) hcalloc(sizeof(struct aminfo));
+	fainfo = (Aminfo) hcalloc(sizeof(struct aminfo));
+
+	freecl = NULL;
+
+	if (!validlist)
+	    lastambig = 0;
+	amatches = NULL;
+	mnum = 0;
+	unambig_mnum = -1;
+	isuf = NULL;
+	insmnum = insgnum = 1;
+	insgroup = oldlist = oldins = 0;
+	begcmgroup("default", 0);
+	menucmp = menuacc = newmatches = onlyexpl = 0;
+
+	runhookdef(COMPCTLBEFOREHOOK, NULL);
+
+	s = dupstring(os);
+	if (compfunc)
+	    callcompfunc(s, compfunc);
+	else {
+	    struct ccmakedat dat;
+
+	    dat.str = s;
+	    dat.incmd = incmd;
+	    dat.lst = lst;
+	    runhookdef(COMPCTLMAKEHOOK, (void *) &dat);
+	}
+	endcmgroup(NULL);
+
+	runhookdef(COMPCTLAFTERHOOK,
+		   (void *) ((amatches && !oldlist) ? 1L : 0L));
+
+	if (oldlist) {
+	    nmatches = onm;
+	    validlist = 1;
+	    amatches = lastmatches;
+	    lmatches = lastlmatches;
+	    if (pmatches) {
+		freematches(pmatches);
+		pmatches = NULL;
+		hasperm = 0;
+	    }
+	    redup(osi, 0);
+
+	    return 0;
+	}
+	PERMALLOC {
+	    if (lastmatches) {
+		freematches(lastmatches);
+		lastmatches = NULL;
+	    }
+	    permmatches(1);
+	    amatches = pmatches;
+	    lastpermmnum = permmnum;
+	    lastpermgnum = permgnum;
+	} LASTALLOC;
+
+	lastmatches = pmatches;
+	lastlmatches = lmatches;
+	pmatches = NULL;
+	hasperm = 0;
+	hasoldlist = 1;
+
+	if (nmatches && !errflag) {
+	    validlist = 1;
+
+	    redup(osi, 0);
+
+	    return 0;
+	}
+	if (!m || !(m = m->next))
+	    break;
+
+	errflag = 0;
+	compmatcher++;
+    }
+    redup(osi, 0);
+    return 1;
+}
+
+/* Check if we have to complete a parameter name. */
+
+/**/
+char *
+check_param(char *s, int set, int test)
+{
+    char *p;
+
+    zsfree(parpre);
+    parpre = NULL;
+
+    if (!test)
+	ispar = parq = eparq = 0;
+    /* Try to find a `$'. */
+    for (p = s + offs; p > s && *p != String && *p != Qstring; p--);
+    if (*p == String || *p == Qstring) {
+	/* Handle $$'s */
+	while (p > s && (p[-1] == String || p[-1] == Qstring))
+	    p--;
+	while ((p[1] == String || p[1] == Qstring) &&
+	       (p[2] == String || p[2] == Qstring))
+	    p += 2;
+    }
+    if ((*p == String || *p == Qstring) && p[1] != Inpar && p[1] != Inbrack) {
+	/* This is really a parameter expression (not $(...) or $[...]). */
+	char *b = p + 1, *e = b;
+	int n = 0, br = 1, nest = 0;
+
+	if (*b == Inbrace) {
+	    char *tb = b;
+
+	    /* If this is a ${...}, see if we are before the '}'. */
+	    if (!skipparens(Inbrace, Outbrace, &tb))
+		return NULL;
+
+	    /* Ignore the possible (...) flags. */
+	    b++, br++;
+	    n = skipparens(Inpar, Outpar, &b);
+
+	    for (tb = p - 1; tb > s && *tb != Outbrace && *tb != Inbrace; tb--);
+	    if (tb > s && *tb == Inbrace && (tb[-1] == String || *tb == Qstring))
+		nest = 1;
+	}
+
+	/* Ignore the stuff before the parameter name. */
+	for (; *b; b++)
+	    if (*b != '^' && *b != Hat &&
+		*b != '=' && *b != Equals &&
+		*b != '~' && *b != Tilde)
+		break;
+	if (*b == '#' || *b == Pound || *b == '+')
+	    b++;
+
+	e = b;
+	if (br) {
+	    while (*e == (test ? Dnull : '"'))
+		e++, parq++;
+	    if (!test)
+		b = e;
+	}
+	/* Find the end of the name. */
+	if (*e == Quest || *e == Star || *e == String || *e == Qstring ||
+	    *e == '?'   || *e == '*'  || *e == '$'    ||
+	    *e == '-'   || *e == '!'  || *e == '@')
+	    e++;
+	else if (idigit(*e))
+	    while (idigit(*e))
+		e++;
+	else if (iident(*e))
+	    while (iident(*e) ||
+		   (comppatmatch && *comppatmatch && (*e == Star || *e == Quest)))
+		e++;
+
+	/* Now make sure that the cursor is inside the name. */
+	if (offs <= e - s && offs >= b - s && n <= 0) {
+	    char sav;
+
+	    if (br) {
+		p = e;
+		while (*p == (test ? Dnull : '"'))
+		    p++, parq--, eparq++;
+	    }
+	    /* It is. */
+	    if (test)
+		return b;
+	    /* If we were called from makecomplistflags(), we have to set the
+	     * global variables. */
+
+	    if (set) {
+		if (br >= 2) {
+		    mflags |= CMF_PARBR;
+		    if (nest)
+			mflags |= CMF_PARNEST;
+		}
+		/* Get the prefix (anything up to the character before the name). */
+		isuf = dupstring(e);
+		untokenize(isuf);
+		sav = *b;
+		*b = *e = '\0';
+		ripre = dyncat((ripre ? ripre : ""), s);
+		ipre = dyncat((ipre ? ipre : ""), s);
+		*b = sav;
+
+		untokenize(ipre);
+	    }
+	    /* Save the prefix. */
+	    if (compfunc) {
+		parflags = (br >= 2 ? CMF_PARBR : 0);
+		sav = *b;
+		*b = '\0';
+		untokenize(parpre = ztrdup(s));
+		*b = sav;
+	    }
+	    /* And adjust wb, we, and offs again. */
+	    offs -= b - s;
+	    wb = cs - offs;
+	    we = wb + e - b;
+	    ispar = (br >= 2 ? 2 : 1);
+	    b[we-wb] = '\0';
+	    return b;
+	}
+    }
+    return NULL;
+}
+
+/* Copy the given string and remove backslashes from the copy and return it. */
+
+/**/
+char *
+rembslash(char *s)
+{
+    char *t = s = dupstring(s);
+
+    while (*s)
+	if (*s == '\\') {
+	    chuck(s);
+	    if (*s)
+		s++;
+	} else
+	    s++;
+
+    return t;
+}
+
+/* This should probably be moved into tokenize(). */
+
+/**/
+char *
+ctokenize(char *p)
+{
+    char *r = p;
+    int bslash = 0;
+
+    tokenize(p);
+
+    for (p = r; *p; p++) {
+	if (*p == '\\')
+	    bslash = 1;
+	else {
+	    if (*p == '$' || *p == '{' || *p == '}') {
+		if (bslash)
+		    p[-1] = Bnull;
+		else
+		    *p = (*p == '$' ? String :
+			  (*p == '{' ? Inbrace : Outbrace));
+	    }
+	    bslash = 0;
+	}
+    }
+    return r;
+}
+
+/**/
+char *
+comp_str(int *ipl, int *pl, int untok)
+{
+    char *p = dupstring(compprefix);
+    char *s = dupstring(compsuffix);
+    char *ip = dupstring(compiprefix);
+    char *str;
+    int lp, ls, lip;
+
+    if (!untok) {
+	ctokenize(p);
+	remnulargs(p);
+	ctokenize(s);
+	remnulargs(s);
+    }
+    lp = strlen(p);
+    ls = strlen(s);
+    lip = strlen(ip);
+    str = zhalloc(lip + lp + ls + 1);
+    strcpy(str, ip);
+    strcat(str, p);
+    strcat(str, s);
+
+    if (ipl)
+	*ipl = lip;
+    if (pl)
+	*pl = lp;
+
+    return str;
+}
+
+/* This is for compset -q. */
+
+/**/
+int
+set_comp_sep(void)
+{
+    int lip, lp;
+    char *s = comp_str(&lip, &lp, 0);
+    LinkList foo = newlinklist();
+    LinkNode n;
+    int owe = we, owb = wb, ocs = cs, swb, swe, scs, soffs, ne = noerrs;
+    int tl, got = 0, i = 0, cur = -1, oll = ll, sl;
+    int ois = instring, oib = inbackt, noffs = lip + lp;
+    char *tmp, *p, *ns, *ol = (char *) line, sav, oaq = autoq, *qp, *qs;
+
+    if (compisuffix)
+	s = dyncat(s, compisuffix);
+    untokenize(s);
+
+    swb = swe = soffs = 0;
+    ns = NULL;
+
+    /* Put the string in the lexer buffer and call the lexer to *
+     * get the words we have to expand.                        */
+    zleparse = 1;
+    addedx = 1;
+    noerrs = 1;
+    lexsave();
+    tmp = (char *) zhalloc(tl = 3 + strlen(s));
+    tmp[0] = ' ';
+    memcpy(tmp + 1, s, noffs);
+    tmp[(scs = cs = 1 + noffs)] = 'x';
+    strcpy(tmp + 2 + noffs, s + noffs);
+    tmp = rembslash(tmp);
+    inpush(dupstrspace(tmp), 0, NULL);
+    line = (unsigned char *) tmp;
+    ll = tl - 1;
+    strinbeg(0);
+    noaliases = 1;
+    do {
+	ctxtlex();
+	if (tok == LEXERR) {
+	    int j;
+
+	    if (!tokstr)
+		break;
+	    for (j = 0, p = tokstr; *p; p++)
+		if (*p == Snull || *p == Dnull)
+		    j++;
+	    if (j & 1) {
+		tok = STRING;
+		if (p > tokstr && p[-1] == ' ')
+		    p[-1] = '\0';
+	    }
+	}
+	if (tok == ENDINPUT || tok == LEXERR)
+	    break;
+	if (tokstr && *tokstr)
+	    addlinknode(foo, (p = ztrdup(tokstr)));
+	else
+	    p = NULL;
+	if (!got && !zleparse) {
+	    DPUTS(!p, "no current word in substr");
+	    got = 1;
+	    cur = i;
+	    swb = wb - 1;
+	    swe = we - 1;
+	    soffs = cs - swb;
+	    chuck(p + soffs);
+	    ns = dupstring(p);
+	}
+	i++;
+    } while (tok != ENDINPUT && tok != LEXERR);
+    noaliases = 0;
+    strinend();
+    inpop();
+    errflag = zleparse = 0;
+    noerrs = ne;
+    lexrestore();
+    wb = owb;
+    we = owe;
+    cs = ocs;
+    line = (unsigned char *) ol;
+    ll = oll;
+    if (cur < 0 || i < 1)
+	return 1;
+    owb = offs;
+    offs = soffs;
+    if ((p = check_param(ns, 0, 1))) {
+	for (p = ns; *p; p++)
+	    if (*p == Dnull)
+		*p = '"';
+	    else if (*p == Snull)
+		*p = '\'';
+    }
+    offs = owb;
+    if (*ns == Snull || *ns == Dnull) {
+	instring = (*ns == Snull ? 1 : 2);
+	inbackt = 0;
+	swb++;
+	if (ns[strlen(ns) - 1] == *ns && ns[1])
+	    swe--;
+	autoq = (*ns == Snull ? '\'' : '"');
+    } else {
+	instring = 0;
+	autoq = '\0';
+    }
+    for (p = ns, i = swb; *p; p++, i++) {
+	if (INULL(*p)) {
+	    if (i < scs)
+		soffs--;
+	    if (p[1] || *p != Bnull) {
+		if (*p == Bnull) {
+		    if (scs == i + 1)
+			scs++, soffs++;
+		} else {
+		    if (scs > i--)
+			scs--;
+		}
+	    } else {
+		if (scs == swe)
+		    scs--;
+	    }
+	    chuck(p--);
+	}
+    }
+    sav = s[(i = swb - 1)];
+    s[i] = '\0';
+    qp = tricat(qipre, rembslash(s), "");
+    s[i] = sav;
+    if (swe < swb)
+	swe = swb;
+    swe--;
+    sl = strlen(s);
+    if (swe > sl)
+	swe = sl, ns[swe - swb + 1] = '\0';
+    qs = tricat(rembslash(s + swe), qisuf, "");
+    sl = strlen(ns);
+    if (soffs > sl)
+	soffs = sl;
+
+    {
+	int set = CP_QUOTE | CP_QUOTING, unset = 0;
+
+	zsfree(compquote);
+	zsfree(compquoting);
+	if (instring == 2) {
+	    compquote = "\"";
+	    compquoting = "double";
+	} else if (instring == 1) {
+	    compquote = "'";
+	    compquoting = "single";
+	} else {
+	    compquote = compquoting = "";
+	    unset = set;
+	    set = 0;
+	}
+	compquote = ztrdup(compquote);
+	compquoting = ztrdup(compquoting);
+	comp_setunset(0, 0, set, unset);
+
+	if (unset(COMPLETEINWORD)) {
+	    untokenize(ns);
+	    zsfree(compprefix);
+	    compprefix = ztrdup(ns);
+	    zsfree(compsuffix);
+	    compsuffix = ztrdup("");
+	} else {
+	    char *ss, sav;
+	    
+	    ss = ns + soffs;
+
+	    sav = *ss;
+	    *ss = '\0';
+	    untokenize(ns);
+	    compprefix = ztrdup(ns);
+	    *ss = sav;
+	    untokenize(ss);
+	    compsuffix = ztrdup(ss);
+	}
+	zsfree(compiprefix);
+	compiprefix = ztrdup("");
+	zsfree(compisuffix);
+	compisuffix = ztrdup("");
+	zsfree(compqiprefix);
+	zsfree(compqisuffix);
+	if (ois) {
+	    compqiprefix = qp;
+	    compqisuffix = qs;
+	} else {
+	    compqiprefix = ztrdup(quotename(qp, NULL));
+	    zsfree(qp);
+	    compqisuffix = ztrdup(quotename(qs, NULL));
+	    zsfree(qs);
+	}
+	freearray(compwords);
+	i = countlinknodes(foo);
+	compwords = (char **) zalloc((i + 1) * sizeof(char *));
+	for (n = firstnode(foo), i = 0; n; incnode(n), i++) {
+	    p = compwords[i] = (char *) getdata(n);
+	    untokenize(p);
+	}
+	compcurrent = cur + 1;
+	compwords[i] = NULL;
+    }
+    autoq = oaq;
+    instring = ois;
+    inbackt = oib;
+
+    return 0;
+}
+
+/* This stores the strings from the list in an array. */
+
+/**/
+void
+set_list_array(char *name, LinkList l)
+{
+    char **a, **p;
+    LinkNode n;
+
+    a = (char **) zalloc((countlinknodes(l) + 1) * sizeof(char *));
+    for (p = a, n = firstnode(l); n; incnode(n))
+	*p++ = ztrdup((char *) getdata(n));
+    *p = NULL;
+
+    setaparam(name, a);
+}
+
+/* Get the words from a variable or a (list of words). */
+
+/**/
+char **
+get_user_var(char *nam)
+{
+    if (!nam)
+	return NULL;
+    else if (*nam == '(') {
+	/* It's a (...) list, not a parameter name. */
+	char *ptr, *s, **uarr, **aptr;
+	int count = 0, notempty = 0, brk = 0;
+	LinkList arrlist = newlinklist();
+
+	ptr = dupstring(nam);
+	s = ptr + 1;
+	while (*++ptr) {
+	    if (*ptr == '\\' && ptr[1])
+		chuck(ptr), notempty = 1;
+	    else if (*ptr == ',' || inblank(*ptr) || *ptr == ')') {
+		if (*ptr == ')')
+		    brk++;
+		if (notempty) {
+		    *ptr = '\0';
+		    count++;
+		    if (*s == '\n')
+			s++;
+		    addlinknode(arrlist, s);
+		}
+		s = ptr + 1;
+		notempty = 0;
+	    } else {
+		notempty = 1;
+		if (*ptr == Meta)
+		    ptr++;
+	    }
+	    if (brk)
+		break;
+	}
+	if (!brk || !count)
+	    return NULL;
+	*ptr = '\0';
+	aptr = uarr = (char **) zhalloc(sizeof(char *) * (count + 1));
+
+	while ((*aptr++ = (char *)ugetnode(arrlist)));
+	uarr[count] = NULL;
+	return uarr;
+    } else {
+	/* Otherwise it should be a parameter name. */
+	char **arr = NULL, *val;
+
+	if ((arr = getaparam(nam)) || (arr = gethparam(nam)))
+	    return (incompfunc ? arrdup(arr) : arr);
+
+	if ((val = getsparam(nam))) {
+	    arr = (char **) zhalloc(2*sizeof(char *));
+	    arr[0] = (incompfunc ? dupstring(val) : val);
+	    arr[1] = NULL;
+	}
+	return arr;
+    }
+}
+
+/* This is used by compadd to add a couple of matches. The arguments are
+ * the strings given via options. The last argument is the array with
+ * the matches. */
+
+/**/
+int
+addmatches(Cadata dat, char **argv)
+{
+    char *s, *ms, *lipre = NULL, *lisuf = NULL, *lpre = NULL, *lsuf = NULL;
+    char **aign = NULL, **dparr = NULL, oaq = autoq, *oppre = dat->ppre;
+    char *oqp = qipre, *oqs = qisuf, qc, **disp = NULL;
+    int lpl, lsl, pl, sl, bcp = 0, bcs = 0, bpadd = 0, bsadd = 0;
+    int llpl = 0, llsl = 0, nm = mnum, gflags = 0, ohp = haspattern;
+    int oisalt = 0, isalt, isexact, doadd, ois = instring, oib = inbackt;
+    Cline lc = NULL, pline = NULL, sline = NULL;
+    Cmatch cm;
+    struct cmlist mst;
+    Cmlist oms = mstack;
+    Patprog cp = NULL;
+    LinkList aparl = NULL, oparl = NULL, dparl = NULL;
+    Brinfo bp, bpl = brbeg, obpl, bsl = brend, obsl;
+
+    for (bp = brbeg; bp; bp = bp->next)
+	bp->curpos = ((dat->aflags & CAF_QUOTE) ? bp->pos : bp->qpos);
+    for (bp = brend; bp; bp = bp->next)
+	bp->curpos = ((dat->aflags & CAF_QUOTE) ? bp->pos : bp->qpos);
+
+    if (dat->flags & CMF_ISPAR)
+	dat->flags |= parflags;
+    if (compquote && (qc = *compquote)) {
+	if (qc == '`') {
+	    instring = 0;
+	    inbackt = 0;
+	    autoq = '\0';
+	} else {
+	    instring = (qc == '\'' ? 1 : 2);
+	    inbackt = 0;
+	    autoq = qc;
+	}
+    } else {
+	instring = inbackt = 0;
+	autoq = '\0';
+    }
+    qipre = ztrdup(compqiprefix ? compqiprefix : "");
+    qisuf = ztrdup(compqisuffix ? compqisuffix : "");
+
+    /* Switch back to the heap that was used when the completion widget
+     * was invoked. */
+    SWITCHHEAPS(compheap) {
+	HEAPALLOC {
+	    if ((doadd = (!dat->apar && !dat->opar && !dat->dpar)) &&
+		(dat->aflags & CAF_MATCH))
+		hasmatched = 1;
+	    if (dat->apar)
+		aparl = newlinklist();
+	    if (dat->opar)
+		oparl = newlinklist();
+	    if (dat->dpar) {
+		if (*(dat->dpar) == '(')
+		    dparr = NULL;
+		else if ((dparr = get_user_var(dat->dpar)) && !*dparr)
+		    dparr = NULL;
+		dparl = newlinklist();
+	    }
+	    if (dat->exp) {
+		curexpl = (Cexpl) zhalloc(sizeof(struct cexpl));
+		curexpl->count = curexpl->fcount = 0;
+		curexpl->str = dupstring(dat->exp);
+	    } else
+		curexpl = NULL;
+
+	    /* Store the matcher in our stack of matchers. */
+	    if (dat->match) {
+		mst.next = mstack;
+		mst.matcher = dat->match;
+		mstack = &mst;
+
+		if (!mnum)
+		    add_bmatchers(dat->match);
+
+		addlinknode(matchers, dat->match);
+		dat->match->refc++;
+	    }
+	    if (mnum && (mstack || bmatchers))
+		update_bmatchers();
+
+	    /* Get the suffixes to ignore. */
+	    if (dat->ign)
+		aign = get_user_var(dat->ign);
+	    /* Get the display strings. */
+	    if (dat->disp)
+		if ((disp = get_user_var(dat->disp)))
+		    disp--;
+	    /* Get the contents of the completion variables if we have
+	     * to perform matching. */
+	    if (dat->aflags & CAF_MATCH) {
+		lipre = dupstring(compiprefix);
+		lisuf = dupstring(compisuffix);
+		lpre = dupstring(compprefix);
+		lsuf = dupstring(compsuffix);
+		llpl = strlen(lpre);
+		llsl = strlen(lsuf);
+		/* Test if there is an existing -P prefix. */
+		if (dat->pre && *dat->pre) {
+		    char *dp = rembslash(dat->pre);
+
+		    pl = pfxlen(dp, lpre);
+		    llpl -= pl;
+		    lpre += pl;
+		}
+	    }
+	    /* Now duplicate the strings we have from the command line. */
+	    if (dat->ipre)
+		dat->ipre = (lipre ? dyncat(lipre, dat->ipre) :
+			     dupstring(dat->ipre));
+	    else if (lipre)
+		dat->ipre = lipre;
+	    if (dat->isuf)
+		dat->isuf = (lisuf ? dyncat(lisuf, dat->isuf) :
+			     dupstring(dat->isuf));
+	    else if (lisuf)
+		dat->isuf = lisuf;
+	    if (dat->ppre) {
+		if (!(dat->aflags & CAF_QUOTE)) {
+		    dat->ppre = quotename(dat->ppre, NULL);
+		    if ((dat->flags & CMF_FILE) &&
+			dat->ppre[0] == '\\' && dat->ppre[1] == '~')
+			chuck(dat->ppre);
+		} else
+		    dat->ppre = dupstring(dat->ppre);
+		lpl = strlen(dat->ppre);
+	    } else
+		lpl = 0;
+	    if (dat->psuf) {
+		if (!(dat->aflags & CAF_QUOTE))
+		    dat->psuf = quotename(dat->psuf, NULL);
+		else
+		    dat->psuf = dupstring(dat->psuf);
+		lsl = strlen(dat->psuf);
+	    } else
+		lsl = 0;
+	    if (dat->aflags & CAF_MATCH) {
+		int ml;
+
+		s = dat->ppre ? dat->ppre : "";
+		if ((ml = match_str(lpre, s, &bpl, 0, NULL, 0, 0, 1)) >= 0) {
+		    if (matchsubs) {
+			Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
+
+			tmp->prefix = matchsubs;
+			if (matchlastpart)
+			    matchlastpart->next = tmp;
+			else
+			    matchparts = tmp;
+		    }
+		    pline = matchparts;
+		    lpre += ml;
+		    bcp = ml;
+		    bpadd = strlen(s) - ml;
+		} else {
+		    if (llpl <= lpl && strpfx(lpre, s))
+			lpre = "";
+		    else if (llpl > lpl && strpfx(s, lpre))
+			lpre += lpl;
+		    else
+			*argv = NULL;
+		    bcp = lpl;
+		}
+
+		s = dat->psuf ? dat->psuf : "";
+		if ((ml = match_str(lsuf, s, &bsl, 0, NULL, 1, 0, 1)) >= 0) {
+		    if (matchsubs) {
+			Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, CLF_SUF);
+
+			tmp->suffix = matchsubs;
+			if (matchlastpart)
+			    matchlastpart->next = tmp;
+			else
+			    matchparts = tmp;
+		    }
+		    sline = revert_cline(matchparts);
+		    lsuf[llsl - ml] = '\0';
+		    bcs = ml;
+		    bsadd = strlen(s) - ml;
+		} else {
+		    if (llsl <= lsl && strsfx(lsuf, s))
+			lsuf = "";
+		    else if (llsl > lsl && strsfx(s, lsuf))
+			lsuf[llsl - lsl] = '\0';
+		    else
+			*argv = NULL;
+		    bcs = lsl;
+		}
+		if (comppatmatch && *comppatmatch) {
+		    int is = (*comppatmatch == '*');
+		    char *tmp = (char *) zhalloc(2 + llpl + llsl);
+
+		    strcpy(tmp, lpre);
+		    tmp[llpl] = 'x';
+		    strcpy(tmp + llpl + is, lsuf);
+
+		    tokenize(tmp);
+		    remnulargs(tmp);
+		    if (haswilds(tmp)) {
+			if (is)
+			    tmp[llpl] = Star;
+			if ((cp = patcompile(tmp, 0, NULL)))
+			    haspattern = 1;
+		    }
+		}
+	    }
+	    if (*argv) {
+		if (dat->pre)
+		    dat->pre = dupstring(dat->pre);
+		if (dat->suf)
+		    dat->suf = dupstring(dat->suf);
+		if (!dat->prpre && (dat->prpre = oppre)) {
+		    singsub(&(dat->prpre));
+		    untokenize(dat->prpre);
+		} else
+		    dat->prpre = dupstring(dat->prpre);
+		/* Select the group in which to store the matches. */
+		gflags = (((dat->aflags & CAF_NOSORT ) ? CGF_NOSORT  : 0) |
+			  ((dat->aflags & CAF_UNIQALL) ? CGF_UNIQALL : 0) |
+			  ((dat->aflags & CAF_UNIQCON) ? CGF_UNIQCON : 0));
+		if (dat->group) {
+		    endcmgroup(NULL);
+		    begcmgroup(dat->group, gflags);
+		} else {
+		    endcmgroup(NULL);
+		    begcmgroup("default", 0);
+		}
+		/* Select the set of matches. */
+		oisalt = (dat->aflags & CAF_ALT);
+
+		if (dat->remf) {
+		    dat->remf = dupstring(dat->remf);
+		    dat->rems = NULL;
+		} else if (dat->rems)
+		    dat->rems = dupstring(dat->rems);
+	    }
+	    /* Walk through the matches given. */
+	    obpl = bpl;
+	    obsl = bsl;
+	    for (; (s = *argv); argv++) {
+		bpl = obpl;
+		bsl = obsl;
+		if (disp) {
+		    if (!*++disp)
+			disp = NULL;
+		}
+		sl = strlen(s);
+		isalt = oisalt;
+		if ((!dat->psuf || !*(dat->psuf)) && aign) {
+		    /* Do the suffix-test. If the match has one of the
+		     * suffixes from ign, we put it in the alternate set. */
+		    char **pt = aign;
+		    int filell;
+
+		    for (isalt = 0; !isalt && *pt; pt++)
+			if ((filell = strlen(*pt)) < sl
+			    && !strcmp(*pt, s + sl - filell))
+			    isalt = 1;
+
+		    if (isalt && !doadd) {
+			if (dparr && !*++dparr)
+			    dparr = NULL;
+			continue;
+		    }
+		}
+		if (!(dat->aflags & CAF_MATCH)) {
+		    if (dat->aflags & CAF_QUOTE)
+			ms = dupstring(s);
+		    else
+			sl = strlen(ms = quotename(s, NULL));
+		    lc = bld_parts(ms, sl, -1, NULL);
+		    isexact = 0;
+		} else if (!(ms = comp_match(lpre, lsuf, s, cp, &lc,
+					     (!(dat->aflags & CAF_QUOTE) ?
+					      ((dat->ppre && dat->ppre) ||
+					       !(dat->flags & CMF_FILE) ? 1 : 2) : 0),
+					     &bpl, bcp, &bsl, bcs,
+					     &isexact))) {
+		    if (dparr && !*++dparr)
+			dparr = NULL;
+		    continue;
+		}
+		if (doadd) {
+		    Brinfo bp;
+
+		    for (bp = obpl; bp; bp = bp->next)
+			bp->curpos += bpadd;
+		    for (bp = obsl; bp; bp = bp->next)
+			bp->curpos += bsadd;
+
+		    if ((cm = add_match_data(isalt, ms, lc, dat->ipre, NULL,
+					     dat->isuf, dat->pre, dat->prpre,
+					     dat->ppre, pline,
+					     dat->psuf, sline,
+					     dat->suf, dat->flags, isexact))) {
+			cm->rems = dat->rems;
+			cm->remf = dat->remf;
+			if (disp)
+			    cm->disp = dupstring(*disp);
+		    }
+		} else {
+		    if (dat->apar)
+			addlinknode(aparl, ms);
+		    if (dat->opar)
+			addlinknode(oparl, s);
+		    if (dat->dpar && dparr) {
+			addlinknode(dparl, *dparr);
+			if (!*++dparr)
+			    dparr = NULL;
+		    }
+		    free_cline(lc);
+		}
+	    }
+	    if (dat->apar)
+		set_list_array(dat->apar, aparl);
+	    if (dat->opar)
+		set_list_array(dat->opar, oparl);
+	    if (dat->dpar)
+		set_list_array(dat->dpar, dparl);
+	    if (dat->exp)
+		addexpl();
+	} LASTALLOC;
+    } SWITCHBACKHEAPS;
+
+    /* We switched back to the current heap, now restore the stack of
+     * matchers. */
+    mstack = oms;
+
+    instring = ois;
+    inbackt = oib;
+    autoq = oaq;
+    zsfree(qipre);
+    zsfree(qisuf);
+    qipre = oqp;
+    qisuf = oqs;
+
+    if (mnum == nm)
+	haspattern = ohp;
+
+    return (mnum == nm);
+}
+
+/* This adds all the data we have for a match. */
+
+/**/
+Cmatch
+add_match_data(int alt, char *str, Cline line,
+	       char *ipre, char *ripre, char *isuf,
+	       char *pre, char *prpre,
+	       char *ppre, Cline pline,
+	       char *psuf, Cline sline,
+	       char *suf, int flags, int exact)
+{
+    Cmatch cm;
+    Aminfo ai = (alt ? fainfo : ainfo);
+    int palen, salen, qipl, ipl, pl, ppl, qisl, isl, psl;
+    int sl, lpl, lsl, ml;
+
+    palen = salen = qipl = ipl = pl = ppl = qisl = isl = psl = 0;
+
+    DPUTS(!line, "BUG: add_match_data() without cline");
+
+    cline_matched(line);
+    if (pline)
+	cline_matched(pline);
+    if (sline)
+	cline_matched(sline);
+
+    /* If there is a path suffix, we build a cline list for it and
+     * append it to the list for the match itself. */
+    if (!sline && psuf)
+	salen = (psl = strlen(psuf));
+    if (isuf)
+	salen += (isl = strlen(isuf));
+    if (qisuf)
+	salen += (qisl = strlen(qisuf));
+
+    if (salen) {
+	char *asuf = (char *) zhalloc(salen);
+	Cline pp, p, s, sl = NULL;
+	
+
+	if (psl)
+	    memcpy(asuf, psuf, psl);
+	if (isl)
+	    memcpy(asuf + psl, isuf, isl);
+	if (qisl)
+	    memcpy(asuf + psl + isl, qisuf, qisl);
+
+	for (pp = NULL, p = line; p->next; pp = p, p = p->next);
+
+	if (salen > qisl) {
+	    s = bld_parts(asuf, salen - qisl, salen - qisl, &sl);
+
+	    if (sline) {
+		Cline sp;
+
+		sline = cp_cline(sline, 1);
+
+		for (sp = sline; sp->next; sp = sp->next);
+		sp->next = s;
+		s = sline;
+	    }
+	    if (!(p->flags & (CLF_SUF | CLF_MID)) &&
+		!p->llen && !p->wlen && !p->olen) {
+		if (p->prefix) {
+		    Cline q;
+
+		    for (q = p->prefix; q->next; q = q->next);
+		    q->next = s->prefix;
+		    s->prefix = p->prefix;
+		    p->prefix = NULL;
+		}
+		s->flags |= (p->flags & CLF_MATCHED);
+		free_cline(p);
+		if (pp)
+		    pp->next = s;
+		else
+		    line = s;
+	    } else
+		p->next = s;
+	}
+	if (qisl) {
+	    Cline qsl = bld_parts(asuf + psl + isl, qisl, qisl, NULL);
+
+	    qsl->flags |= CLF_SUF;
+	    qsl->suffix = qsl->prefix;
+	    qsl->prefix = NULL;
+	    if (sl)
+		sl->next = qsl;
+	    else if (sline) {
+		Cline sp;
+
+		sline = cp_cline(sline, 1);
+
+		for (sp = sline; sp->next; sp = sp->next);
+		sp->next = qsl;
+		p->next = sline;
+	    } else
+		p->next = qsl;
+	}
+    } else if (sline) {
+	Cline p;
+
+	for (p = line; p->next; p = p->next);
+	p->next = cp_cline(sline, 1);
+    }
+    /* The prefix is handled differently because the completion code
+     * is much more eager to insert the -P prefix than it is to insert
+     * the -S suffix. */
+    if (qipre)
+	palen = (qipl = strlen(qipre));
+    if (ipre)
+	palen += (ipl = strlen(ipre));
+    if (pre)
+	palen += (pl = strlen(pre));
+    if (!pline && ppre)
+	palen += (ppl = strlen(ppre));
+
+    if (pl) {
+	if (ppl || pline) {
+	    Cline lp, p;
+
+	    if (pline)
+		for (p = cp_cline(pline, 1), lp = p; lp->next; lp = lp->next);
+	    else
+		p = bld_parts(ppre, ppl, ppl, &lp);
+
+	    if (lp->prefix && !(line->flags & (CLF_SUF | CLF_MID)) &&
+		!p->llen && !p->wlen && !p->olen) {
+		Cline lpp;
+
+		for (lpp = lp->prefix; lpp->next; lpp = lpp->next);
+
+		lpp->next = line->prefix;
+		line->prefix = lp->prefix;
+		lp->prefix = NULL;
+
+		free_cline(lp);
+
+		if (p != lp) {
+		    Cline q;
+
+		    for (q = p; q->next != lp; q = q->next);
+
+		    q->next = line;
+		    line = p;
+		}
+	    } else {
+		lp->next = line;
+		line = p;
+	    }
+	}
+	if (pl) {
+	    Cline lp, p = bld_parts(pre, pl, pl, &lp);
+
+	    lp->next = line;
+	    line = p;
+	}
+	if (ipl) {
+	    Cline lp, p = bld_parts(ipre, ipl, ipl, &lp);
+
+	    lp->next = line;
+	    line = p;
+	}
+	if (qipl) {
+	    Cline lp, p = bld_parts(qipre, qipl, qipl, &lp);
+
+	    lp->next = line;
+	    line = p;
+	}
+    } else if (palen || pline) {
+	Cline p, lp;
+
+	if (palen) {
+	    char *apre = (char *) zhalloc(palen);
+
+	    if (qipl)
+		memcpy(apre, qipre, qipl);
+	    if (ipl)
+		memcpy(apre + qipl, ipre, ipl);
+	    if (pl)
+		memcpy(apre + qipl + ipl, pre, pl);
+	    if (ppl)
+		memcpy(apre + qipl + ipl + pl, ppre, ppl);
+
+	    p = bld_parts(apre, palen, palen, &lp);
+
+	    if (pline)
+		for (lp->next = cp_cline(pline, 1); lp->next; lp = lp->next);
+	} else
+	    for (p = lp = cp_cline(pline, 1); lp->next; lp = lp->next);
+
+	if (lp->prefix && !(line->flags & (CLF_SUF | CLF_MID)) &&
+	    !p->llen && !p->wlen && !p->olen) {
+	    Cline lpp;
+
+	    for (lpp = lp->prefix; lpp->next; lpp = lpp->next);
+
+	    lpp->next = line->prefix;
+	    line->prefix = lp->prefix;
+	    lp->prefix = NULL;
+
+	    free_cline(lp);
+
+	    if (p != lp) {
+		Cline q;
+
+		for (q = p; q->next != lp; q = q->next);
+
+		q->next = line;
+		line = p;
+	    }
+	} else {
+	    lp->next = line;
+	    line = p;
+	}
+    }
+    /* Allocate and fill the match structure. */
+    cm = (Cmatch) zhalloc(sizeof(struct cmatch));
+    cm->str = str;
+    cm->ppre = (ppre && *ppre ? ppre : NULL);
+    cm->psuf = (psuf && *psuf ? psuf : NULL);
+    cm->prpre = ((flags & CMF_FILE) && prpre && *prpre ? prpre : NULL);
+    if (qipre && *qipre)
+	cm->ipre = (ipre && *ipre ? dyncat(qipre, ipre) : dupstring(qipre));
+    else
+	cm->ipre = (ipre && *ipre ? ipre : NULL);
+    cm->ripre = (ripre && *ripre ? ripre : NULL);
+    if (qisuf && *qisuf)
+	cm->isuf = (isuf && *isuf ? dyncat(isuf, qisuf) : dupstring(qisuf));
+    else
+	cm->isuf = (isuf && *isuf ? isuf : NULL);
+    cm->pre = pre;
+    cm->suf = suf;
+    cm->flags = flags;
+    if (nbrbeg) {
+	int *p;
+	Brinfo bp;
+
+	cm->brpl = (int *) zhalloc(nbrbeg * sizeof(int));
+
+	for (p = cm->brpl, bp = brbeg; bp; p++, bp = bp->next)
+	    *p = bp->curpos;
+    } else
+	cm->brpl = NULL;
+    if (nbrend) {
+	int *p;
+	Brinfo bp;
+
+	cm->brsl = (int *) zhalloc(nbrend * sizeof(int));
+
+	for (p = cm->brsl, bp = brend; bp; p++, bp = bp->next)
+	    *p = bp->curpos;
+    } else
+	cm->brsl = NULL;
+    cm->qipl = qipl;
+    cm->qisl = qisl;
+    cm->autoq = (autoq ? autoq : (inbackt ? '`' : '\0'));
+    cm->rems = cm->remf = cm->disp = NULL;
+
+    if ((lastprebr || lastpostbr) && !hasbrpsfx(cm, lastprebr, lastpostbr))
+	return NULL;
+
+    /* Then build the unambiguous cline list. */
+    ai->line = join_clines(ai->line, line);
+
+    mnum++;
+    ai->count++;
+
+    addlinknode((alt ? fmatches : matches), cm);
+
+    newmatches = 1;
+
+    /* One more match for this explanation. */
+    if (curexpl) {
+	if (alt)
+	    curexpl->fcount++;
+	else
+	    curexpl->count++;
+    }
+    if (!ai->firstm)
+	ai->firstm = cm;
+
+    sl = strlen(str);
+    lpl = (cm->ppre ? strlen(cm->ppre) : 0);
+    lsl = (cm->psuf ? strlen(cm->psuf) : 0);
+    ml = sl + lpl + lsl;
+
+    if (ml < minmlen)
+	minmlen = ml;
+    if (ml > maxmlen)
+	maxmlen = ml;
+
+    /* Do we have an exact match? More than one? */
+    if (exact) {
+	if (!ai->exact) {
+	    ai->exact = 1;
+	    if (incompfunc) {
+		/* If a completion widget is active, we make the exact
+		 * string available in `compstate'. */
+
+		char *e;
+
+		zsfree(compexactstr);
+		compexactstr = e = (char *) zalloc(ml + 1);
+		if (cm->ppre) {
+		    strcpy(e, cm->ppre);
+		    e += lpl;
+		}
+		strcpy(e, str);
+		e += sl;
+		if (cm->psuf)
+		    strcpy(e, cm->psuf);
+		comp_setunset(0, 0, CP_EXACTSTR, 0);
+	    }
+	    ai->exactm = cm;
+	} else {
+	    ai->exact = 2;
+	    ai->exactm = NULL;
+	    if (incompfunc)
+		comp_setunset(0, 0, 0, CP_EXACTSTR);
+	}
+    }
+    return cm;
+}
+
+/* This begins a new group of matches. */
+
+/**/
+void
+begcmgroup(char *n, int flags)
+{
+    if (n) {
+	Cmgroup p = amatches;
+
+	while (p) {
+	    if (p->name &&
+		flags == (p->flags & (CGF_NOSORT|CGF_UNIQALL|CGF_UNIQCON)) &&
+		!strcmp(n, p->name)) {
+		mgroup = p;
+
+		expls = p->lexpls;
+		matches = p->lmatches;
+		fmatches = p->lfmatches;
+		allccs = p->lallccs;
+
+		return;
+	    }
+	    p = p->next;
+	}
+    }
+    mgroup = (Cmgroup) zhalloc(sizeof(struct cmgroup));
+    mgroup->name = dupstring(n);
+    mgroup->lcount = mgroup->llcount = mgroup->mcount = 0;
+    mgroup->flags = flags;
+    mgroup->matches = NULL;
+    mgroup->ylist = NULL;
+    mgroup->expls = NULL;
+
+    mgroup->lexpls = expls = newlinklist();
+    mgroup->lmatches = matches = newlinklist();
+    mgroup->lfmatches = fmatches = newlinklist();
+
+    mgroup->lallccs = allccs = ((flags & CGF_NOSORT) ? NULL : newlinklist());
+
+    mgroup->next = amatches;
+    amatches = mgroup;
+}
+
+/* End the current group for now. */
+
+/**/
+void
+endcmgroup(char **ylist)
+{
+    mgroup->ylist = ylist;
+}
+
+/* Add an explanation string to the current group, joining duplicates. */
+
+/**/
+void
+addexpl(void)
+{
+    LinkNode n;
+    Cexpl e;
+
+    for (n = firstnode(expls); n; incnode(n)) {
+	e = (Cexpl) getdata(n);
+	if (!strcmp(curexpl->str, e->str)) {
+	    e->count += curexpl->count;
+	    e->fcount += curexpl->fcount;
+
+	    return;
+	}
+    }
+    addlinknode(expls, curexpl);
+    newmatches = 1;
+}
+
+/* The comparison function for matches (used for sorting). */
+
+/**/
+static int
+matchcmp(Cmatch *a, Cmatch *b)
+{
+    if ((*a)->disp) {
+	if ((*b)->disp) {
+	    if ((*a)->flags & CMF_DISPLINE) {
+		if ((*b)->flags & CMF_DISPLINE)
+		    return strcmp((*a)->disp, (*b)->disp);
+		else
+		    return -1;
+	    } else {
+		if ((*b)->flags & CMF_DISPLINE)
+		    return 1;
+		else
+		    return strcmp((*a)->disp, (*b)->disp);
+	    }
+	}
+	return -1;
+    }
+    if ((*b)->disp)
+	return 1;
+
+    return strbpcmp(&((*a)->str), &((*b)->str));
+}
+
+/* This tests whether two matches are equal (would produce the same
+ * strings on the command line). */
+
+#define matchstreq(a, b) ((!(a) && !(b)) || ((a) && (b) && !strcmp((a), (b))))
+
+/**/
+static int
+matcheq(Cmatch a, Cmatch b)
+{
+    return matchstreq(a->ipre, b->ipre) &&
+	matchstreq(a->pre, b->pre) &&
+	matchstreq(a->ppre, b->ppre) &&
+	matchstreq(a->psuf, b->psuf) &&
+	matchstreq(a->suf, b->suf) &&
+	((!a->disp && !b->disp && matchstreq(a->str, b->str)) ||
+	 (a->disp && b->disp && !strcmp(a->disp, b->disp) &&
+	  matchstreq(a->str, b->str)));
+}
+
+/* Make an array from a linked list. The second argument says whether *
+ * the array should be sorted. The third argument is used to return   *
+ * the number of elements in the resulting array. The fourth argument *
+ * is used to return the number of NOLIST elements. */
+
+/**/
+static Cmatch *
+makearray(LinkList l, int type, int flags, int *np, int *nlp, int *llp)
+{
+    Cmatch *ap, *bp, *cp, *rp;
+    LinkNode nod;
+    int n, nl = 0, ll = 0;
+
+    /* Build an array for the matches. */
+    rp = ap = (Cmatch *) ncalloc(((n = countlinknodes(l)) + 1) *
+				 sizeof(Cmatch));
+
+    /* And copy them into it. */
+    for (nod = firstnode(l); nod; incnode(nod))
+	*ap++ = (Cmatch) getdata(nod);
+    *ap = NULL;
+
+    if (!type) {
+	if (flags) {
+	    char **ap, **bp, **cp;
+
+	    /* Now sort the array (it contains strings). */
+	    qsort((void *) rp, n, sizeof(char *),
+		  (int (*) _((const void *, const void *)))strbpcmp);
+
+	    /* And delete the ones that occur more than once. */
+	    for (ap = cp = (char **) rp; *ap; ap++) {
+		*cp++ = *ap;
+		for (bp = ap; bp[1] && !strcmp(*ap, bp[1]); bp++, n--);
+		ap = bp;
+	    }
+	    *cp = NULL;
+	}
+    } else {
+	if (!(flags & CGF_NOSORT)) {
+	    /* Now sort the array (it contains matches). */
+	    qsort((void *) rp, n, sizeof(Cmatch),
+		  (int (*) _((const void *, const void *)))matchcmp);
+
+	    if (!(flags & CGF_UNIQCON)) {
+		/* And delete the ones that occur more than once. */
+		for (ap = cp = rp; *ap; ap++) {
+		    *cp++ = *ap;
+		    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
+		    ap = bp;
+		    /* Mark those, that would show the same string in the list. */
+		    for (; bp[1] && !(*ap)->disp && !(bp[1])->disp &&
+			     !strcmp((*ap)->str, (bp[1])->str); bp++)
+			(bp[1])->flags |= CMF_NOLIST;
+		}
+		*cp = NULL;
+	    }
+	    for (ap = rp; *ap; ap++) {
+		if ((*ap)->disp && ((*ap)->flags & CMF_DISPLINE))
+		    ll++;
+		if ((*ap)->flags & CMF_NOLIST)
+		    nl++;
+	    }
+	} else {
+	    if (!(flags & CGF_UNIQALL) && !(flags & CGF_UNIQCON)) {
+		for (ap = rp; *ap; ap++) {
+		    for (bp = cp = ap + 1; *bp; bp++) {
+			if (!matcheq(*ap, *bp))
+			    *cp++ = *bp;
+			else
+			    n--;
+		    }
+		    *cp = NULL;
+		}
+	    } else if (!(flags & CGF_UNIQCON)) {
+		for (ap = cp = rp; *ap; ap++) {
+		    *cp++ = *ap;
+		    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
+		    ap = bp;
+		    for (; bp[1] && !(*ap)->disp && !(bp[1])->disp &&
+			     !strcmp((*ap)->str, (bp[1])->str); bp++)
+			(bp[1])->flags |= CMF_NOLIST;
+		}
+		*cp = NULL;
+	    }
+	    for (ap = rp; *ap; ap++) {
+		if ((*ap)->disp && ((*ap)->flags & CMF_DISPLINE))
+		    ll++;
+		if ((*ap)->flags & CMF_NOLIST)
+		    nl++;
+	    }
+	}
+    }
+    if (np)
+	*np = n;
+    if (nlp)
+	*nlp = nl;
+    if (llp)
+	*llp = ll;
+    return rp;
+}
+
+/* This duplicates one match. */
+
+/**/
+static Cmatch
+dupmatch(Cmatch m, int nbeg, int nend)
+{
+    Cmatch r;
+
+    r = (Cmatch) ncalloc(sizeof(struct cmatch));
+
+    r->str = ztrdup(m->str);
+    r->ipre = ztrdup(m->ipre);
+    r->ripre = ztrdup(m->ripre);
+    r->isuf = ztrdup(m->isuf);
+    r->ppre = ztrdup(m->ppre);
+    r->psuf = ztrdup(m->psuf);
+    r->prpre = ztrdup(m->prpre);
+    r->pre = ztrdup(m->pre);
+    r->suf = ztrdup(m->suf);
+    r->flags = m->flags;
+    if (nbeg) {
+	int *p, *q, i;
+
+	r->brpl = (int *) zalloc(nbeg * sizeof(int));
+
+	for (p = r->brpl, q = m->brpl, i = nbeg; i--; p++, q++)
+	    *p = *q;
+    } else
+	r->brpl = NULL;
+    if (nend) {
+	int *p, *q, i;
+
+	r->brsl = (int *) zalloc(nend * sizeof(int));
+
+	for (p = r->brsl, q = m->brsl, i = nend; i--; p++, q++)
+	    *p = *q;
+    } else
+	r->brsl = NULL;
+    r->rems = ztrdup(m->rems);
+    r->remf = ztrdup(m->remf);
+    r->autoq = m->autoq;
+    r->qipl = m->qipl;
+    r->qisl = m->qisl;
+    r->disp = dupstring(m->disp);
+
+    return r;
+}
+
+/* This duplicates all groups of matches. */
+
+/**/
+int
+permmatches(int last)
+{
+    Cmgroup g = amatches, n;
+    Cmatch *p, *q;
+    Cexpl *ep, *eq, e, o;
+    LinkList mlist;
+    static int fi = 0;
+    int nn, nl, ll, gn = 1, mn = 1, rn;
+
+    if (pmatches && !newmatches)
+	return fi;
+
+    newmatches = fi = 0;
+
+    if (pmatches)
+	freematches(pmatches);
+
+    pmatches = lmatches = NULL;
+    nmatches = smatches = 0;
+
+    if (!ainfo->count) {
+	if (last)
+	    ainfo = fainfo;
+	fi = 1;
+    }
+    while (g) {
+	HEAPALLOC {
+	    if (empty(g->lmatches))
+		/* We have no matches, try ignoring fignore. */
+		mlist = g->lfmatches;
+	    else
+		mlist = g->lmatches;
+
+	    g->matches = makearray(mlist, 1, g->flags, &nn, &nl, &ll);
+	    g->mcount = nn;
+	    if ((g->lcount = nn - nl) < 0)
+		g->lcount = 0;
+	    g->llcount = ll;
+	    if (g->ylist) {
+		g->lcount = arrlen(g->ylist);
+		smatches = 2;
+	    }
+	    g->expls = (Cexpl *) makearray(g->lexpls, 0, 0, &(g->ecount),
+					   NULL, NULL);
+
+	    g->ccount = 0;
+	} LASTALLOC;
+
+	nmatches += g->mcount;
+	smatches += g->lcount;
+
+	n = (Cmgroup) ncalloc(sizeof(struct cmgroup));
+
+	if (!lmatches)
+	    lmatches = n;
+	if (pmatches)
+	    pmatches->prev = n;
+	n->next = pmatches;
+	pmatches = n;
+	n->prev = 0;
+	n->num = gn++;
+
+	n->flags = g->flags;
+	n->mcount = g->mcount;
+	n->matches = p = (Cmatch *) ncalloc((n->mcount + 1) *
+					    sizeof(Cmatch));
+	for (q = g->matches; *q; q++, p++)
+	    *p = dupmatch(*q, nbrbeg, nbrend);
+	*p = NULL;
+
+	n->lcount = g->lcount;
+	n->llcount = g->llcount;
+	if (g->ylist)
+	    n->ylist = arrdup(g->ylist);
+	else
+	    n->ylist = NULL;
+
+	if ((n->ecount = g->ecount)) {
+	    n->expls = ep = (Cexpl *) ncalloc((n->ecount + 1) *
+					      sizeof(Cexpl));
+	    for (eq = g->expls; (o = *eq); eq++, ep++) {
+		*ep = e = (Cexpl) ncalloc(sizeof(struct cexpl));
+		e->count = (fi ? o->fcount : o->count);
+		e->str = ztrdup(o->str);
+	    }
+	    *ep = NULL;
+	} else
+	    n->expls = NULL;
+
+	n->widths = NULL;
+
+	g = g->next;
+    }
+    for (g = pmatches; g; g = g->next) {
+	g->nbrbeg = nbrbeg;
+	g->nbrend = nbrend;
+	for (rn = 1, q = g->matches; *q; q++) {
+	    (*q)->rnum = rn++;
+	    (*q)->gnum = mn++;
+	}
+    }
+    hasperm = 1;
+    permmnum = mn - 1;
+    permgnum = gn - 1;
+    listdat.valid = 0;
+
+    return fi;
+}
+
+/* This frees one match. */
+
+/**/
+static void
+freematch(Cmatch m, int nbeg, int nend)
+{
+    if (!m) return;
+
+    zsfree(m->str);
+    zsfree(m->ipre);
+    zsfree(m->ripre);
+    zsfree(m->isuf);
+    zsfree(m->ppre);
+    zsfree(m->psuf);
+    zsfree(m->pre);
+    zsfree(m->suf);
+    zsfree(m->prpre);
+    zsfree(m->rems);
+    zsfree(m->remf);
+    zsfree(m->disp);
+    zfree(m->brpl, nbeg * sizeof(int));
+    zfree(m->brsl, nend * sizeof(int));
+
+    zfree(m, sizeof(m));
+}
+
+/* This frees the groups of matches. */
+
+/**/
+void
+freematches(Cmgroup g)
+{
+    Cmgroup n;
+    Cmatch *m;
+    Cexpl *e;
+
+    while (g) {
+	n = g->next;
+	
+	for (m = g->matches; *m; m++)
+	    freematch(*m, g->nbrbeg, g->nbrend);
+
+	if (g->ylist)
+	    freearray(g->ylist);
+
+	if ((e = g->expls)) {
+	    while (*e) {
+		zsfree((*e)->str);
+		free(*e);
+		e++;
+	    }
+	    free(g->expls);
+	}
+	free(g);
+
+	g = n;
+    }
+}
diff --git a/Src/Zle/complete.c b/Src/Zle/complete.c
index 283b8de62..b4d32a34c 100644
--- a/Src/Zle/complete.c
+++ b/Src/Zle/complete.c
@@ -1,5 +1,5 @@
 /*
- * complete.c - the complete module
+ * complete.c - the complete module, interface part
  *
  * This file is part of zsh, the Z shell.
  *
@@ -28,10 +28,55 @@
  */
 
 #include "complete.mdh"
-#include "complete.pro"
 #define GLOBAL_PROTOTYPES
 #include "zle_tricky.pro"
 #undef GLOBAL_PROTOTYPES
+#include "complete.pro"
+
+/* Global matcher. */
+
+/**/
+Cmlist cmatcher;
+
+/* global variables for shell parameters in new style completion */
+
+/**/
+zlong compcurrent,
+      compmatcher,
+      compmatchertot,
+      complistmax,
+      complistlines;
+
+/**/
+char **compwords,
+     *compprefix,
+     *compsuffix,
+     *compiprefix,
+     *compisuffix,
+     *compqiprefix,
+     *compqisuffix,
+     *compmatcherstr,
+     *compcontext,
+     *compparameter,
+     *compredirect,
+     *compquote,
+     *compquoting,
+     *comprestore,
+     *complist,
+     *compforcelist,
+     *compinsert,
+     *compexact,
+     *compexactstr,
+     *comppatmatch,
+     *comppatinsert,
+     *complastprompt,
+     *comptoend,
+     *compoldlist,
+     *compoldins,
+     *compvared;
+
+/**/
+Param *comprpms, *compkpms;
 
 /**/
 void
@@ -88,6 +133,7 @@ freecpattern(Cpattern p)
 
 /* Copy a list of completion matchers. */
 
+/**/
 static Cmlist
 cpcmlist(Cmlist l)
 {
@@ -399,7 +445,7 @@ bin_compadd(char *name, char **argv, char *ops, int func)
     }
     dat.ipre = dat.isuf = dat.ppre = dat.psuf = dat.prpre =
 	dat.pre = dat.suf = dat.group = dat.rems = dat.remf = dat.disp = 
-	dat.ign = dat.exp = dat.apar = dat.opar = dat.dpar = dat.ylist = NULL;
+	dat.ign = dat.exp = dat.apar = dat.opar = dat.dpar = NULL;
     dat.match = NULL;
     dat.flags = 0;
     dat.aflags = CAF_MATCH;
@@ -462,10 +508,6 @@ bin_compadd(char *name, char **argv, char *ops, int func)
 		if (!(dat.aflags & CAF_UNIQALL))
 		    dat.aflags |= CAF_UNIQCON;
 		break;
-	    case 'y':
-		sp = &(dat.ylist);
-		e = "string expected after -%c";
-		break;
 	    case 'i':
 		sp = &(dat.ipre);
 		e = "string expected after -%c";
@@ -644,6 +686,7 @@ restrict_range(int b, int e)
     }
 }
 
+/**/
 static int
 do_comp_vars(int test, int na, char *sa, int nb, char *sb, int mod)
 {
@@ -1284,12 +1327,36 @@ static struct paramdef patab[] = {
     PARAMDEF("compmatchers", PM_ARRAY|PM_SPECIAL, NULL, cmsetfn, cmgetfn, cmunsetfn)
 };
 
+/* The order of the entries in this table has to match the *HOOK
+ * macros in comp.h */
+
+/**/
+struct hookdef comphooks[] = {
+    HOOKDEF("insert_match", NULL, HOOKF_ALL),
+    HOOKDEF("menu_start", NULL, HOOKF_ALL),
+    HOOKDEF("compctl_make", NULL, 0),
+    HOOKDEF("compctl_before", NULL, 0),
+    HOOKDEF("compctl_after", NULL, 0),
+    HOOKDEF("comp_list_matches", ilistmatches, 0),
+};
+
 /**/
 int
 setup_complete(Module m)
 {
-    makecompparamsptr = makecompparams;
-    comp_setunsetptr = comp_setunset;
+    hasperm = 0;
+
+    comprpms = compkpms = NULL;
+    compwords = NULL;
+    compprefix = compsuffix = compiprefix = compisuffix = 
+	compqiprefix = compqisuffix = compmatcherstr = 
+	compcontext = compparameter = compredirect = compquote =
+	compquoting = comprestore = complist = compinsert =
+	compexact = compexactstr = comppatmatch = comppatinsert =
+	compforcelist = complastprompt = comptoend = 
+	compoldlist = compoldins = compvared = NULL;
+
+    hascompmod = 1;
 
     return 0;
 }
@@ -1298,6 +1365,14 @@ setup_complete(Module m)
 int
 boot_complete(Module m)
 {
+    addhookfunc("complete", (Hookfn) do_completion);
+    addhookfunc("before_complete", (Hookfn) before_complete);
+    addhookfunc("after_complete", (Hookfn) after_complete);
+    addhookfunc("accept_completion", (Hookfn) accept_last);
+    addhookfunc("reverse_menu", (Hookfn) reverse_menu);
+    addhookfunc("list_matches", (Hookfn) list_matches);
+    addhookfunc("invalidate_list", (Hookfn) invalidate_list);
+    addhookdefs(m->nam, comphooks, sizeof(comphooks)/sizeof(*comphooks));
     if (!(addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)) |
 	  addconddefs(m->nam, cotab, sizeof(cotab)/sizeof(*cotab)) |
 	  addparamdefs(m->nam, patab, sizeof(patab)/sizeof(*patab)) |
@@ -1312,6 +1387,14 @@ boot_complete(Module m)
 int
 cleanup_complete(Module m)
 {
+    deletehookfunc("complete", (Hookfn) do_completion);
+    deletehookfunc("before_complete", (Hookfn) before_complete);
+    deletehookfunc("after_complete", (Hookfn) after_complete);
+    deletehookfunc("accept_completion", (Hookfn) accept_last);
+    deletehookfunc("reverse_menu", (Hookfn) reverse_menu);
+    deletehookfunc("list_matches", (Hookfn) list_matches);
+    deletehookfunc("invalidate_list", (Hookfn) invalidate_list);
+    deletehookdefs(m->nam, comphooks, sizeof(comphooks)/sizeof(*comphooks));
     deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
     deleteconddefs(m->nam, cotab, sizeof(cotab)/sizeof(*cotab));
     deleteparamdefs(m->nam, patab, sizeof(patab)/sizeof(*patab));
@@ -1323,8 +1406,34 @@ cleanup_complete(Module m)
 int
 finish_complete(Module m)
 {
-    makecompparamsptr = NULL;
-    comp_setunsetptr = NULL;
+    freearray(compwords);
+    zsfree(compprefix);
+    zsfree(compsuffix);
+    zsfree(compiprefix);
+    zsfree(compisuffix);
+    zsfree(compqiprefix);
+    zsfree(compqisuffix);
+    zsfree(compmatcherstr);
+    zsfree(compcontext);
+    zsfree(compparameter);
+    zsfree(compredirect);
+    zsfree(compquote);
+    zsfree(compquoting);
+    zsfree(comprestore);
+    zsfree(complist);
+    zsfree(compforcelist);
+    zsfree(compinsert);
+    zsfree(compexact);
+    zsfree(compexactstr);
+    zsfree(comppatmatch);
+    zsfree(comppatinsert);
+    zsfree(complastprompt);
+    zsfree(comptoend);
+    zsfree(compoldlist);
+    zsfree(compoldins);
+    zsfree(compvared);
+
+    hascompmod = 0;
 
     return 0;
 }
diff --git a/Src/Zle/complete.mdd b/Src/Zle/complete.mdd
index 628058e2a..3ea802065 100644
--- a/Src/Zle/complete.mdd
+++ b/Src/Zle/complete.mdd
@@ -8,4 +8,6 @@ autoprefixconds="prefix suffix between after"
 
 autoparams="compmatchers"
 
-objects="complete.o"
+headers="comp.h"
+
+objects="complete.o compcore.o compmatch.o compresult.o"
diff --git a/Src/Zle/complist.c b/Src/Zle/complist.c
index cc2ac7517..405f3a6d2 100644
--- a/Src/Zle/complist.c
+++ b/Src/Zle/complist.c
@@ -622,7 +622,7 @@ domenuselect(Hookdef dummy, Chdata dat)
 		fixsuffix();
 		validlist = 0;
 		amatches = pmatches = lastmatches = NULL;
-		invalidatelist();
+		invalidate_list();
 		PERMALLOC {
 		    menucomplete(zlenoargs);
 		} LASTALLOC;
@@ -653,7 +653,7 @@ domenuselect(Hookdef dummy, Chdata dat)
 		s->nbrbeg = nbrbeg;
 		s->nbrend = nbrend;
 		s->nmatches = nmatches;
-		acceptlast();
+		accept_last();
 		do_menucmp(0);
 		mselect = (*(minfo.cur))->gnum;
 		setwish = 1;
@@ -913,7 +913,7 @@ boot_complist(Module m)
 		 NULL, 0);
 	return -1;
     }
-    addhookfunc("list_matches", (Hookfn) complistmatches);
+    addhookfunc("comp_list_matches", (Hookfn) complistmatches);
     addhookfunc("menu_start", (Hookfn) domenuselect);
     mskeymap = newkeymap(NULL, "menuselect");
     linkkeymap(mskeymap, "menuselect", 1);
@@ -941,7 +941,7 @@ cleanup_complist(Module m)
     free(mgtab);
 
     deletezlefunction(w_menuselect);
-    deletehookfunc("list_matches", (Hookfn) complistmatches);
+    deletehookfunc("comp_list_matches", (Hookfn) complistmatches);
     deletehookfunc("menu_start", (Hookfn) domenuselect);
     unlinkkeymap("menuselect", 1);
     return 0;
diff --git a/Src/Zle/compmatch.c b/Src/Zle/compmatch.c
new file mode 100644
index 000000000..32e0c3a68
--- /dev/null
+++ b/Src/Zle/compmatch.c
@@ -0,0 +1,1906 @@
+/*
+ * compmatch.c - the complete module, completion matching code
+ *
+ * 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 "complete.mdh"
+#define GLOBAL_PROTOTYPES
+#include "zle_tricky.pro"
+#undef GLOBAL_PROTOTYPES
+#include "compmatch.pro"
+
+/* Convenience macro for calling bslashquote() (formerly quotename()). */
+
+#define quotename(s, e) bslashquote(s, e, instring)
+
+/* This compares two cpattern lists and returns non-zero if they are
+ * equal. */
+
+/**/
+static int
+cmp_cpatterns(Cpattern a, Cpattern b)
+{
+    while (a) {
+	if (a->equiv != b->equiv || memcmp(a->tab, b->tab, 256))
+	    return 0;
+	a = a->next;
+	b = b->next;
+    }
+    return 1;
+}
+
+/* This compares two cmatchers and returns non-zero if they are equal. */
+
+/**/
+static int
+cmp_cmatchers(Cmatcher a, Cmatcher b)
+{
+    return (a == b ||
+	    (a->flags == b->flags &&
+	     a->llen == b->llen && a->wlen == b->wlen &&
+	     (!a->llen || cmp_cpatterns(a->line, b->line)) &&
+	     (a->wlen <= 0 || cmp_cpatterns(a->word, b->word)) &&
+	     (!(a->flags & CMF_LEFT) ||
+	      (a->lalen == b->lalen &&
+	       (!a->lalen || cmp_cpatterns(a->left, b->left)))) &&
+	     (!(a->flags & CMF_RIGHT) ||
+	      (a->ralen == b->ralen &&
+	       (!a->ralen || cmp_cpatterns(a->right, b->right))))));
+}
+
+/* Add the given matchers to the bmatcher list. */
+
+/**/
+void
+add_bmatchers(Cmatcher m)
+{
+    Cmlist old = bmatchers, *q = &bmatchers, n;
+
+    for (; m; m = m->next) {
+	if ((!m->flags && m->wlen > 0 && m->llen > 0) ||
+	    (m->flags == CMF_RIGHT && m->wlen == -1 && !m->llen)) {
+	    *q = n = (Cmlist) zhalloc(sizeof(struct cmlist));
+	    n->matcher = m;
+	    q = &(n->next);
+	}
+    }
+    *q = old;
+}
+
+/* This is called when the matchers in the mstack have changed to
+ * ensure that the bmatchers list contains no matchers not in mstack. */
+
+/**/
+void
+update_bmatchers(void)
+{
+    Cmlist p = bmatchers, q = NULL, ms;
+    Cmatcher mp;
+    int t;
+
+    while (p) {
+	t = 0;
+	for (ms = mstack; ms && !t; ms = ms->next)
+	    for (mp = ms->matcher; mp && !t; mp = mp->next)
+		t = cmp_cmatchers(mp, p->matcher);
+
+	p = p->next;
+	if (!t) {
+	    if (q)
+		q->next = p;
+	    else
+		bmatchers = p;
+	}
+    }
+}
+
+/* This returns a new Cline structure. */
+
+/**/
+Cline
+get_cline(char *l, int ll, char *w, int wl, char *o, int ol, int fl)
+{
+    Cline r;
+
+    /* Prefer to take it from the buffer list (freecl), if there
+     * is none, allocate a new one. */
+
+    if ((r = freecl))
+	freecl = r->next;
+    else
+	r = (Cline) zhalloc(sizeof(*r));
+
+    r->next = NULL;
+    r->line = l; r->llen = ll;
+    r->word = w; r->wlen = wl;
+    r->orig = o; r->olen = ol;
+    r->slen = 0;
+    r->flags = fl;
+    r->prefix = r->suffix = NULL;
+    return r;
+}
+
+/* This frees a cline list. */
+
+/**/
+void
+free_cline(Cline l)
+{
+    Cline n;
+
+    while (l) {
+	n = l->next;
+	l->next = freecl;
+	freecl = l;
+	free_cline(l->prefix);
+	free_cline(l->suffix);
+	l = n;
+    }
+}
+
+/* Copy a cline list. */
+
+/**/
+Cline
+cp_cline(Cline l, int deep)
+{
+    Cline r = NULL, *p = &r, t, lp = NULL;
+
+    while (l) {
+	if ((t = freecl))
+	    freecl = t->next;
+	else
+	    t = (Cline) zhalloc(sizeof(*t));
+	memcpy(t, l, sizeof(*t));
+	if (deep) {
+	    if (t->prefix)
+		t->prefix = cp_cline(t->prefix, 0);
+	    if (t->suffix)
+		t->suffix = cp_cline(t->suffix, 0);
+	}
+	*p = lp = t;
+	p = &(t->next);
+	l = l->next;
+    }
+    *p = NULL;
+
+    return r;
+}
+
+/* Calculate the length of a cline and its sub-lists. */
+
+/**/
+int
+cline_sublen(Cline l)
+{
+    int len = ((l->flags & CLF_LINE) ? l->llen : l->wlen);
+
+    if (l->olen && !((l->flags & CLF_SUF) ? l->suffix : l->prefix))
+	len += l->olen;
+    else {
+	Cline p;
+
+	for (p = l->prefix; p; p = p->next)
+	    len += ((p->flags & CLF_LINE) ? p->llen : p->wlen);
+	for (p = l->suffix; p; p = p->next)
+	    len += ((p->flags & CLF_LINE) ? p->llen : p->wlen);
+    }
+    return len;
+}
+
+/* Set the lengths in the cline lists. */
+
+/**/
+void
+cline_setlens(Cline l, int both)
+{
+    while (l) {
+	l->max = cline_sublen(l);
+	if (both)
+	    l->min = l->max;
+	l = l->next;
+    }
+}
+
+/* This sets the CLF_MATCHED flag in the given clines. */
+
+/**/
+void
+cline_matched(Cline p)
+{
+    while (p) {
+	p->flags |= CLF_MATCHED;
+	cline_matched(p->prefix);
+	cline_matched(p->suffix);
+
+	p = p->next;
+    }
+}
+
+/* This reverts the order of the elements of the given cline list and
+ * returns a pointer to the new head. */
+
+/**/
+Cline
+revert_cline(Cline p)
+{
+    Cline r = NULL, n;
+
+    while (p) {
+	n = p->next;
+	p->next = r;
+	r = p;
+	p = n;
+    }
+    return r;
+}
+
+/* Global variables used during matching: a char-buffer for the string to
+ * use for the match, and two cline lists for the two levels we use. */
+
+/**/
+char *matchbuf = NULL;
+/**/
+int matchbuflen = 0, matchbufadded;
+
+/**/
+Cline matchparts, matchlastpart;
+/**/
+Cline matchsubs, matchlastsub;
+
+/* This initialises the variables above. */
+
+/**/
+static void
+start_match(void)
+{
+    if (matchbuf)
+	*matchbuf = '\0';
+    matchbufadded = 0;
+    matchparts = matchlastpart = matchsubs = matchlastsub = NULL;
+}
+
+/* This aborts a matching, freeing the cline lists build. */
+
+/**/
+static void
+abort_match(void)
+{
+    free_cline(matchparts);
+    free_cline(matchsubs);
+    matchparts = matchsubs = NULL;
+}
+
+/* This adds a new string in the static char buffer. The arguments are
+ * the matcher used (if any), the strings from the line and the word
+ * and the length of the string from the word. The last argument is
+ * non-zero if we are matching a suffix (where the given string has to 
+ * be prepended to the contents of the buffer). */
+
+/**/
+static void
+add_match_str(Cmatcher m, char *l, char *w, int wl, int sfx)
+{
+    /* Get the string and length to insert: either from the line 
+     * or from the match. */
+    if (m && (m->flags & CMF_LINE)) {
+	wl = m->llen; w = l;
+    }
+    if (wl) {
+	/* Probably resize the buffer. */
+	if (matchbuflen - matchbufadded <= wl) {
+	    int blen = matchbuflen + wl + 20;
+	    char *buf;
+
+	    buf = (char *) zalloc(blen);
+	    memcpy(buf, matchbuf, matchbuflen);
+	    zfree(matchbuf, matchbuflen);
+	    matchbuf = buf;
+	    matchbuflen = blen;
+	}
+	/* Insert the string. */
+	if (sfx) {
+	    memmove(matchbuf + wl, matchbuf, matchbufadded + 1);
+	    memcpy(matchbuf, w, wl);
+	} else
+	    memcpy(matchbuf + matchbufadded, w, wl);
+	matchbufadded += wl;
+	matchbuf[matchbufadded] = '\0';
+    }
+}
+
+/* This adds a cline for a word-part during matching. Arguments are the
+ * matcher used, pointers to the line and word strings for the anchor,
+ * a pointer to the original line string for the whole part, the string
+ * before (or after) the anchor that has not yet been added, the length
+ * of the line-string for that, and a flag saying if we are matching a 
+ * suffix. */
+
+/**/
+static void
+add_match_part(Cmatcher m, char *l, char *w, int wl,
+	       char *o, int ol, char *s, int sl, int osl, int sfx)
+{
+    Cline p, lp;
+
+    /* If the anchors are equal, we keep only one. */
+
+    if (!strncmp(l, w, wl))
+	l = NULL;
+
+    /* Split the new part into parts and turn the last one into a
+     * `suffix' if we have a left anchor. */
+
+    p = bld_parts(s, sl, osl, &lp);
+
+    p->flags &= ~CLF_NEW;
+    if (m && (m->flags & CMF_LEFT)) {
+	lp->flags |= CLF_SUF;
+	lp->suffix = lp->prefix;
+	lp->prefix = NULL;
+    }
+    /* cline lists for suffixes are sorted from back to front, so we have
+     * to revert the list we got. */
+    if (sfx)
+	p = revert_cline(lp = p);
+    /* Now add the sub-clines we already had. */
+    if (matchsubs) {
+	if (sfx) {
+	    Cline q;
+
+	    if ((q = lp->prefix)) {
+		while (q->next)
+		    q = q->next;
+		q->next = matchsubs;
+	    } else
+		lp->prefix = matchsubs;
+
+	    matchlastsub->next = NULL;
+	} else {
+	    matchlastsub->next = p->prefix;
+	    p->prefix = matchsubs;
+	}
+	matchsubs = matchlastsub = NULL;
+    }
+    /* Store the arguments in the last part-cline. */
+    lp->line = l; lp->llen = wl;
+    lp->word = w; lp->wlen = wl;
+    lp->orig = o; lp->olen = ol;
+    lp->flags &= ~CLF_NEW;
+
+    /* Finally, put the new parts on the list. */
+    if (matchlastpart)
+	matchlastpart->next = p;
+    else
+	matchparts = p;
+    matchlastpart = lp;
+}
+
+/* This adds a new sub-cline. Arguments are the matcher and the strings from
+ * the line and the word. */
+
+/**/
+static void
+add_match_sub(Cmatcher m, char *l, int ll, char *w, int wl)
+{
+    int flags;
+    Cline n;
+
+    /* Check if we are interested only in the string from the line. */
+    if (m && (m->flags & CMF_LINE)) {
+	w = NULL; wl = 0;
+	flags = CLF_LINE;
+    } else
+	flags = 0;
+
+    /* And add the cline. */
+    if (wl || ll) {
+	n = get_cline(l, ll, w, wl, NULL, 0, flags);
+	if (matchlastsub)
+	    matchlastsub->next = n;
+	else
+	    matchsubs = n;
+	matchlastsub = n;
+    }
+}
+
+/* This tests if the string from the line l matches the word w. In bp
+ * the offset for the brace is returned, in rwlp the length of the
+ * matched prefix or suffix, not including the stuff before or after
+ * the last anchor is given. When sfx is non-zero matching is done from
+ * the ends of the strings backward, if test is zero, the global variables
+ * above are used to build the string for the match and the cline. If
+ * part is non-zero, we are satisfied if only a part of the line-string
+ * is used (and return the length used). */
+
+/**/
+int
+match_str(char *l, char *w, Brinfo *bpp, int bc, int *rwlp,
+	  int sfx, int test, int part)
+{
+    int ll = strlen(l), lw = strlen(w), oll = ll, olw = lw;
+    int il = 0, iw = 0, t, ind, add, he = 0, bpc, obc = bc;
+    VARARR(unsigned char, ea, ll + 1);
+    char *ow;
+    Cmlist ms;
+    Cmatcher mp, lm = NULL;
+    Brinfo bp = NULL;
+
+    if (!test) {
+	start_match();
+	bp = *bpp;
+    }
+    /* Adjust the pointers and get the values for subscripting and
+     * incrementing. */
+
+    if (sfx) {
+	l += ll; w += lw;
+	ind = -1; add = -1;
+    } else {
+	ind = 0; add = 1;
+    }
+    /* ow will always point to the beginning (or end) of that sub-string
+     * in w that wasn't put in the match-variables yet. */
+
+    ow = w;
+
+    /* If the brace is at the beginning, we have to treat it now. */
+
+    if (!test && bp && bc >= bp->pos) {
+	bp->curpos = bc;
+	bp = bp->next;
+    }
+    while (ll && lw) {
+	/* First try the matchers. */
+	for (mp = NULL, ms = mstack; !mp && ms; ms = ms->next) {
+	    for (mp = ms->matcher; mp; mp = mp->next) {
+		t = 1;
+		if ((lm && lm == mp) ||
+		    ((oll == ll || olw == lw) &&
+		     (test == 1 || (test && !mp->left && !mp->right)) &&
+		     mp->wlen < 0))
+		    /* If we were called recursively, don't use `*' patterns
+		     * at the beginning (avoiding infinite recursion). */
+		    continue;
+
+		if (mp->wlen < 0) {
+		    int both, loff, aoff, llen, alen, zoff, moff, ct, ict;
+		    char *tp, savl = '\0', savw;
+		    Cpattern ap;
+
+		    /* This is for `*' patterns, first initialise some
+		     * local variables. */
+		    llen = mp->llen;
+		    alen = (mp->flags & CMF_LEFT ? mp->lalen : mp->ralen);
+
+		    /* Give up if we don't have enough characters for the
+		     * line-string and the anchor. */
+		    if (ll < llen + alen || lw < alen)
+			continue;
+
+		    if (mp->flags & CMF_LEFT) {
+			ap = mp->left; zoff = 0; moff = alen;
+			if (sfx) {
+			    both = 0; loff = -llen; aoff = -(llen + alen);
+			} else {
+			    both = 1; loff = alen; aoff = 0;
+			}
+		    } else {
+			ap = mp->right; zoff = alen; moff = 0;
+			if (sfx) {
+			    both = 1; loff = -(llen + alen); aoff = -alen;
+			} else {
+			    both = 0; loff = 0; aoff = llen;
+			}
+		    }
+		    /* Try to match the line pattern and the anchor. */
+		    if (!pattern_match(mp->line, l + loff, NULL, NULL))
+			continue;
+		    if (ap) {
+			if (!pattern_match(ap, l + aoff, NULL, NULL) ||
+			    (both && (!pattern_match(ap, w + aoff, NULL, NULL) ||
+				      !match_parts(l + aoff, w + aoff, alen,
+						   part))))
+				continue;
+		    } else if (!both || il || iw)
+			continue;
+
+		    /* Fine, now we call ourselves recursively to find the
+		     * string matched by the `*'. */
+		    if (sfx) {
+			savl = l[-(llen + zoff)];
+			l[-(llen + zoff)] = '\0';
+		    }
+		    for (t = 0, tp = w, ct = 0, ict = lw - alen + 1;
+			 ict;
+			 tp += add, ct++, ict--) {
+			if ((both &&
+			     (!ap || !test ||
+			      !pattern_match(ap, tp + aoff, NULL, NULL))) ||
+			    (!both &&
+			     pattern_match(ap, tp - moff, NULL, NULL) &&
+			     match_parts(l + aoff , tp - moff, alen, part))) {
+			    if (sfx) {
+				savw = tp[-zoff];
+				tp[-zoff] = '\0';
+				t = match_str(l - ll, w - lw,
+					      NULL, 0, NULL, 1, 2, part);
+				tp[-zoff] = savw;
+			    } else
+				t = match_str(l + llen + moff, tp + moff,
+					      NULL, 0, NULL, 0, 1, part);
+			    if (t || !both)
+				break;
+			}
+		    }
+		    ict = ct;
+		    if (sfx)
+			l[-(llen + zoff)] = savl;
+
+		    /* Have we found a position in w where the rest of l
+		     * matches? */
+		    if (!t)
+			continue;
+
+		    /* Yes, add the strings and clines if this is a 
+		     * top-level call. */
+		    if (!test && (!he || (llen + alen))) {
+			char *op, *lp, *map, *wap, *wmp;
+			int ol;
+
+			if (sfx) {
+			    op = w; ol = ow - w; lp = l - (llen + alen);
+			    map = tp - alen;
+			    if (mp->flags & CMF_LEFT) {
+				wap = tp - alen; wmp = tp;
+			    } else {
+				wap = w - alen; wmp = tp - alen;
+			    }
+			} else {
+			    op = ow; ol = w - ow; lp = l;
+			    map = ow;
+			    if (mp->flags & CMF_LEFT) {
+				wap = w; wmp = w + alen;
+			    } else {
+				wap = tp; wmp = ow;
+			    }
+			}
+			/* If the matcher says that we are only interested
+			 * in the line pattern, we just add that and the
+			 * anchor and the string not added yet. Otherwise
+			 * we add a new part. */
+			if (mp->flags & CMF_LINE) {
+			    add_match_str(NULL, NULL, op, ol, sfx);
+			    add_match_str(NULL, NULL, lp, llen + alen, sfx);
+			    add_match_sub(NULL, NULL, ol, op, ol);
+			    add_match_sub(NULL, NULL, llen + alen,
+					  lp, llen + alen);
+			} else if (sfx) {
+			    add_match_str(NULL, NULL,
+					  map, ct + ol + alen, sfx);
+			    add_match_part(mp, l + aoff, wap, alen,
+					   l + loff, llen, op, ol, ol, sfx);
+			    add_match_sub(NULL, NULL, 0, wmp, ct);
+			} else {
+			    add_match_str(NULL, NULL,
+					  map, ct + ol + alen, sfx);
+			    if (both) {
+				add_match_sub(NULL, NULL, ol, op, ol);
+				ol = -1;
+			    } else
+				ct += ol;
+			    add_match_part(mp, l + aoff, wap, alen,
+					   l + loff, llen, wmp, ct, ol, sfx);
+			}
+		    }
+		    /* Now skip over the matched portion and the anchor. */
+		    llen += alen; alen += ict;
+		    if (sfx) {
+			l -= llen; w -= alen;
+		    } else {
+			l += llen; w += alen;
+		    }
+		    ll -= llen; il += llen;
+		    lw -= alen; iw += alen;
+		    bc += llen;
+
+		    if (!test)
+			while (bp &&
+			       bc >= (bpc = (useqbr ? bp->qpos : bp->pos))) {
+			    bp->curpos = matchbufadded + bpc - bc + obc;
+			    bp = bp->next;
+			}
+		    ow = w;
+
+		    if (!llen && !alen) {
+			lm = mp;
+			if (he)
+			    mp = NULL;
+			else
+			    he = 1;
+		    } else {
+			lm = NULL; he = 0;
+		    }
+		    break;
+		} else if (ll >= mp->llen && lw >= mp->wlen) {
+		    /* Non-`*'-pattern. */
+		    char *tl, *tw;
+		    int tll, tlw, til, tiw;
+
+		    /* We do this only if the line- and word-substrings
+		     * are not equal. */
+		    if (!(mp->flags & (CMF_LEFT | CMF_RIGHT)) &&
+			mp->llen == mp->wlen &&
+			!(sfx ? strncmp(l - mp->llen, w - mp->wlen, mp->llen) :
+			  strncmp(l, w, mp->llen)))
+			continue;
+
+		    /* Using local variables to make the following
+		     * independent of whether we match a prefix or a
+		     * suffix. */
+		    if (sfx) {
+			tl = l - mp->llen; tw = w - mp->wlen;
+			til = ll - mp->llen; tiw = lw - mp->wlen;
+			tll = il + mp->llen; tlw = iw + mp->wlen;
+		    } else {
+			tl = l; tw = w;
+			til = il; tiw = iw;
+			tll = ll; tlw = lw;
+		    }
+		    if (mp->flags & CMF_LEFT) {
+			/* Try to match the left anchor, if any. */
+			if (til < mp->lalen || tiw < mp->lalen)
+			    continue;
+			else if (mp->left)
+			    t = pattern_match(mp->left, tl - mp->lalen,
+					      NULL, NULL) &&
+				pattern_match(mp->left, tw - mp->lalen,
+					      NULL, NULL);
+			else
+			    t = (!sfx && !il && !iw);
+		    }
+		    if (mp->flags & CMF_RIGHT) {
+			/* Try to match the right anchor, if any. */
+			if (tll < mp->llen + mp->ralen ||
+			    tlw < mp->wlen + mp->ralen)
+			    continue;
+			else if (mp->left)
+			    t = pattern_match(mp->right,
+					      tl + mp->llen - mp->ralen,
+					      NULL, NULL) &&
+				pattern_match(mp->right,
+					      tw + mp->wlen - mp->ralen,
+					      NULL, NULL);
+			else
+			    t = (sfx && !il && !iw);
+		    }
+		    /* Now try to match the line and word patterns. */
+		    if (!t ||
+			!pattern_match(mp->line, tl, NULL, ea) ||
+			!pattern_match(mp->word, tw, ea, NULL))
+			continue;
+
+		    /* Probably add the matched strings. */
+		    if (!test) {
+			if (sfx)
+			    add_match_str(NULL, NULL, w, ow - w, 0);
+			else
+			    add_match_str(NULL, NULL, ow, w - ow, 0);
+			add_match_str(mp, tl, tw, mp->wlen, 0);
+			if (sfx)
+			    add_match_sub(NULL, NULL, 0, w, ow - w);
+			else
+			    add_match_sub(NULL, NULL, 0, ow, w - ow);
+
+			add_match_sub(mp, tl, mp->llen, tw, mp->wlen);
+		    }
+		    if (sfx) {
+			l = tl;	w = tw;
+		    } else {
+			l += mp->llen; w += mp->wlen;
+		    }
+		    il += mp->llen; iw += mp->wlen;
+		    ll -= mp->llen; lw -= mp->wlen;
+		    bc += mp->llen;
+
+		    if (!test)
+			while (bp &&
+			       bc >= (bpc = (useqbr ? bp->qpos : bp->pos))) {
+			    bp->curpos = matchbufadded + bpc - bc + obc;
+			    bp = bp->next;
+			}
+		    ow = w;
+		    lm = NULL;
+		    he = 0;
+		    break;
+		}
+	    }
+	}
+	if (mp)
+	    continue;
+
+	if (l[ind] == w[ind]) {
+	    /* No matcher could be used, but the strings have the same
+	     * character here, skip over it. */
+	    l += add; w += add;
+	    il++; iw++;
+	    ll--; lw--;
+	    bc++;
+	    if (!test)
+		while (bp && bc >= (useqbr ? bp->qpos : bp->pos)) {
+		    bp->curpos = matchbufadded + (sfx ? (ow - w) : (w - ow)) + obc;
+		    bp = bp->next;
+		}
+	    lm = NULL;
+	    he = 0;
+	} else {
+	    /* No matcher and different characters: l does not match w. */
+	    if (test)
+		return 0;
+
+	    abort_match();
+
+	    return -1;
+	}
+    }
+    /* If this is a recursive call, we just return if l matched w or not. */
+    if (test)
+	return (part || !ll);
+
+    /* In top-level calls, if ll is non-zero (unmatched portion in l),
+     * we have to free the collected clines. */
+    if (!part && ll) {
+	abort_match();
+
+	return -1;
+    }
+    if (rwlp)
+	*rwlp = iw - (sfx ? ow - w : w - ow);
+
+    /* If we matched a suffix, the anchors stored in the top-clines
+     * will be in the wrong clines: shifted by one. Adjust this. */
+    if (sfx && matchparts) {
+	Cline t, tn, s;
+
+	if (matchparts->prefix || matchparts->suffix) {
+	    t = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
+	    t->next = matchparts;
+	    if (matchparts->prefix)
+		t->prefix = (Cline) 1;
+	    else
+		t->suffix = (Cline) 1;
+	    matchparts = t;
+	}
+	for (t = matchparts; (tn = t->next); t = tn) {
+	    s = (tn->prefix ? tn->prefix : tn->suffix);
+	    if (t->suffix)
+		t->suffix = s;
+	    else
+		t->prefix = s;
+	}
+	t->prefix = t->suffix = NULL;
+    }
+    /* Finally, return the number of matched characters. */
+
+    *bpp = bp;
+    return (part ? il : iw);
+}
+
+/* Wrapper for match_str(), only for a certain length and only doing
+ * the test. */
+
+/**/
+static int
+match_parts(char *l, char *w, int n, int part)
+{
+    char lsav = l[n], wsav = w[n];
+    int ret;
+
+    l[n] = w[n] = '\0';
+    ret = match_str(l, w, NULL, 0, NULL, 0, 1, part);
+    l[n] = lsav;
+    w[n] = wsav;
+
+    return ret;
+}
+
+/* Check if the word w is matched by the strings in pfx and sfx (the prefix
+ * and the suffix from the line) or the pattern cp. In clp a cline list for
+ * w is returned.
+ * qu is non-zero if the words has to be quoted before processed any further.
+ * bpl and bsl are used to report the positions where the brace-strings in
+ * the prefix and the suffix have to be re-inserted if this match is inserted
+ * in the line.
+ * The return value is the string to use as a completion or NULL if the prefix
+ * and the suffix don't match the word w. */
+
+/**/
+char *
+comp_match(char *pfx, char *sfx, char *w, Patprog cp, Cline *clp, int qu,
+	   Brinfo *bpl, int bcp, Brinfo *bsl, int bcs, int *exact)
+{
+    char *r = NULL;
+
+    if (cp) {
+	/* We have a globcomplete-like pattern, just use that. */
+	int wl;
+
+	r = w;
+	if (!pattry(cp, r))
+	    return NULL;
+    
+	r = (qu ? quotename(r, NULL) : dupstring(r));
+	if (qu == 2 && r[0] == '\\' && r[1] == '~')
+	    chuck(r);
+	/* We still break it into parts here, trying to build a sensible
+	 * cline list for these matches, too. */
+	w = dupstring(w);
+	wl = strlen(w);
+	*clp = bld_parts(w, wl, wl, NULL);
+	*exact = 0;
+    } else {
+	Cline pli, plil;
+	int mpl, rpl, wl;
+
+	w = (qu ? quotename(w, NULL) : dupstring(w));
+	if (qu == 2 && w[0] == '\\' && w[1] == '~')
+	    chuck(w);
+
+	wl = strlen(w);
+
+	/* Always try to match the prefix. */
+
+	useqbr = qu;
+	if ((mpl = match_str(pfx, w, bpl, bcp, &rpl, 0, 0, 0)) < 0)
+	    return NULL;
+
+	if (sfx && *sfx) {
+	    int wpl = matchbufadded, msl, rsl;
+	    VARARR(char, wpfx, wpl);
+	    Cline mli, mlil;
+
+	    /* We also have a suffix to match, so first save the
+	     * contents of the global matching variables. */
+	    memcpy(wpfx, matchbuf, wpl);
+	    if (matchsubs) {
+		Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
+
+		tmp->prefix = matchsubs;
+		if (matchlastpart)
+		    matchlastpart->next = tmp;
+		else
+		    matchparts = tmp;
+	    }
+	    pli = matchparts;
+	    plil = matchlastpart;
+
+	    /* The try to match the suffix. */
+
+	    if ((msl = match_str(sfx, w + mpl, bsl, bcs, &rsl, 1, 0, 0)) < 0) {
+		free_cline(pli);
+
+		return NULL;
+	    }
+	    /* Matched, so add the string in the middle and the saved
+	     * string for the prefix, and build a combined cline list
+	     * for the prefix and the suffix. */
+	    if (matchsubs) {
+		Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, CLF_SUF);
+
+		tmp->suffix = matchsubs;
+		if (matchlastpart)
+		    matchlastpart->next = tmp;
+		else
+		    matchparts = tmp;
+	    }
+	    add_match_str(NULL, NULL, w + rpl, wl - rpl - rsl, 1);
+	    add_match_str(NULL, NULL, wpfx, wpl, 1);
+
+	    mli = bld_parts(w + rpl, wl - rpl - rsl,
+			    (mpl - rpl) + (msl - rsl), &mlil);
+	    mlil->flags |= CLF_MID;
+	    mlil->slen = msl - rsl;
+	    mlil->next = revert_cline(matchparts);
+
+	    if (plil)
+		plil->next = mli;
+	    else
+		pli = mli;
+	} else {
+	    /* Only a prefix, add the string and a part-cline for it. */
+	    add_match_str(NULL, NULL, w + rpl, wl - rpl, 0);
+
+	    add_match_part(NULL, NULL, NULL, 0, NULL, 0, w + rpl, wl - rpl,
+			   mpl - rpl, 0);
+	    pli = matchparts;
+	}
+	r = dupstring(matchbuf ? matchbuf : "");
+
+	*clp = pli;
+
+	/* Test if the string built is equal to the one from the line. */
+	if (sfx && *sfx) {
+	    int pl = strlen(pfx);
+
+	    *exact = (!strncmp(pfx, w, pl) && !strcmp(sfx, w + pl));
+	} else
+	    *exact = !strcmp(pfx, w);
+    }
+    if (!qu)
+	hasunqu = 1;
+
+    return r;
+}
+
+/* Check if the given pattern matches the given string.             *
+ * `in' and `out' are used for {...} classes. In `out' we store the *
+ * character number that was matched. In the word pattern this is   *
+ * given in `in' so that we can easily test if we found the         *
+ * corresponding character. */
+
+/**/
+static int
+pattern_match(Cpattern p, char *s, unsigned char *in, unsigned char *out)
+{
+    unsigned char c;
+
+    while (p) {
+	c = *((unsigned char *) s);
+
+	if (out)
+	    *out = 0;
+
+	if (p->equiv) {
+	    if (in) {
+		c = p->tab[c];
+		if ((*in && *in != c) || (!*in && !c))
+		    return 0;
+	    } else if (out) {
+		if (!(*out = p->tab[c]))
+		    return 0;
+	    } else if (!p->tab[c])
+		return 0;
+
+	    if (in && *in)
+		in++;
+	    if (out)
+		out++;
+	} else if (!p->tab[c])
+	    return 0;
+
+	s++;
+	p = p->next;
+    }
+    return 1;
+}
+
+/* This splits the given string into a list of cline structs, separated
+ * at those places where one of the anchors of an `*' pattern was found.
+ * plen gives the number of characters on the line that matched this
+ * string. In lp we return a pointer to the last cline struct we build. */
+
+/**/
+Cline
+bld_parts(char *str, int len, int plen, Cline *lp)
+{
+    Cline ret = NULL, *q = &ret, n;
+    Cmlist ms;
+    Cmatcher mp;
+    int t, op = plen;
+    char *p = str;
+
+    while (len) {
+	for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
+	    mp = ms->matcher;
+	    if (mp->flags == CMF_RIGHT && mp->wlen == -1 &&
+		!mp->llen && len >= mp->ralen && mp->ralen &&
+		pattern_match(mp->right, str, NULL, NULL)) {
+		int olen = str - p, llen;
+
+		/* We found an anchor, create a new cline. The NEW flag
+		 * is set if the characters before the anchor were not
+		 * on the line. */
+		*q = n = get_cline(NULL, mp->ralen, str, mp->ralen, NULL, 0,
+				   ((plen < 0) ? CLF_NEW : 0));
+
+		/* If there were any characters before the anchor, add
+		 * them as a cline struct. */
+
+		if (p != str) {
+		    llen = (op < 0 ? 0 : op);
+
+		    if (llen > olen)
+			llen = olen;
+		    n->prefix = get_cline(NULL, llen, p, olen, NULL, 0, 0);
+		}
+		q = &(n->next);
+		str += mp->ralen; len -= mp->ralen;
+		plen -= mp->ralen;
+		op -= olen;
+		p = str;
+		t = 1;
+	    }
+	}
+	if (!t) {
+	    /* No anchor was found here, skip. */
+	    str++; len--;
+	    plen--;
+	}
+    }
+    /* This is the cline struct for the remaining string at the end. */
+
+    *q = n = get_cline(NULL, 0, NULL, 0, NULL, 0, (plen < 0 ? CLF_NEW : 0));
+    if (p != str) {
+	int olen = str - p, llen = (op < 0 ? 0 : op);
+
+	if (llen > olen)
+	    llen = olen;
+	n->prefix = get_cline(NULL, llen, p, olen, NULL, 0, 0);
+    }
+    n->next = NULL;
+
+    if (lp)
+	*lp = n;
+
+    return ret;
+}
+
+/* This builds all the possible line patterns for the pattern pat in the
+ * buffer line. Initially line is the same as lp, but during recursive
+ * calls lp is incremented for storing successive characters. Whenever
+ * a full possible string is build, we test if this line matches the
+ * string given by wlen and word. The in argument contains the characters
+ * to use for the correspondence classes, it was filled by a call to 
+ * pattern_match() in the calling function.
+ * The return value is the length of the string matched in the word, it
+ * is zero if we couldn't build a line that matches the word. */
+
+/**/
+static int
+bld_line(Cpattern pat, char *line, char *lp,
+	 char *word, int wlen, unsigned char *in, int sfx)
+{
+    if (pat) {
+	/* Still working on the pattern. */
+
+	int i, l;
+	unsigned char c = 0;
+
+	/* Get the number of the character for a correspondence class
+	 * if it has a correxponding class. */
+	if (pat->equiv)
+	    if ((c = *in))
+		in++;
+
+	/* Walk through the table in the pattern and try the characters
+	 * that may appear in the current position. */
+	for (i = 0; i < 256; i++)
+	    if ((pat->equiv && c) ? (c == pat->tab[i]) : pat->tab[i]) {
+		*lp = i;
+		/* We stored the character, now call ourselves to build
+		 * the rest. */
+		if ((l = bld_line(pat->next, line, lp + 1, word, wlen,
+				  in, sfx)))
+		    return l;
+	    }
+    } else {
+	/* We reached the end, i.e. the line string is fully build, now
+	 * see if it matches the given word. */
+
+	Cmlist ms;
+	Cmatcher mp;
+	int l = lp - line, t, rl = 0, ind, add;
+	VARARR(unsigned char, ea, l + 1);
+
+	/* Quick test if the strings are exactly the same. */
+	if (l == wlen && !strncmp(line, word, l))
+	    return l;
+
+	if (sfx) {
+	    line = lp; word += wlen;
+	    ind = -1; add = -1;
+	} else {
+	    ind = 0; add = 1;
+	}
+	/* We loop through the whole line string built. */
+	while (l && wlen) {
+	    if (word[ind] == line[ind]) {
+		/* The same character in both strings, skip over. */
+		line += add; word += add;
+		l--; wlen--; rl++;
+	    } else {
+		t = 0;
+		for (ms = bmatchers; ms && !t; ms = ms->next) {
+		    mp = ms->matcher;
+		    if (!mp->flags && mp->wlen <= wlen && mp->llen <= l &&
+			pattern_match(mp->line, (sfx ? line - mp->llen : line),
+				      NULL, ea) &&
+			pattern_match(mp->word, (sfx ? word - mp->wlen : word),
+				      ea, NULL)) {
+			/* Both the line and the word pattern matched,
+			 * now skip over the matched portions. */
+			if (sfx) {
+			    line -= mp->llen; word -= mp->wlen;
+			} else {
+			    line += mp->llen; word += mp->wlen;
+			}
+			l -= mp->llen; wlen -= mp->wlen; rl += mp->wlen;
+			t = 1;
+		    }
+		}
+		if (!t)
+		    /* Didn't match, give up. */
+		    return 0;
+	    }
+	}
+	if (!l)
+	    /* Unmatched portion in the line built, return matched length. */
+	    return rl;
+    }
+    return 0;
+}
+
+/* This builds a string that may be put on the line that fully matches the
+ * given strings. The return value is NULL if no such string could be built
+ * or that string in local static memory, dup it. */
+
+/**/
+static char *
+join_strs(int la, char *sa, int lb, char *sb)
+{
+    static char *rs = NULL;
+    static int rl = 0;
+
+    VARARR(unsigned char, ea, (la > lb ? la : lb) + 1);
+    Cmlist ms;
+    Cmatcher mp;
+    int t, bl, rr = rl;
+    char *rp = rs;
+
+    while (la && lb) {
+	if (*sa != *sb) {
+	    /* Different characters, try the matchers. */
+	    for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
+		mp = ms->matcher;
+		if (!mp->flags && mp->wlen > 0 && mp->llen > 0 &&
+		    mp->wlen <= la && mp->wlen <= lb) {
+		    /* The pattern has no anchors and the word
+		     * pattern fits, try it. */
+		    if ((t = pattern_match(mp->word, sa, NULL, ea)) ||
+			pattern_match(mp->word, sb, NULL, ea)) {
+			/* It matched one of the strings, t says which one. */
+			VARARR(char, line, mp->llen + 1);
+			char **ap, **bp;
+			int *alp, *blp;
+
+			if (t) {
+			    ap = &sa; alp = &la;
+			    bp = &sb; blp = &lb;
+			} else {
+			    ap = &sb; alp = &lb;
+			    bp = &sa; blp = &la;
+			}
+			/* Now try to build a string that matches the other
+			 * string. */
+			if ((bl = bld_line(mp->line, line, line,
+					   *bp, *blp, ea, 0))) {
+			    /* Found one, put it into the return string. */
+			    line[mp->llen] = '\0';
+			    if (rr <= mp->llen) {
+				char *or = rs;
+
+				rs = realloc(rs, (rl += 20));
+				rr += 20;
+				rp += rs - or;
+			    }
+			    memcpy(rp, line, mp->llen);
+			    rp += mp->llen; rr -= mp->llen;
+			    *ap += mp->wlen; *alp -= mp->wlen;
+			    *bp += bl; *blp -= bl;
+			    t = 1;
+			} else
+			    t = 0;
+		    }
+		}
+	    }
+	    if (!t)
+		break;
+	} else {
+	    /* Same character, just take it. */
+	    if (rr <= 1) {
+		char *or = rs;
+
+		rs = realloc(rs, (rl += 20));
+		rr += 20;
+		rp += rs - or;
+	    }
+	    *rp++ = *sa; rr--;
+	    sa++; sb++;
+	    la--; lb--;
+	}
+    }
+    if (la || lb)
+	return NULL;
+
+    *rp = '\0';
+
+    return rs;
+}
+
+/* This compares the anchors stored in two top-level clines. */
+
+/**/
+static int
+cmp_anchors(Cline o, Cline n, int join)
+{
+    int line = 0;
+    char *j;
+
+    /* First try the exact strings. */
+    if ((!(o->flags & CLF_LINE) && o->wlen == n->wlen &&
+	 (!o->word || !strncmp(o->word, n->word, o->wlen))) ||
+	(line = ((!o->line && !n->line && !o->wlen && !n->wlen) ||
+		 (o->llen == n->llen && o->line && n->line &&
+		  !strncmp(o->line, n->line, o->llen))))) {
+	if (line) {
+	    o->flags |= CLF_LINE;
+	    o->word = NULL;
+	    n->wlen = 0;
+	}
+	return 1;
+    }
+    /* Didn't work, try to build a string matching both anchors. */
+    if (join && !(o->flags & CLF_JOIN) && o->word && n->word &&
+	(j = join_strs(o->wlen, o->word, n->wlen, n->word))) {
+	o->flags |= CLF_JOIN;
+	o->wlen = strlen(j);
+	o->word = dupstring(j);
+
+	return 2;
+    }
+    return 0;
+}
+
+/* Below is the code to join two cline lists. This struct is used to walk
+ * through a sub-list. */
+
+typedef struct cmdata *Cmdata;
+
+struct cmdata {
+    Cline cl, pcl;
+    char *str, *astr;
+    int len, alen, olen, line;
+};
+
+/* This is used to ensure that a cmdata struct contains usable data.
+ * The return value is non-zero if we reached the end. */
+
+static int
+check_cmdata(Cmdata md, int sfx)
+{
+    /* We will use the str and len fields to contain the next sub-string
+     * in the list. If len is zero, we have to use the next cline. */
+    if (!md->len) {
+	/* If there is none, we reached the end. */
+	if (!md->cl)
+	    return 1;
+
+	/* Otherwise, get the string. Only the line-string or both.
+	 * We also have to adjust the pointer if this is for a suffix. */
+	if (md->cl->flags & CLF_LINE) {
+	    md->line = 1;
+	    md->len = md->cl->llen;
+	    md->str = md->cl->line;
+	} else {
+	    md->line = 0;
+	    md->len = md->olen = md->cl->wlen;
+	    if ((md->str = md->cl->word) && sfx)
+		md->str += md->len;
+	    md->alen = md->cl->llen;
+	    if ((md->astr = md->cl->line) && sfx)
+		md->astr += md->alen;
+	}
+	md->pcl = md->cl;
+	md->cl = md->cl->next;
+    }
+    return 0;
+}
+
+/* This puts the not-yet-matched portion back into the last cline and 
+ * returns that. */
+
+static Cline
+undo_cmdata(Cmdata md, int sfx)
+{
+    Cline r = md->pcl;
+
+    if (md->line) {
+	r->word = NULL;
+	r->wlen = 0;
+	r->flags |= CLF_LINE;
+	r->llen = md->len;
+	r->line = md->str - (sfx ? md->len : 0);
+    } else if (md->len != md->olen) {
+	r->wlen = md->len;
+	r->word = md->str - (sfx ? md->len : 0);
+    }
+    return r;
+}
+
+/* This tries to build a string matching a sub-string in a sub-cline
+ * that could not be matched otherwise. */
+
+static Cline
+join_sub(Cmdata md, char *str, int len, int *mlen, int sfx, int join)
+{
+    if (!check_cmdata(md, sfx)) {
+	char *ow = str, *nw = md->str;
+	int ol = len, nl = md->len;
+	Cmlist ms;
+	Cmatcher mp;
+	VARARR(unsigned char, ea, (ol > nl ? ol : nl) + 1);
+	int t;
+
+	if (sfx) {
+	    ow += ol; nw += nl;
+	}
+	for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
+	    mp = ms->matcher;
+	    /* We use only those patterns that match a non-empty
+	     * string in both the line and the word and that have
+	     * no anchors. */
+	    if (!mp->flags && mp->wlen > 0 && mp->llen > 0) {
+		/* We first test, if the old string matches already the
+		 * new one. */
+		if (mp->llen <= ol && mp->wlen <= nl &&
+		    pattern_match(mp->line, ow - (sfx ? mp->llen : 0),
+				  NULL, ea) &&
+		    pattern_match(mp->word, nw - (sfx ? mp->wlen : 0),
+				  ea, NULL)) {
+		    /* It did, update the contents of the cmdata struct
+		     * and return a cline for the matched part. */
+		    if (sfx)
+			md->str -= mp->wlen;
+		    else
+			md->str += mp->wlen;
+		    md->len -= mp->wlen;
+		    *mlen = mp->llen;
+
+		    return get_cline(NULL, 0, ow - (sfx ? mp->llen : 0),
+				     mp->llen, NULL, 0, 0);
+		}
+		/* Otherwise we will try to build a string that matches
+		 * both strings. But try the pattern only if the word-
+		 * pattern matches one of the strings. */
+		if (join && mp->wlen <= ol && mp->wlen <= nl &&
+		    ((t = pattern_match(mp->word, ow - (sfx ? mp->wlen : 0),
+				       NULL, ea)) ||
+		     pattern_match(mp->word, nw - (sfx ? mp->wlen : 0),
+				   NULL, ea))) {
+		    VARARR(char, line, mp->llen + 1);
+		    int bl;
+
+		    /* Then build all the possible lines and see
+		     * if one of them matches the other string. */
+		    if ((bl = bld_line(mp->line, line, line,
+				       (t ? nw : ow), (t ? nl : ol),
+				       ea, sfx))) {
+			/* Yep, one of the lines matched the other
+			 * string. */
+			line[mp->llen] = '\0';
+
+			if (t) {
+			    ol = mp->wlen; nl = bl;
+			} else {
+			    ol = bl; nl = mp->wlen;
+			}
+			if (sfx)
+			    md->str -= nl;
+			else
+			    md->str += nl;
+			md->len -= nl;
+			*mlen = ol;
+
+			return get_cline(NULL, 0, dupstring(line), mp->llen,
+					 NULL, 0, CLF_JOIN);
+		    }
+		}
+	    }
+	}
+    }
+    return NULL;
+}
+
+/* This is used to match a sub-string in a sub-cline. The length of the
+ * matched portion is returned. This tests only for exact equality. */
+
+static int
+sub_match(Cmdata md, char *str, int len, int sfx)
+{
+    int ret = 0, l, ind, add;
+    char *p, *q;
+
+    if (sfx) {
+	str += len;
+	ind = -1; add = -1;
+    } else {
+	ind = 0; add = 1;
+    }
+    /* str and len describe the old string, in md we have the new one. */
+    while (len) {
+	if (check_cmdata(md, sfx))
+	    return ret;
+
+	for (l = 0, p = str, q = md->str;
+	     l < len && l < md->len && p[ind] == q[ind];
+	     l++, p += add, q += add);
+
+	if (l) {
+	    /* There was a common prefix, use it. */
+	    md->len -= l; len -= l;
+	    if (sfx) {
+		md->str -= l; str -= l;
+	    } else {
+		md->str += l; str += l;
+	    }
+	    ret += l;
+	} else if (md->line || md->len != md->olen || !md->astr)
+	    return ret;
+	else {
+	    /* We still have the line string to try. */
+	    md->line = 1;
+	    md->len = md->alen;
+	    md->str = md->astr;
+	}
+    }
+    return ret;
+}
+
+/* This is used to build a common prefix or suffix sub-list. If requested
+ * it returns the unmatched cline lists in orest and nrest. */
+
+/**/
+static void
+join_psfx(Cline ot, Cline nt, Cline *orest, Cline *nrest, int sfx)
+{
+    Cline p = NULL, o, n;
+    struct cmdata md, omd;
+    char **sstr = NULL;
+    int len, join = 0, line = 0, *slen = NULL;
+
+    if (sfx) {
+	o = ot->suffix; n = nt->suffix;
+    } else {
+	o = ot->prefix;	n = nt->prefix;
+    }
+    if (!o) {
+	if (orest)
+	    *orest = NULL;
+	if (nrest)
+	    *nrest = n;
+
+	return;
+    }
+    if (!n) {
+	if (sfx)
+	    ot->suffix = NULL;
+	else
+	    ot->prefix = NULL;
+
+	if (orest)
+	    *orest = o;
+	else
+	    free_cline(o);
+	if (nrest)
+	    *nrest = NULL;
+	return;
+    }
+    md.cl = n;
+    md.len = 0;
+
+    /* Walk through the old list. */
+    while (o) {
+	join = 0;
+	memcpy(&omd, &md, sizeof(struct cmdata));
+
+	/* We first get the length of the prefix equal in both strings. */
+	if (o->flags & CLF_LINE) {
+	    if ((len = sub_match(&md, o->line, o->llen, sfx)) != o->llen) {
+		join = 1; line = 1; slen = &(o->llen); sstr = &(o->line);
+	    }
+	} else if ((len = sub_match(&md, o->word, o->wlen, sfx)) != o->wlen) {
+	    if (o->line) {
+		memcpy(&md, &omd, sizeof(struct cmdata));
+		o->flags |= CLF_LINE | CLF_DIFF;
+
+		continue;
+	    }
+	    join = 1; line = 0; slen = &(o->wlen); sstr = &(o->word);
+	}
+	if (join) {
+	    /* There is a rest that is different in the two lists,
+	     * we try to build a new cline matching both strings. */
+	    Cline joinl;
+	    int jlen;
+
+	    if ((joinl = join_sub(&md, *sstr + len, *slen - len,
+				  &jlen, sfx, !(o->flags & CLF_JOIN)))) {
+		/* We have one, insert it into the list. */
+		joinl->flags |= CLF_DIFF;
+		if (len + jlen != *slen) {
+		    Cline rest;
+
+		    rest = get_cline(NULL, 0, *sstr + (sfx ? 0 : len + jlen),
+				     *slen - len - jlen, NULL, 0, 0);
+
+		    rest->next = o->next;
+		    joinl->next = rest;
+		} else
+		    joinl->next = o->next;
+
+		if (len) {
+		    if (sfx)
+			*sstr += *slen - len;
+		    *slen = len;
+		    o->next = joinl;
+		} else {
+		    o->next = NULL;
+		    free_cline(o);
+		    if (p)
+			p->next = joinl;
+		    else if (sfx)
+			ot->suffix = joinl;
+		    else
+			ot->prefix = joinl;
+		}
+		o = joinl;
+		join = 0;
+	    }
+	}
+	if (join) {
+	    /* We couldn't build a cline for a common string, so we
+	     * cut the list here. */
+	    if (len) {
+		Cline r;
+
+		if (orest) {
+		    if (line)
+			r = get_cline(o->line + len, *slen - len,
+				      NULL, 0, NULL, 0, o->flags);
+		    else
+			r = get_cline(NULL, 0, o->word + len, *slen - len,
+				      NULL, 0, o->flags);
+
+		    r->next = o->next;
+		    *orest = r;
+
+		    *slen = len;
+		    o->next = NULL;
+		} else {
+		    if (sfx)
+			*sstr += *slen - len;
+		    *slen = len;
+		    free_cline(o->next);
+		    o->next = NULL;
+		}
+	    } else {
+		if (p)
+		    p->next = NULL;
+		else if (sfx)
+		    ot->suffix = NULL;
+		else
+		    ot->prefix = NULL;
+
+		if (orest)
+		    *orest = o;
+		else
+		    free_cline(o);
+	    }
+	    if (!orest || !nrest)
+		ot->flags |= CLF_MISS;
+
+	    if (nrest)
+		*nrest = undo_cmdata(&md, sfx);
+
+	    return;
+	}
+	p = o;
+	o = o->next;
+    }
+    if (md.len || md.cl)
+	ot->flags |= CLF_MISS;
+    if (orest)
+	*orest = NULL;
+    if (nrest)
+	*nrest = undo_cmdata(&md, sfx);
+}
+
+/* This builds the common prefix and suffix for a mid-cline -- the one
+ * describing the place where the prefix and the suffix meet. */
+
+/**/
+static void
+join_mid(Cline o, Cline n)
+{
+    if (o->flags & CLF_JOIN) {
+	/* The JOIN flag is set in the old cline struct if it was
+	 * already joined with another one. In this case the suffix
+	 * field contains the suffix from previous calls. */
+	Cline nr;
+
+	join_psfx(o, n, NULL, &nr, 0);
+
+	n->suffix = revert_cline(nr);
+
+	join_psfx(o, n, NULL, NULL, 1);
+    } else {
+	/* This is the first time for both structs, so the prefix field
+	 * contains the whole sub-list. */
+	Cline or, nr;
+
+	o->flags |= CLF_JOIN;
+
+	/* We let us give both rests and use them as the suffixes. */
+	join_psfx(o, n, &or, &nr, 0);
+
+	if (or)
+	    or->llen = (o->slen > or->wlen ? or->wlen : o->slen);
+	o->suffix = revert_cline(or);
+	n->suffix = revert_cline(nr);
+
+	join_psfx(o, n, NULL, NULL, 1);
+    }
+    n->suffix = NULL;
+}
+
+/* This turns the sequence of anchor cline structs from b to e into a
+ * prefix sequence, puts it before the prefix of e and then tries to
+ * join that with the prefix of a.
+ * This is needed if some matches had a anchor match spec and others
+ * didn't. */
+
+/**/
+static void
+sub_join(Cline a, Cline b, Cline e, int anew)
+{
+    if (!e->suffix && a->prefix) {
+	Cline op = e->prefix, n = NULL, *p = &n, t, ca;
+	int min = 0, max = 0;
+
+	for (; b != e; b = b->next) {
+	    if ((*p = t = b->prefix)) {
+		while (t->next)
+		    t = t->next;
+		p = &(t->next);
+	    }
+	    b->suffix = b->prefix = NULL;
+	    b->flags &= ~CLF_SUF;
+	    min += b->min;
+	    max += b->max;
+	    *p = b;
+	    p = &(b->next);
+	}
+	*p = e->prefix;
+	ca = a->prefix;
+
+	while (n != op) {
+	    e->prefix = cp_cline(n, 0);
+	    a->prefix = cp_cline(ca, 0);
+
+	    if (anew) {
+		join_psfx(e, a, NULL, NULL, 0);
+		if (e->prefix) {
+		    e->min += min;
+		    e->max += max;
+		    break;
+		}
+	    } else {
+		join_psfx(e, a, NULL, NULL, 0);
+		if (a->prefix) {
+		    a->min += min;
+		    a->max += max;
+		    break;
+		}
+	    }
+	    min -= n->min;
+	    max -= n->max;
+
+	    n = n->next;
+	}
+    }
+}
+
+/* This simplifies the cline list given as the first argument so that
+ * it also matches the second list. */
+
+/**/
+Cline
+join_clines(Cline o, Cline n)
+{
+    cline_setlens(n, 1);
+
+    /* First time called, just return the new list. On further invocations
+     * we will get it as the first argument. */
+    if (!o)
+	return n;
+    else {
+	Cline oo = o, nn = n, po = NULL, pn = NULL;
+
+	/* Walk through the lists. */
+	while (o && n) {
+	    /* If one of them describes a new part and the other one does
+	     * not, synchronise them by searching an old part in the
+	     * other list. */
+	    if ((o->flags & CLF_NEW) && !(n->flags & CLF_NEW)) {
+		Cline t, tn;
+
+		for (t = o; (tn = t->next) && (tn->flags & CLF_NEW); t = tn);
+		if (tn && cmp_anchors(tn, n, 0)) {
+		    sub_join(n, o, tn, 1);
+
+		    if (po)
+			po->next = tn;
+		    else
+			oo = tn;
+		    t->next = NULL;
+		    free_cline(o);
+		    o = tn;
+		    o->flags |= CLF_MISS;
+		    continue;
+		}
+	    }
+	    if (!(o->flags & CLF_NEW) && (n->flags & CLF_NEW)) {
+		Cline t, tn;
+
+		for (t = n; (tn = t->next) && (tn->flags & CLF_NEW); t = tn);
+		if (tn && cmp_anchors(o, tn, 0)) {
+		    sub_join(o, n, tn, 0);
+
+		    n = tn;
+		    o->flags |= CLF_MISS;
+		    continue;
+		}
+	    }
+	    /* Almost the same as above, but for the case that they
+	     * describe different types of parts (prefix, suffix, or mid). */
+	    if ((o->flags & (CLF_SUF | CLF_MID)) !=
+		(n->flags & (CLF_SUF | CLF_MID))) {
+		Cline t, tn;
+
+		for (t = n;
+		     (tn = t->next) &&
+			 (tn->flags & (CLF_SUF | CLF_MID)) !=
+			 (o->flags  & (CLF_SUF | CLF_MID));
+		     t = tn);
+		if (tn && cmp_anchors(o, tn, 1)) {
+		    sub_join(o, n, tn, 0);
+
+		    n = tn;
+		    continue;
+		}
+		for (t = o;
+		     (tn = t->next) &&
+			 (tn->flags & (CLF_SUF | CLF_MID)) !=
+			 (n->flags  & (CLF_SUF | CLF_MID));
+		     t = tn);
+		if (tn && cmp_anchors(tn, n, 1)) {
+		    sub_join(n, o, tn, 1);
+		    if (po)
+			po->next = tn;
+		    else
+			oo = tn;
+		    t->next = NULL;
+		    free_cline(o);
+		    o = tn;
+		    continue;
+		}
+		if (o->flags & CLF_MID) {
+		    o->flags = (o->flags & ~CLF_MID) | (n->flags & CLF_SUF);
+		    if (n->flags & CLF_SUF) {
+			free_cline(o->prefix);
+			o->prefix = NULL;
+		    } else {
+			free_cline(o->suffix);
+			o->suffix = NULL;
+		    }
+		}
+		break;
+	    }
+	    /* Now see if they have matching anchors. If not, cut the list. */
+	    if (!(o->flags & CLF_MID) && !cmp_anchors(o, n, 1)) {
+		Cline t, tn;
+
+		for (t = n; (tn = t->next) && !cmp_anchors(o, tn, 1); t = tn);
+
+		if (tn) {
+		    sub_join(o, n, tn, 0);
+
+		    n = tn;
+		    o->flags |= CLF_MISS;
+		    continue;
+		} else {
+		    for (t = o; (tn = t->next) && !cmp_anchors(n, tn, 1);
+			 t = tn);
+
+		    if (tn) {
+			sub_join(n, o, tn, 1);
+
+			if (po)
+			    po->next = tn;
+			else
+			    oo = tn;
+			o = tn;
+			o->flags |= CLF_MISS;
+			continue;
+		    } else {
+			if (o->flags & CLF_SUF)
+			    break;
+
+			o->word = o->line = o->orig = NULL;
+			o->wlen = 0;
+			free_cline(o->next);
+			o->next = NULL;
+			o->flags |= CLF_MISS;
+		    }
+		}
+	    }
+	    /* Ok, they are equal, now copy the information about the
+             * original string if needed, calculate minimum and maximum
+	     * lengths, and join the sub-lists. */
+	    if (!o->orig && !o->olen) {
+		o->orig = n->orig;
+		o->olen = n->olen;
+	    }
+	    if (n->min < o->min)
+		o->min = n->min;
+	    if (n->max > o->max)
+		o->max = n->max;
+	    if (o->flags & CLF_MID)
+		join_mid(o, n);
+	    else
+		join_psfx(o, n, NULL, NULL, (o->flags & CLF_SUF));
+
+	    po = o;
+	    o = o->next;
+	    pn = n;
+	    n = n->next;
+	}
+	/* Free the rest of the old list. */
+	if (o) {
+	    if (po)
+		po->next = NULL;
+	    else
+		oo = NULL;
+
+	    free_cline(o);
+	}
+	free_cline(nn);
+
+	return oo;
+    }
+}
+
diff --git a/Src/Zle/compresult.c b/Src/Zle/compresult.c
new file mode 100644
index 000000000..fe997b12b
--- /dev/null
+++ b/Src/Zle/compresult.c
@@ -0,0 +1,1940 @@
+/*
+ * compresult.c - the complete module, completion result handling
+ *
+ * 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 "complete.mdh"
+#define GLOBAL_PROTOTYPES
+#include "zle_tricky.pro"
+#undef GLOBAL_PROTOTYPES
+#include "compresult.pro"
+
+/* Convenience macro for calling bslashquote() (formerly quotename()). *
+ * This uses the instring variable above.                              */
+
+#define quotename(s, e) bslashquote(s, e, instring)
+
+#define inststr(X) inststrlen((X),1,-1)
+
+/* This cuts the cline list before the stuff that isn't worth
+ * inserting in the line. */
+
+/**/
+static Cline
+cut_cline(Cline l)
+{
+    Cline q, p, e = NULL, maxp = NULL;
+    int sum = 0, max = 0, tmp, ls = 0;
+
+    /* If no match was added with matching, we don't really know
+     * which parts of the unambiguous string are worth keeping,
+     * so for now we keep everything (in the hope that this
+     * produces a string containing at least everything that was 
+     * originally on the line). */
+
+    if (!hasmatched) {
+	cline_setlens(l, 0);
+	return l;
+    }
+    e = l = cp_cline(l, 0);
+
+    /* First, search the last struct for which we have something on
+     * the line. Anything before that is kept. */
+
+    for (q = NULL, p = l; p; p = p->next) {
+	if (p->orig || p->olen || !(p->flags & CLF_NEW))
+	    e = p->next;
+	if (!p->suffix && (p->wlen || p->llen || p->prefix))
+	    q = p;
+    }
+    if (!e && q && !q->orig && !q->olen && (q->flags & CLF_MISS) &&
+	!(q->flags & CLF_MATCHED) && (q->word ? q->wlen : q->llen) < 3) {
+	q->word = q->line = NULL;
+	q->wlen = q->llen = 0;
+    }
+    /* Then keep all structs without missing characters. */
+
+    while (e && !(e->flags & CLF_MISS))
+	e = e->next;
+
+    if (e) {
+	/* Then we see if there is another struct with missing
+	 * characters. If not, we keep the whole list. */
+
+	for (p = e->next; p && !(p->flags & CLF_MISS); p = p->next);
+
+	if (p) {
+	    for (p = e; p; p = p->next) {
+		if (!(p->flags & CLF_MISS))
+		    sum += p->max;
+		else {
+		    tmp = cline_sublen(p);
+		    if (tmp > 2 && tmp > ((p->max + p->min) >> 1))
+			sum += tmp - (p->max - tmp);
+		    else if (tmp < p->min)
+			sum -= (((p->max + p->min) >> 1) - tmp) << (tmp < 2);
+		}
+		if (sum > max) {
+		    max = sum;
+		    maxp = p;
+		}
+	    }
+	    if (max)
+		e = maxp;
+	    else {
+		int len = 0;
+
+		cline_setlens(l, 0);
+		ls = 1;
+
+		for (p = e; p; p = p->next)
+		    len += p->max;
+
+		if (len > ((minmlen << 1) / 3))
+		    return l;
+	    }
+	    e->line = e->word = NULL;
+	    e->llen = e->wlen = e->olen = 0;
+	    e->next = NULL;
+	}
+    }
+    if (!ls)
+	cline_setlens(l, 0);
+
+    return l;
+}
+
+/* This builds the unambiguous string. If ins is non-zero, it is
+ * immediatly inserted in the line. Otherwise csp is used to return
+ * the relative cursor position in the string returned. */
+
+/**/
+static char *
+cline_str(Cline l, int ins, int *csp)
+{
+    Cline s;
+    int ocs = cs, ncs, pcs, scs, pm, pmax, pmm, sm, smax, smm, d, dm, mid;
+    int i, j, li = 0, cbr;
+    Brinfo brp, brs;
+
+    l = cut_cline(l);
+
+    pmm = smm = dm = 0;
+    pm = pmax = sm = smax = d = mid = cbr = -1;
+
+    /* Get the information about the brace beginning and end we have
+     * to re-insert. */
+    if (ins) {
+	Brinfo bp;
+	int olen = we - wb;
+
+	if ((brp = brbeg)) {
+	    for (bp = brbeg; bp; bp = bp->next) {
+		bp->curpos = (hasunqu ? bp->pos : bp->qpos);
+		olen -= strlen(bp->str);
+	    }
+	}
+	if ((brs = lastbrend)) {
+	    for (bp = brend; bp; bp = bp->next)
+		olen -= strlen(bp->str);
+
+	    for (bp = brend; bp; bp = bp->next)
+		bp->curpos = olen - (hasunqu ? bp->pos : bp->qpos);
+	}
+	while (brp && !brp->curpos) {
+	    inststrlen(brp->str, 1, -1);
+	    brp = brp->next;
+	}
+	while (brs && !brs->curpos) {
+	    if (cbr < 0)
+		cbr = cs;
+	    inststrlen(brs->str, 1, -1);
+	    brs = brs->prev;
+	}
+    }
+    /* Walk through the top-level cline list. */
+    while (l) {
+	/* Insert the original string if no prefix. */
+	if (l->olen && !(l->flags & CLF_SUF) && !l->prefix) {
+	    pcs = cs + l->olen;
+	    inststrlen(l->orig, 1, l->olen);
+	} else {
+	    /* Otherwise insert the prefix. */
+	    for (s = l->prefix; s; s = s->next) {
+		pcs = cs + s->llen;
+		if (s->flags & CLF_LINE)
+		    inststrlen(s->line, 1, s->llen);
+		else
+		    inststrlen(s->word, 1, s->wlen);
+		scs = cs;
+
+		if ((s->flags & CLF_DIFF) && (!dm || (s->flags & CLF_MATCHED))) {
+		    d = cs; dm = s->flags & CLF_MATCHED;
+		}
+		li += s->llen;
+	    }
+	}
+	if (ins) {
+	    int ocs, bl;
+
+	    while (brp && li >= brp->curpos) {
+		ocs = cs;
+		bl = strlen(brp->str);
+		cs = pcs - (li - brp->curpos);
+		inststrlen(brp->str, 1, bl);
+		cs = ocs + bl;
+		pcs += bl;
+		scs += bl;
+		brp = brp->next;
+	    }
+	}
+	/* Remember the position if this is the first prefix with
+	 * missing characters. */
+	if ((l->flags & CLF_MISS) && !(l->flags & CLF_SUF) &&
+	    ((pmax < (l->min - l->max) && (!pmm || (l->flags & CLF_MATCHED))) ||
+	     ((l->flags & CLF_MATCHED) && !pmm))) {
+	    pm = cs; pmax = l->min - l->max; pmm = l->flags & CLF_MATCHED;
+	}
+	if (ins) {
+	    int ocs, bl;
+
+	    while (brs && li >= brs->curpos) {
+		ocs = cs;
+		bl = strlen(brs->str);
+		cs = scs - (li - brs->curpos);
+		if (cbr < 0)
+		    cbr = cs;
+		inststrlen(brs->str, 1, bl);
+		cs = ocs + bl;
+		pcs += bl;
+		brs = brs->prev;
+	    }
+	}
+	pcs = cs;
+	/* Insert the anchor. */
+	if (l->flags & CLF_LINE)
+	    inststrlen(l->line, 1, l->llen);
+	else
+	    inststrlen(l->word, 1, l->wlen);
+	scs = cs;
+	if (ins) {
+	    int ocs, bl;
+
+	    li += l->llen;
+
+	    while (brp && li >= brp->curpos) {
+		ocs = cs;
+		bl = strlen(brp->str);
+		cs = pcs + l->llen - (li - brp->curpos);
+		inststrlen(brp->str, 1, bl);
+		cs = ocs + bl;
+		pcs += bl;
+		scs += bl;
+		brp = brp->next;
+	    }
+	}
+	/* Remember the cursor position for suffixes and mids. */
+	if (l->flags & CLF_MISS) {
+	    if (l->flags & CLF_MID)
+		mid = cs;
+	    else if ((l->flags & CLF_SUF) && 
+		     ((smax < (l->min - l->max) &&
+		       (!smm || (l->flags & CLF_MATCHED))) ||
+		      ((l->flags & CLF_MATCHED) && !smm))) {
+		sm = cs; smax = l->min - l->max; smm = l->flags & CLF_MATCHED;
+	    }
+	}
+	if (ins) {
+	    int ocs, bl;
+
+	    while (brs && li >= brs->curpos) {
+		ocs = cs;
+		bl = strlen(brs->str);
+		cs = scs - (li - brs->curpos);
+		if (cbr < 0)
+		    cbr = cs;
+		inststrlen(brs->str, 1, bl);
+		cs = ocs + bl;
+		pcs += bl;
+		brs = brs->prev;
+	    }
+	}
+	/* And now insert the suffix or the original string. */
+	if (l->olen && (l->flags & CLF_SUF) && !l->suffix) {
+	    pcs = cs;
+	    inststrlen(l->orig, 1, l->olen);
+	    if (ins) {
+		int ocs, bl;
+
+		li += l->olen;
+
+		while (brp && li >= brp->curpos) {
+		    ocs = cs;
+		    bl = strlen(brp->str);
+		    cs = pcs + l->olen - (li - brp->curpos);
+		    inststrlen(brp->str, 1, bl);
+		    cs = ocs + bl;
+		    pcs += bl;
+		    brp = brp->next;
+		}
+		while (brs && li >= brs->curpos) {
+		    ocs = cs;
+		    bl = strlen(brs->str);
+		    cs = pcs + l->olen - (li - brs->curpos);
+		    if (cbr < 0)
+			cbr = cs;
+		    inststrlen(brs->str, 1, bl);
+		    cs = ocs + bl;
+		    pcs += bl;
+		    brs = brs->prev;
+		}
+	    }
+	} else {
+	    Cline js = NULL;
+
+	    for (j = -1, i = 0, s = l->suffix; s; s = s->next) {
+		if (j < 0 && (s->flags & CLF_DIFF))
+		    j = i, js = s;
+		pcs = cs;
+		if (s->flags & CLF_LINE) {
+		    inststrlen(s->line, 0, s->llen);
+		    i += s->llen; scs = cs + s->llen;
+		} else {
+		    inststrlen(s->word, 0, s->wlen);
+		    i += s->wlen; scs = cs + s->wlen;
+		}
+		if (ins) {
+		    int ocs, bl;
+
+		    li += s->llen;
+
+		    while (brp && li >= brp->curpos) {
+			ocs = cs;
+			bl = strlen(brp->str);
+			cs = pcs + (li - brp->curpos);
+			inststrlen(brp->str, 1, bl);
+			cs = ocs + bl;
+			pcs += bl;
+			scs += bl;
+			brp = brp->next;
+		    }
+		    while (brs && li >= brs->curpos) {
+			ocs = cs;
+			bl = strlen(brs->str);
+			cs = scs - (li - brs->curpos);
+			if (cbr < 0)
+			    cbr = cs;
+			inststrlen(brs->str, 1, bl);
+			cs = ocs + bl;
+			pcs += bl;
+			brs = brs->prev;
+		    }
+		}
+	    }
+	    cs += i;
+	    if (j >= 0 && (!dm || (js->flags & CLF_MATCHED))) {
+		d = cs - j; dm = js->flags & CLF_MATCHED;
+	    }
+	}
+	l = l->next;
+    }
+    if (ins) {
+	int ocs = cs;
+
+	for (; brp; brp = brp->next)
+	    inststrlen(brp->str, 1, -1);
+	for (; brs; brs = brs->prev) {
+	    if (cbr < 0)
+		cbr = cs;
+	    inststrlen(brs->str, 1, -1);
+	}
+	if (mid >= ocs)
+	    mid += cs - ocs;
+	if (pm >= ocs)
+	    pm += cs - ocs;
+	if (sm >= ocs)
+	    sm += cs - ocs;
+	if (d >= ocs)
+	    d += cs - ocs;
+    }
+    /* This calculates the new cursor position. If we had a mid cline
+     * with missing characters, we take this, otherwise if we have a
+     * prefix with missing characters, we take that, the same for a
+     * suffix, and finally a place where the matches differ. */
+    ncs = (cbr >= 0 ? cbr :
+	   (mid >= 0 ? mid :
+	    (pm >= 0 ? pm : (sm >= 0 ? sm : (d >= 0 ? d : cs)))));
+
+    if (!ins) {
+	/* We always inserted the string in the line. If that was not
+	 * requested, we copy it and remove from the line. */
+	char *r = zalloc((i = cs - ocs) + 1);
+
+	memcpy(r, (char *) (line + ocs), i);
+	r[i] = '\0';
+	cs = ocs;
+	foredel(i);
+
+	*csp = ncs - ocs;
+
+	return r;
+    }
+    lastend = cs;
+    cs = ncs;
+
+    return NULL;
+}
+
+/* This is a utility function using the function above to allow access
+ * to the unambiguous string and cursor position via compstate. */
+
+/**/
+char *
+unambig_data(int *cp)
+{
+    static char *scache = NULL;
+    static int ccache;
+
+    if (mnum && ainfo) {
+	if (mnum != unambig_mnum) {
+	    zsfree(scache);
+	    scache = cline_str((ainfo->count ? ainfo->line : fainfo->line),
+			       0, &ccache);
+	}
+    } else if (mnum != unambig_mnum || !ainfo || !scache) {
+	zsfree(scache);
+	scache = ztrdup("");
+	ccache = 0;
+    }
+    unambig_mnum = mnum;
+    if (cp)
+	*cp = ccache + 1;
+
+    return scache;
+}
+
+/* Insert the given match. This returns the number of characters inserted.
+ * scs is used to return the position where a automatically created suffix
+ * has to be inserted. */
+
+/**/
+static int
+instmatch(Cmatch m, int *scs)
+{
+    int l, r = 0, ocs, a = cs, brb = 0, bradd, *brpos;
+    Brinfo bp;
+
+    zsfree(lastprebr);
+    zsfree(lastpostbr);
+    lastprebr = lastpostbr = NULL;
+
+    /* Ignored prefix. */
+    if (m->ipre) {
+	char *p = m->ipre + (menuacc ? m->qipl : 0);
+
+	inststrlen(p, 1, (l = strlen(p)));
+	r += l;
+    }
+    /* -P prefix. */
+    if (m->pre) {
+	inststrlen(m->pre, 1, (l = strlen(m->pre)));
+	r += l;
+    }
+    /* Path prefix. */
+    if (m->ppre) {
+	inststrlen(m->ppre, 1, (l = strlen(m->ppre)));
+	r += l;
+    }
+    /* The string itself. */
+    inststrlen(m->str, 1, (l = strlen(m->str)));
+    r += l;
+    ocs = cs;
+    /* Re-insert the brace beginnings, if any. */
+    if (brbeg) {
+	int pcs = cs;
+
+	l = 0;
+	for (bp = brbeg, brpos = m->brpl,
+		 bradd = (m->pre ? strlen(m->pre) : 0);
+	     bp; bp = bp->next, brpos++) {
+	    cs = a + *brpos + bradd;
+	    pcs = cs;
+	    l = strlen(bp->str);
+	    bradd += l;
+	    brpcs = cs;
+	    inststrlen(bp->str, 1, l);
+	    r += l;
+	    ocs += l;
+	}
+	lastprebr = (char *) zalloc(pcs - a + 1);
+	memcpy(lastprebr, (char *) line + a, pcs - a);
+	lastprebr[pcs - a] = '\0';
+	cs = ocs;
+    }
+    /* Path suffix. */
+    if (m->psuf) {
+	inststrlen(m->psuf, 1, (l = strlen(m->psuf)));
+	r += l;
+    }
+    /* Re-insert the brace end. */
+    if (brend) {
+	a = cs;
+	for (bp = brend, brpos = m->brsl, bradd = 0; bp; bp = bp->next, brpos++) {
+	    cs = a - *brpos;
+	    ocs = brscs = cs;
+	    l = strlen(bp->str);
+	    bradd += l;
+	    inststrlen(bp->str, 1, l);
+	    brb = cs;
+	    r += l;
+	}
+	cs = a + bradd;
+	if (scs)
+	    *scs = ocs;
+    } else {
+	brscs = -1;
+
+	if (scs)
+	    *scs = cs;
+    }
+    /* -S suffix */
+    if (m->suf) {
+	inststrlen(m->suf, 1, (l = strlen(m->suf)));
+	r += l;
+    }
+    /* ignored suffix */
+    if (m->isuf) {
+	inststrlen(m->isuf, 1, (l = strlen(m->isuf)));
+	r += l;
+    }
+    if (brend) {
+	lastpostbr = (char *) zalloc(cs - brb + 1);
+	memcpy(lastpostbr, (char *) line + brb, cs - brb);
+	lastpostbr[cs - brb] = '\0';
+    }
+    lastend = cs;
+    cs = ocs;
+
+    return r;
+}
+
+/* Check if the match has the given prefix/suffix before/after the
+ * braces. */
+
+/**/
+int
+hasbrpsfx(Cmatch m, char *pre, char *suf)
+{
+    char *op = lastprebr, *os = lastpostbr;
+    VARARR(char, oline, ll);
+    int oll = ll, ocs = cs, ole = lastend, opcs = brpcs, oscs = brscs, ret;
+
+    memcpy(oline, line, ll);
+
+    lastprebr = lastpostbr = NULL;
+
+    instmatch(m, NULL);
+
+    cs = 0;
+    foredel(ll);
+    spaceinline(oll);
+    memcpy(line, oline, oll);
+    cs = ocs;
+    lastend = ole;
+    brpcs = opcs;
+    brscs = oscs;
+
+    ret = (((!pre && !lastprebr) ||
+	    (pre && lastprebr && !strcmp(pre, lastprebr))) &&
+	   ((!suf && !lastpostbr) ||
+	    (suf && lastpostbr && !strcmp(suf, lastpostbr))));
+
+    zsfree(lastprebr);
+    zsfree(lastpostbr);
+    lastprebr = op;
+    lastpostbr = os;
+
+    return ret;
+}
+
+/* Handle the case were we found more than one match. */
+
+/**/
+int
+do_ambiguous(void)
+{
+    int ret = 0;
+
+    menucmp = menuacc = 0;
+
+    /* If we have to insert the first match, call do_single().  This is *
+     * how REC_EXACT takes effect.  We effectively turn the ambiguous   *
+     * completion into an unambiguous one.                              */
+    if (ainfo && ainfo->exact == 1 && useexact && !(fromcomp & FC_LINE)) {
+	minfo.cur = NULL;
+	do_single(ainfo->exactm);
+	invalidatelist();
+	return ret;
+    }
+    /* Setting lastambig here means that the completion is ambiguous and *
+     * AUTO_MENU might want to start a menu completion next time round,  *
+     * but this might be overridden below if we can complete an          *
+     * unambiguous prefix.                                               */
+    lastambig = 1;
+
+    if (usemenu || (haspattern && comppatinsert &&
+		    !strcmp(comppatinsert, "menu"))) {
+	/* We are in a position to start using menu completion due to one  *
+	 * of the menu completion options, or due to the menu-complete-    *
+	 * word command, or due to using GLOB_COMPLETE which does menu-    *
+	 * style completion regardless of the setting of the normal menu   *
+	 * completion options.                                             */
+	do_ambig_menu();
+    } else if (ainfo) {
+	int atend = (cs == we), la, eq, tcs;
+
+	minfo.cur = NULL;
+	minfo.asked = 0;
+
+	fixsuffix();
+
+	/* First remove the old string from the line. */
+	cs = wb;
+	foredel(we - wb);
+
+	/* Now get the unambiguous string and insert it into the line. */
+	cline_str(ainfo->line, 1, NULL);
+	if (eparq) {
+	    tcs = cs;
+	    cs = lastend;
+	    for (eq = eparq; eq; eq--)
+		inststrlen("\"", 0, 1);
+	    cs = tcs;
+	}
+	/* la is non-zero if listambiguous may be used. Copying and
+	 * comparing the line looks like BFI but it is the easiest
+	 * solution. Really. */
+	la = (ll != origll || strncmp(origline, (char *) line, ll));
+
+	/* If REC_EXACT and AUTO_MENU are set and what we inserted is an  *
+	 * exact match, we want menu completion the next time round       *
+	 * so we set fromcomp, to ensure that the word on the line is not *
+	 * taken as an exact match. Also we remember if we just moved the *
+	 * cursor into the word.                                          */
+	fromcomp = ((isset(AUTOMENU) ? FC_LINE : 0) |
+		    ((atend && cs != lastend) ? FC_INWORD : 0));
+
+	/* Probably move the cursor to the end. */
+	if (movetoend == 3)
+	    cs = lastend;
+
+	/* If the LIST_AMBIGUOUS option (meaning roughly `show a list only *
+	 * if the completion is completely ambiguous') is set, and some    *
+	 * prefix was inserted, return now, bypassing the list-displaying  *
+	 * code.  On the way, invalidate the list and note that we don't   *
+	 * want to enter an AUTO_MENU imediately.                          */
+	if (uselist == 3 && la) {
+	    int fc = fromcomp;
+
+	    invalidatelist();
+	    fromcomp = fc;
+	    lastambig = 0;
+	    clearlist = 1;
+	    return ret;
+	}
+    } else
+	return ret;
+
+    /* At this point, we might want a completion listing.  Show the listing *
+     * if it is needed.                                                     */
+    if (isset(LISTBEEP))
+	ret = 1;
+
+    if (uselist && (usemenu != 2 || (!listshown && !oldlist)) &&
+	((!showinglist && (!listshown || !oldlist)) ||
+	 (usemenu == 3 && !oldlist)) &&
+	(smatches >= 2 || (compforcelist && *compforcelist)))
+	showinglist = -2;
+
+    return ret;
+}
+
+/* This is a stat that ignores backslashes in the filename.  The `ls' *
+ * parameter says if we have to do lstat() or stat().  I think this   *
+ * should instead be done by use of a general function to expand a    *
+ * filename (stripping backslashes), combined with the actual         *
+ * (l)stat().                                                         */
+
+/**/
+int
+ztat(char *nam, struct stat *buf, int ls)
+{
+    char b[PATH_MAX], *p;
+
+    for (p = b; p < b + sizeof(b) - 1 && *nam; nam++)
+	if (*nam == '\\' && nam[1])
+	    *p++ = *++nam;
+	else
+	    *p++ = *nam;
+    *p = '\0';
+
+    return ls ? lstat(b, buf) : stat(b, buf);
+}
+
+/* Insert a single match in the command line. */
+
+/**/
+void
+do_single(Cmatch m)
+{
+    int l, sr = 0, scs;
+    int havesuff = 0;
+    int partest = (m->ripre || ((m->flags & CMF_ISPAR) && parpre));
+    char *str = m->str, *ppre = m->ppre, *psuf = m->psuf, *prpre = m->prpre;
+
+    if (!prpre) prpre = "";
+    if (!ppre) ppre = "";
+    if (!psuf) psuf = "";
+
+    fixsuffix();
+
+    if (!minfo.cur) {
+	/* We are currently not in a menu-completion, *
+	 * so set the position variables.             */
+	minfo.pos = wb;
+	minfo.we = (movetoend >= 2 || (movetoend == 1 && !menucmp));
+	minfo.end = we;
+    }
+    /* If we are already in a menu-completion or if we have done a *
+     * glob completion, we have to delete some of the stuff on the *
+     * command line.                                               */
+    if (minfo.cur)
+	l = minfo.len + minfo.insc;
+    else
+	l = we - wb;
+
+    minfo.insc = 0;
+    cs = minfo.pos;
+    foredel(l);
+
+    /* And then we insert the new string. */
+    minfo.len = instmatch(m, &scs);
+    minfo.end = cs;
+    cs = minfo.pos + minfo.len;
+
+    if (m->suf) {
+	havesuff = 1;
+	minfo.insc = ztrlen(m->suf);
+	minfo.len -= minfo.insc;
+	if (minfo.we) {
+	    minfo.end += minfo.insc;
+	    if (m->flags & CMF_REMOVE) {
+		makesuffixstr(m->remf, m->rems, minfo.insc);
+		if (minfo.insc == 1)
+		    suffixlen[STOUC(m->suf[0])] = 1;
+	    }
+	}
+    } else {
+	/* There is no user-specified suffix, *
+	 * so generate one automagically.     */
+	cs = scs;
+	if (partest && (m->flags & CMF_PARBR)) {
+	    int pq;
+
+	    /*{{*/
+	    /* Completing a parameter in braces.  Add a removable `}' suffix. */
+	    cs += eparq;
+	    for (pq = parq; pq; pq--)
+		inststrlen("\"", 1, 1);
+	    minfo.insc += parq;
+	    inststrlen("}", 1, 1);
+	    minfo.insc++;
+	    if (minfo.we)
+		minfo.end += minfo.insc;
+	    if (m->flags & CMF_PARNEST)
+		havesuff = 1;
+	}
+	if (((m->flags & CMF_FILE) || (partest && isset(AUTOPARAMSLASH))) &&
+	    cs > 0 && line[cs - 1] != '/') {
+	    /* If we have a filename or we completed a parameter name      *
+	     * and AUTO_PARAM_SLASH is set, lets see if it is a directory. *
+	     * If it is, we append a slash.                                */
+	    struct stat buf;
+	    char *p;
+	    int t = 0;
+
+	    if (m->ipre && m->ipre[0] == '~' && !m->ipre[1])
+		t = 1;
+	    else {
+		/* Build the path name. */
+		if (partest && !*psuf && !(m->flags & CMF_PARNEST)) {
+		    int ne = noerrs;
+
+		    p = (char *) zhalloc(strlen((m->flags & CMF_ISPAR) ?
+						parpre : m->ripre) +
+					 strlen(str) + 2);
+		    sprintf(p, "%s%s%c",
+			    ((m->flags & CMF_ISPAR) ? parpre : m->ripre), str,
+			    ((m->flags & CMF_PARBR) ? Outbrace : '\0'));
+		    noerrs = 1;
+		    parsestr(p);
+		    singsub(&p);
+		    errflag = 0;
+		    noerrs = ne;
+		} else {
+		    p = (char *) zhalloc(strlen(prpre) + strlen(str) +
+				 strlen(psuf) + 3);
+		    sprintf(p, "%s%s%s", ((prpre && *prpre) ?
+					  prpre : "./"), str, psuf);
+		}
+		/* And do the stat. */
+		t = (!(sr = ztat(p, &buf, 0)) && S_ISDIR(buf.st_mode));
+	    }
+	    if (t) {
+		/* It is a directory, so add the slash. */
+		havesuff = 1;
+		inststrlen("/", 1, 1);
+		minfo.insc++;
+		if (minfo.we)
+		    minfo.end++;
+		if (!menucmp || minfo.we) {
+		    if (m->remf || m->rems)
+			makesuffixstr(m->remf, m->rems, 1);
+		    else if (isset(AUTOREMOVESLASH)) {
+			makesuffix(1);
+			suffixlen['/'] = 1;
+		    }
+		}
+	    }
+	}
+	if (!minfo.insc)
+	    cs = minfo.pos + minfo.len - m->qisl;
+    }
+    /* If completing in a brace expansion... */
+    if (brbeg) {
+	if (havesuff) {
+	    /*{{*/
+	    /* If a suffix was added, and is removable, let *
+	     * `,' and `}' remove it.                       */
+	    if (isset(AUTOPARAMKEYS))
+		suffixlen[','] = suffixlen['}'] = suffixlen[256];
+	} else if (!menucmp) {
+	    /*{{*/
+	    /* Otherwise, add a `,' suffix, and let `}' remove it. */
+	    cs = scs;
+	    havesuff = 1;
+	    inststrlen(",", 1, 1);
+	    minfo.insc++;
+	    makesuffix(1);
+	    if ((!menucmp || minfo.we) && isset(AUTOPARAMKEYS))
+		suffixlen[','] = suffixlen['}'] = 1;
+	}
+    } else if (!havesuff && (!(m->flags & CMF_FILE) || !sr)) {
+	/* If we didn't add a suffix, add a space, unless we are *
+	 * doing menu completion or we are completing files and  *
+	 * the string doesn't name an existing file.             */
+	if (m->autoq && (!m->isuf || m->isuf[0] != m->autoq)) {
+	    inststrlen(&(m->autoq), 1, 1);
+	    minfo.insc++;
+	}
+	if (!menucmp && (usemenu != 3 || insspace)) {
+	    inststrlen(" ", 1, 1);
+	    minfo.insc++;
+	    if (minfo.we)
+		makesuffix(1);
+	}
+    }
+    if (minfo.we && partest && isset(AUTOPARAMKEYS))
+	makeparamsuffix(((m->flags & CMF_PARBR) ? 1 : 0), minfo.insc - parq);
+
+    if ((menucmp && !minfo.we) || !movetoend) {
+	cs = minfo.end;
+	if (cs + m->qisl == lastend)
+	    cs += minfo.insc;
+    }
+    {
+	Cmatch *om = minfo.cur;
+	struct chdata dat;
+
+	dat.matches = amatches;
+	dat.num = nmatches;
+	dat.cur = m;
+
+	if (menucmp)
+	    minfo.cur = &m;
+	runhookdef(INSERTMATCHHOOK, (void *) &dat);
+	minfo.cur = om;
+    }
+}
+
+/* Do completion, given that we are in the middle of a menu completion.  We *
+ * don't need to generate a list of matches, because that's already been    *
+ * done by previous commands.  We will either list the completions, or      *
+ * insert the next completion.                                              */
+
+/**/
+void
+do_menucmp(int lst)
+{
+    /* Just list the matches if the list was requested. */
+    if (lst == COMP_LIST_COMPLETE) {
+	showinglist = -2;
+	return;
+    }
+    /* Otherwise go to the next match in the array... */
+    HEAPALLOC {
+	do {
+	    if (!*++(minfo.cur)) {
+		do {
+		    if (!(minfo.group = (minfo.group)->next))
+			minfo.group = amatches;
+		} while (!(minfo.group)->mcount);
+		minfo.cur = minfo.group->matches;
+	    }
+	} while (menuacc &&
+		 !hasbrpsfx(*(minfo.cur), minfo.prebr, minfo.postbr));
+	/* ... and insert it into the command line. */
+	metafy_line();
+	do_single(*(minfo.cur));
+	unmetafy_line();
+    } LASTALLOC;
+}
+
+/**/
+int
+reverse_menu(Hookdef dummy, void *dummy2)
+{
+    HEAPALLOC {
+	do {
+	    if (minfo.cur == (minfo.group)->matches) {
+		do {
+		    if (!(minfo.group = (minfo.group)->prev))
+			minfo.group = lmatches;
+		} while (!(minfo.group)->mcount);
+		minfo.cur = (minfo.group)->matches + (minfo.group)->mcount - 1;
+	    } else
+		minfo.cur--;
+	} while (menuacc &&
+		 !hasbrpsfx(*(minfo.cur), minfo.prebr, minfo.postbr));
+	metafy_line();
+	do_single(*(minfo.cur));
+	unmetafy_line();
+    } LASTALLOC;
+
+    return 0;
+}
+
+/* Accepts the current completion and starts a new arg, *
+ * with the next completions. This gives you a way to   *
+ * accept several selections from the list of matches.  */
+
+/**/
+int
+accept_last(void)
+{
+    if (!menuacc) {
+	zsfree(minfo.prebr);
+	minfo.prebr = ztrdup(lastprebr);
+	zsfree(minfo.postbr);
+	minfo.postbr = ztrdup(lastpostbr);
+
+	if (listshown && (lastprebr || lastpostbr)) {
+	    Cmgroup g;
+	    Cmatch *m;
+
+	    for (g = amatches, m = NULL; g && (!m || !*m); g = g->next)
+		for (m = g->matches; *m; m++)
+		    if (!hasbrpsfx(*m, minfo.prebr, minfo.postbr)) {
+			showinglist = -2;
+			break;
+		    }
+	}
+    }
+    menuacc++;
+
+    if (brbeg) {
+	int l;
+
+	iremovesuffix(',', 1);
+
+	l = (brscs >= 0 ? brscs : cs) - brpcs;
+
+	zsfree(lastbrbeg->str);
+	lastbrbeg->str = (char *) zalloc(l + 2);
+	memcpy(lastbrbeg->str, line + brpcs, l);
+	lastbrbeg->str[l] = ',';
+	lastbrbeg->str[l + 1] = '\0';
+    } else {
+	int l;
+
+	cs = minfo.pos + minfo.len + minfo.insc;
+	iremovesuffix(' ', 1);
+	l = cs;
+	cs = minfo.pos + minfo.len + minfo.insc - (*(minfo.cur))->qisl;
+	if (cs < l)
+	    foredel(l - cs);
+	else if (cs > ll)
+	    cs = ll;
+	inststrlen(" ", 1, 1);
+	if (parpre)
+	    inststr(parpre);
+	minfo.insc = minfo.len = 0;
+	minfo.pos = cs;
+	minfo.we = 1;
+    }
+    return 0;
+}
+
+/* This maps the value in v into the range [0,m-1], decrementing v
+ * if it is non-negative and making negative values count backwards. */
+
+/**/
+static int
+comp_mod(int v, int m)
+{
+    if (v >= 0)
+	v--;
+    if (v >= 0)
+	return v % m;
+    else {
+	while (v < 0)
+	    v += m;
+	return v;
+    }
+}
+
+/* This handles the beginning of menu-completion. */
+
+/**/
+static void
+do_ambig_menu(void)
+{
+    Cmatch *mc;
+
+    if (usemenu != 3) {
+	menucmp = 1;
+	menuacc = 0;
+	minfo.cur = NULL;
+    } else {
+	if (oldlist) {
+	    if (oldins && minfo.cur)
+		acceptlast();
+	} else
+	    minfo.cur = NULL;
+    }
+    if (insgroup) {
+	insgnum = comp_mod(insgnum, lastpermgnum);
+	for (minfo.group = amatches;
+	     minfo.group && (minfo.group)->num != insgnum + 1;
+	     minfo.group = (minfo.group)->next);
+	if (!minfo.group || !(minfo.group)->mcount) {
+	    minfo.cur = NULL;
+	    minfo.asked = 0;
+	    return;
+	}
+	insmnum = comp_mod(insmnum, (minfo.group)->mcount);
+    } else {
+	insmnum = comp_mod(insmnum, lastpermmnum);
+	for (minfo.group = amatches;
+	     minfo.group && (minfo.group)->mcount <= insmnum;
+	     minfo.group = (minfo.group)->next)
+	    insmnum -= (minfo.group)->mcount;
+	if (!minfo.group) {
+	    minfo.cur = NULL;
+	    minfo.asked = 0;
+	    return;
+	}
+    }
+    mc = (minfo.group)->matches + insmnum;
+    do_single(*mc);
+    minfo.cur = mc;
+}
+
+/* Return the real number of matches. */
+
+/**/
+zlong
+num_matches(int normal)
+{
+    int alt;
+
+    PERMALLOC {
+	alt = permmatches(0);
+    } LASTALLOC;
+
+    if (normal)
+	return (alt ? 0 : nmatches);
+    else
+	return (alt ? nmatches : 0);
+}
+
+/* Return the number of screen lines needed for the list. */
+
+/**/
+zlong
+list_lines(void)
+{
+    Cmgroup oam;
+
+    PERMALLOC {
+	permmatches(0);
+    } LASTALLOC;
+
+    oam = amatches;
+    amatches = pmatches;
+    listdat.valid = 0;
+    calclist();
+    listdat.valid = 0;
+    amatches = oam;
+
+    return listdat.nlines;
+}
+
+/**/
+void
+comp_list(char *v)
+{
+    zsfree(complist);
+    complist = ztrdup(v);
+
+    onlyexpl = (v && strstr(v, "expl"));
+}
+
+/* This is used to print the explanation string. *
+ * It returns the number of lines printed.       */
+
+/**/
+int
+printfmt(char *fmt, int n, int dopr, int doesc)
+{
+    char *p = fmt, nc[DIGBUFSIZE];
+    int l = 0, cc = 0, b = 0, s = 0, u = 0, m;
+
+    for (; *p; p++) {
+	/* Handle the `%' stuff (%% == %, %n == <number of matches>). */
+	if (doesc && *p == '%') {
+	    if (*++p) {
+		m = 0;
+		switch (*p) {
+		case '%':
+		    if (dopr)
+			putc('%', shout);
+		    cc++;
+		    break;
+		case 'n':
+		    sprintf(nc, "%d", n);
+		    if (dopr)
+			fprintf(shout, nc);
+		    cc += strlen(nc);
+		    break;
+		case 'B':
+		    b = 1;
+		    if (dopr)
+			tcout(TCBOLDFACEBEG);
+		    break;
+		case 'b':
+		    b = 0; m = 1;
+		    if (dopr)
+			tcout(TCALLATTRSOFF);
+		    break;
+		case 'S':
+		    s = 1;
+		    if (dopr)
+			tcout(TCSTANDOUTBEG);
+		    break;
+		case 's':
+		    s = 0; m = 1;
+		    if (dopr)
+			tcout(TCSTANDOUTEND);
+		    break;
+		case 'U':
+		    u = 1;
+		    if (dopr)
+			tcout(TCUNDERLINEBEG);
+		    break;
+		case 'u':
+		    u = 0; m = 1;
+		    if (dopr)
+			tcout(TCUNDERLINEEND);
+		    break;
+		case '{':
+		    for (p++; *p && (*p != '%' || p[1] != '}'); p++, cc++)
+			if (dopr)
+			    putc(*p, shout);
+		    if (*p)
+			p++;
+		    else
+			p--;
+		    break;
+		}
+		if (dopr && m) {
+		    if (b)
+			tcout(TCBOLDFACEBEG);
+		    if (s)
+			tcout(TCSTANDOUTBEG);
+		    if (u)
+			tcout(TCUNDERLINEBEG);
+		}
+	    } else
+		break;
+	} else {
+	    cc++;
+	    if (*p == '\n') {
+		if (dopr) {
+		    if (tccan(TCCLEAREOL))
+			tcout(TCCLEAREOL);
+		    else {
+			int s = columns - 1 - (cc % columns);
+
+			while (s-- > 0)
+			    putc(' ', shout);
+		    }
+		}
+		l += 1 + (cc / columns);
+		cc = 0;
+	    }
+	    if (dopr)
+		putc(*p, shout);
+	}
+    }
+    if (dopr) {
+	if (tccan(TCCLEAREOL))
+	    tcout(TCCLEAREOL);
+	else {
+	    int s = columns - 1 - (cc % columns);
+
+	    while (s-- > 0)
+		putc(' ', shout);
+	}
+    }
+    return l + (cc / columns);
+}
+
+/* This skips over matches that are not to be listed. */
+
+/**/
+Cmatch *
+skipnolist(Cmatch *p)
+{
+    while (*p && (((*p)->flags & (CMF_NOLIST | CMF_HIDE)) ||
+		  ((*p)->disp && ((*p)->flags & (CMF_DISPLINE | CMF_HIDE)))))
+	p++;
+
+    return p;
+}
+
+/**/
+void
+calclist(void)
+{
+    Cmgroup g;
+    Cmatch *p, m;
+    Cexpl *e;
+    int hidden = 0, nlist = 0, nlines = 0, add = 2 + isset(LISTTYPES);
+    int max = 0, i;
+    VARARR(int, mlens, nmatches + 1);
+
+    if (listdat.valid && onlyexpl == listdat.onlyexpl &&
+	menuacc == listdat.menuacc &&
+	lines == listdat.lines && columns == listdat.columns)
+	return;
+
+    for (g = amatches; g; g = g->next) {
+	char **pp = g->ylist;
+	int nl = 0, l, glong = 1, gshort = columns, ndisp = 0, totl = 0;
+
+	if (!onlyexpl && pp) {
+	    /* We have an ylist, lets see, if it contains newlines. */
+	    hidden = 1;
+	    while (!nl && *pp)
+		nl = !!strchr(*pp++, '\n');
+
+	    pp = g->ylist;
+	    if (nl || !pp[1]) {
+		/* Yup, there are newlines, count lines. */
+		char *nlptr, *sptr;
+
+		g->flags |= CGF_LINES;
+		hidden = 1;
+		while ((sptr = *pp)) {
+		    while (sptr && *sptr) {
+			nlines += (nlptr = strchr(sptr, '\n'))
+			    ? 1 + (nlptr-sptr)/columns
+			    : strlen(sptr)/columns;
+			sptr = nlptr ? nlptr+1 : NULL;
+		    }
+		    nlines++;
+		    pp++;
+		}
+		nlines--;
+	    } else {
+		while (*pp) {
+		    l = strlen(*pp);
+		    ndisp++;
+		    if (l > glong)
+			glong = l;
+		    if (l < gshort)
+			gshort = l;
+		    totl += l;
+		    nlist++;
+		    pp++;
+		}
+	    }
+	} else if (!onlyexpl) {
+	    for (p = g->matches; (m = *p); p++) {
+		if (menuacc && !hasbrpsfx(m, minfo.prebr, minfo.postbr)) {
+		    m->flags |= CMF_HIDE;
+		    continue;
+		}
+		m->flags &= ~CMF_HIDE;
+
+		if (m->disp) {
+		    if (m->flags & CMF_DISPLINE) {
+			nlines += 1 + printfmt(m->disp, 0, 0, 0);
+			g->flags |= CGF_HASDL;
+		    } else {
+			l = niceztrlen(m->disp);
+			ndisp++;
+			if (l > glong)
+			    glong = l;
+			if (l < gshort)
+			    gshort = l;
+			totl += l;
+			mlens[m->gnum] = l;
+		    }
+		    nlist++;
+		} else if (!(m->flags & CMF_NOLIST)) {
+		    l = niceztrlen(m->str);
+		    ndisp++;
+		    if (l > glong)
+			glong = l;
+		    if (l < gshort)
+			gshort = l;
+		    totl += l;
+		    mlens[m->gnum] = l;
+		    nlist++;
+		} else
+		    hidden = 1;
+	    }
+	}
+	if ((e = g->expls)) {
+	    while (*e) {
+		if ((*e)->count)
+		    nlines += 1 + printfmt((*e)->str, (*e)->count, 0, 1);
+		e++;
+	    }
+	}
+	g->totl = totl + (ndisp * add);
+	g->dcount = ndisp;
+	g->width = glong + add;
+	g->shortest = gshort + add;
+	if ((g->cols = columns / g->width) > g->dcount)
+	    g->cols = g->dcount;
+	if (g->cols) {
+	    i = g->cols * g->width - add;
+	    if (i > max)
+		max = i;
+	}
+    }
+    if (!onlyexpl) {
+	for (g = amatches; g; g = g->next) {
+	    char **pp;
+	    int glines = 0;
+
+	    zfree(g->widths, 0);
+	    g->widths = NULL;
+
+	    if ((pp = g->ylist)) {
+		if (!(g->flags & CGF_LINES)) {
+		    if (g->cols) {
+			glines += (arrlen(pp) + g->cols - 1) / g->cols;
+			if (g->cols > 1)
+			    g->width += (max - (g->width * g->cols - add)) / g->cols;
+		    } else {
+			g->cols = 1;
+			g->width = 1;
+			
+			while (*pp)
+			    glines += 1 + (strlen(*pp++) / columns);
+		    }
+		}
+	    } else {
+		if (g->cols) {
+		    glines += (g->dcount + g->cols - 1) / g->cols;
+		    if (g->cols > 1)
+			g->width += (max - (g->width * g->cols - add)) / g->cols;
+		} else if (!(g->flags & CGF_LINES)) {
+		    g->cols = 1;
+		    g->width = 0;
+		    
+		    for (p = g->matches; (m = *p); p++)
+			if (!(m->flags & CMF_HIDE)) {
+			    if (m->disp) {
+				if (!(m->flags & CMF_DISPLINE))
+				    glines += 1 + (mlens[m->gnum] / columns);
+			    } else if (!(m->flags & CMF_NOLIST))
+				glines += 1 + ((1 + mlens[m->gnum]) / columns);
+			}
+		}
+	    }
+	    g->lins = glines;
+	    nlines += glines;
+	}
+    }
+    if (!onlyexpl && isset(LISTPACKED)) {
+	char **pp;
+	int *ws, tlines, tline, tcols, maxlen, nth, width;
+
+	for (g = amatches; g; g = g->next) {
+	    ws = g->widths = (int *) zalloc(columns * sizeof(int));
+	    memset(ws, 0, columns * sizeof(int));
+	    tlines = g->lins;
+	    tcols = g->cols;
+	    width = 0;
+
+	    if ((pp = g->ylist)) {
+		if (!(g->flags & CGF_LINES)) {
+		    int yl = arrlen(pp), i;
+		    VARARR(int, ylens, yl);
+
+		    for (i = 0; *pp; i++, pp++)
+			ylens[i] = strlen(*pp) + add;
+
+		    if (isset(LISTROWSFIRST)) {
+			int count, tcol, first, maxlines = 0, llines;
+
+			for (tcols = columns / g->shortest; tcols > g->cols;
+			     tcols--) {
+			    for (nth = first = maxlen = width = maxlines =
+				     llines = tcol = 0,
+				     count = g->dcount;
+				 count > 0; count--) {
+				if (ylens[nth] > maxlen)
+				    maxlen = ylens[nth];
+				nth += tcols;
+				tlines++;
+				if (nth >= g->dcount) {
+				    if ((width += maxlen) >= columns)
+					break;
+				    ws[tcol++] = maxlen;
+				    maxlen = 0;
+				    nth = ++first;
+				    if (llines > maxlines)
+					maxlines = llines;
+				    llines = 0;
+				}
+			    }
+			    if (nth < yl) {
+				ws[tcol++] = maxlen;
+				width += maxlen;
+			    }
+			    if (!count && width < columns)
+				break;
+			}
+			if (tcols > g->cols)
+			    tlines = maxlines;
+		    } else {
+			for (tlines = ((g->totl + columns) / columns);
+			     tlines < g->lins; tlines++) {
+			    for (pp = g->ylist, nth = tline = width =
+				     maxlen = tcols = 0;
+				 *pp; nth++, pp++) {
+				if (ylens[nth] > maxlen)
+				    maxlen = ylens[nth];
+				if (++tline == tlines) {
+				    if ((width += maxlen) >= columns)
+					break;
+				    ws[tcols++] = maxlen;
+				    maxlen = tline = 0;
+				}
+			    }
+			    if (tline) {
+				ws[tcols++] = maxlen;
+				width += maxlen;
+			    }
+			    if (nth == yl && width < columns)
+				break;
+			}
+		    }
+		}
+	    } else if (g->width) {
+		if (isset(LISTROWSFIRST)) {
+		    int addlen, count, tcol, maxlines = 0, llines, i;
+		    Cmatch *first;
+
+		    for (tcols = columns / g->shortest; tcols > g->cols;
+			 tcols--) {
+			p = first = skipnolist(g->matches);
+			for (maxlen = width = maxlines = llines = tcol = 0,
+				 count = g->dcount;
+			     count > 0; count--) {
+			    m = *p;
+			    addlen = mlens[m->gnum] + add;
+			    if (addlen > maxlen)
+				maxlen = addlen;
+			    for (i = tcols; i && *p; i--)
+				p = skipnolist(p + 1);
+
+			    llines++;
+			    if (!*p) {
+				if (llines > maxlines)
+				    maxlines = llines;
+				llines = 0;
+
+				if ((width += maxlen) >= columns)
+				    break;
+				ws[tcol++] = maxlen;
+				maxlen = 0;
+
+				p = first = skipnolist(first + 1);
+			    }
+			}
+			if (tlines) {
+			    ws[tcol++] = maxlen;
+			    width += maxlen;
+			}
+			if (!count && width < columns)
+			    break;
+		    }
+		    if (tcols > g->cols)
+			tlines = maxlines;
+		} else {
+		    int addlen;
+
+		    for (tlines = ((g->totl + columns) / columns);
+			 tlines < g->lins; tlines++) {
+			for (p = g->matches, nth = tline = width =
+				 maxlen = tcols = 0;
+			     (m = *p); p++, nth++) {
+			    if (!(m->flags &
+				  (m->disp ? (CMF_DISPLINE | CMF_HIDE) :
+				   (CMF_NOLIST | CMF_HIDE)))) {
+				addlen = mlens[m->gnum] + add;
+				if (addlen > maxlen)
+				    maxlen = addlen;
+				if (++tline == tlines) {
+				    if ((width += maxlen) >= columns)
+					break;
+				    ws[tcols++] = maxlen;
+				    maxlen = tline = 0;
+				}
+			    }
+			}
+			if (tline) {
+			    ws[tcols++] = maxlen;
+			    width += maxlen;
+			}
+			if (nth == g->dcount && width < columns)
+			    break;
+		    }
+		}
+	    }
+	    if (tlines == g->lins) {
+		zfree(ws, columns * sizeof(int));
+		g->widths = NULL;
+	    } else {
+		nlines += tlines - g->lins;
+		g->lins = tlines;
+		g->cols = tcols;
+		g->totl = width;
+		width -= add;
+		if (width > max)
+		    max = width;
+	    }
+	}
+	for (g = amatches; g; g = g->next) {
+	    if (g->widths) {
+		int *p, a = (max - g->totl + add) / g->cols;
+
+		for (i = g->cols, p = g->widths; i; i--, p++)
+		    *p += a;
+	    } else if (g->width && g->cols > 1)
+		g->width += (max - (g->width * g->cols - add)) / g->cols;
+	}
+    }
+    listdat.valid = 1;
+    listdat.hidden = hidden;
+    listdat.nlist = nlist;
+    listdat.nlines = nlines;
+    listdat.menuacc = menuacc;
+    listdat.onlyexpl = onlyexpl;
+    listdat.columns = columns;
+    listdat.lines = lines;
+}
+
+/**/
+int asklist(void)
+{
+    /* Set the cursor below the prompt. */
+    trashzle();
+    showinglist = listshown = 0;
+
+    clearflag = (isset(USEZLE) && !termflags &&
+		 complastprompt && *complastprompt);
+
+    /* Maybe we have to ask if the user wants to see the list. */
+    if ((!minfo.cur || !minfo.asked) &&
+	((complistmax && listdat.nlist > complistmax) ||
+	 (!complistmax && listdat.nlines >= lines))) {
+	int qup;
+	zsetterm();
+	qup = printfmt("zsh: do you wish to see all %n possibilities? ",
+		       listdat.nlist, 1, 1);
+	fflush(shout);
+	if (getzlequery() != 'y') {
+	    if (clearflag) {
+		putc('\r', shout);
+		tcmultout(TCUP, TCMULTUP, qup);
+		if (tccan(TCCLEAREOD))
+		    tcout(TCCLEAREOD);
+		tcmultout(TCUP, TCMULTUP, nlnct);
+	    } else
+		putc('\n', shout);
+	    if (minfo.cur)
+		minfo.asked = 2;
+	    return 1;
+	}
+	if (clearflag) {
+	    putc('\r', shout);
+	    tcmultout(TCUP, TCMULTUP, qup);
+	    if (tccan(TCCLEAREOD))
+		tcout(TCCLEAREOD);
+	} else
+	    putc('\n', shout);
+	settyinfo(&shttyinfo);
+	if (minfo.cur)
+	    minfo.asked = 1;
+    }
+    return 0;
+}
+
+/**/
+int
+printlist(int over, CLPrintFunc printm)
+{
+    Cmgroup g;
+    Cmatch *p, m;
+    Cexpl *e;
+    int pnl = 0, cl = (over ? listdat.nlines : -1);
+    int mc = 0, ml = 0, printed = 0;
+
+    if (cl < 2) {
+	cl = -1;
+	if (tccan(TCCLEAREOD))
+	    tcout(TCCLEAREOD);
+    }
+    g = amatches;
+    while (g) {
+	char **pp = g->ylist;
+
+	if ((e = g->expls)) {
+	    int l;
+
+	    while (*e) {
+		if ((*e)->count) {
+		    if (pnl) {
+			putc('\n', shout);
+			pnl = 0;
+			ml++;
+			if (cl >= 0 && --cl <= 1) {
+			    cl = -1;
+			    if (tccan(TCCLEAREOD))
+				tcout(TCCLEAREOD);
+			}
+		    }
+		    l = printfmt((*e)->str, (*e)->count, 1, 1);
+		    ml += l;
+		    if (cl >= 0 && (cl -= l) <= 1) {
+			cl = -1;
+			if (tccan(TCCLEAREOD))
+			    tcout(TCCLEAREOD);
+		    }
+		    pnl = 1;
+		}
+		e++;
+	    }
+	}
+	if (!listdat.onlyexpl && pp && *pp) {
+	    if (pnl) {
+		putc('\n', shout);
+		pnl = 0;
+		ml++;
+		if (cl >= 0 && --cl <= 1) {
+		    cl = -1;
+		    if (tccan(TCCLEAREOD))
+			tcout(TCCLEAREOD);
+		}
+	    }
+	    if (g->flags & CGF_LINES) {
+		while (*pp) {
+		    zputs(*pp, shout);
+		    if (*++pp)
+			putc('\n', shout);
+		}
+	    } else {
+		int n = g->lcount, nl, nc, i, a;
+		char **pq;
+
+		nl = nc = g->lins;
+
+		while (n && nl--) {
+		    i = g->cols;
+		    mc = 0;
+		    pq = pp;
+		    while (n && i--) {
+			if (pq - g->ylist >= g->lcount)
+			    break;
+			zputs(*pq, shout);
+			if (i) {
+			    a = (g->widths ? g->widths[mc] : g->width) -
+				strlen(*pq);
+			    while (a--)
+				putc(' ', shout);
+			}
+			pq += (isset(LISTROWSFIRST) ? 1 : nc);
+			mc++;
+			n--;
+		    }
+		    if (n) {
+			putc('\n', shout);
+			ml++;
+			if (cl >= 0 && --cl <= 1) {
+			    cl = -1;
+			    if (tccan(TCCLEAREOD))
+				tcout(TCCLEAREOD);
+			}
+		    }
+		    pp += (isset(LISTROWSFIRST) ? g->cols : 1);
+		}
+	    }
+	} else if (!listdat.onlyexpl && g->lcount) {
+	    int n = g->dcount, nl, nc, i, j, wid;
+	    Cmatch *q;
+
+	    nl = nc = g->lins;
+
+	    if (g->flags & CGF_HASDL) {
+		for (p = g->matches; (m = *p); p++)
+		    if (m->disp && (m->flags & CMF_DISPLINE)) {
+			if (pnl) {
+			    putc('\n', shout);
+			    pnl = 0;
+			    ml++;
+			    if (cl >= 0 && --cl <= 1) {
+				cl = -1;
+				if (tccan(TCCLEAREOD))
+				    tcout(TCCLEAREOD);
+			    }
+			}
+			printed++;
+			printm(g, p, 0, ml, 1, 0, NULL, NULL);
+			pnl = 1;
+		    }
+	    }
+	    if (n && pnl) {
+		putc('\n', shout);
+		pnl = 0;
+		ml++;
+		if (cl >= 0 && --cl <= 1) {
+		    cl = -1;
+		    if (tccan(TCCLEAREOD))
+			tcout(TCCLEAREOD);
+		}
+	    }
+	    for (p = skipnolist(g->matches); n && nl--;) {
+		i = g->cols;
+		mc = 0;
+		q = p;
+		while (n && i--) {
+		    wid = (g->widths ? g->widths[mc] : g->width);
+		    if (!(m = *q)) {
+			printm(g, NULL, mc, ml, (!i), wid, NULL, NULL);
+			break;
+		    }
+		    if (!m->disp && (m->flags & CMF_FILE)) {
+			struct stat buf;
+			char *pb;
+
+			pb = (char *) zhalloc((m->prpre ? strlen(m->prpre) : 0) +
+					     3 + strlen(m->str));
+			sprintf(pb, "%s%s", (m->prpre ? m->prpre : "./"),
+				m->str);
+
+			if (ztat(pb, &buf, 1))
+			    printm(g, q, mc, ml, (!i), wid, NULL, NULL);
+			else
+			    printm(g, q, mc, ml, (!i), wid, pb, &buf);
+		    } else
+			printm(g, q, mc, ml, (!i), wid, NULL, NULL);
+
+		    printed++;
+
+		    if (--n)
+			for (j = (isset(LISTROWSFIRST) ? 1 : nc); j && *q; j--)
+			    q = skipnolist(q + 1);
+		    mc++;
+		}
+		while (i-- > 0)
+		    printm(g, NULL, mc++, ml, (!i),
+			   (g->widths ? g->widths[mc] : g->width), NULL, NULL);
+
+		if (n) {
+		    putc('\n', shout);
+		    ml++;
+		    if (cl >= 0 && --cl <= 1) {
+			cl = -1;
+			if (tccan(TCCLEAREOD))
+			    tcout(TCCLEAREOD);
+		    }
+		    if (nl)
+			for (j = (isset(LISTROWSFIRST) ? g->cols : 1); j && *p; j--)
+			    p = skipnolist(p + 1);
+		}
+	    }
+	}
+	if (g->lcount)
+	    pnl = 1;
+	g = g->next;
+    }
+    if (clearflag) {
+	/* Move the cursor up to the prompt, if always_last_prompt *
+	 * is set and all that...                                  */
+	if ((ml = listdat.nlines + nlnct - 1) < lines) {
+	    tcmultout(TCUP, TCMULTUP, ml);
+	    showinglist = -1;
+	} else
+	    clearflag = 0, putc('\n', shout);
+    } else
+	putc('\n', shout);
+    listshown = (clearflag ? 1 : -1);
+
+    return printed;
+}
+
+/**/
+static void
+iprintm(Cmgroup g, Cmatch *mp, int mc, int ml, int lastc, int width,
+	char *path, struct stat *buf)
+{
+    Cmatch m;
+    int len = 0;
+
+    if (!mp)
+	return;
+
+    m = *mp;
+    if (m->disp) {
+	if (m->flags & CMF_DISPLINE) {
+	    printfmt(m->disp, 0, 1, 0);
+	    return;
+	}
+	nicezputs(m->disp, shout);
+	len = niceztrlen(m->disp);
+    } else {
+	nicezputs(m->str, shout);
+	len = niceztrlen(m->str);
+
+	if (isset(LISTTYPES)) {
+	    if (buf)
+		putc(file_type(buf->st_mode), shout);
+	    len++;
+	}
+    }
+    if (!lastc) {
+	len = width - len;
+
+	while (len-- > 0)
+	    putc(' ', shout);
+    }
+}
+
+/**/
+int
+ilistmatches(Hookdef dummy, Chdata dat)
+{
+    calclist();
+
+    if (!listdat.nlines) {
+	showinglist = listshown = 0;
+	return 1;
+    }
+    if (asklist())
+	return 0;
+
+    printlist(0, iprintm);
+
+    return 0;
+}
+
+/* List the matches.  Note that the list entries are metafied. */
+
+/**/
+int
+list_matches(Hookdef dummy, void *dummy2)
+{
+    struct chdata dat;
+
+#ifdef DEBUG
+    /* Sanity check */
+    if (!validlist) {
+	showmsg("BUG: listmatches called with bogus list");
+	return 1;
+    }
+#endif
+
+    dat.matches = amatches;
+    dat.num = nmatches;
+    dat.cur = NULL;
+    return runhookdef(COMPLISTMATCHESHOOK, (void *) &dat);
+}
+
+/* Invalidate the completion list. */
+
+/**/
+int
+invalidate_list(void)
+{
+    if (showinglist == -2)
+	listmatches();
+    if (validlist) {
+	freematches(lastmatches);
+	lastmatches = NULL;
+	hasoldlist = 0;
+    }
+    lastambig = menucmp = menuacc = validlist = showinglist = fromcomp = 0;
+    listdat.valid = 0;
+    if (listshown < 0)
+	listshown = 0;
+    minfo.cur = NULL;
+    minfo.asked = 0;
+    zsfree(minfo.prebr);
+    zsfree(minfo.postbr);
+    minfo.postbr = minfo.prebr = NULL;
+    compwidget = NULL;
+
+    return 0;
+}
diff --git a/Src/Zle/zle.h b/Src/Zle/zle.h
index 470aa890f..2dfeb6950 100644
--- a/Src/Zle/zle.h
+++ b/Src/Zle/zle.h
@@ -144,19 +144,53 @@ typedef struct cutbuffer *Cutbuffer;
 
 #define KRINGCT 8   /* number of buffers in the kill ring */
 
+/* Types of completion. */
+
+#define COMP_COMPLETE        0
+#define COMP_LIST_COMPLETE   1
+#define COMP_SPELL           2
+#define COMP_EXPAND          3
+#define COMP_EXPAND_COMPLETE 4
+#define COMP_LIST_EXPAND     5
+#define COMP_ISEXPAND(X) ((X) >= COMP_EXPAND)
+
+/* Information about one brace run. */
+
+typedef struct brinfo *Brinfo;
+
+struct brinfo {
+    Brinfo next;		/* next in list */
+    Brinfo prev;		/* previous (only for closing braces) */
+    char *str;			/* the string to insert */
+    int pos;			/* original position */
+    int qpos;			/* original position, with quoting */
+    int curpos;			/* position for current match */
+};
+
 /* Convenience macros for the hooks */
 
-#define LISTMATCHESHOOK   (zlehooks + 0)
-#define INSERTMATCHHOOK   (zlehooks + 1)
-#define MENUSTARTHOOK     (zlehooks + 2)
-#define COMPCTLMAKEHOOK   (zlehooks + 3)
-#define COMPCTLBEFOREHOOK (zlehooks + 4)
-#define COMPCTLAFTERHOOK  (zlehooks + 5)
+#define LISTMATCHESHOOK    (zlehooks + 0)
+#define COMPLETEHOOK       (zlehooks + 1)
+#define BEFORECOMPLETEHOOK (zlehooks + 2)
+#define AFTERCOMPLETEHOOK  (zlehooks + 3)
+#define ACCEPTCOMPHOOK     (zlehooks + 4)
+#define REVERSEMENUHOOK    (zlehooks + 5)
+#define INVALIDATELISTHOOK (zlehooks + 6)
 
-/* compctl hook data structs */
+/* complete hook data struct */
 
-struct ccmakedat {
-    char *str;
-    int incmd;
+typedef struct compldat *Compldat;
+
+struct compldat {
+    char *s;
     int lst;
+    int incmd;
 };
+
+/* List completion matches. */
+
+#define listmatches() runhookdef(LISTMATCHESHOOK, NULL)
+
+/* Invalidate the completion list. */
+
+#define invalidatelist() runhookdef(INVALIDATELISTHOOK, NULL)
diff --git a/Src/Zle/zle.mdd b/Src/Zle/zle.mdd
index c3d6672a4..3235c88a1 100644
--- a/Src/Zle/zle.mdd
+++ b/Src/Zle/zle.mdd
@@ -6,7 +6,7 @@ objects="zle_bindings.o zle_hist.o zle_keymap.o zle_main.o \
 zle_misc.o zle_move.o zle_params.o zle_refresh.o \
 zle_thingy.o zle_tricky.o zle_utils.o zle_vi.o zle_word.o"
 
-headers="zle.h zle_things.h comp.h"
+headers="zle.h zle_things.h"
 
 :<<\Make
 zle_things.h: thingies.list zle_things.sed
diff --git a/Src/Zle/zle_main.c b/Src/Zle/zle_main.c
index 56ecd02ba..f29da3e0e 100644
--- a/Src/Zle/zle_main.c
+++ b/Src/Zle/zle_main.c
@@ -30,14 +30,6 @@
 #include "zle.mdh"
 #include "zle_main.pro"
 
-/* Defined by the complete module, called in zle_tricky.c. */
-
-/**/
-void (*makecompparamsptr) _((void));
-
-/**/
-void (*comp_setunsetptr) _((int, int, int, int));
-
 /* != 0 if in a shell function called from completion, such that read -[cl]  *
  * will work (i.e., the line is metafied, and the above word arrays are OK). */
 
@@ -49,50 +41,10 @@ int incompctlfunc;
 /**/
 int incompfunc;
 
-/* Global matcher. */
-
-/**/
-Cmlist cmatcher;
-
-/* global variables for shell parameters in new style completion */
+/* != 0 if completion module is loaded */
 
 /**/
-zlong compcurrent,
-      compmatcher,
-      compmatchertot,
-      complistmax,
-      complistlines;
-
-/**/
-char **compwords,
-     *compprefix,
-     *compsuffix,
-     *compiprefix,
-     *compisuffix,
-     *compqiprefix,
-     *compqisuffix,
-     *compmatcherstr,
-     *compcontext,
-     *compparameter,
-     *compredirect,
-     *compquote,
-     *compquoting,
-     *comprestore,
-     *complist,
-     *compforcelist,
-     *compinsert,
-     *compexact,
-     *compexactstr,
-     *comppatmatch,
-     *comppatinsert,
-     *complastprompt,
-     *comptoend,
-     *compoldlist,
-     *compoldins,
-     *compvared;
-
-/**/
-Param *comprpms, *compkpms;
+int hascompmod;
 
 /* != 0 if we're done editing */
 
@@ -1022,12 +974,13 @@ static struct builtin bintab[] = {
 
 /**/
 struct hookdef zlehooks[] = {
-    HOOKDEF("list_matches", ilistmatches, 0),
-    HOOKDEF("insert_match", NULL, HOOKF_ALL),
-    HOOKDEF("menu_start", NULL, HOOKF_ALL),
-    HOOKDEF("compctl_make", NULL, 0),
-    HOOKDEF("compctl_before", NULL, 0),
-    HOOKDEF("compctl_after", NULL, 0),
+    HOOKDEF("list_matches", NULL, 0),
+    HOOKDEF("complete", NULL, 0),
+    HOOKDEF("before_complete", NULL, 0),
+    HOOKDEF("after_complete", NULL, 0),
+    HOOKDEF("accept_completion", NULL, 0),
+    HOOKDEF("reverse_menu", NULL, 0),
+    HOOKDEF("invalidate_list", NULL, 0),
 };
 
 /**/
@@ -1050,30 +1003,16 @@ setup_zle(Module m)
     /* miscellaneous initialisations */
     stackhist = stackcs = -1;
     kungetbuf = (char *) zalloc(kungetsz = 32);
-    hasperm = 0;
 
     /* initialise the keymap system */
     init_keymaps();
 
     varedarg = NULL;
 
-    incompfunc = incompctlfunc = 0;
-
-    comprpms = compkpms = NULL;
-    compwords = NULL;
-    compprefix = compsuffix = compiprefix = compisuffix = 
-	compqiprefix = compqisuffix = compmatcherstr = 
-	compcontext = compparameter = compredirect = compquote =
-	compquoting = comprestore = complist = compinsert =
-	compexact = compexactstr = comppatmatch = comppatinsert =
-	compforcelist = complastprompt = comptoend = 
-	compoldlist = compoldins = compvared = NULL;
+    incompfunc = incompctlfunc = hascompmod = 0;
 
     clwords = (char **) zcalloc((clwsize = 16) * sizeof(char *));
 
-    makecompparamsptr = NULL;
-    comp_setunsetptr = NULL;
-
     return 0;
 }
 
@@ -1132,33 +1071,6 @@ finish_zle(Module m)
 
     getkeyptr = NULL;
 
-    freearray(compwords);
-    zsfree(compprefix);
-    zsfree(compsuffix);
-    zsfree(compiprefix);
-    zsfree(compisuffix);
-    zsfree(compqiprefix);
-    zsfree(compqisuffix);
-    zsfree(compmatcherstr);
-    zsfree(compcontext);
-    zsfree(compparameter);
-    zsfree(compredirect);
-    zsfree(compquote);
-    zsfree(compquoting);
-    zsfree(comprestore);
-    zsfree(complist);
-    zsfree(compforcelist);
-    zsfree(compinsert);
-    zsfree(compexact);
-    zsfree(compexactstr);
-    zsfree(comppatmatch);
-    zsfree(comppatinsert);
-    zsfree(complastprompt);
-    zsfree(comptoend);
-    zsfree(compoldlist);
-    zsfree(compoldins);
-    zsfree(compvared);
-
     zfree(clwords, clwsize * sizeof(char *));
 
     return 0;
diff --git a/Src/Zle/zle_misc.c b/Src/Zle/zle_misc.c
index 136a9d432..18e38ee3a 100644
--- a/Src/Zle/zle_misc.c
+++ b/Src/Zle/zle_misc.c
@@ -640,7 +640,7 @@ Thingy
 executenamedcommand(char *prmt)
 {
     Thingy cmd;
-    int len, l = strlen(prmt), ols = listshown, feep = 0;
+    int len, l = strlen(prmt), ols = listshown, feep = 0, listed = 0, curlist = 0;
     char *ptr;
     char *okeymap = curkeymapname;
 
@@ -660,14 +660,31 @@ executenamedcommand(char *prmt)
 	    selectkeymap(okeymap, 1);
 	    if ((listshown = ols))
 		showinglist = -2;
-	    else
-		clearlist = 1;
+	    else if (listed)
+		clearlist = listshown = 1;
+
 	    return NULL;
 	}
 	if(cmd == Th(z_clearscreen)) {
 	    clearscreen(zlenoargs);
+	    if (curlist) {
+		int zmultsav = zmult;
+
+		zmult = 1;
+		listlist(cmdll);
+		showinglist = 0;
+		zmult = zmultsav;
+	    }
 	} else if(cmd == Th(z_redisplay)) {
 	    redisplay(zlenoargs);
+	    if (curlist) {
+		int zmultsav = zmult;
+
+		zmult = 1;
+		listlist(cmdll);
+		showinglist = 0;
+		zmult = zmultsav;
+	    }
 	} else if(cmd == Th(z_viquotedinsert)) {
 	    *ptr = '^';
 	    zrefresh();
@@ -675,23 +692,28 @@ executenamedcommand(char *prmt)
 	    if(c == EOF || !c || len == NAMLEN)
 		feep = 1;
 	    else
-		*ptr++ = c, len++;
+		*ptr++ = c, len++, curlist = 0;
 	} else if(cmd == Th(z_quotedinsert)) {
 	    if((c = getkey(0)) == EOF || !c || len == NAMLEN)
 		feep = 1;
 	    else
-		*ptr++ = c, len++;
+		*ptr++ = c, len++, curlist = 0;
 	} else if(cmd == Th(z_backwarddeletechar) ||
 	    	cmd == Th(z_vibackwarddeletechar)) {
 	    if (len)
-		len--, ptr--;
+		len--, ptr--, curlist = 0;
 	} else if(cmd == Th(z_killregion) || cmd == Th(z_backwardkillword) ||
-	    	cmd == Th(z_vibackwardkillword)) {
+		  cmd == Th(z_vibackwardkillword)) {
+	    if (len)
+		curlist = 0;
 	    while (len && (len--, *--ptr != '-'));
 	} else if(cmd == Th(z_killwholeline) || cmd == Th(z_vikillline) ||
 	    	cmd == Th(z_backwardkillline)) {
 	    len = 0;
 	    ptr = cmdbuf;
+	    if (listed)
+		clearlist = listshown = 1;
+	    curlist = 0;
 	} else {
 	    if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) {
 		Thingy r;
@@ -704,8 +726,8 @@ executenamedcommand(char *prmt)
 		    selectkeymap(okeymap, 1);
 		    if ((listshown = ols))
 			showinglist = -2;
-		    else
-			clearlist = 1;
+		    else if (listed)
+			clearlist = listshown = 1;
 		    return r;
 		}
 		unrefthingy(r);
@@ -728,15 +750,19 @@ executenamedcommand(char *prmt)
 
 		    scanhashtable(thingytab, 1, 0, DISABLED, scancompcmd, 0);
 		} LASTALLOC;
-		if (empty(cmdll))
+		if (empty(cmdll)) {
 		    feep = 1;
-		else if (cmd == Th(z_listchoices) ||
+		    if (listed)
+			clearlist = listshown = 1;
+		    curlist = 0;
+		} else if (cmd == Th(z_listchoices) ||
 		    cmd == Th(z_deletecharorlist)) {
 		    int zmultsav = zmult;
 		    *ptr = '_';
 		    statusll = l + len + 1;
 		    zmult = 1;
 		    listlist(cmdll);
+		    listed = curlist = 1;
 		    showinglist = 0;
 		    zmult = zmultsav;
 		} else if (!nextnode(firstnode(cmdll))) {
@@ -756,6 +782,7 @@ executenamedcommand(char *prmt)
 			statusll = l + cmdambig + 1;
 			zmult = 1;
 			listlist(cmdll);
+			listed = curlist = 1;
 			showinglist = 0;
 			zmult = zmultsav;
 		    }
@@ -765,7 +792,7 @@ executenamedcommand(char *prmt)
 		if (len == NAMLEN || icntrl(c) || cmd != Th(z_selfinsert))
 		    feep = 1;
 		else
-		    *ptr++ = c, len++;
+		    *ptr++ = c, len++, curlist = 0;
 	    }
 	}
 	if (feep)
diff --git a/Src/Zle/zle_thingy.c b/Src/Zle/zle_thingy.c
index 72a0f120d..a4191a9a4 100644
--- a/Src/Zle/zle_thingy.c
+++ b/Src/Zle/zle_thingy.c
@@ -424,7 +424,7 @@ bin_zle_refresh(char *name, char **args, char *ops, char func)
 	} else if (ops['c'])
 	    clearlist = 1;
     } else if (ops['c'])
-	clearlist = 1;
+	clearlist = listshown = 1;
     zrefresh();
 
     clearlist = ocl;
diff --git a/Src/Zle/zle_tricky.c b/Src/Zle/zle_tricky.c
index a5f6dbc88..14c1791d1 100644
--- a/Src/Zle/zle_tricky.c
+++ b/Src/Zle/zle_tricky.c
@@ -42,13 +42,14 @@
  * file only are not translated: they remain indexes into the metafied  *
  * line.                                                                */
 
-
 #define inststr(X) inststrlen((X),1,-1)
 
 /* The line before completion was tried. */
 
-static char *origline;
-static int origcs, origll;
+/**/
+char *origline;
+/**/
+int origcs, origll;
 
 /* Words on the command line, for use in completion */
  
@@ -68,54 +69,18 @@ int wb, we;
 /**/
 int offs;
 
-/* We store the following prefixes/suffixes:                               *
- * ipre,ripre  -- the ignored prefix (quoted and unquoted)                 *
- * isuf        -- the ignored suffix                                       *
- * autoq       -- quotes to automatically insert                           */
+/* These control the type of completion that will be done.  They are       *
+ * affected by the choice of ZLE command and by relevant shell options.    *
+ * usemenu is set to 2 if we have to start automenu and 3 if we have to    *
+ * insert a match as if for menucompletion but without really starting it. */
 
 /**/
-char *ipre, *ripre, *isuf, *qipre, *qisuf, autoq;
-
-/* the last completion widget called */
+int usemenu, useglob;
 
-static Widget lastcompwidget;
-
-/* These control the type of completion that will be done.  They are      *
- * affected by the choice of ZLE command and by relevant shell options.   *
- * usemenu is set to 2 if we have to start automenu and 3 if we have to   *
- * insert a match as if for menucompletion but without really stating it. */
+/* != 0 if we are in the middle of a menu completion. */
 
 /**/
-int usemenu, useglob, useexact, useline, uselist;
-
-/* Non-zero if we should keep an old list. */
-
-static int oldlist, oldins;
-
-/* Non-zero if we have to redisplay the list of matches. */
-
-static int showagain = 0;
-
-/* The match and group number to insert when starting menucompletion.   */
-
-static int insmnum, insgnum, insgroup, insspace;
-
-/* This is used to decide when the cursor should be moved to the end of    *
- * the inserted word: 0 - never, 1 - only when a single match is inserted, *
- * 2 - when a full match is inserted (single or menu), 3 - always.         */
-
-static int movetoend;
-
-/* != 0 if we are in the middle of a menu completion and number of matches
-* accepted with accept-and-menu-complete */
-
-/**/
-int menucmp, menuacc;
-
-/* Information about menucompletion. */
-
-/**/
-struct menuinfo minfo;
+int menucmp;
 
 /* Lists of brace-infos before/after cursor (first and last for each). */
 
@@ -125,164 +90,34 @@ Brinfo brbeg, lastbrbeg, brend, lastbrend;
 /**/
 int nbrbeg, nbrend;
 
-static char *lastprebr, *lastpostbr;
-static int hasunqu, useqbr, brpcs, brscs;
-
-/* The list of matches.  fmatches contains the matches we first ignore *
- * because of fignore.                                                 */
-
-/**/
-LinkList matches, fmatches;
-
-/* This holds the list of matches-groups. lastmatches holds the last list of 
- * permanently allocated matches, pmatches is the same for the list
- * currently built, amatches is the heap allocated stuff during completion
- * (after all matches have been generated it is an alias for pmatches), and
- * lmatches/lastlmatches is a pointer to the last element in the lists. */
-
 /**/
-Cmgroup lastmatches, pmatches, amatches, lmatches, lastlmatches;
-
-/* Non-zero if we have permanently allocated matches (old and new). */
-
-/**/
-int hasoldlist, hasperm;
-
-/* Non-zero if we have newly added matches. */
-
-/**/
-int newmatches;
-
-/* Number of permanently allocated matches and groups. */
-
-static int permmnum, permgnum, lastpermmnum, lastpermgnum;
-
-/* The total number of matches and the number of matches to be listed. */
-
-/**/
-int nmatches, smatches;
+char *lastprebr, *lastpostbr;
 
 /* !=0 if we have a valid completion list. */
 
 /**/
 int validlist;
 
-/* != 0 if only explanation strings should be printed */
-
-/**/
-int onlyexpl;
-
-/* Information about the matches for listing. */
-
-/**/
-struct cldata listdat;
-
-/* This flag is non-zero if we are completing a pattern (with globcomplete) */
-
-/**/
-int ispattern, haspattern;
-
-/* Non-zero if at least one match was added without -U. */
+/* Non-zero if we have to redisplay the list of matches. */
 
 /**/
-int hasmatched;
-
-/* A parameter expansion prefix (like ${). */
-
-static char *parpre;
-
-/* Flags for parameter expansions for new style completion. */
-
-static int parflags;
+int showagain = 0;
 
 /* This holds the word we are completing in quoted from. */
 
 static char *qword;
 
-/* The current group of matches. */
-
-static Cmgroup mgroup;
-
-/* Match counters: all matches, normal matches (not alternate set). */
-
-/**/
-int mnum;
-
-/* The match counter when unambig_data() was called. */
-
-static int unambig_mnum;
-
-/* Match flags for all matches in this group. */
-
-/**/
-int mflags;
-
-/* Length of longest/shortest match. */
-
-static int maxmlen, minmlen;
-
-/* This holds the explanation strings we have to print in this group and *
- * a pointer to the current cexpl structure. */
-
-static LinkList expls;
+/* The quoted prefix/suffix and a flag saying if we want to add the
+ * closing quote. */
 
 /**/
-Cexpl curexpl;
-
-/* A stack of completion matchers to be used. */
-
-/**/
-Cmlist mstack;
-
-/* The completion matchers used when building new stuff for the line. */
-
-/**/
-Cmlist bmatchers;
-
-/* A list with references to all matchers we used. */
-
-/**/
-LinkList matchers;
-
-/* A heap of free Cline structures. */
-
-static Cline freecl;
-
-/* Ambiguous information. */
-
-static Aminfo ainfo, fainfo;
+char *qipre, *qisuf, autoq;
 
 /* This contains the name of the function to call if this is for a new  *
  * style completion. */
 
-static char *compfunc = NULL;
-
-/* The memory heap to use for new style completion generation. */
-
-/**/
-Heap compheap;
-
-/* Find out if we have to insert a tab (instead of trying to complete). */
-
-/* A list of some data.
- *
- * Well, actually, it's the list of all compctls used so far, but since
- * conceptually we don't know anything about compctls here... */
-
 /**/
-LinkList allccs;
-
-/**/
-static int
-usetab(void)
-{
-    unsigned char *s = line + cs - 1;
-
-    for (; s >= line && *s != '\n'; s--)
-	if (*s != '\t' && *s != ' ')
-	    return 0;
-    return 1;
-}
+char *compfunc = NULL;
 
 /* Non-zero if the last completion done was ambiguous (used to find   *
  * out if AUTOMENU should start).  More precisely, it's nonzero after *
@@ -298,28 +133,26 @@ usetab(void)
 /**/
 int lastambig;
 
-/* This says what of the state the line is in when completion is started *
- * came from a previous completion. If the FC_LINE bit is set, the       *
- * string was inserted. If FC_INWORD is set, the last completion moved   *
- * the cursor into the word although it was at the end of it when the    *
- * last completion was invoked.                                          *
- * This is used to detect if the string should be taken as an exact      *
- * match (see do_ambiguous()) and if the cursor has to be moved to the   *
- * end of the word before generating the completions.                    */
-
-static int fromcomp;
-
-/* This holds the end-position of the last string inserted into the line. */
+/* Arguments for and return value of completion widget. */
 
-static int lastend;
+/**/
+char **cfargs;
+/**/
+int cfret;
 
-#define FC_LINE   1
-#define FC_INWORD 2
+/* Find out if we have to insert a tab (instead of trying to complete). */
 
-/* Arguments for and return value of completion widget. */
+/**/
+static int
+usetab(void)
+{
+    unsigned char *s = line + cs - 1;
 
-static char **cfargs;
-static int cfret;
+    for (; s >= line && *s != '\n'; s--)
+	if (*s != '\t' && *s != ' ')
+	    return 0;
+    return 1;
+}
 
 /**/
 int
@@ -387,21 +220,15 @@ spellword(char **args)
 int
 deletecharorlist(char **args)
 {
-    Cmgroup mg = minfo.group;
-    Cmatch *mc = minfo.cur;
-    int ret;
-
     usemenu = !!isset(MENUCOMPLETE);
     useglob = isset(GLOBCOMPLETE);
+
     if (cs != ll) {
 	fixsuffix();
-	ret = deletechar(args);
-    } else
-	ret = docomplete(COMP_LIST_COMPLETE);
-
-    minfo.cur = mc;
-    minfo.group = mg;
-    return ret;
+	invalidatelist();
+	return deletechar(args);
+    }
+    return docomplete(COMP_LIST_COMPLETE);
 }
 
 /**/
@@ -462,92 +289,17 @@ reversemenucomplete(char **args)
     if (!menucmp)
 	return menucomplete(args);
 
-    HEAPALLOC {
-	do {
-	    if (minfo.cur == (minfo.group)->matches) {
-		do {
-		    if (!(minfo.group = (minfo.group)->prev))
-			minfo.group = lmatches;
-		} while (!(minfo.group)->mcount);
-		minfo.cur = (minfo.group)->matches + (minfo.group)->mcount - 1;
-	    } else
-		minfo.cur--;
-	} while (menuacc &&
-		 !hasbrpsfx(*(minfo.cur), minfo.prebr, minfo.postbr));
-	metafy_line();
-	do_single(*(minfo.cur));
-	unmetafy_line();
-    } LASTALLOC;
+    runhookdef(REVERSEMENUHOOK, NULL);
     return 0;
 }
 
-/* Accepts the current completion and starts a new arg, *
- * with the next completions. This gives you a way to   *
- * accept several selections from the list of matches.  */
-
-/**/
-void
-acceptlast(void)
-{
-    if (!menuacc) {
-	zsfree(minfo.prebr);
-	minfo.prebr = ztrdup(lastprebr);
-	zsfree(minfo.postbr);
-	minfo.postbr = ztrdup(lastpostbr);
-
-	if (listshown && (lastprebr || lastpostbr)) {
-	    Cmgroup g;
-	    Cmatch *m;
-
-	    for (g = amatches, m = NULL; g && (!m || !*m); g = g->next)
-		for (m = g->matches; *m; m++)
-		    if (!hasbrpsfx(*m, minfo.prebr, minfo.postbr)) {
-			showinglist = -2;
-			break;
-		    }
-	}
-    }
-    menuacc++;
-
-    if (brbeg) {
-	int l;
-
-	iremovesuffix(',', 1);
-
-	l = (brscs >= 0 ? brscs : cs) - brpcs;
-
-	zsfree(lastbrbeg->str);
-	lastbrbeg->str = (char *) zalloc(l + 2);
-	memcpy(lastbrbeg->str, line + brpcs, l);
-	lastbrbeg->str[l] = ',';
-	lastbrbeg->str[l + 1] = '\0';
-    } else {
-	int l;
-
-	cs = minfo.pos + minfo.len + minfo.insc;
-	iremovesuffix(' ', 1);
-	l = cs;
-	cs = minfo.pos + minfo.len + minfo.insc - (*(minfo.cur))->qisl;
-	if (cs < l)
-	    foredel(l - cs);
-	else if (cs > ll)
-	    cs = ll;
-	inststrlen(" ", 1, 1);
-	if (parpre)
-	    inststr(parpre);
-	minfo.insc = minfo.len = 0;
-	minfo.pos = cs;
-	minfo.we = 1;
-    }
-}
-
 /**/
 int
 acceptandmenucomplete(char **args)
 {
     if (!menucmp)
 	return 1;
-    acceptlast();
+    runhookdef(ACCEPTCOMPHOOK, NULL);
     return menucomplete(args);
 }
 
@@ -555,11 +307,12 @@ acceptandmenucomplete(char **args)
  * position, in a redirection, or in a parameter expansion.   */
 
 /**/
-int lincmd, linredir, ispar, parq, eparq, linwhat, linarr;
+int lincmd, linredir, linarr;
 
 /* The string for the redirection operator. */
 
-static char *rdstr;
+/**/
+char *rdstr;
 
 /* This holds the name of the current command (used to find the right *
  * compctl).                                                          */
@@ -569,7 +322,8 @@ char *cmdstr;
 
 /* This hold the name of the variable we are working on. */
 
-static char *varname;
+/**/
+char *varname;
 
 /* != 0 if we are in a subscript */
 
@@ -591,25 +345,6 @@ int instring, inbackt;
 
 #define quotename(s, e) bslashquote(s, e, instring)
 
-/* Copy the given string and remove backslashes from the copy and return it. */
-
-/**/
-char *
-rembslash(char *s)
-{
-    char *t = s = dupstring(s);
-
-    while (*s)
-	if (*s == '\\') {
-	    chuck(s);
-	    if (*s)
-		s++;
-	} else
-	    s++;
-
-    return t;
-}
-
 /* Check if the given string is the name of a parameter and if this *
  * parameter is one worth expanding.                                */
 
@@ -628,7 +363,7 @@ checkparams(char *p)
 		    e = 1;
 	    }
     return (n == 1) ? (getsparam(p) != NULL) :
-	(!menucmp && e && isset(RECEXACT));
+	(!menucmp && e && (!hascompmod || isset(RECEXACT)));
 }
 
 /* Check if the given string has wildcards.  The difficulty is that we *
@@ -692,15 +427,10 @@ cmphaswilds(char *str)
 
 /**/
 char *
-check_param(char *s, int set, int test)
+parambeg(char *s)
 {
     char *p;
 
-    zsfree(parpre);
-    parpre = NULL;
-
-    if (!test)
-	ispar = parq = eparq = 0;
     /* Try to find a `$'. */
     for (p = s + offs; p > s && *p != String && *p != Qstring; p--);
     if (*p == String || *p == Qstring) {
@@ -743,10 +473,8 @@ check_param(char *s, int set, int test)
 
 	e = b;
 	if (br) {
-	    while (*e == (test ? Dnull : '"'))
-		e++, parq++;
-	    if (!test)
-		b = e;
+	    while (*e == Dnull)
+		e++;
 	}
 	/* Find the end of the name. */
 	if (*e == Quest || *e == Star || *e == String || *e == Qstring ||
@@ -757,60 +485,17 @@ check_param(char *s, int set, int test)
 	    while (idigit(*e))
 		e++;
 	else if (iident(*e))
-	    while (iident(*e) ||
-		   (comppatmatch && *comppatmatch &&
-		    (*e == Star || *e == Quest)))
+	    while (iident(*e))
 		e++;
 
 	/* Now make sure that the cursor is inside the name. */
 	if (offs <= e - s && offs >= b - s && n <= 0) {
-	    char sav;
-
 	    if (br) {
 		p = e;
-		while (*p == (test ? Dnull : '"'))
-		    p++, parq--, eparq++;
+		while (*p == Dnull)
+		    p++;
 	    }
 	    /* It is. */
-	    if (test)
-		return b;
-	    /* If we were called from makecomplistflags(), we have to set the
-	     * global variables. */
-
-	    if (set) {
-		if (br >= 2) {
-		    mflags |= CMF_PARBR;
-		    if (nest)
-			mflags |= CMF_PARNEST;
-		}
-		/* Get the prefix (anything up to the character before the name). */
-		isuf = dupstring(e);
-		untokenize(isuf);
-		sav = *b;
-		*b = *e = '\0';
-		ripre = dyncat((ripre ? ripre : ""), s);
-		ipre = dyncat((ipre ? ipre : ""), s);
-		*b = sav;
-
-		untokenize(ipre);
-	    }
-	    else
-		parq = eparq = 0;
-
-	    /* Save the prefix. */
-	    if (compfunc) {
-		parflags = (br >= 2 ? CMF_PARBR : 0);
-		sav = *b;
-		*b = '\0';
-		untokenize(parpre = ztrdup(s));
-		*b = sav;
-	    }
-	    /* And adjust wb, we, and offs again. */
-	    offs -= b - s;
-	    wb = cs - offs;
-	    we = wb + e - b;
-	    ispar = (br >= 2 ? 2 : 1);
-	    b[we-wb] = '\0';
 	    return b;
 	}
     }
@@ -824,33 +509,10 @@ static int
 docomplete(int lst)
 {
     char *s, *ol;
-    int olst = lst, chl = 0, ne = noerrs, ocs, ret = 0, omc = menucmp;
+    int olst = lst, chl = 0, ne = noerrs, ocs, ret = 0;
 
-    if (showagain && validlist)
-	showinglist = -2;
-    showagain = 0;
-
-    /* If we are doing a menu-completion... */
-
-    if (menucmp && lst != COMP_LIST_EXPAND && 
-	(!compwidget || compwidget == lastcompwidget)) {
-	do_menucmp(lst);
+    if (runhookdef(BEFORECOMPLETEHOOK, (void *) &lst))
 	return 0;
-    }
-    lastcompwidget = compwidget;
-
-    /* We may have to reset the cursor to its position after the   *
-     * string inserted by the last completion. */
-
-    if (fromcomp & FC_INWORD)
-	if ((cs = lastend) > ll)
-	    cs = ll;
-
-    /* Check if we have to start a menu-completion (via automenu). */
-
-    if (isset(AUTOMENU) && lastambig &&
-	(!isset(BASHAUTOLIST) || lastambig == 2))
-	usemenu = 2;
 
     /* Expand history references before starting completion.  If anything *
      * changed, do no more.                                               */
@@ -930,7 +592,7 @@ docomplete(int lst)
 		/* The word starts with `=', see if we can expand it. */
 		q = s + 1;
 		if (cmdnamtab->getnode(cmdnamtab, q) || hashcmd(q, pathchecked)) {
-		    if (isset(RECEXACT))
+		    if (!hascompmod || isset(RECEXACT))
 			lst = COMP_EXPAND;
 		    else {
 			int t0, n = 0;
@@ -1081,51 +743,11 @@ docomplete(int lst)
     zsfree(qword);
     unmetafy_line();
 
-    if (menucmp && !omc) {
-	struct chdata dat;
+    runhookdef(AFTERCOMPLETEHOOK, (void *) &lst);
 
-	dat.matches = amatches;
-	dat.num = nmatches;
-	dat.cur = NULL;
-	if (runhookdef(MENUSTARTHOOK, (void *) &dat))
-	    menucmp = menuacc = 0;
-    }
     return ret;
 }
 
-/* Do completion, given that we are in the middle of a menu completion.  We *
- * don't need to generate a list of matches, because that's already been    *
- * done by previous commands.  We will either list the completions, or      *
- * insert the next completion.                                              */
-
-/**/
-void
-do_menucmp(int lst)
-{
-    /* Just list the matches if the list was requested. */
-    if (lst == COMP_LIST_COMPLETE) {
-	showinglist = -2;
-	return;
-    }
-    /* Otherwise go to the next match in the array... */
-    HEAPALLOC {
-	do {
-	    if (!*++(minfo.cur)) {
-		do {
-		    if (!(minfo.group = (minfo.group)->next))
-			minfo.group = amatches;
-		} while (!(minfo.group)->mcount);
-		minfo.cur = minfo.group->matches;
-	    }
-	} while (menuacc &&
-		 !hasbrpsfx(*(minfo.cur), minfo.prebr, minfo.postbr));
-	/* ... and insert it into the command line. */
-	metafy_line();
-	do_single(*(minfo.cur));
-	unmetafy_line();
-    } LASTALLOC;
-}
-
 /* 1 if we are completing the prefix */
 static int comppref;
 
@@ -1193,7 +815,7 @@ dupstrspace(const char *str)
  * functions (there's one for each direction).                             */
 
 /**/
-static void
+void
 metafy_line(void)
 {
     int len = ll;
@@ -1209,7 +831,7 @@ metafy_line(void)
 }
 
 /**/
-static void
+void
 unmetafy_line(void)
 {
     cs = ztrsub((char *) line + cs, (char *) line);
@@ -1634,7 +1256,7 @@ get_comp_string(void)
 	/* This variable will hold the current word in quoted form. */
 	qword = ztrdup(s);
 	offs = cs - wb;
-	if ((p = check_param(s, 0, 1))) {
+	if ((p = parambeg(s))) {
 	    for (p = s; *p; p++)
 		if (*p == Dnull)
 		    *p = '"';
@@ -1925,6 +1547,26 @@ get_comp_string(void)
     return (char *)s;
 }
 
+/* Insert the given string into the command line.  If move is non-zero, *
+ * the cursor position is changed and len is the length of the string   *
+ * to insert (if it is -1, the length is calculated here).              *
+ * The last argument says if we should quote the string.                */
+
+/**/
+int
+inststrlen(char *str, int move, int len)
+{
+    if (!len || !str)
+	return 0;
+    if (len == -1)
+	len = strlen(str);
+    spaceinline(len);
+    strncpy((char *)(line + cs), str, len);
+    if (move)
+	cs += len;
+    return len;
+}
+
 /* Expand the current word. */
 
 /**/
@@ -1980,12 +1622,6 @@ doexpansion(char *s, int lst, int olst, int explincmd)
 	    untokenize(ss);
 	    ss = quotename(ss, NULL);
 	    inststr(ss);
-#if 0
-	    if (nonempty(vl)) {
-		spaceinline(1);
-		line[cs++] = ' ';
-	    }
-#endif
 	    if (olst != COMP_EXPAND_COMPLETE || nonempty(vl) ||
 		(cs && line[cs-1] != '/')) {
 		spaceinline(1);
@@ -2012,3513 +1648,55 @@ gotword(void)
     }
 }
 
-/* This compares two cpattern lists and returns non-zero if they are
- * equal. */
-
-static int
-cmp_cpatterns(Cpattern a, Cpattern b)
-{
-    while (a) {
-	if (a->equiv != b->equiv || memcmp(a->tab, b->tab, 256))
-	    return 0;
-	a = a->next;
-	b = b->next;
-    }
-    return 1;
-}
-
-/* This compares two cmatchers and returns non-zero if they are equal. */
-
-static int
-cmp_cmatchers(Cmatcher a, Cmatcher b)
-{
-    return (a == b ||
-	    (a->flags == b->flags &&
-	     a->llen == b->llen && a->wlen == b->wlen &&
-	     (!a->llen || cmp_cpatterns(a->line, b->line)) &&
-	     (a->wlen <= 0 || cmp_cpatterns(a->word, b->word)) &&
-	     (!(a->flags & CMF_LEFT) ||
-	      (a->lalen == b->lalen &&
-	       (!a->lalen || cmp_cpatterns(a->left, b->left)))) &&
-	     (!(a->flags & CMF_RIGHT) ||
-	      (a->ralen == b->ralen &&
-	       (!a->ralen || cmp_cpatterns(a->right, b->right))))));
-}
-
-/* Add the given matchers to the bmatcher list. */
-
-static void
-add_bmatchers(Cmatcher m)
-{
-    Cmlist old = bmatchers, *q = &bmatchers, n;
-
-    for (; m; m = m->next) {
-	if ((!m->flags && m->wlen > 0 && m->llen > 0) ||
-	    (m->flags == CMF_RIGHT && m->wlen == -1 && !m->llen)) {
-	    *q = n = (Cmlist) zhalloc(sizeof(struct cmlist));
-	    n->matcher = m;
-	    q = &(n->next);
-	}
-    }
-    *q = old;
-}
-
-/* This is called when the matchers in the mstack have changed to
- * ensure that the bmatchers list contains no matchers not in mstack. */
-
-static void
-update_bmatchers(void)
-{
-    Cmlist p = bmatchers, q = NULL, ms;
-    Cmatcher mp;
-    int t;
-
-    while (p) {
-	t = 0;
-	for (ms = mstack; ms && !t; ms = ms->next)
-	    for (mp = ms->matcher; mp && !t; mp = mp->next)
-		t = cmp_cmatchers(mp, p->matcher);
-
-	p = p->next;
-	if (!t) {
-	    if (q)
-		q->next = p;
-	    else
-		bmatchers = p;
-	}
-    }
-}
-
-/* This returns a new Cline structure. */
-
-static Cline
-get_cline(char *l, int ll, char *w, int wl, char *o, int ol, int fl)
-{
-    Cline r;
-
-    /* Prefer to take it from the buffer list (freecl), if there
-     * is none, allocate a new one. */
-
-    if ((r = freecl))
-	freecl = r->next;
-    else
-	r = (Cline) zhalloc(sizeof(*r));
-
-    r->next = NULL;
-    r->line = l; r->llen = ll;
-    r->word = w; r->wlen = wl;
-    r->orig = o; r->olen = ol;
-    r->slen = 0;
-    r->flags = fl;
-    r->prefix = r->suffix = NULL;
-    return r;
-}
-
-/* This frees a cline list. */
-
-static void
-free_cline(Cline l)
-{
-    Cline n;
-
-    while (l) {
-	n = l->next;
-	l->next = freecl;
-	freecl = l;
-	free_cline(l->prefix);
-	free_cline(l->suffix);
-	l = n;
-    }
-}
-
-/* Copy a cline list. */
-
-static Cline
-cp_cline(Cline l, int deep)
-{
-    Cline r = NULL, *p = &r, t, lp = NULL;
-
-    while (l) {
-	if ((t = freecl))
-	    freecl = t->next;
-	else
-	    t = (Cline) zhalloc(sizeof(*t));
-	memcpy(t, l, sizeof(*t));
-	if (deep) {
-	    if (t->prefix)
-		t->prefix = cp_cline(t->prefix, 0);
-	    if (t->suffix)
-		t->suffix = cp_cline(t->suffix, 0);
-	}
-	*p = lp = t;
-	p = &(t->next);
-	l = l->next;
-    }
-    *p = NULL;
-
-    return r;
-}
-
-/* Calculate the length of a cline and its sub-lists. */
-
-static int
-cline_sublen(Cline l)
-{
-    int len = ((l->flags & CLF_LINE) ? l->llen : l->wlen);
-
-    if (l->olen && !((l->flags & CLF_SUF) ? l->suffix : l->prefix))
-	len += l->olen;
-    else {
-	Cline p;
-
-	for (p = l->prefix; p; p = p->next)
-	    len += ((p->flags & CLF_LINE) ? p->llen : p->wlen);
-	for (p = l->suffix; p; p = p->next)
-	    len += ((p->flags & CLF_LINE) ? p->llen : p->wlen);
-    }
-    return len;
-}
-
-/* Set the lengths in the cline lists. */
-
-static void
-cline_setlens(Cline l, int both)
-{
-    while (l) {
-	l->max = cline_sublen(l);
-	if (both)
-	    l->min = l->max;
-	l = l->next;
-    }
-}
-
-/* This sets the CLF_MATCHED flag in the given clines. */
-
-static void
-cline_matched(Cline p)
-{
-    while (p) {
-	p->flags |= CLF_MATCHED;
-	cline_matched(p->prefix);
-	cline_matched(p->suffix);
-
-	p = p->next;
-    }
-}
-
-/* This reverts the order of the elements of the given cline list and
- * returns a pointer to the new head. */
-
-static Cline
-revert_cline(Cline p)
-{
-    Cline r = NULL, n;
-
-    while (p) {
-	n = p->next;
-	p->next = r;
-	r = p;
-	p = n;
-    }
-    return r;
-}
-
-/* Check if the given pattern matches the given string.             *
- * `in' and `out' are used for {...} classes. In `out' we store the *
- * character number that was matched. In the word pattern this is   *
- * given in `in' so that we can easily test if we found the         *
- * corresponding character. */
-
-/**/
-static int
-pattern_match(Cpattern p, char *s, unsigned char *in, unsigned char *out)
-{
-    unsigned char c;
-
-    while (p) {
-	c = *((unsigned char *) s);
-
-	if (out)
-	    *out = 0;
-
-	if (p->equiv) {
-	    if (in) {
-		c = p->tab[c];
-		if ((*in && *in != c) || (!*in && !c))
-		    return 0;
-	    } else if (out) {
-		if (!(*out = p->tab[c]))
-		    return 0;
-	    } else if (!p->tab[c])
-		return 0;
-
-	    if (in && *in)
-		in++;
-	    if (out)
-		out++;
-	} else if (!p->tab[c])
-	    return 0;
-
-	s++;
-	p = p->next;
-    }
-    return 1;
-}
-
-/* This splits the given string into a list of cline structs, separated
- * at those places where one of the anchors of an `*' pattern was found.
- * plen gives the number of characters on the line that matched this
- * string. In lp we return a pointer to the last cline struct we build. */
-
-static Cline
-bld_parts(char *str, int len, int plen, Cline *lp)
-{
-    Cline ret = NULL, *q = &ret, n;
-    Cmlist ms;
-    Cmatcher mp;
-    int t, op = plen;
-    char *p = str;
-
-    while (len) {
-	for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
-	    mp = ms->matcher;
-	    if (mp->flags == CMF_RIGHT && mp->wlen == -1 &&
-		!mp->llen && len >= mp->ralen && mp->ralen &&
-		pattern_match(mp->right, str, NULL, NULL)) {
-		int olen = str - p, llen;
-
-		/* We found an anchor, create a new cline. The NEW flag
-		 * is set if the characters before the anchor were not
-		 * on the line. */
-		*q = n = get_cline(NULL, mp->ralen, str, mp->ralen, NULL, 0,
-				   ((plen < 0) ? CLF_NEW : 0));
-
-		/* If there were any characters before the anchor, add
-		 * them as a cline struct. */
-
-		if (p != str) {
-		    llen = (op < 0 ? 0 : op);
-
-		    if (llen > olen)
-			llen = olen;
-		    n->prefix = get_cline(NULL, llen, p, olen, NULL, 0, 0);
-		}
-		q = &(n->next);
-		str += mp->ralen; len -= mp->ralen;
-		plen -= mp->ralen;
-		op -= olen;
-		p = str;
-		t = 1;
-	    }
-	}
-	if (!t) {
-	    /* No anchor was found here, skip. */
-	    str++; len--;
-	    plen--;
-	}
-    }
-    /* This is the cline struct for the remaining string at the end. */
-
-    *q = n = get_cline(NULL, 0, NULL, 0, NULL, 0, (plen < 0 ? CLF_NEW : 0));
-    if (p != str) {
-	int olen = str - p, llen = (op < 0 ? 0 : op);
-
-	if (llen > olen)
-	    llen = olen;
-	n->prefix = get_cline(NULL, llen, p, olen, NULL, 0, 0);
-    }
-    n->next = NULL;
-
-    if (lp)
-	*lp = n;
-
-    return ret;
-}
-
-/* Global variables used during matching: a char-buffer for the string to
- * use for the match, and two cline lists for the two levels we use. */
-
-static char *matchbuf = NULL;
-static int matchbuflen = 0, matchbufadded;
-
-static Cline matchparts, matchlastpart;
-static Cline matchsubs, matchlastsub;
-
-/* This initialises the variables above. */
-
-static void
-start_match(void)
-{
-    if (matchbuf)
-	*matchbuf = '\0';
-    matchbufadded = 0;
-    matchparts = matchlastpart = matchsubs = matchlastsub = NULL;
-}
-
-/* This aborts a matching, freeing the cline lists build. */
-
-static void
-abort_match(void)
-{
-    free_cline(matchparts);
-    free_cline(matchsubs);
-    matchparts = matchsubs = NULL;
-}
-
-/* This adds a new string in the static char buffer. The arguments are
- * the matcher used (if any), the strings from the line and the word
- * and the length of the string from the word. The last argument is
- * non-zero if we are matching a suffix (where the given string has to 
- * be prepended to the contents of the buffer). */
-
-static void
-add_match_str(Cmatcher m, char *l, char *w, int wl, int sfx)
-{
-    /* Get the string and length to insert: either from the line 
-     * or from the match. */
-    if (m && (m->flags & CMF_LINE)) {
-	wl = m->llen; w = l;
-    }
-    if (wl) {
-	/* Probably resize the buffer. */
-	if (matchbuflen - matchbufadded <= wl) {
-	    int blen = matchbuflen + wl + 20;
-	    char *buf;
-
-	    buf = (char *) zalloc(blen);
-	    memcpy(buf, matchbuf, matchbuflen);
-	    zfree(matchbuf, matchbuflen);
-	    matchbuf = buf;
-	    matchbuflen = blen;
-	}
-	/* Insert the string. */
-	if (sfx) {
-	    memmove(matchbuf + wl, matchbuf, matchbufadded + 1);
-	    memcpy(matchbuf, w, wl);
-	} else
-	    memcpy(matchbuf + matchbufadded, w, wl);
-	matchbufadded += wl;
-	matchbuf[matchbufadded] = '\0';
-    }
-}
-
-/* This adds a cline for a word-part during matching. Arguments are the
- * matcher used, pointers to the line and word strings for the anchor,
- * a pointer to the original line string for the whole part, the string
- * before (or after) the anchor that has not yet been added, the length
- * of the line-string for that, and a flag saying if we are matching a 
- * suffix. */
-
-static void
-add_match_part(Cmatcher m, char *l, char *w, int wl,
-	       char *o, int ol, char *s, int sl, int osl, int sfx)
-{
-    Cline p, lp;
-
-    /* If the anchors are equal, we keep only one. */
-
-    if (!strncmp(l, w, wl))
-	l = NULL;
-
-    /* Split the new part into parts and turn the last one into a
-     * `suffix' if we have a left anchor. */
-
-    p = bld_parts(s, sl, osl, &lp);
-
-    p->flags &= ~CLF_NEW;
-    if (m && (m->flags & CMF_LEFT)) {
-	lp->flags |= CLF_SUF;
-	lp->suffix = lp->prefix;
-	lp->prefix = NULL;
-    }
-    /* cline lists for suffixes are sorted from back to front, so we have
-     * to revert the list we got. */
-    if (sfx)
-	p = revert_cline(lp = p);
-    /* Now add the sub-clines we already had. */
-    if (matchsubs) {
-	if (sfx) {
-	    Cline q;
-
-	    if ((q = lp->prefix)) {
-		while (q->next)
-		    q = q->next;
-		q->next = matchsubs;
-	    } else
-		lp->prefix = matchsubs;
-
-	    matchlastsub->next = NULL;
-	} else {
-	    matchlastsub->next = p->prefix;
-	    p->prefix = matchsubs;
-	}
-	matchsubs = matchlastsub = NULL;
-    }
-    /* Store the arguments in the last part-cline. */
-    lp->line = l; lp->llen = wl;
-    lp->word = w; lp->wlen = wl;
-    lp->orig = o; lp->olen = ol;
-    lp->flags &= ~CLF_NEW;
-
-    /* Finally, put the new parts on the list. */
-    if (matchlastpart)
-	matchlastpart->next = p;
-    else
-	matchparts = p;
-    matchlastpart = lp;
-}
-
-/* This adds a new sub-cline. Arguments are the matcher and the strings from
- * the line and the word. */
-
-static void
-add_match_sub(Cmatcher m, char *l, int ll, char *w, int wl)
-{
-    int flags;
-    Cline n;
-
-    /* Check if we are interested only in the string from the line. */
-    if (m && (m->flags & CMF_LINE)) {
-	w = NULL; wl = 0;
-	flags = CLF_LINE;
-    } else
-	flags = 0;
-
-    /* And add the cline. */
-    if (wl || ll) {
-	n = get_cline(l, ll, w, wl, NULL, 0, flags);
-	if (matchlastsub)
-	    matchlastsub->next = n;
-	else
-	    matchsubs = n;
-	matchlastsub = n;
-    }
-}
-
-/* This tests if the string from the line l matches the word w. In bp
- * the offset for the brace is returned, in rwlp the length of the
- * matched prefix or suffix, not including the stuff before or after
- * the last anchor is given. When sfx is non-zero matching is done from
- * the ends of the strings backward, if test is zero, the global variables
- * above are used to build the string for the match and the cline. If
- * part is non-zero, we are satisfied if only a part of the line-string
- * is used (and return the length used). */
-
-static int
-match_str(char *l, char *w, Brinfo *bpp, int bc, int *rwlp,
-	  int sfx, int test, int part)
-{
-    int ll = strlen(l), lw = strlen(w), oll = ll, olw = lw;
-    int il = 0, iw = 0, t, ind, add, he = 0, bpc, obc = bc;
-    VARARR(unsigned char, ea, ll + 1);
-    char *ow;
-    Cmlist ms;
-    Cmatcher mp, lm = NULL;
-    Brinfo bp = NULL;
-
-    if (!test) {
-	start_match();
-	bp = *bpp;
-    }
-    /* Adjust the pointers and get the values for subscripting and
-     * incrementing. */
-
-    if (sfx) {
-	l += ll; w += lw;
-	ind = -1; add = -1;
-    } else {
-	ind = 0; add = 1;
-    }
-    /* ow will always point to the beginning (or end) of that sub-string
-     * in w that wasn't put in the match-variables yet. */
-
-    ow = w;
-
-    /* If the brace is at the beginning, we have to treat it now. */
-
-    if (!test && bp && bc >= bp->pos) {
-	bp->curpos = bc;
-	bp = bp->next;
-    }
-    while (ll && lw) {
-	/* First try the matchers. */
-	for (mp = NULL, ms = mstack; !mp && ms; ms = ms->next) {
-	    for (mp = ms->matcher; mp; mp = mp->next) {
-		t = 1;
-		if ((lm && lm == mp) ||
-		    ((oll == ll || olw == lw) &&
-		     (test == 1 || (test && !mp->left && !mp->right)) &&
-		     mp->wlen < 0))
-		    /* If we were called recursively, don't use `*' patterns
-		     * at the beginning (avoiding infinite recursion). */
-		    continue;
-
-		if (mp->wlen < 0) {
-		    int both, loff, aoff, llen, alen, zoff, moff, ct, ict;
-		    char *tp, savl = '\0', savw;
-		    Cpattern ap;
-
-		    /* This is for `*' patterns, first initialise some
-		     * local variables. */
-		    llen = mp->llen;
-		    alen = (mp->flags & CMF_LEFT ? mp->lalen : mp->ralen);
-
-		    /* Give up if we don't have enough characters for the
-		     * line-string and the anchor. */
-		    if (ll < llen + alen || lw < alen)
-			continue;
-
-		    if (mp->flags & CMF_LEFT) {
-			ap = mp->left; zoff = 0; moff = alen;
-			if (sfx) {
-			    both = 0; loff = -llen; aoff = -(llen + alen);
-			} else {
-			    both = 1; loff = alen; aoff = 0;
-			}
-		    } else {
-			ap = mp->right; zoff = alen; moff = 0;
-			if (sfx) {
-			    both = 1; loff = -(llen + alen); aoff = -alen;
-			} else {
-			    both = 0; loff = 0; aoff = llen;
-			}
-		    }
-		    /* Try to match the line pattern and the anchor. */
-		    if (!pattern_match(mp->line, l + loff, NULL, NULL))
-			continue;
-		    if (ap) {
-			if (!pattern_match(ap, l + aoff, NULL, NULL) ||
-			    (both && (!pattern_match(ap, w + aoff, NULL, NULL) ||
-				      !match_parts(l + aoff, w + aoff, alen,
-						   part))))
-				continue;
-		    } else if (!both || il || iw)
-			continue;
-
-		    /* Fine, now we call ourselves recursively to find the
-		     * string matched by the `*'. */
-		    if (sfx) {
-			savl = l[-(llen + zoff)];
-			l[-(llen + zoff)] = '\0';
-		    }
-		    for (t = 0, tp = w, ct = 0, ict = lw - alen + 1;
-			 ict;
-			 tp += add, ct++, ict--) {
-			if ((both &&
-			     (!ap || !test ||
-			      !pattern_match(ap, tp + aoff, NULL, NULL))) ||
-			    (!both &&
-			     pattern_match(ap, tp - moff, NULL, NULL) &&
-			     match_parts(l + aoff , tp - moff, alen, part))) {
-			    if (sfx) {
-				savw = tp[-zoff];
-				tp[-zoff] = '\0';
-				t = match_str(l - ll, w - lw,
-					      NULL, 0, NULL, 1, 2, part);
-				tp[-zoff] = savw;
-			    } else
-				t = match_str(l + llen + moff, tp + moff,
-					      NULL, 0, NULL, 0, 1, part);
-			    if (t || !both)
-				break;
-			}
-		    }
-		    ict = ct;
-		    if (sfx)
-			l[-(llen + zoff)] = savl;
-
-		    /* Have we found a position in w where the rest of l
-		     * matches? */
-		    if (!t)
-			continue;
-
-		    /* Yes, add the strings and clines if this is a 
-		     * top-level call. */
-		    if (!test && (!he || (llen + alen))) {
-			char *op, *lp, *map, *wap, *wmp;
-			int ol;
-
-			if (sfx) {
-			    op = w; ol = ow - w; lp = l - (llen + alen);
-			    map = tp - alen;
-			    if (mp->flags & CMF_LEFT) {
-				wap = tp - alen; wmp = tp;
-			    } else {
-				wap = w - alen; wmp = tp - alen;
-			    }
-			} else {
-			    op = ow; ol = w - ow; lp = l;
-			    map = ow;
-			    if (mp->flags & CMF_LEFT) {
-				wap = w; wmp = w + alen;
-			    } else {
-				wap = tp; wmp = ow;
-			    }
-			}
-			/* If the matcher says that we are only interested
-			 * in the line pattern, we just add that and the
-			 * anchor and the string not added yet. Otherwise
-			 * we add a new part. */
-			if (mp->flags & CMF_LINE) {
-			    add_match_str(NULL, NULL, op, ol, sfx);
-			    add_match_str(NULL, NULL, lp, llen + alen, sfx);
-			    add_match_sub(NULL, NULL, ol, op, ol);
-			    add_match_sub(NULL, NULL, llen + alen,
-					  lp, llen + alen);
-			} else if (sfx) {
-			    add_match_str(NULL, NULL,
-					  map, ct + ol + alen, sfx);
-			    add_match_part(mp, l + aoff, wap, alen,
-					   l + loff, llen, op, ol, ol, sfx);
-			    add_match_sub(NULL, NULL, 0, wmp, ct);
-			} else {
-			    add_match_str(NULL, NULL,
-					  map, ct + ol + alen, sfx);
-			    if (both) {
-				add_match_sub(NULL, NULL, ol, op, ol);
-				ol = -1;
-			    } else
-				ct += ol;
-			    add_match_part(mp, l + aoff, wap, alen,
-					   l + loff, llen, wmp, ct, ol, sfx);
-			}
-		    }
-		    /* Now skip over the matched portion and the anchor. */
-		    llen += alen; alen += ict;
-		    if (sfx) {
-			l -= llen; w -= alen;
-		    } else {
-			l += llen; w += alen;
-		    }
-		    ll -= llen; il += llen;
-		    lw -= alen; iw += alen;
-		    bc += llen;
-
-		    if (!test)
-			while (bp &&
-			       bc >= (bpc = (useqbr ? bp->qpos : bp->pos))) {
-			    bp->curpos = matchbufadded + bpc - bc + obc;
-			    bp = bp->next;
-			}
-		    ow = w;
-
-		    if (!llen && !alen) {
-			lm = mp;
-			if (he)
-			    mp = NULL;
-			else
-			    he = 1;
-		    } else {
-			lm = NULL; he = 0;
-		    }
-		    break;
-		} else if (ll >= mp->llen && lw >= mp->wlen) {
-		    /* Non-`*'-pattern. */
-		    char *tl, *tw;
-		    int tll, tlw, til, tiw;
-
-		    /* We do this only if the line- and word-substrings
-		     * are not equal. */
-		    if (!(mp->flags & (CMF_LEFT | CMF_RIGHT)) &&
-			mp->llen == mp->wlen &&
-			!(sfx ? strncmp(l - mp->llen, w - mp->wlen, mp->llen) :
-			  strncmp(l, w, mp->llen)))
-			continue;
-
-		    /* Using local variables to make the following
-		     * independent of whether we match a prefix or a
-		     * suffix. */
-		    if (sfx) {
-			tl = l - mp->llen; tw = w - mp->wlen;
-			til = ll - mp->llen; tiw = lw - mp->wlen;
-			tll = il + mp->llen; tlw = iw + mp->wlen;
-		    } else {
-			tl = l; tw = w;
-			til = il; tiw = iw;
-			tll = ll; tlw = lw;
-		    }
-		    if (mp->flags & CMF_LEFT) {
-			/* Try to match the left anchor, if any. */
-			if (til < mp->lalen || tiw < mp->lalen)
-			    continue;
-			else if (mp->left)
-			    t = pattern_match(mp->left, tl - mp->lalen,
-					      NULL, NULL) &&
-				pattern_match(mp->left, tw - mp->lalen,
-					      NULL, NULL);
-			else
-			    t = (!sfx && !il && !iw);
-		    }
-		    if (mp->flags & CMF_RIGHT) {
-			/* Try to match the right anchor, if any. */
-			if (tll < mp->llen + mp->ralen ||
-			    tlw < mp->wlen + mp->ralen)
-			    continue;
-			else if (mp->left)
-			    t = pattern_match(mp->right,
-					      tl + mp->llen - mp->ralen,
-					      NULL, NULL) &&
-				pattern_match(mp->right,
-					      tw + mp->wlen - mp->ralen,
-					      NULL, NULL);
-			else
-			    t = (sfx && !il && !iw);
-		    }
-		    /* Now try to match the line and word patterns. */
-		    if (!t ||
-			!pattern_match(mp->line, tl, NULL, ea) ||
-			!pattern_match(mp->word, tw, ea, NULL))
-			continue;
-
-		    /* Probably add the matched strings. */
-		    if (!test) {
-			if (sfx)
-			    add_match_str(NULL, NULL, w, ow - w, 0);
-			else
-			    add_match_str(NULL, NULL, ow, w - ow, 0);
-			add_match_str(mp, tl, tw, mp->wlen, 0);
-			if (sfx)
-			    add_match_sub(NULL, NULL, 0, w, ow - w);
-			else
-			    add_match_sub(NULL, NULL, 0, ow, w - ow);
-
-			add_match_sub(mp, tl, mp->llen, tw, mp->wlen);
-		    }
-		    if (sfx) {
-			l = tl;	w = tw;
-		    } else {
-			l += mp->llen; w += mp->wlen;
-		    }
-		    il += mp->llen; iw += mp->wlen;
-		    ll -= mp->llen; lw -= mp->wlen;
-		    bc += mp->llen;
-
-		    if (!test)
-			while (bp &&
-			       bc >= (bpc = (useqbr ? bp->qpos : bp->pos))) {
-			    bp->curpos = matchbufadded + bpc - bc + obc;
-			    bp = bp->next;
-			}
-		    ow = w;
-		    lm = NULL;
-		    he = 0;
-		    break;
-		}
-	    }
-	}
-	if (mp)
-	    continue;
-
-	if (l[ind] == w[ind]) {
-	    /* No matcher could be used, but the strings have the same
-	     * character here, skip over it. */
-	    l += add; w += add;
-	    il++; iw++;
-	    ll--; lw--;
-	    bc++;
-	    if (!test)
-		while (bp && bc >= (useqbr ? bp->qpos : bp->pos)) {
-		    bp->curpos = matchbufadded + (sfx ? (ow - w) : (w - ow)) + obc;
-		    bp = bp->next;
-		}
-	    lm = NULL;
-	    he = 0;
-	} else {
-	    /* No matcher and different characters: l does not match w. */
-	    if (test)
-		return 0;
-
-	    abort_match();
-
-	    return -1;
-	}
-    }
-    /* If this is a recursive call, we just return if l matched w or not. */
-    if (test)
-	return (part || !ll);
-
-    /* In top-level calls, if ll is non-zero (unmatched portion in l),
-     * we have to free the collected clines. */
-    if (!part && ll) {
-	abort_match();
-
-	return -1;
-    }
-    if (rwlp)
-	*rwlp = iw - (sfx ? ow - w : w - ow);
-
-    /* If we matched a suffix, the anchors stored in the top-clines
-     * will be in the wrong clines: shifted by one. Adjust this. */
-    if (sfx && matchparts) {
-	Cline t, tn, s;
-
-	if (matchparts->prefix || matchparts->suffix) {
-	    t = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
-	    t->next = matchparts;
-	    if (matchparts->prefix)
-		t->prefix = (Cline) 1;
-	    else
-		t->suffix = (Cline) 1;
-	    matchparts = t;
-	}
-	for (t = matchparts; (tn = t->next); t = tn) {
-	    s = (tn->prefix ? tn->prefix : tn->suffix);
-	    if (t->suffix)
-		t->suffix = s;
-	    else
-		t->prefix = s;
-	}
-	t->prefix = t->suffix = NULL;
-    }
-    /* Finally, return the number of matched characters. */
-
-    *bpp = bp;
-    return (part ? il : iw);
-}
-
-/* Wrapper for match_str(), only for a certain length and only doing
- * the test. */
-
-/**/
-static int
-match_parts(char *l, char *w, int n, int part)
-{
-    char lsav = l[n], wsav = w[n];
-    int ret;
-
-    l[n] = w[n] = '\0';
-    ret = match_str(l, w, NULL, 0, NULL, 0, 1, part);
-    l[n] = lsav;
-    w[n] = wsav;
-
-    return ret;
-}
-
-/* Check if the word w is matched by the strings in pfx and sfx (the prefix
- * and the suffix from the line) or the pattern cp. In clp a cline list for
- * w is returned.
- * qu is non-zero if the words has to be quoted before processed any further.
- * bpl and bsl are used to report the positions where the brace-strings in
- * the prefix and the suffix have to be re-inserted if this match is inserted
- * in the line.
- * The return value is the string to use as a completion or NULL if the prefix
- * and the suffix don't match the word w. */
-
-/**/
-char *
-comp_match(char *pfx, char *sfx, char *w, Patprog cp, Cline *clp, int qu,
-	   Brinfo *bpl, int bcp, Brinfo *bsl, int bcs, int *exact)
-{
-    char *r = NULL;
-
-    if (cp) {
-	/* We have a globcomplete-like pattern, just use that. */
-	int wl;
-
-	r = w;
-	if (!pattry(cp, r))
-	    return NULL;
-    
-	r = (qu ? quotename(r, NULL) : dupstring(r));
-	if (qu == 2 && r[0] == '\\' && r[1] == '~')
-	    chuck(r);
-	/* We still break it into parts here, trying to build a sensible
-	 * cline list for these matches, too. */
-	w = dupstring(w);
-	wl = strlen(w);
-	*clp = bld_parts(w, wl, wl, NULL);
-	*exact = 0;
-    } else {
-	Cline pli, plil;
-	int mpl, rpl, wl;
-
-	w = (qu ? quotename(w, NULL) : dupstring(w));
-	if (qu == 2 && w[0] == '\\' && w[1] == '~')
-	    chuck(w);
-
-	wl = strlen(w);
-
-	/* Always try to match the prefix. */
-
-	useqbr = qu;
-	if ((mpl = match_str(pfx, w, bpl, bcp, &rpl, 0, 0, 0)) < 0)
-	    return NULL;
-
-	if (sfx && *sfx) {
-	    int wpl = matchbufadded, msl, rsl;
-	    VARARR(char, wpfx, wpl);
-	    Cline mli, mlil;
-
-	    /* We also have a suffix to match, so first save the
-	     * contents of the global matching variables. */
-	    memcpy(wpfx, matchbuf, wpl);
-	    if (matchsubs) {
-		Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
-
-		tmp->prefix = matchsubs;
-		if (matchlastpart)
-		    matchlastpart->next = tmp;
-		else
-		    matchparts = tmp;
-	    }
-	    pli = matchparts;
-	    plil = matchlastpart;
-
-	    /* The try to match the suffix. */
-
-	    if ((msl = match_str(sfx, w + mpl, bsl, bcs, &rsl, 1, 0, 0)) < 0) {
-		free_cline(pli);
-
-		return NULL;
-	    }
-	    /* Matched, so add the string in the middle and the saved
-	     * string for the prefix, and build a combined cline list
-	     * for the prefix and the suffix. */
-	    if (matchsubs) {
-		Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, CLF_SUF);
-
-		tmp->suffix = matchsubs;
-		if (matchlastpart)
-		    matchlastpart->next = tmp;
-		else
-		    matchparts = tmp;
-	    }
-	    add_match_str(NULL, NULL, w + rpl, wl - rpl - rsl, 1);
-	    add_match_str(NULL, NULL, wpfx, wpl, 1);
-
-	    mli = bld_parts(w + rpl, wl - rpl - rsl,
-			    (mpl - rpl) + (msl - rsl), &mlil);
-	    mlil->flags |= CLF_MID;
-	    mlil->slen = msl - rsl;
-	    mlil->next = revert_cline(matchparts);
-
-	    if (plil)
-		plil->next = mli;
-	    else
-		pli = mli;
-	} else {
-	    /* Only a prefix, add the string and a part-cline for it. */
-	    add_match_str(NULL, NULL, w + rpl, wl - rpl, 0);
-
-	    add_match_part(NULL, NULL, NULL, 0, NULL, 0, w + rpl, wl - rpl,
-			   mpl - rpl, 0);
-	    pli = matchparts;
-	}
-	r = dupstring(matchbuf ? matchbuf : "");
-
-	*clp = pli;
-
-	/* Test if the string built is equal to the one from the line. */
-	if (sfx && *sfx) {
-	    int pl = strlen(pfx);
-
-	    *exact = (!strncmp(pfx, w, pl) && !strcmp(sfx, w + pl));
-	} else
-	    *exact = !strcmp(pfx, w);
-    }
-    if (!qu)
-	hasunqu = 1;
-
-    return r;
-}
-
-/* This builds all the possible line patterns for the pattern pat in the
- * buffer line. Initially line is the same as lp, but during recursive
- * calls lp is incremented for storing successive characters. Whenever
- * a full possible string is build, we test if this line matches the
- * string given by wlen and word. The in argument contains the characters
- * to use for the correspondence classes, it was filled by a call to 
- * pattern_match() in the calling function.
- * The return value is the length of the string matched in the word, it
- * is zero if we couldn't build a line that matches the word. */
-
-static int
-bld_line(Cpattern pat, char *line, char *lp,
-	 char *word, int wlen, unsigned char *in, int sfx)
-{
-    if (pat) {
-	/* Still working on the pattern. */
-
-	int i, l;
-	unsigned char c = 0;
-
-	/* Get the number of the character for a correspondence class
-	 * if it has a correxponding class. */
-	if (pat->equiv)
-	    if ((c = *in))
-		in++;
-
-	/* Walk through the table in the pattern and try the characters
-	 * that may appear in the current position. */
-	for (i = 0; i < 256; i++)
-	    if ((pat->equiv && c) ? (c == pat->tab[i]) : pat->tab[i]) {
-		*lp = i;
-		/* We stored the character, now call ourselves to build
-		 * the rest. */
-		if ((l = bld_line(pat->next, line, lp + 1, word, wlen,
-				  in, sfx)))
-		    return l;
-	    }
-    } else {
-	/* We reached the end, i.e. the line string is fully build, now
-	 * see if it matches the given word. */
-
-	Cmlist ms;
-	Cmatcher mp;
-	int l = lp - line, t, rl = 0, ind, add;
-	VARARR(unsigned char, ea, l + 1);
-
-	/* Quick test if the strings are exactly the same. */
-	if (l == wlen && !strncmp(line, word, l))
-	    return l;
-
-	if (sfx) {
-	    line = lp; word += wlen;
-	    ind = -1; add = -1;
-	} else {
-	    ind = 0; add = 1;
-	}
-	/* We loop through the whole line string built. */
-	while (l && wlen) {
-	    if (word[ind] == line[ind]) {
-		/* The same character in both strings, skip over. */
-		line += add; word += add;
-		l--; wlen--; rl++;
-	    } else {
-		t = 0;
-		for (ms = bmatchers; ms && !t; ms = ms->next) {
-		    mp = ms->matcher;
-		    if (!mp->flags && mp->wlen <= wlen && mp->llen <= l &&
-			pattern_match(mp->line, (sfx ? line - mp->llen : line),
-				      NULL, ea) &&
-			pattern_match(mp->word, (sfx ? word - mp->wlen : word),
-				      ea, NULL)) {
-			/* Both the line and the word pattern matched,
-			 * now skip over the matched portions. */
-			if (sfx) {
-			    line -= mp->llen; word -= mp->wlen;
-			} else {
-			    line += mp->llen; word += mp->wlen;
-			}
-			l -= mp->llen; wlen -= mp->wlen; rl += mp->wlen;
-			t = 1;
-		    }
-		}
-		if (!t)
-		    /* Didn't match, give up. */
-		    return 0;
-	    }
-	}
-	if (!l)
-	    /* Unmatched portion in the line built, return matched length. */
-	    return rl;
-    }
-    return 0;
-}
-
-/* This builds a string that may be put on the line that fully matches the
- * given strings. The return value is NULL if no such string could be built
- * or that string in local static memory, dup it. */
-
-static char *
-join_strs(int la, char *sa, int lb, char *sb)
-{
-    static char *rs = NULL;
-    static int rl = 0;
-
-    VARARR(unsigned char, ea, (la > lb ? la : lb) + 1);
-    Cmlist ms;
-    Cmatcher mp;
-    int t, bl, rr = rl;
-    char *rp = rs;
-
-    while (la && lb) {
-	if (*sa != *sb) {
-	    /* Different characters, try the matchers. */
-	    for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
-		mp = ms->matcher;
-		if (!mp->flags && mp->wlen > 0 && mp->llen > 0 &&
-		    mp->wlen <= la && mp->wlen <= lb) {
-		    /* The pattern has no anchors and the word
-		     * pattern fits, try it. */
-		    if ((t = pattern_match(mp->word, sa, NULL, ea)) ||
-			pattern_match(mp->word, sb, NULL, ea)) {
-			/* It matched one of the strings, t says which one. */
-			VARARR(char, line, mp->llen + 1);
-			char **ap, **bp;
-			int *alp, *blp;
-
-			if (t) {
-			    ap = &sa; alp = &la;
-			    bp = &sb; blp = &lb;
-			} else {
-			    ap = &sb; alp = &lb;
-			    bp = &sa; blp = &la;
-			}
-			/* Now try to build a string that matches the other
-			 * string. */
-			if ((bl = bld_line(mp->line, line, line,
-					   *bp, *blp, ea, 0))) {
-			    /* Found one, put it into the return string. */
-			    line[mp->llen] = '\0';
-			    if (rr <= mp->llen) {
-				char *or = rs;
-
-				rs = realloc(rs, (rl += 20));
-				rr += 20;
-				rp += rs - or;
-			    }
-			    memcpy(rp, line, mp->llen);
-			    rp += mp->llen; rr -= mp->llen;
-			    *ap += mp->wlen; *alp -= mp->wlen;
-			    *bp += bl; *blp -= bl;
-			    t = 1;
-			} else
-			    t = 0;
-		    }
-		}
-	    }
-	    if (!t)
-		break;
-	} else {
-	    /* Same character, just take it. */
-	    if (rr <= 1) {
-		char *or = rs;
-
-		rs = realloc(rs, (rl += 20));
-		rr += 20;
-		rp += rs - or;
-	    }
-	    *rp++ = *sa; rr--;
-	    sa++; sb++;
-	    la--; lb--;
-	}
-    }
-    if (la || lb)
-	return NULL;
-
-    *rp = '\0';
-
-    return rs;
-}
-
-/* This compares the anchors stored in two top-level clines. */
-
-static int
-cmp_anchors(Cline o, Cline n, int join)
-{
-    int line = 0;
-    char *j;
-
-    /* First try the exact strings. */
-    if ((!(o->flags & CLF_LINE) && o->wlen == n->wlen &&
-	 (!o->word || !strncmp(o->word, n->word, o->wlen))) ||
-	(line = ((!o->line && !n->line && !o->wlen && !n->wlen) ||
-		 (o->llen == n->llen && o->line && n->line &&
-		  !strncmp(o->line, n->line, o->llen))))) {
-	if (line) {
-	    o->flags |= CLF_LINE;
-	    o->word = NULL;
-	    n->wlen = 0;
-	}
-	return 1;
-    }
-    /* Didn't work, try to build a string matching both anchors. */
-    if (join && !(o->flags & CLF_JOIN) && o->word && n->word &&
-	(j = join_strs(o->wlen, o->word, n->wlen, n->word))) {
-	o->flags |= CLF_JOIN;
-	o->wlen = strlen(j);
-	o->word = dupstring(j);
-
-	return 2;
-    }
-    return 0;
-}
-
-/* Below is the code to join two cline lists. This struct is used to walk
- * through a sub-list. */
-
-typedef struct cmdata *Cmdata;
-
-struct cmdata {
-    Cline cl, pcl;
-    char *str, *astr;
-    int len, alen, olen, line;
-};
-
-/* This is used to ensure that a cmdata struct contains usable data.
- * The return value is non-zero if we reached the end. */
-
-static int
-check_cmdata(Cmdata md, int sfx)
-{
-    /* We will use the str and len fields to contain the next sub-string
-     * in the list. If len is zero, we have to use the next cline. */
-    if (!md->len) {
-	/* If there is none, we reached the end. */
-	if (!md->cl)
-	    return 1;
-
-	/* Otherwise, get the string. Only the line-string or both.
-	 * We also have to adjust the pointer if this is for a suffix. */
-	if (md->cl->flags & CLF_LINE) {
-	    md->line = 1;
-	    md->len = md->cl->llen;
-	    md->str = md->cl->line;
-	} else {
-	    md->line = 0;
-	    md->len = md->olen = md->cl->wlen;
-	    if ((md->str = md->cl->word) && sfx)
-		md->str += md->len;
-	    md->alen = md->cl->llen;
-	    if ((md->astr = md->cl->line) && sfx)
-		md->astr += md->alen;
-	}
-	md->pcl = md->cl;
-	md->cl = md->cl->next;
-    }
-    return 0;
-}
-
-/* This puts the not-yet-matched portion back into the last cline and 
- * returns that. */
-
-static Cline
-undo_cmdata(Cmdata md, int sfx)
-{
-    Cline r = md->pcl;
-
-    if (md->line) {
-	r->word = NULL;
-	r->wlen = 0;
-	r->flags |= CLF_LINE;
-	r->llen = md->len;
-	r->line = md->str - (sfx ? md->len : 0);
-    } else if (md->len != md->olen) {
-	r->wlen = md->len;
-	r->word = md->str - (sfx ? md->len : 0);
-    }
-    return r;
-}
-
-/* This tries to build a string matching a sub-string in a sub-cline
- * that could not be matched otherwise. */
-
-static Cline
-join_sub(Cmdata md, char *str, int len, int *mlen, int sfx, int join)
-{
-    if (!check_cmdata(md, sfx)) {
-	char *ow = str, *nw = md->str;
-	int ol = len, nl = md->len;
-	Cmlist ms;
-	Cmatcher mp;
-	VARARR(unsigned char, ea, (ol > nl ? ol : nl) + 1);
-	int t;
-
-	if (sfx) {
-	    ow += ol; nw += nl;
-	}
-	for (t = 0, ms = bmatchers; ms && !t; ms = ms->next) {
-	    mp = ms->matcher;
-	    /* We use only those patterns that match a non-empty
-	     * string in both the line and the word and that have
-	     * no anchors. */
-	    if (!mp->flags && mp->wlen > 0 && mp->llen > 0) {
-		/* We first test, if the old string matches already the
-		 * new one. */
-		if (mp->llen <= ol && mp->wlen <= nl &&
-		    pattern_match(mp->line, ow - (sfx ? mp->llen : 0),
-				  NULL, ea) &&
-		    pattern_match(mp->word, nw - (sfx ? mp->wlen : 0),
-				  ea, NULL)) {
-		    /* It did, update the contents of the cmdata struct
-		     * and return a cline for the matched part. */
-		    if (sfx)
-			md->str -= mp->wlen;
-		    else
-			md->str += mp->wlen;
-		    md->len -= mp->wlen;
-		    *mlen = mp->llen;
-
-		    return get_cline(NULL, 0, ow - (sfx ? mp->llen : 0),
-				     mp->llen, NULL, 0, 0);
-		}
-		/* Otherwise we will try to build a string that matches
-		 * both strings. But try the pattern only if the word-
-		 * pattern matches one of the strings. */
-		if (join && mp->wlen <= ol && mp->wlen <= nl &&
-		    ((t = pattern_match(mp->word, ow - (sfx ? mp->wlen : 0),
-				       NULL, ea)) ||
-		     pattern_match(mp->word, nw - (sfx ? mp->wlen : 0),
-				   NULL, ea))) {
-		    VARARR(char, line, mp->llen + 1);
-		    int bl;
-
-		    /* Then build all the possible lines and see
-		     * if one of them matches the other string. */
-		    if ((bl = bld_line(mp->line, line, line,
-				       (t ? nw : ow), (t ? nl : ol),
-				       ea, sfx))) {
-			/* Yep, one of the lines matched the other
-			 * string. */
-			line[mp->llen] = '\0';
-
-			if (t) {
-			    ol = mp->wlen; nl = bl;
-			} else {
-			    ol = bl; nl = mp->wlen;
-			}
-			if (sfx)
-			    md->str -= nl;
-			else
-			    md->str += nl;
-			md->len -= nl;
-			*mlen = ol;
-
-			return get_cline(NULL, 0, dupstring(line), mp->llen,
-					 NULL, 0, CLF_JOIN);
-		    }
-		}
-	    }
-	}
-    }
-    return NULL;
-}
-
-/* This is used to match a sub-string in a sub-cline. The length of the
- * matched portion is returned. This tests only for exact equality. */
-
-static int
-sub_match(Cmdata md, char *str, int len, int sfx)
-{
-    int ret = 0, l, ind, add;
-    char *p, *q;
-
-    if (sfx) {
-	str += len;
-	ind = -1; add = -1;
-    } else {
-	ind = 0; add = 1;
-    }
-    /* str and len describe the old string, in md we have the new one. */
-    while (len) {
-	if (check_cmdata(md, sfx))
-	    return ret;
-
-	for (l = 0, p = str, q = md->str;
-	     l < len && l < md->len && p[ind] == q[ind];
-	     l++, p += add, q += add);
-
-	if (l) {
-	    /* There was a common prefix, use it. */
-	    md->len -= l; len -= l;
-	    if (sfx) {
-		md->str -= l; str -= l;
-	    } else {
-		md->str += l; str += l;
-	    }
-	    ret += l;
-	} else if (md->line || md->len != md->olen || !md->astr)
-	    return ret;
-	else {
-	    /* We still have the line string to try. */
-	    md->line = 1;
-	    md->len = md->alen;
-	    md->str = md->astr;
-	}
-    }
-    return ret;
-}
-
-/* This is used to build a common prefix or suffix sub-list. If requested
- * it returns the unmatched cline lists in orest and nrest. */
-
-static void
-join_psfx(Cline ot, Cline nt, Cline *orest, Cline *nrest, int sfx)
-{
-    Cline p = NULL, o, n;
-    struct cmdata md, omd;
-    char **sstr = NULL;
-    int len, join = 0, line = 0, *slen = NULL;
-
-    if (sfx) {
-	o = ot->suffix; n = nt->suffix;
-    } else {
-	o = ot->prefix;	n = nt->prefix;
-    }
-    if (!o) {
-	if (orest)
-	    *orest = NULL;
-	if (nrest)
-	    *nrest = n;
-
-	return;
-    }
-    if (!n) {
-	if (sfx)
-	    ot->suffix = NULL;
-	else
-	    ot->prefix = NULL;
-
-	if (orest)
-	    *orest = o;
-	else
-	    free_cline(o);
-	if (nrest)
-	    *nrest = NULL;
-	return;
-    }
-    md.cl = n;
-    md.len = 0;
-
-    /* Walk through the old list. */
-    while (o) {
-	join = 0;
-	memcpy(&omd, &md, sizeof(struct cmdata));
-
-	/* We first get the length of the prefix equal in both strings. */
-	if (o->flags & CLF_LINE) {
-	    if ((len = sub_match(&md, o->line, o->llen, sfx)) != o->llen) {
-		join = 1; line = 1; slen = &(o->llen); sstr = &(o->line);
-	    }
-	} else if ((len = sub_match(&md, o->word, o->wlen, sfx)) != o->wlen) {
-	    if (o->line) {
-		memcpy(&md, &omd, sizeof(struct cmdata));
-		o->flags |= CLF_LINE | CLF_DIFF;
-
-		continue;
-	    }
-	    join = 1; line = 0; slen = &(o->wlen); sstr = &(o->word);
-	}
-	if (join) {
-	    /* There is a rest that is different in the two lists,
-	     * we try to build a new cline matching both strings. */
-	    Cline joinl;
-	    int jlen;
-
-	    if ((joinl = join_sub(&md, *sstr + len, *slen - len,
-				  &jlen, sfx, !(o->flags & CLF_JOIN)))) {
-		/* We have one, insert it into the list. */
-		joinl->flags |= CLF_DIFF;
-		if (len + jlen != *slen) {
-		    Cline rest;
-
-		    rest = get_cline(NULL, 0, *sstr + (sfx ? 0 : len + jlen),
-				     *slen - len - jlen, NULL, 0, 0);
-
-		    rest->next = o->next;
-		    joinl->next = rest;
-		} else
-		    joinl->next = o->next;
-
-		if (len) {
-		    if (sfx)
-			*sstr += *slen - len;
-		    *slen = len;
-		    o->next = joinl;
-		} else {
-		    o->next = NULL;
-		    free_cline(o);
-		    if (p)
-			p->next = joinl;
-		    else if (sfx)
-			ot->suffix = joinl;
-		    else
-			ot->prefix = joinl;
-		}
-		o = joinl;
-		join = 0;
-	    }
-	}
-	if (join) {
-	    /* We couldn't build a cline for a common string, so we
-	     * cut the list here. */
-	    if (len) {
-		Cline r;
-
-		if (orest) {
-		    if (line)
-			r = get_cline(o->line + len, *slen - len,
-				      NULL, 0, NULL, 0, o->flags);
-		    else
-			r = get_cline(NULL, 0, o->word + len, *slen - len,
-				      NULL, 0, o->flags);
-
-		    r->next = o->next;
-		    *orest = r;
-
-		    *slen = len;
-		    o->next = NULL;
-		} else {
-		    if (sfx)
-			*sstr += *slen - len;
-		    *slen = len;
-		    free_cline(o->next);
-		    o->next = NULL;
-		}
-	    } else {
-		if (p)
-		    p->next = NULL;
-		else if (sfx)
-		    ot->suffix = NULL;
-		else
-		    ot->prefix = NULL;
-
-		if (orest)
-		    *orest = o;
-		else
-		    free_cline(o);
-	    }
-	    if (!orest || !nrest)
-		ot->flags |= CLF_MISS;
-
-	    if (nrest)
-		*nrest = undo_cmdata(&md, sfx);
-
-	    return;
-	}
-	p = o;
-	o = o->next;
-    }
-    if (md.len || md.cl)
-	ot->flags |= CLF_MISS;
-    if (orest)
-	*orest = NULL;
-    if (nrest)
-	*nrest = undo_cmdata(&md, sfx);
-}
-
-/* This builds the common prefix and suffix for a mid-cline -- the one
- * describing the place where the prefix and the suffix meet. */
-
-static void
-join_mid(Cline o, Cline n)
-{
-    if (o->flags & CLF_JOIN) {
-	/* The JOIN flag is set in the old cline struct if it was
-	 * already joined with another one. In this case the suffix
-	 * field contains the suffix from previous calls. */
-	Cline nr;
-
-	join_psfx(o, n, NULL, &nr, 0);
-
-	n->suffix = revert_cline(nr);
-
-	join_psfx(o, n, NULL, NULL, 1);
-    } else {
-	/* This is the first time for both structs, so the prefix field
-	 * contains the whole sub-list. */
-	Cline or, nr;
-
-	o->flags |= CLF_JOIN;
-
-	/* We let us give both rests and use them as the suffixes. */
-	join_psfx(o, n, &or, &nr, 0);
-
-	if (or)
-	    or->llen = (o->slen > or->wlen ? or->wlen : o->slen);
-	o->suffix = revert_cline(or);
-	n->suffix = revert_cline(nr);
-
-	join_psfx(o, n, NULL, NULL, 1);
-    }
-    n->suffix = NULL;
-}
-
-/* This turns the sequence of anchor cline structs from b to e into a
- * prefix sequence, puts it before the prefix of e and then tries to
- * join that with the prefix of a.
- * This is needed if some matches had a anchor match spec and others
- * didn't. */
-
-static void
-sub_join(Cline a, Cline b, Cline e, int anew)
-{
-    if (!e->suffix && a->prefix) {
-	Cline op = e->prefix, n = NULL, *p = &n, t, ca;
-	int min = 0, max = 0;
-
-	for (; b != e; b = b->next) {
-	    if ((*p = t = b->prefix)) {
-		while (t->next)
-		    t = t->next;
-		p = &(t->next);
-	    }
-	    b->suffix = b->prefix = NULL;
-	    b->flags &= ~CLF_SUF;
-	    min += b->min;
-	    max += b->max;
-	    *p = b;
-	    p = &(b->next);
-	}
-	*p = e->prefix;
-	ca = a->prefix;
-
-	while (n != op) {
-	    e->prefix = cp_cline(n, 0);
-	    a->prefix = cp_cline(ca, 0);
-
-	    if (anew) {
-		join_psfx(e, a, NULL, NULL, 0);
-		if (e->prefix) {
-		    e->min += min;
-		    e->max += max;
-		    break;
-		}
-	    } else {
-		join_psfx(e, a, NULL, NULL, 0);
-		if (a->prefix) {
-		    a->min += min;
-		    a->max += max;
-		    break;
-		}
-	    }
-	    min -= n->min;
-	    max -= n->max;
-
-	    n = n->next;
-	}
-    }
-}
-
-/* This simplifies the cline list given as the first argument so that
- * it also matches the second list. */
-
-static Cline
-join_clines(Cline o, Cline n)
-{
-    cline_setlens(n, 1);
-
-    /* First time called, just return the new list. On further invocations
-     * we will get it as the first argument. */
-    if (!o)
-	return n;
-    else {
-	Cline oo = o, nn = n, po = NULL, pn = NULL;
-
-	/* Walk through the lists. */
-	while (o && n) {
-	    /* If one of them describes a new part and the other one does
-	     * not, synchronise them by searching an old part in the
-	     * other list. */
-	    if ((o->flags & CLF_NEW) && !(n->flags & CLF_NEW)) {
-		Cline t, tn;
-
-		for (t = o; (tn = t->next) && (tn->flags & CLF_NEW); t = tn);
-		if (tn && cmp_anchors(tn, n, 0)) {
-		    sub_join(n, o, tn, 1);
-
-		    if (po)
-			po->next = tn;
-		    else
-			oo = tn;
-		    t->next = NULL;
-		    free_cline(o);
-		    o = tn;
-		    o->flags |= CLF_MISS;
-		    continue;
-		}
-	    }
-	    if (!(o->flags & CLF_NEW) && (n->flags & CLF_NEW)) {
-		Cline t, tn;
-
-		for (t = n; (tn = t->next) && (tn->flags & CLF_NEW); t = tn);
-		if (tn && cmp_anchors(o, tn, 0)) {
-		    sub_join(o, n, tn, 0);
-
-		    n = tn;
-		    o->flags |= CLF_MISS;
-		    continue;
-		}
-	    }
-	    /* Almost the same as above, but for the case that they
-	     * describe different types of parts (prefix, suffix, or mid). */
-	    if ((o->flags & (CLF_SUF | CLF_MID)) !=
-		(n->flags & (CLF_SUF | CLF_MID))) {
-		Cline t, tn;
-
-		for (t = n;
-		     (tn = t->next) &&
-			 (tn->flags & (CLF_SUF | CLF_MID)) !=
-			 (o->flags  & (CLF_SUF | CLF_MID));
-		     t = tn);
-		if (tn && cmp_anchors(o, tn, 1)) {
-		    sub_join(o, n, tn, 0);
-
-		    n = tn;
-		    continue;
-		}
-		for (t = o;
-		     (tn = t->next) &&
-			 (tn->flags & (CLF_SUF | CLF_MID)) !=
-			 (n->flags  & (CLF_SUF | CLF_MID));
-		     t = tn);
-		if (tn && cmp_anchors(tn, n, 1)) {
-		    sub_join(n, o, tn, 1);
-		    if (po)
-			po->next = tn;
-		    else
-			oo = tn;
-		    t->next = NULL;
-		    free_cline(o);
-		    o = tn;
-		    continue;
-		}
-		if (o->flags & CLF_MID) {
-		    o->flags = (o->flags & ~CLF_MID) | (n->flags & CLF_SUF);
-		    if (n->flags & CLF_SUF) {
-			free_cline(o->prefix);
-			o->prefix = NULL;
-		    } else {
-			free_cline(o->suffix);
-			o->suffix = NULL;
-		    }
-		}
-		break;
-	    }
-	    /* Now see if they have matching anchors. If not, cut the list. */
-	    if (!(o->flags & CLF_MID) && !cmp_anchors(o, n, 1)) {
-		Cline t, tn;
-
-		for (t = n; (tn = t->next) && !cmp_anchors(o, tn, 1); t = tn);
-
-		if (tn) {
-		    sub_join(o, n, tn, 0);
-
-		    n = tn;
-		    o->flags |= CLF_MISS;
-		    continue;
-		} else {
-		    for (t = o; (tn = t->next) && !cmp_anchors(n, tn, 1);
-			 t = tn);
-
-		    if (tn) {
-			sub_join(n, o, tn, 1);
-
-			if (po)
-			    po->next = tn;
-			else
-			    oo = tn;
-			o = tn;
-			o->flags |= CLF_MISS;
-			continue;
-		    } else {
-			if (o->flags & CLF_SUF)
-			    break;
-
-			o->word = o->line = o->orig = NULL;
-			o->wlen = 0;
-			free_cline(o->next);
-			o->next = NULL;
-			o->flags |= CLF_MISS;
-		    }
-		}
-	    }
-	    /* Ok, they are equal, now copy the information about the
-             * original string if needed, calculate minimum and maximum
-	     * lengths, and join the sub-lists. */
-	    if (!o->orig && !o->olen) {
-		o->orig = n->orig;
-		o->olen = n->olen;
-	    }
-	    if (n->min < o->min)
-		o->min = n->min;
-	    if (n->max > o->max)
-		o->max = n->max;
-	    if (o->flags & CLF_MID)
-		join_mid(o, n);
-	    else
-		join_psfx(o, n, NULL, NULL, (o->flags & CLF_SUF));
-
-	    po = o;
-	    o = o->next;
-	    pn = n;
-	    n = n->next;
-	}
-	/* Free the rest of the old list. */
-	if (o) {
-	    if (po)
-		po->next = NULL;
-	    else
-		oo = NULL;
-
-	    free_cline(o);
-	}
-	free_cline(nn);
-
-	return oo;
-    }
-}
-
-/* This adds all the data we have for a match. */
-
-/**/
-Cmatch
-add_match_data(int alt, char *str, Cline line,
-	       char *ipre, char *ripre, char *isuf,
-	       char *pre, char *prpre,
-	       char *ppre, Cline pline,
-	       char *psuf, Cline sline,
-	       char *suf, int flags, int exact)
-{
-    Cmatch cm;
-    Aminfo ai = (alt ? fainfo : ainfo);
-    int palen, salen, qipl, ipl, pl, ppl, qisl, isl, psl;
-    int sl, lpl, lsl, ml;
-
-    palen = salen = qipl = ipl = pl = ppl = qisl = isl = psl = 0;
-
-    DPUTS(!line, "BUG: add_match_data() without cline");
-
-    cline_matched(line);
-    if (pline)
-	cline_matched(pline);
-    if (sline)
-	cline_matched(sline);
-
-    /* If there is a path suffix, we build a cline list for it and
-     * append it to the list for the match itself. */
-    if (!sline && psuf)
-	salen = (psl = strlen(psuf));
-    if (isuf)
-	salen += (isl = strlen(isuf));
-    if (qisuf)
-	salen += (qisl = strlen(qisuf));
-
-    if (salen) {
-	char *asuf = (char *) zhalloc(salen);
-	Cline pp, p, s, sl = NULL;
-	
-
-	if (psl)
-	    memcpy(asuf, psuf, psl);
-	if (isl)
-	    memcpy(asuf + psl, isuf, isl);
-	if (qisl)
-	    memcpy(asuf + psl + isl, qisuf, qisl);
-
-	for (pp = NULL, p = line; p->next; pp = p, p = p->next);
-
-	if (salen > qisl) {
-	    s = bld_parts(asuf, salen - qisl, salen - qisl, &sl);
-
-	    if (sline) {
-		Cline sp;
-
-		sline = cp_cline(sline, 1);
-
-		for (sp = sline; sp->next; sp = sp->next);
-		sp->next = s;
-		s = sline;
-	    }
-	    if (!(p->flags & (CLF_SUF | CLF_MID)) &&
-		!p->llen && !p->wlen && !p->olen) {
-		if (p->prefix) {
-		    Cline q;
-
-		    for (q = p->prefix; q->next; q = q->next);
-		    q->next = s->prefix;
-		    s->prefix = p->prefix;
-		    p->prefix = NULL;
-		}
-		s->flags |= (p->flags & CLF_MATCHED);
-		free_cline(p);
-		if (pp)
-		    pp->next = s;
-		else
-		    line = s;
-	    } else
-		p->next = s;
-	}
-	if (qisl) {
-	    Cline qsl = bld_parts(asuf + psl + isl, qisl, qisl, NULL);
-
-	    qsl->flags |= CLF_SUF;
-	    qsl->suffix = qsl->prefix;
-	    qsl->prefix = NULL;
-	    if (sl)
-		sl->next = qsl;
-	    else if (sline) {
-		Cline sp;
-
-		sline = cp_cline(sline, 1);
-
-		for (sp = sline; sp->next; sp = sp->next);
-		sp->next = qsl;
-		p->next = sline;
-	    } else
-		p->next = qsl;
-	}
-    } else if (sline) {
-	Cline p;
-
-	for (p = line; p->next; p = p->next);
-	p->next = cp_cline(sline, 1);
-    }
-    /* The prefix is handled differently because the completion code
-     * is much more eager to insert the -P prefix than it is to insert
-     * the -S suffix. */
-    if (qipre)
-	palen = (qipl = strlen(qipre));
-    if (ipre)
-	palen += (ipl = strlen(ipre));
-    if (pre)
-	palen += (pl = strlen(pre));
-    if (!pline && ppre)
-	palen += (ppl = strlen(ppre));
-
-    if (pl) {
-	if (ppl || pline) {
-	    Cline lp, p;
-
-	    if (pline)
-		for (p = cp_cline(pline, 1), lp = p; lp->next; lp = lp->next);
-	    else
-		p = bld_parts(ppre, ppl, ppl, &lp);
-
-	    if (lp->prefix && !(line->flags & (CLF_SUF | CLF_MID)) &&
-		!p->llen && !p->wlen && !p->olen) {
-		Cline lpp;
-
-		for (lpp = lp->prefix; lpp->next; lpp = lpp->next);
-
-		lpp->next = line->prefix;
-		line->prefix = lp->prefix;
-		lp->prefix = NULL;
-
-		free_cline(lp);
-
-		if (p != lp) {
-		    Cline q;
-
-		    for (q = p; q->next != lp; q = q->next);
-
-		    q->next = line;
-		    line = p;
-		}
-	    } else {
-		lp->next = line;
-		line = p;
-	    }
-	}
-	if (pl) {
-	    Cline lp, p = bld_parts(pre, pl, pl, &lp);
-
-	    lp->next = line;
-	    line = p;
-	}
-	if (ipl) {
-	    Cline lp, p = bld_parts(ipre, ipl, ipl, &lp);
-
-	    lp->next = line;
-	    line = p;
-	}
-	if (qipl) {
-	    Cline lp, p = bld_parts(qipre, qipl, qipl, &lp);
-
-	    lp->next = line;
-	    line = p;
-	}
-    } else if (palen || pline) {
-	Cline p, lp;
-
-	if (palen) {
-	    char *apre = (char *) zhalloc(palen);
-
-	    if (qipl)
-		memcpy(apre, qipre, qipl);
-	    if (ipl)
-		memcpy(apre + qipl, ipre, ipl);
-	    if (pl)
-		memcpy(apre + qipl + ipl, pre, pl);
-	    if (ppl)
-		memcpy(apre + qipl + ipl + pl, ppre, ppl);
-
-	    p = bld_parts(apre, palen, palen, &lp);
-
-	    if (pline)
-		for (lp->next = cp_cline(pline, 1); lp->next; lp = lp->next);
-	} else
-	    for (p = lp = cp_cline(pline, 1); lp->next; lp = lp->next);
-
-	if (lp->prefix && !(line->flags & (CLF_SUF | CLF_MID)) &&
-	    !p->llen && !p->wlen && !p->olen) {
-	    Cline lpp;
-
-	    for (lpp = lp->prefix; lpp->next; lpp = lpp->next);
-
-	    lpp->next = line->prefix;
-	    line->prefix = lp->prefix;
-	    lp->prefix = NULL;
-
-	    free_cline(lp);
-
-	    if (p != lp) {
-		Cline q;
-
-		for (q = p; q->next != lp; q = q->next);
-
-		q->next = line;
-		line = p;
-	    }
-	} else {
-	    lp->next = line;
-	    line = p;
-	}
-    }
-    /* Allocate and fill the match structure. */
-    cm = (Cmatch) zhalloc(sizeof(struct cmatch));
-    cm->str = str;
-    cm->ppre = (ppre && *ppre ? ppre : NULL);
-    cm->psuf = (psuf && *psuf ? psuf : NULL);
-    cm->prpre = ((flags & CMF_FILE) && prpre && *prpre ? prpre : NULL);
-    if (qipre && *qipre)
-	cm->ipre = (ipre && *ipre ? dyncat(qipre, ipre) : dupstring(qipre));
-    else
-	cm->ipre = (ipre && *ipre ? ipre : NULL);
-    cm->ripre = (ripre && *ripre ? ripre : NULL);
-    if (qisuf && *qisuf)
-	cm->isuf = (isuf && *isuf ? dyncat(isuf, qisuf) : dupstring(qisuf));
-    else
-	cm->isuf = (isuf && *isuf ? isuf : NULL);
-    cm->pre = pre;
-    cm->suf = suf;
-    cm->flags = flags;
-    if (nbrbeg) {
-	int *p;
-	Brinfo bp;
-
-	cm->brpl = (int *) zhalloc(nbrbeg * sizeof(int));
-
-	for (p = cm->brpl, bp = brbeg; bp; p++, bp = bp->next)
-	    *p = bp->curpos;
-    } else
-	cm->brpl = NULL;
-    if (nbrend) {
-	int *p;
-	Brinfo bp;
-
-	cm->brsl = (int *) zhalloc(nbrend * sizeof(int));
-
-	for (p = cm->brsl, bp = brend; bp; p++, bp = bp->next)
-	    *p = bp->curpos;
-    } else
-	cm->brsl = NULL;
-    cm->qipl = qipl;
-    cm->qisl = qisl;
-    cm->autoq = (autoq ? autoq : (inbackt ? '`' : '\0'));
-    cm->rems = cm->remf = cm->disp = NULL;
-
-    if ((lastprebr || lastpostbr) && !hasbrpsfx(cm, lastprebr, lastpostbr))
-	return NULL;
-
-    /* Then build the unambiguous cline list. */
-    ai->line = join_clines(ai->line, line);
-
-    mnum++;
-    ai->count++;
-
-    addlinknode((alt ? fmatches : matches), cm);
-
-    newmatches = 1;
-
-    /* One more match for this explanation. */
-    if (curexpl) {
-	if (alt)
-	    curexpl->fcount++;
-	else
-	    curexpl->count++;
-    }
-    if (!ai->firstm)
-	ai->firstm = cm;
-
-    sl = strlen(str);
-    lpl = (cm->ppre ? strlen(cm->ppre) : 0);
-    lsl = (cm->psuf ? strlen(cm->psuf) : 0);
-    ml = sl + lpl + lsl;
-
-    if (ml < minmlen)
-	minmlen = ml;
-    if (ml > maxmlen)
-	maxmlen = ml;
-
-    /* Do we have an exact match? More than one? */
-    if (exact) {
-	if (!ai->exact) {
-	    ai->exact = 1;
-	    if (incompfunc) {
-		/* If a completion widget is active, we make the exact
-		 * string available in `compstate'. */
-
-		char *e;
-
-		zsfree(compexactstr);
-		compexactstr = e = (char *) zalloc(ml + 1);
-		if (cm->ppre) {
-		    strcpy(e, cm->ppre);
-		    e += lpl;
-		}
-		strcpy(e, str);
-		e += sl;
-		if (cm->psuf)
-		    strcpy(e, cm->psuf);
-		comp_setunsetptr(0, 0, CP_EXACTSTR, 0);
-	    }
-	    ai->exactm = cm;
-	} else {
-	    ai->exact = 2;
-	    ai->exactm = NULL;
-	    if (incompfunc)
-		comp_setunsetptr(0, 0, 0, CP_EXACTSTR);
-	}
-    }
-    return cm;
-}
-
-/* This stores the strings from the list in an array. */
-
-/**/
-void
-set_list_array(char *name, LinkList l)
-{
-    char **a, **p;
-    LinkNode n;
-
-    a = (char **) zalloc((countlinknodes(l) + 1) * sizeof(char *));
-    for (p = a, n = firstnode(l); n; incnode(n))
-	*p++ = ztrdup((char *) getdata(n));
-    *p = NULL;
-
-    setaparam(name, a);
-}
-
-/* This is used by compadd to add a couple of matches. The arguments are
- * the strings given via options. The last argument is the array with
- * the matches. */
-
-/**/
-int
-addmatches(Cadata dat, char **argv)
-{
-    char *s, *ms, *lipre = NULL, *lisuf = NULL, *lpre = NULL, *lsuf = NULL;
-    char **aign = NULL, **dparr = NULL, oaq = autoq, *oppre = dat->ppre;
-    char *oqp = qipre, *oqs = qisuf, qc, **disp = NULL;
-    int lpl, lsl, pl, sl, bcp = 0, bcs = 0, bpadd = 0, bsadd = 0;
-    int llpl = 0, llsl = 0, nm = mnum, gflags = 0, ohp = haspattern;
-    int oisalt = 0, isalt, isexact, doadd, ois = instring, oib = inbackt;
-    Cline lc = NULL, pline = NULL, sline = NULL;
-    Cmatch cm;
-    struct cmlist mst;
-    Cmlist oms = mstack;
-    Patprog cp = NULL;
-    LinkList aparl = NULL, oparl = NULL, dparl = NULL;
-    Brinfo bp, bpl = brbeg, obpl, bsl = brend, obsl;
-
-    for (bp = brbeg; bp; bp = bp->next)
-	bp->curpos = ((dat->aflags & CAF_QUOTE) ? bp->pos : bp->qpos);
-    for (bp = brend; bp; bp = bp->next)
-	bp->curpos = ((dat->aflags & CAF_QUOTE) ? bp->pos : bp->qpos);
-
-    if (dat->flags & CMF_ISPAR)
-	dat->flags |= parflags;
-    if (compquote && (qc = *compquote)) {
-	if (qc == '`') {
-	    instring = 0;
-	    inbackt = 0;
-	    autoq = '\0';
-	} else {
-	    instring = (qc == '\'' ? 1 : 2);
-	    inbackt = 0;
-	    autoq = qc;
-	}
-    } else {
-	instring = inbackt = 0;
-	autoq = '\0';
-    }
-    qipre = ztrdup(compqiprefix ? compqiprefix : "");
-    qisuf = ztrdup(compqisuffix ? compqisuffix : "");
-
-    /* Switch back to the heap that was used when the completion widget
-     * was invoked. */
-    SWITCHHEAPS(compheap) {
-	HEAPALLOC {
-	    if ((doadd = (!dat->apar && !dat->opar && !dat->dpar)) &&
-		(dat->aflags & CAF_MATCH))
-		hasmatched = 1;
-	    if (dat->apar)
-		aparl = newlinklist();
-	    if (dat->opar)
-		oparl = newlinklist();
-	    if (dat->dpar) {
-		if (*(dat->dpar) == '(')
-		    dparr = NULL;
-		else if ((dparr = get_user_var(dat->dpar)) && !*dparr)
-		    dparr = NULL;
-		dparl = newlinklist();
-	    }
-	    if (dat->exp) {
-		curexpl = (Cexpl) zhalloc(sizeof(struct cexpl));
-		curexpl->count = curexpl->fcount = 0;
-		curexpl->str = dupstring(dat->exp);
-	    } else
-		curexpl = NULL;
-
-	    /* Store the matcher in our stack of matchers. */
-	    if (dat->match) {
-		mst.next = mstack;
-		mst.matcher = dat->match;
-		mstack = &mst;
-
-		if (!mnum)
-		    add_bmatchers(dat->match);
-
-		addlinknode(matchers, dat->match);
-		dat->match->refc++;
-	    }
-	    if (mnum && (mstack || bmatchers))
-		update_bmatchers();
-
-	    /* Get the suffixes to ignore. */
-	    if (dat->ign)
-		aign = get_user_var(dat->ign);
-	    /* Get the display strings. */
-	    if (dat->disp)
-		if ((disp = get_user_var(dat->disp)))
-		    disp--;
-	    /* Get the contents of the completion variables if we have
-	     * to perform matching. */
-	    if (dat->aflags & CAF_MATCH) {
-		lipre = dupstring(compiprefix);
-		lisuf = dupstring(compisuffix);
-		lpre = dupstring(compprefix);
-		lsuf = dupstring(compsuffix);
-		llpl = strlen(lpre);
-		llsl = strlen(lsuf);
-		/* Test if there is an existing -P prefix. */
-		if (dat->pre && *dat->pre) {
-		    char *dp = rembslash(dat->pre);
-
-		    pl = pfxlen(dp, lpre);
-		    llpl -= pl;
-		    lpre += pl;
-		}
-	    }
-	    /* Now duplicate the strings we have from the command line. */
-	    if (dat->ipre)
-		dat->ipre = (lipre ? dyncat(lipre, dat->ipre) :
-			     dupstring(dat->ipre));
-	    else if (lipre)
-		dat->ipre = lipre;
-	    if (dat->isuf)
-		dat->isuf = (lisuf ? dyncat(lisuf, dat->isuf) :
-			     dupstring(dat->isuf));
-	    else if (lisuf)
-		dat->isuf = lisuf;
-	    if (dat->ppre) {
-		if (!(dat->aflags & CAF_QUOTE)) {
-		    dat->ppre = quotename(dat->ppre, NULL);
-		    if ((dat->flags & CMF_FILE) &&
-			dat->ppre[0] == '\\' && dat->ppre[1] == '~')
-			chuck(dat->ppre);
-		} else
-		    dat->ppre = dupstring(dat->ppre);
-		lpl = strlen(dat->ppre);
-	    } else
-		lpl = 0;
-	    if (dat->psuf) {
-		if (!(dat->aflags & CAF_QUOTE))
-		    dat->psuf = quotename(dat->psuf, NULL);
-		else
-		    dat->psuf = dupstring(dat->psuf);
-		lsl = strlen(dat->psuf);
-	    } else
-		lsl = 0;
-	    if (dat->aflags & CAF_MATCH) {
-		int ml;
-
-		s = dat->ppre ? dat->ppre : "";
-		if ((ml = match_str(lpre, s, &bpl, 0, NULL, 0, 0, 1)) >= 0) {
-		    if (matchsubs) {
-			Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, 0);
-
-			tmp->prefix = matchsubs;
-			if (matchlastpart)
-			    matchlastpart->next = tmp;
-			else
-			    matchparts = tmp;
-		    }
-		    pline = matchparts;
-		    lpre += ml;
-		    bcp = ml;
-		    bpadd = strlen(s) - ml;
-		} else {
-		    if (llpl <= lpl && strpfx(lpre, s))
-			lpre = "";
-		    else if (llpl > lpl && strpfx(s, lpre))
-			lpre += lpl;
-		    else
-			*argv = NULL;
-		    bcp = lpl;
-		}
-
-		s = dat->psuf ? dat->psuf : "";
-		if ((ml = match_str(lsuf, s, &bsl, 0, NULL, 1, 0, 1)) >= 0) {
-		    if (matchsubs) {
-			Cline tmp = get_cline(NULL, 0, NULL, 0, NULL, 0, CLF_SUF);
-
-			tmp->suffix = matchsubs;
-			if (matchlastpart)
-			    matchlastpart->next = tmp;
-			else
-			    matchparts = tmp;
-		    }
-		    sline = revert_cline(matchparts);
-		    lsuf[llsl - ml] = '\0';
-		    bcs = ml;
-		    bsadd = strlen(s) - ml;
-		} else {
-		    if (llsl <= lsl && strsfx(lsuf, s))
-			lsuf = "";
-		    else if (llsl > lsl && strsfx(s, lsuf))
-			lsuf[llsl - lsl] = '\0';
-		    else
-			*argv = NULL;
-		    bcs = lsl;
-		}
-		if (comppatmatch && *comppatmatch) {
-		    int is = (*comppatmatch == '*');
-		    char *tmp = (char *) zhalloc(2 + llpl + llsl);
-
-		    strcpy(tmp, lpre);
-		    tmp[llpl] = 'x';
-		    strcpy(tmp + llpl + is, lsuf);
-
-		    tokenize(tmp);
-		    remnulargs(tmp);
-		    if (haswilds(tmp)) {
-			if (is)
-			    tmp[llpl] = Star;
-			if ((cp = patcompile(tmp, 0, NULL)))
-			    haspattern = 1;
-		    }
-		}
-	    }
-	    if (*argv) {
-		if (dat->pre)
-		    dat->pre = dupstring(dat->pre);
-		if (dat->suf)
-		    dat->suf = dupstring(dat->suf);
-		if (!dat->prpre && (dat->prpre = oppre)) {
-		    singsub(&(dat->prpre));
-		    untokenize(dat->prpre);
-		} else
-		    dat->prpre = dupstring(dat->prpre);
-		/* Select the group in which to store the matches. */
-		gflags = (((dat->aflags & CAF_NOSORT ) ? CGF_NOSORT  : 0) |
-			  ((dat->aflags & CAF_UNIQALL) ? CGF_UNIQALL : 0) |
-			  ((dat->aflags & CAF_UNIQCON) ? CGF_UNIQCON : 0));
-		if (dat->group) {
-		    endcmgroup(NULL);
-		    begcmgroup(dat->group, gflags);
-		} else {
-		    endcmgroup(NULL);
-		    begcmgroup("default", 0);
-		}
-		if (dat->ylist) {
-		    endcmgroup(NULL);
-		    begcmgroup(NULL, gflags);
-		}
-		/* Select the set of matches. */
-		oisalt = (dat->aflags & CAF_ALT);
-
-		if (dat->remf) {
-		    dat->remf = dupstring(dat->remf);
-		    dat->rems = NULL;
-		} else if (dat->rems)
-		    dat->rems = dupstring(dat->rems);
-	    }
-	    /* Walk through the matches given. */
-	    obpl = bpl;
-	    obsl = bsl;
-	    for (; (s = *argv); argv++) {
-		bpl = obpl;
-		bsl = obsl;
-		if (disp) {
-		    if (!*++disp)
-			disp = NULL;
-		}
-		sl = strlen(s);
-		isalt = oisalt;
-		if ((!dat->psuf || !*(dat->psuf)) && aign) {
-		    /* Do the suffix-test. If the match has one of the
-		     * suffixes from ign, we put it in the alternate set. */
-		    char **pt = aign;
-		    int filell;
-
-		    for (isalt = 0; !isalt && *pt; pt++)
-			if ((filell = strlen(*pt)) < sl
-			    && !strcmp(*pt, s + sl - filell))
-			    isalt = 1;
-
-		    if (isalt && !doadd) {
-			if (dparr && !*++dparr)
-			    dparr = NULL;
-			continue;
-		    }
-		}
-		if (!(dat->aflags & CAF_MATCH)) {
-		    if (dat->aflags & CAF_QUOTE)
-			ms = dupstring(s);
-		    else
-			sl = strlen(ms = quotename(s, NULL));
-		    lc = bld_parts(ms, sl, -1, NULL);
-		    isexact = 0;
-		} else if (!(ms = comp_match(lpre, lsuf, s, cp, &lc,
-					     (!(dat->aflags & CAF_QUOTE) ?
-					      ((dat->ppre && dat->ppre) ||
-					       !(dat->flags & CMF_FILE) ? 1 : 2) : 0),
-					     &bpl, bcp, &bsl, bcs,
-					     &isexact))) {
-		    if (dparr && !*++dparr)
-			dparr = NULL;
-		    continue;
-		}
-		if (doadd) {
-		    Brinfo bp;
-
-		    for (bp = obpl; bp; bp = bp->next)
-			bp->curpos += bpadd;
-		    for (bp = obsl; bp; bp = bp->next)
-			bp->curpos += bsadd;
-
-		    if ((cm = add_match_data(isalt, ms, lc, dat->ipre, NULL,
-					     dat->isuf, dat->pre, dat->prpre,
-					     dat->ppre, pline,
-					     dat->psuf, sline,
-					     dat->suf, dat->flags, isexact))) {
-			cm->rems = dat->rems;
-			cm->remf = dat->remf;
-			if (disp)
-			    cm->disp = dupstring(*disp);
-		    }
-		} else {
-		    if (dat->apar)
-			addlinknode(aparl, ms);
-		    if (dat->opar)
-			addlinknode(oparl, s);
-		    if (dat->dpar && dparr) {
-			addlinknode(dparl, *dparr);
-			if (!*++dparr)
-			    dparr = NULL;
-		    }
-		    free_cline(lc);
-		}
-	    }
-	    if (dat->apar)
-		set_list_array(dat->apar, aparl);
-	    if (dat->opar)
-		set_list_array(dat->opar, oparl);
-	    if (dat->dpar)
-		set_list_array(dat->dpar, dparl);
-	    if (dat->ylist) {
-		if (dat->group) {
-		    endcmgroup(get_user_var(dat->ylist));
-		    begcmgroup(dat->group, gflags);
-		    if (dat->exp)
-			addexpl();
-		} else {
-		    if (dat->exp)
-			addexpl();
-		    endcmgroup(get_user_var(dat->ylist));
-		    begcmgroup("default", 0);
-		}
-	    } else if (dat->exp)
-		addexpl();
-	} LASTALLOC;
-    } SWITCHBACKHEAPS;
-
-    /* We switched back to the current heap, now restore the stack of
-     * matchers. */
-    mstack = oms;
-
-    instring = ois;
-    inbackt = oib;
-    autoq = oaq;
-    zsfree(qipre);
-    zsfree(qisuf);
-    qipre = oqp;
-    qisuf = oqs;
-
-    if (mnum == nm)
-	haspattern = ohp;
-
-    return (mnum == nm);
-}
-
 /**/
 static int
 docompletion(char *s, int lst, int incmd)
 {
-    int ret = 0;
-
-    HEAPALLOC {
-	char *opm;
-	LinkNode n;
-
-	pushheap();
-
-	ainfo = fainfo = NULL;
-	matchers = newlinklist();
-
-	hasunqu = 0;
-	useline = (lst != COMP_LIST_COMPLETE);
-	useexact = isset(RECEXACT);
-	uselist = (useline ?
-		   ((isset(AUTOLIST) && !isset(BASHAUTOLIST)) ? 
-		    (isset(LISTAMBIGUOUS) ? 3 : 2) : 0) : 1);
-	zsfree(comppatmatch);
-	opm = comppatmatch = ztrdup(useglob ? "*" : "");
-	zsfree(comppatinsert);
-	comppatinsert = ztrdup("menu");
-	zsfree(compforcelist);
-	compforcelist = ztrdup("");
-	haspattern = 0;
-	complistmax = getiparam("LISTMAX");
-	zsfree(complastprompt);
-	complastprompt = ztrdup(((isset(ALWAYSLASTPROMPT) && zmult == 1) ||
-				(unset(ALWAYSLASTPROMPT) && zmult != 1)) ?
-				"yes" : "");
-	movetoend = ((cs == we || isset(ALWAYSTOEND)) ? 2 : 1);
-	showinglist = 0;
-	hasmatched = 0;
-	minmlen = 1000000;
-	maxmlen = -1;
-
-	/* Make sure we have the completion list and compctl. */
-	if (makecomplist(s, incmd, lst)) {
-	    /* Error condition: feeeeeeeeeeeeep(). */
-	    cs = 0;
-	    foredel(ll);
-	    inststr(origline);
-	    cs = origcs;
-	    clearlist = 1;
-	    ret = 1;
-	    minfo.cur = NULL;
-	    goto compend;
-	}
-	zsfree(lastprebr);
-	zsfree(lastpostbr);
-	lastprebr = lastpostbr = NULL;
-
-	if (comppatmatch && *comppatmatch && comppatmatch != opm)
-	    haspattern = 1;
-	if (!useline && uselist) {
-	    /* All this and the guy only wants to see the list, sigh. */
-	    cs = 0;
-	    foredel(ll);
-	    inststr(origline);
-	    cs = origcs;
-	    showinglist = -2;
-	} else if (useline == 2 && nmatches > 1) {
-	    int first = 1, nm = nmatches;
-	    Cmatch *mc;
-
-	    menucmp = 1;
-	    menuacc = 0;
-
-	    for (minfo.group = amatches;
-		 minfo.group && !(minfo.group)->mcount;
-		 minfo.group = (minfo.group)->next);
-
-	    mc = (minfo.group)->matches;
-
-	    while (1) {
-		if (!first)
-		    acceptlast();
-		first = 0;
-
-		if (!--nm)
-		    menucmp = 0;
-
-		do_single(*mc);
-		minfo.cur = mc;
-
-		if (!*++(minfo.cur)) {
-		    do {
-			if (!(minfo.group = (minfo.group)->next))
-			    break;
-		    } while (!(minfo.group)->mcount);
-		    if (!minfo.group)
-			break;
-		    minfo.cur = minfo.group->matches;
-		}
-		mc = minfo.cur;
-	    }
-	    menucmp = 0;
-	    minfo.cur = NULL;
-
-	    if (compforcelist && *compforcelist && uselist)
-		showinglist = -2;
-	    else
-		invalidatelist();
-	} else if (useline) {
-	    /* We have matches. */
-	    if (nmatches > 1) {
-		/* There is more than one match. */
-		ret = do_ambiguous();
-	    } else if (nmatches == 1) {
-		/* Only one match. */
-		Cmgroup m = amatches;
-
-		while (!m->mcount)
-		    m = m->next;
-		minfo.cur = NULL;
-		minfo.asked = 0;
-		do_single(m->matches[0]);
-		if (compforcelist && *compforcelist) {
-		    if (uselist)
-			showinglist = -2;
-		    else
-			clearlist = 1;
-		} else
-		    invalidatelist();
-	    }
-	} else {
-	    invalidatelist();
-	    if (compforcelist && *compforcelist)
-		clearlist = 1;
-	    cs = 0;
-	    foredel(ll);
-	    inststr(origline);
-	    cs = origcs;
-	}
-	/* Print the explanation strings if needed. */
-	if (!showinglist && validlist && usemenu != 2 && nmatches != 1 &&
-	    useline != 2 && (!oldlist || !listshown)) {
-	    onlyexpl = 1;
-	    showinglist = -2;
-	}
-      compend:
-	for (n = firstnode(matchers); n; incnode(n))
-	    freecmatcher((Cmatcher) getdata(n));
-
-	ll = strlen((char *)line);
-	if (cs > ll)
-	    cs = ll;
-	popheap();
-    } LASTALLOC;
-    return ret;
-}
-
-/* This calls the given function for new style completion. */
-
-/**/
-static void
-callcompfunc(char *s, char *fn)
-{
-    List list;
-    int lv = lastval;
-    char buf[20];
-
-    if ((list = getshfunc(fn)) != &dummy_list) {
-	char **p, *tmp;
-	int aadd = 0, usea = 1, icf = incompfunc, osc = sfcontext;
-	unsigned int rset, kset;
-	Param *ocrpms = comprpms, *ockpms = compkpms;
-
-	comprpms = (Param *) zalloc(CP_REALPARAMS * sizeof(Param));
-	compkpms = (Param *) zalloc(CP_KEYPARAMS * sizeof(Param));
-
-	rset = CP_ALLREALS;
-	kset = CP_ALLKEYS &
-	    ~(CP_PARAMETER | CP_REDIRECT | CP_QUOTE | CP_QUOTING |
-	      CP_EXACTSTR | CP_FORCELIST | CP_OLDLIST | CP_OLDINS |
-	      (useglob ? 0 : CP_PATMATCH));
-	zsfree(compvared);
-	if (varedarg) {
-	    compvared = ztrdup(varedarg);
-	    kset |= CP_VARED;
-	} else
-	    compvared = ztrdup("");
-	if (!*complastprompt)
-	    kset &= ~CP_LASTPROMPT;
-	zsfree(compcontext);
-	zsfree(compparameter);
-	zsfree(compredirect);
-	compparameter = compredirect = "";
-	if (ispar)
-	    compcontext = (ispar == 2 ? "brace_parameter" : "parameter");
-	else if (linwhat == IN_MATH) {
-	    if (insubscr) {
-		compcontext = "subscript";
-		if (varname) {
-		    compparameter = varname;
-		    kset |= CP_PARAMETER;
-		}
-	    } else
-		compcontext = "math";
-	    usea = 0;
-	} else if (lincmd) {
-	    if (insubscr) {
-		compcontext = "subscript";
-		kset |= CP_PARAMETER;
-	    } else
-		compcontext = "command";
-	} else if (linredir) {
-	    compcontext = "redirect";
-	    if (rdstr)
-		compredirect = rdstr;
-	    kset |= CP_REDIRECT;
-	} else
-	    switch (linwhat) {
-	    case IN_ENV:
-		compcontext = (linarr ? "array_value" : "value");
-		compparameter = varname;
-		kset |= CP_PARAMETER;
-		if (!clwpos) {
-		    clwpos = 1;
-		    clwnum = 2;
-		    zsfree(clwords[1]);
-		    clwords[1] = ztrdup(s);
-		    zsfree(clwords[2]);
-		    clwords[2] = NULL;
-		}
-		aadd = 1;
-		break;
-	    case IN_COND:
-		compcontext = "condition";
-		break;
-	    default:
-		if (cmdstr)
-		    compcontext = "command";
-		else {
-		    compcontext = "value";
-		    kset |= CP_PARAMETER;
-		    if (clwords[0])
-			compparameter = clwords[0];
-		    aadd = 1;
-		}
-	    }
-	compcontext = ztrdup(compcontext);
-	if (compwords)
-	    freearray(compwords);
-	if (usea && (!aadd || clwords[0])) {
-	    char **q;
-
-	    PERMALLOC {
-		q = compwords = (char **)
-		    zalloc((clwnum + 1) * sizeof(char *));
-		for (p = clwords + aadd; *p; p++, q++) {
-		    tmp = dupstring(*p);
-		    untokenize(tmp);
-		    *q = ztrdup(tmp);
-		}
-		*q = NULL;
-	    } LASTALLOC;
-	} else
-	    compwords = (char **) zcalloc(sizeof(char *));
-
-	compparameter = ztrdup(compparameter);
-	compredirect = ztrdup(compredirect);
-	zsfree(compquote);
-	zsfree(compquoting);
-	if (instring) {
-	    if (instring == 1) {
-		compquote = ztrdup("\'");
-		compquoting = ztrdup("single");
-	    } else {
-		compquote = ztrdup("\"");
-		compquoting = ztrdup("double");
-	    }
-	    kset |= CP_QUOTE | CP_QUOTING;
-	} else if (inbackt) {
-	    compquote = ztrdup("`");
-	    compquoting = ztrdup("backtick");
-	    kset |= CP_QUOTE | CP_QUOTING;
-	} else {
-	    compquote = ztrdup("");
-	    compquoting = ztrdup("");
-	}
-	zsfree(compprefix);
-	zsfree(compsuffix);
-	if (unset(COMPLETEINWORD)) {
-	    tmp = quotename(s, NULL);
-	    untokenize(tmp);
-	    compprefix = ztrdup(tmp);
-	    compsuffix = ztrdup("");
-	} else {
-	    char *ss, sav;
-	    
-	    ss = s + offs;
-
-	    sav = *ss;
-	    *ss = '\0';
-	    tmp = quotename(s, NULL);
-	    untokenize(tmp);
-	    compprefix = ztrdup(tmp);
-	    *ss = sav;
-	    ss = quotename(ss, NULL);
-	    untokenize(ss);
-	    compsuffix = ztrdup(ss);
-	}
-	zsfree(compiprefix);
-	compiprefix = ztrdup("");
-	zsfree(compisuffix);
-	compisuffix = ztrdup("");
-	zsfree(compqiprefix);
-	compqiprefix = ztrdup(qipre ? qipre : "");
-	zsfree(compqisuffix);
-	compqisuffix = ztrdup(qisuf ? qisuf : "");
-	compcurrent = (usea ? (clwpos + 1 - aadd) : 0);
-
-	zsfree(complist);
-	switch (uselist) {
-	case 0: complist = ""; kset &= ~CP_LIST; break;
-	case 1: complist = "list"; break;
-	case 2: complist = "autolist"; break;
-	case 3: complist = "ambiguous"; break;
-	}
-	complist = ztrdup(complist);
-	zsfree(compinsert);
-	if (useline) {
-	    switch (usemenu) {
-	    case 0: compinsert = "unambiguous"; break;
-	    case 1: compinsert = "menu"; break;
-	    case 2: compinsert = "automenu"; break;
-	    }
-	} else {
-	    compinsert = "";
-	    kset &= ~CP_INSERT;
-	}
-	compinsert = ztrdup(compinsert);
-	if (useexact)
-	    compexact = ztrdup("accept");
-	else {
-	    compexact = ztrdup("");
-	    kset &= ~CP_EXACT;
-	}
-	zsfree(comptoend);
-	if (movetoend == 1)
-	    comptoend = ztrdup("single");
-	else
-	    comptoend = ztrdup("match");
-	zsfree(compoldlist);
-	zsfree(compoldins);
-	if (hasoldlist && lastpermmnum) {
-	    if (listshown)
-		compoldlist = "shown";
-	    else
-		compoldlist = "yes";
-	    kset |= CP_OLDLIST;
-	    if (minfo.cur) {
-		sprintf(buf, "%d", (*(minfo.cur))->gnum);
-		compoldins = buf;
-		kset |= CP_OLDINS;
-	    } else
-		compoldins = "";
-	} else
-	    compoldlist = compoldins = "";
-	compoldlist = ztrdup(compoldlist);
-	compoldins = ztrdup(compoldins);
-
-	incompfunc = 1;
-	startparamscope();
-	makecompparamsptr();
-	comp_setunsetptr(rset, (~rset & CP_ALLREALS),
-			 kset, (~kset & CP_ALLKEYS));
-	makezleparams(1);
-	sfcontext = SFC_CWIDGET;
-	NEWHEAPS(compheap) {
-	    LinkList largs = NULL;
-	    int olv = lastval;
-
-	    if (*cfargs) {
-		char **p = cfargs;
-
-		largs = newlinklist();
-		addlinknode(largs, dupstring(fn));
-		while (*p)
-		    addlinknode(largs, dupstring(*p++));
-	    }
-	    doshfunc(fn, list, largs, 0, 0);
-	    cfret = lastval;
-	    lastval = olv;
-	} OLDHEAPS;
-	sfcontext = osc;
-	endparamscope();
-	lastcmd = 0;
-	incompfunc = icf;
-
-	if (!complist)
-	    uselist = 0;
-	else if (!strncmp(complist, "list", 4))
-	    uselist = 1;
-	else if (!strncmp(complist, "auto", 4))
-	    uselist = 2;
-	else if (!strncmp(complist, "ambig", 5))
-	    uselist = 3;
-	else
-	    uselist = 0;
-
-	onlyexpl = (complist && strstr(complist, "expl"));
-
-	if (!compinsert)
-	    useline = 0;
-	else if (!strcmp(compinsert, "unambig") ||
-		 !strcmp(compinsert, "unambiguous"))
-	    useline = 1, usemenu = 0;
-	else if (!strcmp(compinsert, "menu"))
-	    useline = 1, usemenu = 1;
-	else if (!strcmp(compinsert, "auto") ||
-		 !strcmp(compinsert, "automenu"))
-	    useline = 1, usemenu = 2;
-	else if (!strcmp(compinsert, "all"))
-	    useline = 2, usemenu = 0;
-	else if (idigit(*compinsert)) {
-	    char *m;
-
-	    useline = 1; usemenu = 3;
-	    insmnum = atoi(compinsert);
-	    if ((m = strchr(compinsert, ':'))) {
-		insgroup = 1;
-		insgnum = atoi(m + 1);
-	    }
-	    insspace = (compinsert[strlen(compinsert) - 1] == ' ');
-	} else
-	    useline = usemenu = 0;
-	useexact = (compexact && !strcmp(compexact, "accept"));
-
-	if (!comptoend || !*comptoend)
-	    movetoend = 0;
-	else if (!strcmp(comptoend, "single"))
-	    movetoend = 1;
-	else if (!strcmp(comptoend, "always"))
-	    movetoend = 3;
-	else
-	    movetoend = 2;
-
-	oldlist = (hasoldlist && compoldlist && !strcmp(compoldlist, "keep"));
-	oldins = (hasoldlist && minfo.cur &&
-		  compoldins && !strcmp(compoldins, "keep"));
-
-	zfree(comprpms, CP_REALPARAMS * sizeof(Param));
-	zfree(compkpms, CP_KEYPARAMS * sizeof(Param));
-	comprpms = ocrpms;
-	compkpms = ockpms;
-    }
-    lastval = lv;
-}
-
-/* Create the completion list.  This is called whenever some bit of   *
- * completion code needs the list.                                    *
- * Along with the list is maintained the prefixes/suffixes etc.  When *
- * any of this becomes invalid -- e.g. if some text is changed on the *
- * command line -- invalidatelist() should be called, to set          *
- * validlist to zero and free up the memory used.  This function      *
- * returns non-zero on error.                                         */
-
-/**/
-static int
-makecomplist(char *s, int incmd, int lst)
-{
-    struct cmlist ms;
-    Cmlist m;
-    char *p, *os = s;
-    int onm = nmatches, osi = movefd(0);
-
-    /* Inside $... ? */
-    if (compfunc && (p = check_param(s, 0, 0)))
-	os = s = p;
-
-    /* We build a copy of the list of matchers to use to make sure that this
-     * works even if a shell function called from the completion code changes
-     * the global matchers. */
-
-    if ((m = cmatcher)) {
-	Cmlist mm, *mp = &mm;
-	int n;
-
-	for (n = 0; m; m = m->next, n++) {
-	    if (m->matcher) {
-		*mp = (Cmlist) zhalloc(sizeof(struct cmlist));
-		(*mp)->matcher = m->matcher;
-		(*mp)->next = NULL;
-		(*mp)->str = dupstring(m->str);
-		mp = &((*mp)->next);
-		addlinknode(matchers, m->matcher);
-		m->matcher->refc++;
-	    }
-	}
-	m = mm;
-	compmatcher = 1;
-	compmatchertot = n;
-    } else
-	compmatcher = 0;
-
-    linwhat = inwhat;
-
-    /* Walk through the global matchers. */
-    for (;;) {
-	bmatchers = NULL;
-	zsfree(compmatcherstr);
-	if (m) {
-	    ms.next = NULL;
-	    ms.matcher = m->matcher;
-	    mstack = &ms;
-
-	    /* Store the matchers used in the bmatchers list which is used
-	     * when building new parts for the string to insert into the 
-	     * line. */
-	    add_bmatchers(m->matcher);
-	    compmatcherstr = ztrdup(m->str);
-	} else {
-	    mstack = NULL;
-	    compmatcherstr = ztrdup("");
-	}
-	ainfo = (Aminfo) hcalloc(sizeof(struct aminfo));
-	fainfo = (Aminfo) hcalloc(sizeof(struct aminfo));
-
-	freecl = NULL;
-
-	if (!validlist)
-	    lastambig = 0;
-	amatches = NULL;
-	mnum = 0;
-	unambig_mnum = -1;
-	isuf = NULL;
-	insmnum = insgnum = 1;
-	insgroup = oldlist = oldins = 0;
-	begcmgroup("default", 0);
-	menucmp = menuacc = newmatches = onlyexpl = 0;
-
-	runhookdef(COMPCTLBEFOREHOOK, NULL);
-
-	s = dupstring(os);
-	if (compfunc)
-	    callcompfunc(s, compfunc);
-	else {
-	    struct ccmakedat dat;
-
-	    dat.str = s;
-	    dat.incmd = incmd;
-	    dat.lst = lst;
-	    runhookdef(COMPCTLMAKEHOOK, (void *) &dat);
-	}
-	endcmgroup(NULL);
-
-	runhookdef(COMPCTLAFTERHOOK,
-		   (void *) ((amatches && !oldlist) ? 1L : 0L));
-
-	if (oldlist) {
-	    nmatches = onm;
-	    validlist = 1;
-	    amatches = lastmatches;
-	    lmatches = lastlmatches;
-	    if (pmatches) {
-		freematches(pmatches);
-		pmatches = NULL;
-		hasperm = 0;
-	    }
-	    redup(osi, 0);
-
-	    return 0;
-	}
-	PERMALLOC {
-	    if (lastmatches) {
-		freematches(lastmatches);
-		lastmatches = NULL;
-	    }
-	    permmatches(1);
-	    amatches = pmatches;
-	    lastpermmnum = permmnum;
-	    lastpermgnum = permgnum;
-	} LASTALLOC;
-
-	lastmatches = pmatches;
-	lastlmatches = lmatches;
-	pmatches = NULL;
-	hasperm = 0;
-	hasoldlist = 1;
-
-	if (nmatches && !errflag) {
-	    validlist = 1;
-
-	    redup(osi, 0);
-
-	    return 0;
-	}
-	if (!m || !(m = m->next))
-	    break;
+    struct compldat dat;
 
-	errflag = 0;
-	compmatcher++;
-    }
-    redup(osi, 0);
-    return 1;
-}
-
-/* This should probably be moved into tokenize(). */
+    dat.s = s;
+    dat.lst = lst;
+    dat.incmd = incmd;
 
-/**/
-static char *
-ctokenize(char *p)
-{
-    char *r = p;
-    int bslash = 0;
-
-    tokenize(p);
-
-    for (p = r; *p; p++) {
-	if (*p == '\\')
-	    bslash = 1;
-	else {
-	    if (*p == '$' || *p == '{' || *p == '}') {
-		if (bslash)
-		    p[-1] = Bnull;
-		else
-		    *p = (*p == '$' ? String :
-			  (*p == '{' ? Inbrace : Outbrace));
-	    }
-	    bslash = 0;
-	}
-    }
-    return r;
+    return runhookdef(COMPLETEHOOK, (void *) &dat);
 }
 
-/**/
-char *
-comp_str(int *ipl, int *pl, int untok)
-{
-    char *p = dupstring(compprefix);
-    char *s = dupstring(compsuffix);
-    char *ip = dupstring(compiprefix);
-    char *str;
-    int lp, ls, lip;
-
-    if (!untok) {
-	ctokenize(p);
-	remnulargs(p);
-	ctokenize(s);
-	remnulargs(s);
-    }
-    lp = strlen(p);
-    ls = strlen(s);
-    lip = strlen(ip);
-    str = zhalloc(lip + lp + ls + 1);
-    strcpy(str, ip);
-    strcat(str, p);
-    strcat(str, s);
-
-    if (ipl)
-	*ipl = lip;
-    if (pl)
-	*pl = lp;
-
-    return str;
-}
+/* Return the length of the common prefix of s and t. */
 
 /**/
 int
-set_comp_sep(void)
+pfxlen(char *s, char *t)
 {
-    int lip, lp;
-    char *s = comp_str(&lip, &lp, 0);
-    LinkList foo = newlinklist();
-    LinkNode n;
-    int owe = we, owb = wb, ocs = cs, swb, swe, scs, soffs, ne = noerrs;
-    int tl, got = 0, i = 0, cur = -1, oll = ll, sl;
-    int ois = instring, oib = inbackt, noffs = lip + lp;
-    char *tmp, *p, *ns, *ol = (char *) line, sav, oaq = autoq, *qp, *qs;
-
-    if (compisuffix)
-	s = dyncat(s, compisuffix);
-    untokenize(s);
-
-    swb = swe = soffs = 0;
-    ns = NULL;
-
-    /* Put the string in the lexer buffer and call the lexer to *
-     * get the words we have to expand.                        */
-    zleparse = 1;
-    addedx = 1;
-    noerrs = 1;
-    lexsave();
-    tmp = (char *) zhalloc(tl = 3 + strlen(s));
-    tmp[0] = ' ';
-    memcpy(tmp + 1, s, noffs);
-    tmp[(scs = cs = 1 + noffs)] = 'x';
-    strcpy(tmp + 2 + noffs, s + noffs);
-    tmp = rembslash(tmp);
-    inpush(dupstrspace(tmp), 0, NULL);
-    line = (unsigned char *) tmp;
-    ll = tl - 1;
-    strinbeg(0);
-    noaliases = 1;
-    do {
-	ctxtlex();
-	if (tok == LEXERR) {
-	    int j;
-
-	    if (!tokstr)
-		break;
-	    for (j = 0, p = tokstr; *p; p++)
-		if (*p == Snull || *p == Dnull)
-		    j++;
-	    if (j & 1) {
-		tok = STRING;
-		if (p > tokstr && p[-1] == ' ')
-		    p[-1] = '\0';
-	    }
-	}
-	if (tok == ENDINPUT || tok == LEXERR)
-	    break;
-	if (tokstr && *tokstr)
-	    addlinknode(foo, (p = ztrdup(tokstr)));
-	else
-	    p = NULL;
-	if (!got && !zleparse) {
-	    DPUTS(!p, "no current word in substr");
-	    got = 1;
-	    cur = i;
-	    swb = wb - 1;
-	    swe = we - 1;
-	    soffs = cs - swb;
-	    chuck(p + soffs);
-	    ns = dupstring(p);
-	}
-	i++;
-    } while (tok != ENDINPUT && tok != LEXERR);
-    noaliases = 0;
-    strinend();
-    inpop();
-    errflag = zleparse = 0;
-    noerrs = ne;
-    lexrestore();
-    wb = owb;
-    we = owe;
-    cs = ocs;
-    line = (unsigned char *) ol;
-    ll = oll;
-    if (cur < 0 || i < 1)
-	return 1;
-    owb = offs;
-    offs = soffs;
-    if ((p = check_param(ns, 0, 1))) {
-	for (p = ns; *p; p++)
-	    if (*p == Dnull)
-		*p = '"';
-	    else if (*p == Snull)
-		*p = '\'';
-    }
-    offs = owb;
-    if (*ns == Snull || *ns == Dnull) {
-	instring = (*ns == Snull ? 1 : 2);
-	inbackt = 0;
-	swb++;
-	if (ns[strlen(ns) - 1] == *ns && ns[1])
-	    swe--;
-	autoq = (*ns == Snull ? '\'' : '"');
-    } else {
-	instring = 0;
-	autoq = '\0';
-    }
-    for (p = ns, i = swb; *p; p++, i++) {
-	if (INULL(*p)) {
-	    if (i < scs)
-		soffs--;
-	    if (p[1] || *p != Bnull) {
-		if (*p == Bnull) {
-		    if (scs == i + 1)
-			scs++, soffs++;
-		} else {
-		    if (scs > i--)
-			scs--;
-		}
-	    } else {
-		if (scs == swe)
-		    scs--;
-	    }
-	    chuck(p--);
-	}
-    }
-    sav = s[(i = swb - 1)];
-    s[i] = '\0';
-    qp = tricat(qipre, rembslash(s), "");
-    s[i] = sav;
-    if (swe < swb)
-	swe = swb;
-    swe--;
-    sl = strlen(s);
-    if (swe > sl)
-	swe = sl, ns[swe - swb + 1] = '\0';
-    qs = tricat(rembslash(s + swe), qisuf, "");
-    sl = strlen(ns);
-    if (soffs > sl)
-	soffs = sl;
-
-    {
-	int set = CP_QUOTE | CP_QUOTING, unset = 0;
-
-	zsfree(compquote);
-	zsfree(compquoting);
-	if (instring == 2) {
-	    compquote = "\"";
-	    compquoting = "double";
-	} else if (instring == 1) {
-	    compquote = "'";
-	    compquoting = "single";
-	} else {
-	    compquote = compquoting = "";
-	    unset = set;
-	    set = 0;
-	}
-	compquote = ztrdup(compquote);
-	compquoting = ztrdup(compquoting);
-	comp_setunsetptr(0, 0, set, unset);
-
-	if (unset(COMPLETEINWORD)) {
-	    untokenize(ns);
-	    zsfree(compprefix);
-	    compprefix = ztrdup(ns);
-	    zsfree(compsuffix);
-	    compsuffix = ztrdup("");
-	} else {
-	    char *ss, sav;
-	    
-	    ss = ns + soffs;
-
-	    sav = *ss;
-	    *ss = '\0';
-	    untokenize(ns);
-	    compprefix = ztrdup(ns);
-	    *ss = sav;
-	    untokenize(ss);
-	    compsuffix = ztrdup(ss);
-	}
-	zsfree(compiprefix);
-	compiprefix = ztrdup("");
-	zsfree(compisuffix);
-	compisuffix = ztrdup("");
-	zsfree(compqiprefix);
-	zsfree(compqisuffix);
-	if (ois) {
-	    compqiprefix = qp;
-	    compqisuffix = qs;
-	} else {
-	    compqiprefix = ztrdup(quotename(qp, NULL));
-	    zsfree(qp);
-	    compqisuffix = ztrdup(quotename(qs, NULL));
-	    zsfree(qs);
-	}
-	freearray(compwords);
-	i = countlinknodes(foo);
-	compwords = (char **) zalloc((i + 1) * sizeof(char *));
-	for (n = firstnode(foo), i = 0; n; incnode(n), i++) {
-	    p = compwords[i] = (char *) getdata(n);
-	    untokenize(p);
-	}
-	compcurrent = cur + 1;
-	compwords[i] = NULL;
-    }
-    autoq = oaq;
-    instring = ois;
-    inbackt = oib;
-
-    return 0;
-}
-
-/* Invalidate the completion list. */
+    int i = 0;
 
-/**/
-void
-invalidatelist(void)
-{
-    if (showinglist == -2)
-	listmatches();
-    if (validlist) {
-	freematches(lastmatches);
-	lastmatches = NULL;
-	hasoldlist = 0;
-    }
-    lastambig = menucmp = menuacc = validlist = showinglist = fromcomp = 0;
-    listdat.valid = 0;
-    if (listshown < 0)
-	listshown = 0;
-    minfo.cur = NULL;
-    minfo.asked = 0;
-    zsfree(minfo.prebr);
-    zsfree(minfo.postbr);
-    minfo.postbr = minfo.prebr = NULL;
-    compwidget = NULL;
+    while (*s && *s == *t)
+	s++, t++, i++;
+    return i;
 }
 
-/* Get the words from a variable or a compctl -k list. */
+/* Return the length of the common suffix of s and t. */
 
-/**/
-char **
-get_user_var(char *nam)
+#if 0
+static int
+sfxlen(char *s, char *t)
 {
-    if (!nam)
-	return NULL;
-    else if (*nam == '(') {
-	/* It's a (...) list, not a parameter name. */
-	char *ptr, *s, **uarr, **aptr;
-	int count = 0, notempty = 0, brk = 0;
-	LinkList arrlist = newlinklist();
-
-	ptr = dupstring(nam);
-	s = ptr + 1;
-	while (*++ptr) {
-	    if (*ptr == '\\' && ptr[1])
-		chuck(ptr), notempty = 1;
-	    else if (*ptr == ',' || inblank(*ptr) || *ptr == ')') {
-		if (*ptr == ')')
-		    brk++;
-		if (notempty) {
-		    *ptr = '\0';
-		    count++;
-		    if (*s == '\n')
-			s++;
-		    addlinknode(arrlist, s);
-		}
-		s = ptr + 1;
-		notempty = 0;
-	    } else {
-		notempty = 1;
-		if (*ptr == Meta)
-		    ptr++;
-	    }
-	    if (brk)
-		break;
-	}
-	if (!brk || !count)
-	    return NULL;
-	*ptr = '\0';
-	aptr = uarr = (char **) zhalloc(sizeof(char *) * (count + 1));
-
-	while ((*aptr++ = (char *)ugetnode(arrlist)));
-	uarr[count] = NULL;
-	return uarr;
-    } else {
-	/* Otherwise it should be a parameter name. */
-	char **arr = NULL, *val;
+    if (*s && *t) {
+	int i = 0;
+	char *s2 = s + strlen(s) - 1, *t2 = t + strlen(t) - 1;
 
-	if ((arr = getaparam(nam)) || (arr = gethparam(nam)))
-	    return (incompfunc ? arrdup(arr) : arr);
+	while (s2 >= s && t2 >= t && *s2 == *t2)
+	    s2--, t2--, i++;
 
-	if ((val = getsparam(nam))) {
-	    arr = (char **) zhalloc(2*sizeof(char *));
-	    arr[0] = (incompfunc ? dupstring(val) : val);
-	    arr[1] = NULL;
-	}
-	return arr;
-    }
+	return i;
+    } else
+	return 0;
 }
+#endif
 
 /* This is strcmp with ignoring backslashes. */
 
 /**/
-static int
+int
 strbpcmp(char **aa, char **bb)
 {
     char *a = *aa, *b = *bb;
@@ -5560,1966 +1738,123 @@ strbpcmp(char **aa, char **bb)
     return (int)(*a - *b);
 }
 
-/* The comparison function for matches (used for sorting). */
-
-static int
-matchcmp(Cmatch *a, Cmatch *b)
-{
-    if ((*a)->disp) {
-	if ((*b)->disp) {
-	    if ((*a)->flags & CMF_DISPLINE) {
-		if ((*b)->flags & CMF_DISPLINE)
-		    return strcmp((*a)->disp, (*b)->disp);
-		else
-		    return -1;
-	    } else {
-		if ((*b)->flags & CMF_DISPLINE)
-		    return 1;
-		else
-		    return strcmp((*a)->disp, (*b)->disp);
-	    }
-	}
-	return -1;
-    }
-    if ((*b)->disp)
-	return 1;
-
-    return strbpcmp(&((*a)->str), &((*b)->str));
-}
-
-/* This tests, whether two matches are equal (would produce the same  *
- * strings on the command line). */
-
-#define matchstreq(a, b) ((!(a) && !(b)) || ((a) && (b) && !strcmp((a), (b))))
-
-static int
-matcheq(Cmatch a, Cmatch b)
-{
-    return matchstreq(a->ipre, b->ipre) &&
-	matchstreq(a->pre, b->pre) &&
-	matchstreq(a->ppre, b->ppre) &&
-	matchstreq(a->psuf, b->psuf) &&
-	matchstreq(a->suf, b->suf) &&
-	((!a->disp && !b->disp && matchstreq(a->str, b->str)) ||
-	 (a->disp && b->disp && !strcmp(a->disp, b->disp) &&
-	  matchstreq(a->str, b->str)));
-}
-
-/* Make an array from a linked list. The second argument says whether *
- * the array should be sorted. The third argument is used to return   *
- * the number of elements in the resulting array. The fourth argument *
- * is used to return the number of NOLIST elements. */
-
-/**/
-static Cmatch *
-makearray(LinkList l, int type, int flags, int *np, int *nlp, int *llp)
-{
-    Cmatch *ap, *bp, *cp, *rp;
-    LinkNode nod;
-    int n, nl = 0, ll = 0;
-
-    /* Build an array for the matches. */
-    rp = ap = (Cmatch *) ncalloc(((n = countlinknodes(l)) + 1) *
-				 sizeof(Cmatch));
-
-    /* And copy them into it. */
-    for (nod = firstnode(l); nod; incnode(nod))
-	*ap++ = (Cmatch) getdata(nod);
-    *ap = NULL;
-
-    if (!type) {
-	if (flags) {
-	    char **ap, **bp, **cp;
-
-	    /* Now sort the array (it contains strings). */
-	    qsort((void *) rp, n, sizeof(char *),
-		  (int (*) _((const void *, const void *)))strbpcmp);
-
-	    /* And delete the ones that occur more than once. */
-	    for (ap = cp = (char **) rp; *ap; ap++) {
-		*cp++ = *ap;
-		for (bp = ap; bp[1] && !strcmp(*ap, bp[1]); bp++, n--);
-		ap = bp;
-	    }
-	    *cp = NULL;
-	}
-    } else {
-	if (!(flags & CGF_NOSORT)) {
-	    /* Now sort the array (it contains matches). */
-	    qsort((void *) rp, n, sizeof(Cmatch),
-		  (int (*) _((const void *, const void *)))matchcmp);
-
-	    if (!(flags & CGF_UNIQCON)) {
-		/* And delete the ones that occur more than once. */
-		for (ap = cp = rp; *ap; ap++) {
-		    *cp++ = *ap;
-		    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
-		    ap = bp;
-		    /* Mark those, that would show the same string in the list. */
-		    for (; bp[1] && !(*ap)->disp && !(bp[1])->disp &&
-			     !strcmp((*ap)->str, (bp[1])->str); bp++)
-			(bp[1])->flags |= CMF_NOLIST;
-		}
-		*cp = NULL;
-	    }
-	    for (ap = rp; *ap; ap++) {
-		if ((*ap)->disp && ((*ap)->flags & CMF_DISPLINE))
-		    ll++;
-		if ((*ap)->flags & CMF_NOLIST)
-		    nl++;
-	    }
-	} else {
-	    if (!(flags & CGF_UNIQALL) && !(flags & CGF_UNIQCON)) {
-		for (ap = rp; *ap; ap++) {
-		    for (bp = cp = ap + 1; *bp; bp++) {
-			if (!matcheq(*ap, *bp))
-			    *cp++ = *bp;
-			else
-			    n--;
-		    }
-		    *cp = NULL;
-		}
-	    } else if (!(flags & CGF_UNIQCON)) {
-		for (ap = cp = rp; *ap; ap++) {
-		    *cp++ = *ap;
-		    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
-		    ap = bp;
-		    for (; bp[1] && !(*ap)->disp && !(bp[1])->disp &&
-			     !strcmp((*ap)->str, (bp[1])->str); bp++)
-			(bp[1])->flags |= CMF_NOLIST;
-		}
-		*cp = NULL;
-	    }
-	    for (ap = rp; *ap; ap++) {
-		if ((*ap)->disp && ((*ap)->flags & CMF_DISPLINE))
-		    ll++;
-		if ((*ap)->flags & CMF_NOLIST)
-		    nl++;
-	    }
-	}
-    }
-    if (np)
-	*np = n;
-    if (nlp)
-	*nlp = nl;
-    if (llp)
-	*llp = ll;
-    return rp;
-}
-
-/* This begins a new group of matches. */
-
-/**/
-static void
-begcmgroup(char *n, int flags)
-{
-    if (n) {
-	Cmgroup p = amatches;
-
-	while (p) {
-	    if (p->name &&
-		flags == (p->flags & (CGF_NOSORT|CGF_UNIQALL|CGF_UNIQCON)) &&
-		!strcmp(n, p->name)) {
-		mgroup = p;
-
-		expls = p->lexpls;
-		matches = p->lmatches;
-		fmatches = p->lfmatches;
-		allccs = p->lallccs;
-
-		return;
-	    }
-	    p = p->next;
-	}
-    }
-    mgroup = (Cmgroup) zhalloc(sizeof(struct cmgroup));
-    mgroup->name = dupstring(n);
-    mgroup->lcount = mgroup->llcount = mgroup->mcount = 0;
-    mgroup->flags = flags;
-    mgroup->matches = NULL;
-    mgroup->ylist = NULL;
-    mgroup->expls = NULL;
-
-    mgroup->lexpls = expls = newlinklist();
-    mgroup->lmatches = matches = newlinklist();
-    mgroup->lfmatches = fmatches = newlinklist();
-
-    mgroup->lallccs = allccs = ((flags & CGF_NOSORT) ? NULL : newlinklist());
-
-    mgroup->next = amatches;
-    amatches = mgroup;
-}
-
-/* End the current group for now. */
-
-/**/
-static void
-endcmgroup(char **ylist)
-{
-    mgroup->ylist = ylist;
-}
-
-/* Add an explanation string to the current group, joining duplicates. */
-
-/**/
-static void
-addexpl(void)
-{
-    LinkNode n;
-    Cexpl e;
-
-    for (n = firstnode(expls); n; incnode(n)) {
-	e = (Cexpl) getdata(n);
-	if (!strcmp(curexpl->str, e->str)) {
-	    e->count += curexpl->count;
-	    e->fcount += curexpl->fcount;
-
-	    return;
-	}
-    }
-    addlinknode(expls, curexpl);
-    newmatches = 1;
-}
-
-/* This duplicates one match. */
-
-/**/
-static Cmatch
-dupmatch(Cmatch m, int nbeg, int nend)
-{
-    Cmatch r;
-
-    r = (Cmatch) ncalloc(sizeof(struct cmatch));
-
-    r->str = ztrdup(m->str);
-    r->ipre = ztrdup(m->ipre);
-    r->ripre = ztrdup(m->ripre);
-    r->isuf = ztrdup(m->isuf);
-    r->ppre = ztrdup(m->ppre);
-    r->psuf = ztrdup(m->psuf);
-    r->prpre = ztrdup(m->prpre);
-    r->pre = ztrdup(m->pre);
-    r->suf = ztrdup(m->suf);
-    r->flags = m->flags;
-    if (nbeg) {
-	int *p, *q, i;
-
-	r->brpl = (int *) zalloc(nbeg * sizeof(int));
-
-	for (p = r->brpl, q = m->brpl, i = nbeg; i--; p++, q++)
-	    *p = *q;
-    } else
-	r->brpl = NULL;
-    if (nend) {
-	int *p, *q, i;
-
-	r->brsl = (int *) zalloc(nend * sizeof(int));
-
-	for (p = r->brsl, q = m->brsl, i = nend; i--; p++, q++)
-	    *p = *q;
-    } else
-	r->brsl = NULL;
-    r->rems = ztrdup(m->rems);
-    r->remf = ztrdup(m->remf);
-    r->autoq = m->autoq;
-    r->qipl = m->qipl;
-    r->qisl = m->qisl;
-    r->disp = dupstring(m->disp);
-
-    return r;
-}
-
-/* This duplicates all groups of matches. */
-
-/**/
-static int
-permmatches(int last)
-{
-    Cmgroup g = amatches, n;
-    Cmatch *p, *q;
-    Cexpl *ep, *eq, e, o;
-    LinkList mlist;
-    static int fi = 0;
-    int nn, nl, ll, gn = 1, mn = 1, rn;
-
-    if (pmatches && !newmatches)
-	return fi;
-
-    newmatches = fi = 0;
-
-    if (pmatches)
-	freematches(pmatches);
-
-    pmatches = lmatches = NULL;
-    nmatches = smatches = 0;
-
-    if (!ainfo->count) {
-	if (last)
-	    ainfo = fainfo;
-	fi = 1;
-    }
-    while (g) {
-	HEAPALLOC {
-	    if (empty(g->lmatches))
-		/* We have no matches, try ignoring fignore. */
-		mlist = g->lfmatches;
-	    else
-		mlist = g->lmatches;
-
-	    g->matches = makearray(mlist, 1, g->flags, &nn, &nl, &ll);
-	    g->mcount = nn;
-	    if ((g->lcount = nn - nl) < 0)
-		g->lcount = 0;
-	    g->llcount = ll;
-	    if (g->ylist) {
-		g->lcount = arrlen(g->ylist);
-		smatches = 2;
-	    }
-	    g->expls = (Cexpl *) makearray(g->lexpls, 0, 0, &(g->ecount),
-					   NULL, NULL);
-
-	    g->ccount = 0;
-	} LASTALLOC;
-
-	nmatches += g->mcount;
-	smatches += g->lcount;
-
-	n = (Cmgroup) ncalloc(sizeof(struct cmgroup));
-
-	if (!lmatches)
-	    lmatches = n;
-	if (pmatches)
-	    pmatches->prev = n;
-	n->next = pmatches;
-	pmatches = n;
-	n->prev = 0;
-	n->num = gn++;
-
-	n->flags = g->flags;
-	n->mcount = g->mcount;
-	n->matches = p = (Cmatch *) ncalloc((n->mcount + 1) *
-					    sizeof(Cmatch));
-	for (q = g->matches; *q; q++, p++)
-	    *p = dupmatch(*q, nbrbeg, nbrend);
-	*p = NULL;
-
-	n->lcount = g->lcount;
-	n->llcount = g->llcount;
-	if (g->ylist)
-	    n->ylist = arrdup(g->ylist);
-	else
-	    n->ylist = NULL;
-
-	if ((n->ecount = g->ecount)) {
-	    n->expls = ep = (Cexpl *) ncalloc((n->ecount + 1) *
-					      sizeof(Cexpl));
-	    for (eq = g->expls; (o = *eq); eq++, ep++) {
-		*ep = e = (Cexpl) ncalloc(sizeof(struct cexpl));
-		e->count = (fi ? o->fcount : o->count);
-		e->str = ztrdup(o->str);
-	    }
-	    *ep = NULL;
-	} else
-	    n->expls = NULL;
-
-	n->widths = NULL;
-
-	g = g->next;
-    }
-    for (g = pmatches; g; g = g->next) {
-	g->nbrbeg = nbrbeg;
-	g->nbrend = nbrend;
-	for (rn = 1, q = g->matches; *q; q++) {
-	    (*q)->rnum = rn++;
-	    (*q)->gnum = mn++;
-	}
-    }
-    hasperm = 1;
-    permmnum = mn - 1;
-    permgnum = gn - 1;
-    listdat.valid = 0;
-
-    return fi;
-}
-
-/* Return the real number of matches. */
-
-/**/
-zlong
-num_matches(int normal)
-{
-    int alt;
-
-    PERMALLOC {
-	alt = permmatches(0);
-    } LASTALLOC;
-
-    if (normal)
-	return (alt ? 0 : nmatches);
-    else
-	return (alt ? nmatches : 0);
-}
-
-/* Return the number of screen lines needed for the list. */
-
-/**/
-zlong
-list_lines(void)
-{
-    Cmgroup oam;
-
-    PERMALLOC {
-	permmatches(0);
-    } LASTALLOC;
-
-    oam = amatches;
-    amatches = pmatches;
-    listdat.valid = 0;
-    calclist();
-    listdat.valid = 0;
-    amatches = oam;
-
-    return listdat.nlines;
-}
-
-/**/
-void
-comp_list(char *v)
-{
-    zsfree(complist);
-    complist = ztrdup(v);
-
-    onlyexpl = (v && strstr(v, "expl"));
-}
-
-/**/
-
-/* This frees one match. */
-
-/**/
-static void
-freematch(Cmatch m, int nbeg, int nend)
-{
-    if (!m) return;
-
-    zsfree(m->str);
-    zsfree(m->ipre);
-    zsfree(m->ripre);
-    zsfree(m->isuf);
-    zsfree(m->ppre);
-    zsfree(m->psuf);
-    zsfree(m->pre);
-    zsfree(m->suf);
-    zsfree(m->prpre);
-    zsfree(m->rems);
-    zsfree(m->remf);
-    zsfree(m->disp);
-    zfree(m->brpl, nbeg * sizeof(int));
-    zfree(m->brsl, nend * sizeof(int));
-
-    zfree(m, sizeof(m));
-}
-
-/* This frees the groups of matches. */
-
-/**/
-void
-freematches(Cmgroup g)
-{
-    Cmgroup n;
-    Cmatch *m;
-    Cexpl *e;
-
-    while (g) {
-	n = g->next;
-	
-	for (m = g->matches; *m; m++)
-	    freematch(*m, g->nbrbeg, g->nbrend);
-
-	if (g->ylist)
-	    freearray(g->ylist);
-
-	if ((e = g->expls)) {
-	    while (*e) {
-		zsfree((*e)->str);
-		free(*e);
-		e++;
-	    }
-	    free(g->expls);
-	}
-	free(g);
-
-	g = n;
-    }
-}
-
-/* Insert the given string into the command line.  If move is non-zero, *
- * the cursor position is changed and len is the length of the string   *
- * to insert (if it is -1, the length is calculated here).              *
- * The last argument says if we should quote the string.                */
-
-/**/
-static int
-inststrlen(char *str, int move, int len)
-{
-    if (!len || !str)
-	return 0;
-    if (len == -1)
-	len = strlen(str);
-    spaceinline(len);
-    strncpy((char *)(line + cs), str, len);
-    if (move)
-	cs += len;
-    return len;
-}
-
-/* This cuts the cline list before the stuff that isn't worth
- * inserting in the line. */
-
-static Cline
-cut_cline(Cline l)
-{
-    Cline q, p, e = NULL, maxp = NULL;
-    int sum = 0, max = 0, tmp, ls = 0;
-
-    /* If no match was added with matching, we don't really know
-     * which parts of the unambiguous string are worth keeping,
-     * so for now we keep everything (in the hope that this
-     * produces a string containing at least everything that was 
-     * originally on the line). */
-
-    if (!hasmatched) {
-	cline_setlens(l, 0);
-	return l;
-    }
-    e = l = cp_cline(l, 0);
-
-    /* First, search the last struct for which we have something on
-     * the line. Anything before that is kept. */
-
-    for (q = NULL, p = l; p; p = p->next) {
-	if (p->orig || p->olen || !(p->flags & CLF_NEW))
-	    e = p->next;
-	if (!p->suffix && (p->wlen || p->llen || p->prefix))
-	    q = p;
-    }
-    if (!e && q && !q->orig && !q->olen && (q->flags & CLF_MISS) &&
-	!(q->flags & CLF_MATCHED) && (q->word ? q->wlen : q->llen) < 3) {
-	q->word = q->line = NULL;
-	q->wlen = q->llen = 0;
-    }
-    /* Then keep all structs without missing characters. */
-
-    while (e && !(e->flags & CLF_MISS))
-	e = e->next;
-
-    if (e) {
-	/* Then we see if there is another struct with missing
-	 * characters. If not, we keep the whole list. */
-
-	for (p = e->next; p && !(p->flags & CLF_MISS); p = p->next);
-
-	if (p) {
-	    for (p = e; p; p = p->next) {
-		if (!(p->flags & CLF_MISS))
-		    sum += p->max;
-		else {
-		    tmp = cline_sublen(p);
-		    if (tmp > 2 && tmp > ((p->max + p->min) >> 1))
-			sum += tmp - (p->max - tmp);
-		    else if (tmp < p->min)
-			sum -= (((p->max + p->min) >> 1) - tmp) << (tmp < 2);
-		}
-		if (sum > max) {
-		    max = sum;
-		    maxp = p;
-		}
-	    }
-	    if (max)
-		e = maxp;
-	    else {
-		int len = 0;
-
-		cline_setlens(l, 0);
-		ls = 1;
-
-		for (p = e; p; p = p->next)
-		    len += p->max;
-
-		if (len > ((minmlen << 1) / 3))
-		    return l;
-	    }
-	    e->line = e->word = NULL;
-	    e->llen = e->wlen = e->olen = 0;
-	    e->next = NULL;
-	}
-    }
-    if (!ls)
-	cline_setlens(l, 0);
-
-    return l;
-}
-
-/* This builds the unambiguous string. If ins is non-zero, it is
- * immediatly inserted in the line. Otherwise csp is used to return
- * the relative cursor position in the string returned. */
-
-static char *
-cline_str(Cline l, int ins, int *csp)
-{
-    Cline s;
-    int ocs = cs, ncs, pcs, scs, pm, pmax, pmm, sm, smax, smm, d, dm, mid;
-    int i, j, li = 0, cbr;
-    Brinfo brp, brs;
-
-    l = cut_cline(l);
-
-    pmm = smm = dm = 0;
-    pm = pmax = sm = smax = d = mid = cbr = -1;
-
-    /* Get the information about the brace beginning and end we have
-     * to re-insert. */
-    if (ins) {
-	Brinfo bp;
-	int olen = we - wb;
-
-	if ((brp = brbeg)) {
-	    for (bp = brbeg; bp; bp = bp->next) {
-		bp->curpos = (hasunqu ? bp->pos : bp->qpos);
-		olen -= strlen(bp->str);
-	    }
-	}
-	if ((brs = lastbrend)) {
-	    for (bp = brend; bp; bp = bp->next)
-		olen -= strlen(bp->str);
-
-	    for (bp = brend; bp; bp = bp->next)
-		bp->curpos = olen - (hasunqu ? bp->pos : bp->qpos);
-	}
-	while (brp && !brp->curpos) {
-	    inststrlen(brp->str, 1, -1);
-	    brp = brp->next;
-	}
-	while (brs && !brs->curpos) {
-	    if (cbr < 0)
-		cbr = cs;
-	    inststrlen(brs->str, 1, -1);
-	    brs = brs->prev;
-	}
-    }
-    /* Walk through the top-level cline list. */
-    while (l) {
-	/* Insert the original string if no prefix. */
-	if (l->olen && !(l->flags & CLF_SUF) && !l->prefix) {
-	    pcs = cs + l->olen;
-	    inststrlen(l->orig, 1, l->olen);
-	} else {
-	    /* Otherwise insert the prefix. */
-	    for (s = l->prefix; s; s = s->next) {
-		pcs = cs + s->llen;
-		if (s->flags & CLF_LINE)
-		    inststrlen(s->line, 1, s->llen);
-		else
-		    inststrlen(s->word, 1, s->wlen);
-		scs = cs;
-
-		if ((s->flags & CLF_DIFF) && (!dm || (s->flags & CLF_MATCHED))) {
-		    d = cs; dm = s->flags & CLF_MATCHED;
-		}
-		li += s->llen;
-	    }
-	}
-	if (ins) {
-	    int ocs, bl;
-
-	    while (brp && li >= brp->curpos) {
-		ocs = cs;
-		bl = strlen(brp->str);
-		cs = pcs - (li - brp->curpos);
-		inststrlen(brp->str, 1, bl);
-		cs = ocs + bl;
-		pcs += bl;
-		scs += bl;
-		brp = brp->next;
-	    }
-	}
-	/* Remember the position if this is the first prefix with
-	 * missing characters. */
-	if ((l->flags & CLF_MISS) && !(l->flags & CLF_SUF) &&
-	    ((pmax < (l->min - l->max) && (!pmm || (l->flags & CLF_MATCHED))) ||
-	     ((l->flags & CLF_MATCHED) && !pmm))) {
-	    pm = cs; pmax = l->min - l->max; pmm = l->flags & CLF_MATCHED;
-	}
-	if (ins) {
-	    int ocs, bl;
-
-	    while (brs && li >= brs->curpos) {
-		ocs = cs;
-		bl = strlen(brs->str);
-		cs = scs - (li - brs->curpos);
-		if (cbr < 0)
-		    cbr = cs;
-		inststrlen(brs->str, 1, bl);
-		cs = ocs + bl;
-		pcs += bl;
-		brs = brs->prev;
-	    }
-	}
-	pcs = cs;
-	/* Insert the anchor. */
-	if (l->flags & CLF_LINE)
-	    inststrlen(l->line, 1, l->llen);
-	else
-	    inststrlen(l->word, 1, l->wlen);
-	scs = cs;
-	if (ins) {
-	    int ocs, bl;
-
-	    li += l->llen;
-
-	    while (brp && li >= brp->curpos) {
-		ocs = cs;
-		bl = strlen(brp->str);
-		cs = pcs + l->llen - (li - brp->curpos);
-		inststrlen(brp->str, 1, bl);
-		cs = ocs + bl;
-		pcs += bl;
-		scs += bl;
-		brp = brp->next;
-	    }
-	}
-	/* Remember the cursor position for suffixes and mids. */
-	if (l->flags & CLF_MISS) {
-	    if (l->flags & CLF_MID)
-		mid = cs;
-	    else if ((l->flags & CLF_SUF) && 
-		     ((smax < (l->min - l->max) &&
-		       (!smm || (l->flags & CLF_MATCHED))) ||
-		      ((l->flags & CLF_MATCHED) && !smm))) {
-		sm = cs; smax = l->min - l->max; smm = l->flags & CLF_MATCHED;
-	    }
-	}
-	if (ins) {
-	    int ocs, bl;
-
-	    while (brs && li >= brs->curpos) {
-		ocs = cs;
-		bl = strlen(brs->str);
-		cs = scs - (li - brs->curpos);
-		if (cbr < 0)
-		    cbr = cs;
-		inststrlen(brs->str, 1, bl);
-		cs = ocs + bl;
-		pcs += bl;
-		brs = brs->prev;
-	    }
-	}
-	/* And now insert the suffix or the original string. */
-	if (l->olen && (l->flags & CLF_SUF) && !l->suffix) {
-	    pcs = cs;
-	    inststrlen(l->orig, 1, l->olen);
-	    if (ins) {
-		int ocs, bl;
-
-		li += l->olen;
-
-		while (brp && li >= brp->curpos) {
-		    ocs = cs;
-		    bl = strlen(brp->str);
-		    cs = pcs + l->olen - (li - brp->curpos);
-		    inststrlen(brp->str, 1, bl);
-		    cs = ocs + bl;
-		    pcs += bl;
-		    brp = brp->next;
-		}
-		while (brs && li >= brs->curpos) {
-		    ocs = cs;
-		    bl = strlen(brs->str);
-		    cs = pcs + l->olen - (li - brs->curpos);
-		    if (cbr < 0)
-			cbr = cs;
-		    inststrlen(brs->str, 1, bl);
-		    cs = ocs + bl;
-		    pcs += bl;
-		    brs = brs->prev;
-		}
-	    }
-	} else {
-	    Cline js = NULL;
-
-	    for (j = -1, i = 0, s = l->suffix; s; s = s->next) {
-		if (j < 0 && (s->flags & CLF_DIFF))
-		    j = i, js = s;
-		pcs = cs;
-		if (s->flags & CLF_LINE) {
-		    inststrlen(s->line, 0, s->llen);
-		    i += s->llen; scs = cs + s->llen;
-		} else {
-		    inststrlen(s->word, 0, s->wlen);
-		    i += s->wlen; scs = cs + s->wlen;
-		}
-		if (ins) {
-		    int ocs, bl;
-
-		    li += s->llen;
-
-		    while (brp && li >= brp->curpos) {
-			ocs = cs;
-			bl = strlen(brp->str);
-			cs = pcs + (li - brp->curpos);
-			inststrlen(brp->str, 1, bl);
-			cs = ocs + bl;
-			pcs += bl;
-			scs += bl;
-			brp = brp->next;
-		    }
-		    while (brs && li >= brs->curpos) {
-			ocs = cs;
-			bl = strlen(brs->str);
-			cs = scs - (li - brs->curpos);
-			if (cbr < 0)
-			    cbr = cs;
-			inststrlen(brs->str, 1, bl);
-			cs = ocs + bl;
-			pcs += bl;
-			brs = brs->prev;
-		    }
-		}
-	    }
-	    cs += i;
-	    if (j >= 0 && (!dm || (js->flags & CLF_MATCHED))) {
-		d = cs - j; dm = js->flags & CLF_MATCHED;
-	    }
-	}
-	l = l->next;
-    }
-    if (ins) {
-	int ocs = cs;
-
-	for (; brp; brp = brp->next)
-	    inststrlen(brp->str, 1, -1);
-	for (; brs; brs = brs->prev) {
-	    if (cbr < 0)
-		cbr = cs;
-	    inststrlen(brs->str, 1, -1);
-	}
-	if (mid >= ocs)
-	    mid += cs - ocs;
-	if (pm >= ocs)
-	    pm += cs - ocs;
-	if (sm >= ocs)
-	    sm += cs - ocs;
-	if (d >= ocs)
-	    d += cs - ocs;
-    }
-    /* This calculates the new cursor position. If we had a mid cline
-     * with missing characters, we take this, otherwise if we have a
-     * prefix with missing characters, we take that, the same for a
-     * suffix, and finally a place where the matches differ. */
-    ncs = (cbr >= 0 ? cbr :
-	   (mid >= 0 ? mid :
-	    (pm >= 0 ? pm : (sm >= 0 ? sm : (d >= 0 ? d : cs)))));
-
-    if (!ins) {
-	/* We always inserted the string in the line. If that was not
-	 * requested, we copy it and remove from the line. */
-	char *r = zalloc((i = cs - ocs) + 1);
-
-	memcpy(r, (char *) (line + ocs), i);
-	r[i] = '\0';
-	cs = ocs;
-	foredel(i);
-
-	*csp = ncs - ocs;
-
-	return r;
-    }
-    lastend = cs;
-    cs = ncs;
-
-    return NULL;
-}
-
-/* This is a utility function using the function above to allow access
- * to the unambiguous string and cursor position via compstate. */
-
-/**/
-char *
-unambig_data(int *cp)
-{
-    static char *scache = NULL;
-    static int ccache;
-
-    if (mnum && ainfo) {
-	if (mnum != unambig_mnum) {
-	    zsfree(scache);
-	    scache = cline_str((ainfo->count ? ainfo->line : fainfo->line),
-			       0, &ccache);
-	}
-    } else if (mnum != unambig_mnum || !ainfo || !scache) {
-	zsfree(scache);
-	scache = ztrdup("");
-	ccache = 0;
-    }
-    unambig_mnum = mnum;
-    if (cp)
-	*cp = ccache + 1;
-
-    return scache;
-}
-
-/* Insert the given match. This returns the number of characters inserted.
- * scs is used to return the position where a automatically created suffix
- * has to be inserted. */
-
-/**/
-static int
-instmatch(Cmatch m, int *scs)
-{
-    int l, r = 0, ocs, a = cs, brb = 0, bradd, *brpos;
-    Brinfo bp;
-
-    zsfree(lastprebr);
-    zsfree(lastpostbr);
-    lastprebr = lastpostbr = NULL;
-
-    /* Ignored prefix. */
-    if (m->ipre) {
-	char *p = m->ipre + (menuacc ? m->qipl : 0);
-
-	inststrlen(p, 1, (l = strlen(p)));
-	r += l;
-    }
-    /* -P prefix. */
-    if (m->pre) {
-	inststrlen(m->pre, 1, (l = strlen(m->pre)));
-	r += l;
-    }
-    /* Path prefix. */
-    if (m->ppre) {
-	inststrlen(m->ppre, 1, (l = strlen(m->ppre)));
-	r += l;
-    }
-    /* The string itself. */
-    inststrlen(m->str, 1, (l = strlen(m->str)));
-    r += l;
-    ocs = cs;
-    /* Re-insert the brace beginnings, if any. */
-    if (brbeg) {
-	int pcs = cs;
-
-	l = 0;
-	for (bp = brbeg, brpos = m->brpl,
-		 bradd = (m->pre ? strlen(m->pre) : 0);
-	     bp; bp = bp->next, brpos++) {
-	    cs = a + *brpos + bradd;
-	    pcs = cs;
-	    l = strlen(bp->str);
-	    bradd += l;
-	    brpcs = cs;
-	    inststrlen(bp->str, 1, l);
-	    r += l;
-	    ocs += l;
-	}
-	lastprebr = (char *) zalloc(pcs - a + 1);
-	memcpy(lastprebr, (char *) line + a, pcs - a);
-	lastprebr[pcs - a] = '\0';
-	cs = ocs;
-    }
-    /* Path suffix. */
-    if (m->psuf) {
-	inststrlen(m->psuf, 1, (l = strlen(m->psuf)));
-	r += l;
-    }
-    /* Re-insert the brace end. */
-    if (brend) {
-	a = cs;
-	for (bp = brend, brpos = m->brsl, bradd = 0; bp; bp = bp->next, brpos++) {
-	    cs = a - *brpos;
-	    ocs = brscs = cs;
-	    l = strlen(bp->str);
-	    bradd += l;
-	    inststrlen(bp->str, 1, l);
-	    brb = cs;
-	    r += l;
-	}
-	cs = a + bradd;
-	if (scs)
-	    *scs = ocs;
-    } else {
-	brscs = -1;
-
-	if (scs)
-	    *scs = cs;
-    }
-    /* -S suffix */
-    if (m->suf) {
-	inststrlen(m->suf, 1, (l = strlen(m->suf)));
-	r += l;
-    }
-    /* ignored suffix */
-    if (m->isuf) {
-	inststrlen(m->isuf, 1, (l = strlen(m->isuf)));
-	r += l;
-    }
-    if (brend) {
-	lastpostbr = (char *) zalloc(cs - brb + 1);
-	memcpy(lastpostbr, (char *) line + brb, cs - brb);
-	lastpostbr[cs - brb] = '\0';
-    }
-    lastend = cs;
-    cs = ocs;
-
-    return r;
-}
-
-/* Check if the match has the given prefix/suffix before/after the
- * braces. */
-
-/**/
-int
-hasbrpsfx(Cmatch m, char *pre, char *suf)
-{
-    char *op = lastprebr, *os = lastpostbr;
-    VARARR(char, oline, ll);
-    int oll = ll, ocs = cs, ole = lastend, opcs = brpcs, oscs = brscs, ret;
-
-    memcpy(oline, line, ll);
-
-    lastprebr = lastpostbr = NULL;
-
-    instmatch(m, NULL);
-
-    cs = 0;
-    foredel(ll);
-    spaceinline(oll);
-    memcpy(line, oline, oll);
-    cs = ocs;
-    lastend = ole;
-    brpcs = opcs;
-    brscs = oscs;
-
-    ret = (((!pre && !lastprebr) ||
-	    (pre && lastprebr && !strcmp(pre, lastprebr))) &&
-	   ((!suf && !lastpostbr) ||
-	    (suf && lastpostbr && !strcmp(suf, lastpostbr))));
-
-    zsfree(lastprebr);
-    zsfree(lastpostbr);
-    lastprebr = op;
-    lastpostbr = os;
-
-    return ret;
-}
-
-/* Handle the case were we found more than one match. */
-
-/**/
-static int
-do_ambiguous(void)
-{
-    int ret = 0;
-
-    menucmp = menuacc = 0;
-
-    /* If we have to insert the first match, call do_single().  This is *
-     * how REC_EXACT takes effect.  We effectively turn the ambiguous   *
-     * completion into an unambiguous one.                              */
-    if (ainfo && ainfo->exact == 1 && useexact && !(fromcomp & FC_LINE)) {
-	minfo.cur = NULL;
-	do_single(ainfo->exactm);
-	invalidatelist();
-	return ret;
-    }
-    /* Setting lastambig here means that the completion is ambiguous and *
-     * AUTO_MENU might want to start a menu completion next time round,  *
-     * but this might be overridden below if we can complete an          *
-     * unambiguous prefix.                                               */
-    lastambig = 1;
-
-    if (usemenu || (haspattern && comppatinsert &&
-		    !strcmp(comppatinsert, "menu"))) {
-	/* We are in a position to start using menu completion due to one  *
-	 * of the menu completion options, or due to the menu-complete-    *
-	 * word command, or due to using GLOB_COMPLETE which does menu-    *
-	 * style completion regardless of the setting of the normal menu   *
-	 * completion options.                                             */
-	do_ambig_menu();
-    } else if (ainfo) {
-	int atend = (cs == we), la, eq, tcs;
-
-	minfo.cur = NULL;
-	minfo.asked = 0;
-
-	fixsuffix();
-
-	/* First remove the old string from the line. */
-	cs = wb;
-	foredel(we - wb);
-
-	/* Now get the unambiguous string and insert it into the line. */
-	cline_str(ainfo->line, 1, NULL);
-	if (eparq) {
-	    tcs = cs;
-	    cs = lastend;
-	    for (eq = eparq; eq; eq--)
-		inststrlen("\"", 0, 1);
-	    cs = tcs;
-	}
-	/* la is non-zero if listambiguous may be used. Copying and
-	 * comparing the line looks like BFI but it is the easiest
-	 * solution. Really. */
-	la = (ll != origll || strncmp(origline, (char *) line, ll));
-
-	/* If REC_EXACT and AUTO_MENU are set and what we inserted is an  *
-	 * exact match, we want menu completion the next time round       *
-	 * so we set fromcomp, to ensure that the word on the line is not *
-	 * taken as an exact match. Also we remember if we just moved the *
-	 * cursor into the word.                                          */
-	fromcomp = ((isset(AUTOMENU) ? FC_LINE : 0) |
-		    ((atend && cs != lastend) ? FC_INWORD : 0));
-
-	/* Probably move the cursor to the end. */
-	if (movetoend == 3)
-	    cs = lastend;
-
-	/* If the LIST_AMBIGUOUS option (meaning roughly `show a list only *
-	 * if the completion is completely ambiguous') is set, and some    *
-	 * prefix was inserted, return now, bypassing the list-displaying  *
-	 * code.  On the way, invalidate the list and note that we don't   *
-	 * want to enter an AUTO_MENU imediately.                          */
-	if (uselist == 3 && la) {
-	    int fc = fromcomp;
-
-	    invalidatelist();
-	    fromcomp = fc;
-	    lastambig = 0;
-	    clearlist = 1;
-	    return ret;
-	}
-    } else
-	return ret;
-
-    /* At this point, we might want a completion listing.  Show the listing *
-     * if it is needed.                                                     */
-    if (isset(LISTBEEP))
-	ret = 1;
-
-    if (uselist && (usemenu != 2 || (!listshown && !oldlist)) &&
-	((!showinglist && (!listshown || !oldlist)) ||
-	 (usemenu == 3 && !oldlist)) &&
-	(smatches >= 2 || (compforcelist && *compforcelist)))
-	showinglist = -2;
-
-    return ret;
-}
-
-/* This is a stat that ignores backslashes in the filename.  The `ls' *
- * parameter says if we have to do lstat() or stat().  I think this   *
- * should instead be done by use of a general function to expand a    *
- * filename (stripping backslashes), combined with the actual         *
- * (l)stat().                                                         */
-
-/**/
-int
-ztat(char *nam, struct stat *buf, int ls)
-{
-    char b[PATH_MAX], *p;
-
-    for (p = b; p < b + sizeof(b) - 1 && *nam; nam++)
-	if (*nam == '\\' && nam[1])
-	    *p++ = *++nam;
-	else
-	    *p++ = *nam;
-    *p = '\0';
-
-    return ls ? lstat(b, buf) : stat(b, buf);
-}
-
-/* Insert a single match in the command line. */
-
-/**/
-void
-do_single(Cmatch m)
-{
-    int l, sr = 0, scs;
-    int havesuff = 0;
-    int partest = (m->ripre || ((m->flags & CMF_ISPAR) && parpre));
-    char *str = m->str, *ppre = m->ppre, *psuf = m->psuf, *prpre = m->prpre;
-
-    if (!prpre) prpre = "";
-    if (!ppre) ppre = "";
-    if (!psuf) psuf = "";
-
-    fixsuffix();
-
-    if (!minfo.cur) {
-	/* We are currently not in a menu-completion, *
-	 * so set the position variables.             */
-	minfo.pos = wb;
-	minfo.we = (movetoend >= 2 || (movetoend == 1 && !menucmp));
-	minfo.end = we;
-    }
-    /* If we are already in a menu-completion or if we have done a *
-     * glob completion, we have to delete some of the stuff on the *
-     * command line.                                               */
-    if (minfo.cur)
-	l = minfo.len + minfo.insc;
-    else
-	l = we - wb;
-
-    minfo.insc = 0;
-    cs = minfo.pos;
-    foredel(l);
-
-    /* And then we insert the new string. */
-    minfo.len = instmatch(m, &scs);
-    minfo.end = cs;
-    cs = minfo.pos + minfo.len;
-
-    if (m->suf) {
-	havesuff = 1;
-	minfo.insc = ztrlen(m->suf);
-	minfo.len -= minfo.insc;
-	if (minfo.we) {
-	    minfo.end += minfo.insc;
-	    if (m->flags & CMF_REMOVE) {
-		makesuffixstr(m->remf, m->rems, minfo.insc);
-		if (minfo.insc == 1)
-		    suffixlen[STOUC(m->suf[0])] = 1;
-	    }
-	}
-    } else {
-	/* There is no user-specified suffix, *
-	 * so generate one automagically.     */
-	cs = scs;
-	if (partest && (m->flags & CMF_PARBR)) {
-	    int pq;
-
-	    /*{{*/
-	    /* Completing a parameter in braces.  Add a removable `}' suffix. */
-	    cs += eparq;
-	    for (pq = parq; pq; pq--)
-		inststrlen("\"", 1, 1);
-	    minfo.insc += parq;
-	    inststrlen("}", 1, 1);
-	    minfo.insc++;
-	    if (minfo.we)
-		minfo.end += minfo.insc;
-	    if (m->flags & CMF_PARNEST)
-		havesuff = 1;
-	}
-	if (((m->flags & CMF_FILE) || (partest && isset(AUTOPARAMSLASH))) &&
-	    cs > 0 && line[cs - 1] != '/') {
-	    /* If we have a filename or we completed a parameter name      *
-	     * and AUTO_PARAM_SLASH is set, lets see if it is a directory. *
-	     * If it is, we append a slash.                                */
-	    struct stat buf;
-	    char *p;
-	    int t = 0;
-
-	    if (m->ipre && m->ipre[0] == '~' && !m->ipre[1])
-		t = 1;
-	    else {
-		/* Build the path name. */
-		if (partest && !*psuf && !(m->flags & CMF_PARNEST)) {
-		    int ne = noerrs;
-
-		    p = (char *) zhalloc(strlen((m->flags & CMF_ISPAR) ?
-						parpre : m->ripre) +
-					 strlen(str) + 2);
-		    sprintf(p, "%s%s%c",
-			    ((m->flags & CMF_ISPAR) ? parpre : m->ripre), str,
-			    ((m->flags & CMF_PARBR) ? Outbrace : '\0'));
-		    noerrs = 1;
-		    parsestr(p);
-		    singsub(&p);
-		    errflag = 0;
-		    noerrs = ne;
-		} else {
-		    p = (char *) zhalloc(strlen(prpre) + strlen(str) +
-				 strlen(psuf) + 3);
-		    sprintf(p, "%s%s%s", ((prpre && *prpre) ?
-					  prpre : "./"), str, psuf);
-		}
-		/* And do the stat. */
-		t = (!(sr = ztat(p, &buf, 0)) && S_ISDIR(buf.st_mode));
-	    }
-	    if (t) {
-		/* It is a directory, so add the slash. */
-		havesuff = 1;
-		inststrlen("/", 1, 1);
-		minfo.insc++;
-		if (minfo.we)
-		    minfo.end++;
-		if (!menucmp || minfo.we) {
-		    if (m->remf || m->rems)
-			makesuffixstr(m->remf, m->rems, 1);
-		    else if (isset(AUTOREMOVESLASH)) {
-			makesuffix(1);
-			suffixlen['/'] = 1;
-		    }
-		}
-	    }
-	}
-	if (!minfo.insc)
-	    cs = minfo.pos + minfo.len - m->qisl;
-    }
-    /* If completing in a brace expansion... */
-    if (brbeg) {
-	if (havesuff) {
-	    /*{{*/
-	    /* If a suffix was added, and is removable, let *
-	     * `,' and `}' remove it.                       */
-	    if (isset(AUTOPARAMKEYS))
-		suffixlen[','] = suffixlen['}'] = suffixlen[256];
-	} else if (!menucmp) {
-	    /*{{*/
-	    /* Otherwise, add a `,' suffix, and let `}' remove it. */
-	    cs = scs;
-	    havesuff = 1;
-	    inststrlen(",", 1, 1);
-	    minfo.insc++;
-	    makesuffix(1);
-	    if ((!menucmp || minfo.we) && isset(AUTOPARAMKEYS))
-		suffixlen[','] = suffixlen['}'] = 1;
-	}
-    } else if (!havesuff && (!(m->flags & CMF_FILE) || !sr)) {
-	/* If we didn't add a suffix, add a space, unless we are *
-	 * doing menu completion or we are completing files and  *
-	 * the string doesn't name an existing file.             */
-	if (m->autoq && (!m->isuf || m->isuf[0] != m->autoq)) {
-	    inststrlen(&(m->autoq), 1, 1);
-	    minfo.insc++;
-	}
-	if (!menucmp && (usemenu != 3 || insspace)) {
-	    inststrlen(" ", 1, 1);
-	    minfo.insc++;
-	    if (minfo.we)
-		makesuffix(1);
-	}
-    }
-    if (minfo.we && partest && isset(AUTOPARAMKEYS))
-	makeparamsuffix(((m->flags & CMF_PARBR) ? 1 : 0), minfo.insc - parq);
-
-    if ((menucmp && !minfo.we) || !movetoend) {
-	cs = minfo.end;
-	if (cs + m->qisl == lastend)
-	    cs += minfo.insc;
-    }
-    {
-	Cmatch *om = minfo.cur;
-	struct chdata dat;
-
-	dat.matches = amatches;
-	dat.num = nmatches;
-	dat.cur = m;
-
-	if (menucmp)
-	    minfo.cur = &m;
-	runhookdef(INSERTMATCHHOOK, (void *) &dat);
-	minfo.cur = om;
-    }
-}
-
-/* This maps the value in v into the range [0,m-1], decrementing v
- * if it is non-negative and making negative values count backwards. */
-
-static int
-comp_mod(int v, int m)
-{
-    if (v >= 0)
-	v--;
-    if (v >= 0)
-	return v % m;
-    else {
-	while (v < 0)
-	    v += m;
-	return v;
-    }
-}
-
-/* This handles the beginning of menu-completion. */
-
-/**/
-static void
-do_ambig_menu(void)
-{
-    Cmatch *mc;
-
-    if (usemenu != 3) {
-	menucmp = 1;
-	menuacc = 0;
-	minfo.cur = NULL;
-    } else {
-	if (oldlist) {
-	    if (oldins && minfo.cur)
-		acceptlast();
-	} else
-	    minfo.cur = NULL;
-    }
-    if (insgroup) {
-	insgnum = comp_mod(insgnum, lastpermgnum);
-	for (minfo.group = amatches;
-	     minfo.group && (minfo.group)->num != insgnum + 1;
-	     minfo.group = (minfo.group)->next);
-	if (!minfo.group || !(minfo.group)->mcount) {
-	    minfo.cur = NULL;
-	    minfo.asked = 0;
-	    return;
-	}
-	insmnum = comp_mod(insmnum, (minfo.group)->mcount);
-    } else {
-	insmnum = comp_mod(insmnum, lastpermmnum);
-	for (minfo.group = amatches;
-	     minfo.group && (minfo.group)->mcount <= insmnum;
-	     minfo.group = (minfo.group)->next)
-	    insmnum -= (minfo.group)->mcount;
-	if (!minfo.group) {
-	    minfo.cur = NULL;
-	    minfo.asked = 0;
-	    return;
-	}
-    }
-    mc = (minfo.group)->matches + insmnum;
-    do_single(*mc);
-    minfo.cur = mc;
-}
-
-/* Return the length of the common prefix of s and t. */
-
-/**/
-int
-pfxlen(char *s, char *t)
-{
-    int i = 0;
-
-    while (*s && *s == *t)
-	s++, t++, i++;
-    return i;
-}
-
-/* Return the length of the common suffix of s and t. */
-
-#if 0
-static int
-sfxlen(char *s, char *t)
-{
-    if (*s && *t) {
-	int i = 0;
-	char *s2 = s + strlen(s) - 1, *t2 = t + strlen(t) - 1;
-
-	while (s2 >= s && t2 >= t && *s2 == *t2)
-	    s2--, t2--, i++;
-
-	return i;
-    } else
-	return 0;
-}
-#endif
-
-/* This is used to print the explanation string. *
- * It returns the number of lines printed.       */
+/* This is used to print expansions. */
 
 /**/
 int
-printfmt(char *fmt, int n, int dopr, int doesc)
-{
-    char *p = fmt, nc[DIGBUFSIZE];
-    int l = 0, cc = 0, b = 0, s = 0, u = 0, m;
-
-    for (; *p; p++) {
-	/* Handle the `%' stuff (%% == %, %n == <number of matches>). */
-	if (doesc && *p == '%') {
-	    if (*++p) {
-		m = 0;
-		switch (*p) {
-		case '%':
-		    if (dopr)
-			putc('%', shout);
-		    cc++;
-		    break;
-		case 'n':
-		    sprintf(nc, "%d", n);
-		    if (dopr)
-			fprintf(shout, nc);
-		    cc += strlen(nc);
-		    break;
-		case 'B':
-		    b = 1;
-		    if (dopr)
-			tcout(TCBOLDFACEBEG);
-		    break;
-		case 'b':
-		    b = 0; m = 1;
-		    if (dopr)
-			tcout(TCALLATTRSOFF);
-		    break;
-		case 'S':
-		    s = 1;
-		    if (dopr)
-			tcout(TCSTANDOUTBEG);
-		    break;
-		case 's':
-		    s = 0; m = 1;
-		    if (dopr)
-			tcout(TCSTANDOUTEND);
-		    break;
-		case 'U':
-		    u = 1;
-		    if (dopr)
-			tcout(TCUNDERLINEBEG);
-		    break;
-		case 'u':
-		    u = 0; m = 1;
-		    if (dopr)
-			tcout(TCUNDERLINEEND);
-		    break;
-		case '{':
-		    for (p++; *p && (*p != '%' || p[1] != '}'); p++, cc++)
-			if (dopr)
-			    putc(*p, shout);
-		    if (*p)
-			p++;
-		    else
-			p--;
-		    break;
-		}
-		if (dopr && m) {
-		    if (b)
-			tcout(TCBOLDFACEBEG);
-		    if (s)
-			tcout(TCSTANDOUTBEG);
-		    if (u)
-			tcout(TCUNDERLINEBEG);
-		}
-	    } else
-		break;
-	} else {
-	    cc++;
-	    if (*p == '\n') {
-		if (dopr) {
-		    if (tccan(TCCLEAREOL))
-			tcout(TCCLEAREOL);
-		    else {
-			int s = columns - 1 - (cc % columns);
-
-			while (s-- > 0)
-			    putc(' ', shout);
-		    }
-		}
-		l += 1 + (cc / columns);
-		cc = 0;
-	    }
-	    if (dopr)
-		putc(*p, shout);
-	}
-    }
-    if (dopr) {
-	if (tccan(TCCLEAREOL))
-	    tcout(TCCLEAREOL);
-	else {
-	    int s = columns - 1 - (cc % columns);
-
-	    while (s-- > 0)
-		putc(' ', shout);
-	}
-    }
-    return l + (cc / columns);
-}
-
-/* This skips over matches that are not to be listed. */
-
-/**/
-Cmatch *
-skipnolist(Cmatch *p)
-{
-    while (*p && (((*p)->flags & (CMF_NOLIST | CMF_HIDE)) ||
-		  ((*p)->disp && ((*p)->flags & (CMF_DISPLINE | CMF_HIDE)))))
-	p++;
-
-    return p;
-}
-
-/* List the matches.  Note that the list entries are metafied. */
-
-/**/
-void
-listmatches(void)
-{
-    struct chdata dat;
-
-#ifdef DEBUG
-    /* Sanity check */
-    if (!validlist) {
-	showmsg("BUG: listmatches called with bogus list");
-	return;
-    }
-#endif
-
-    dat.matches = amatches;
-    dat.num = nmatches;
-    dat.cur = NULL;
-    runhookdef(LISTMATCHESHOOK, (void *) &dat);
-}
-
-/**/
-void
-calclist(void)
+listlist(LinkList l)
 {
-    Cmgroup g;
-    Cmatch *p, m;
-    Cexpl *e;
-    int hidden = 0, nlist = 0, nlines = 0, add = 2 + isset(LISTTYPES);
-    int max = 0, i;
-    VARARR(int, mlens, nmatches + 1);
-
-    if (listdat.valid && onlyexpl == listdat.onlyexpl &&
-	menuacc == listdat.menuacc &&
-	lines == listdat.lines && columns == listdat.columns)
-	return;
-
-    for (g = amatches; g; g = g->next) {
-	char **pp = g->ylist;
-	int nl = 0, l, glong = 1, gshort = columns, ndisp = 0, totl = 0;
-
-	if (!onlyexpl && pp) {
-	    /* We have an ylist, lets see, if it contains newlines. */
-	    hidden = 1;
-	    while (!nl && *pp)
-		nl = !!strchr(*pp++, '\n');
-
-	    pp = g->ylist;
-	    if (nl || !pp[1]) {
-		/* Yup, there are newlines, count lines. */
-		char *nlptr, *sptr;
-
-		g->flags |= CGF_LINES;
-		hidden = 1;
-		while ((sptr = *pp)) {
-		    while (sptr && *sptr) {
-			nlines += (nlptr = strchr(sptr, '\n'))
-			    ? 1 + (nlptr-sptr)/columns
-			    : strlen(sptr)/columns;
-			sptr = nlptr ? nlptr+1 : NULL;
-		    }
-		    nlines++;
-		    pp++;
-		}
-		nlines--;
-	    } else {
-		while (*pp) {
-		    l = strlen(*pp);
-		    ndisp++;
-		    if (l > glong)
-			glong = l;
-		    if (l < gshort)
-			gshort = l;
-		    totl += l;
-		    nlist++;
-		    pp++;
-		}
-	    }
-	} else if (!onlyexpl) {
-	    for (p = g->matches; (m = *p); p++) {
-		if (menuacc && !hasbrpsfx(m, minfo.prebr, minfo.postbr)) {
-		    m->flags |= CMF_HIDE;
-		    continue;
-		}
-		m->flags &= ~CMF_HIDE;
+    int num = countlinknodes(l);
+    VARARR(char *, data, (num + 1));
+    LinkNode node;
+    char **p;
+    VARARR(int, lens, num);
+    VARARR(int, widths, columns);
+    int longest = 0, shortest = columns, totl = 0;
+    int len, ncols, nlines, tolast, col, i, max, pack = 0, *lenp;
+
+    for (node = firstnode(l), p = data; node; incnode(node), p++)
+	*p = (char *) getdata(node);
+    *p = NULL;
 
-		if (m->disp) {
-		    if (m->flags & CMF_DISPLINE) {
-			nlines += 1 + printfmt(m->disp, 0, 0, 0);
-			g->flags |= CGF_HASDL;
-		    } else {
-			l = niceztrlen(m->disp);
-			ndisp++;
-			if (l > glong)
-			    glong = l;
-			if (l < gshort)
-			    gshort = l;
-			totl += l;
-			mlens[m->gnum] = l;
+    qsort((void *) data, num, sizeof(char *),
+	  (int (*) _((const void *, const void *))) strbpcmp);
+
+    for (p = data, lenp = lens; *p; p++, lenp++) {
+	len = *lenp = niceztrlen(*p) + 2;
+	if (len > longest)
+	    longest = len;
+	if (len < shortest)
+	    shortest = len;
+	totl += len;
+    }
+    if ((ncols = ((columns + 2) / longest))) {
+	int tlines, tline, tcols, maxlen, nth, width;
+
+	nlines = (num + ncols - 1) / ncols;
+
+	if (isset(LISTPACKED)) {
+	    if (isset(LISTROWSFIRST)) {
+		int count, tcol, first, maxlines = 0, llines;
+
+		for (tcols = columns / shortest; tcols > ncols;
+		     tcols--) {
+		    for (nth = first = maxlen = width = maxlines =
+			     llines = tcol = 0,
+			     count = num;
+			 count > 0; count--) {
+			if (!(nth % tcols))
+			    llines++;
+			if (lens[nth] > maxlen)
+			    maxlen = lens[nth];
+			nth += tcols;
+			tlines++;
+			if (nth >= num) {
+			    if ((width += maxlen) >= columns)
+				break;
+			    widths[tcol++] = maxlen;
+			    maxlen = 0;
+			    nth = ++first;
+			    if (llines > maxlines)
+				maxlines = llines;
+			    llines = 0;
+			}
 		    }
-		    nlist++;
-		} else if (!(m->flags & CMF_NOLIST)) {
-		    l = niceztrlen(m->str);
-		    ndisp++;
-		    if (l > glong)
-			glong = l;
-		    if (l < gshort)
-			gshort = l;
-		    totl += l;
-		    mlens[m->gnum] = l;
-		    nlist++;
-		} else
-		    hidden = 1;
-	    }
-	}
-	if ((e = g->expls)) {
-	    while (*e) {
-		if ((*e)->count)
-		    nlines += 1 + printfmt((*e)->str, (*e)->count, 0, 1);
-		e++;
-	    }
-	}
-	g->totl = totl + (ndisp * add);
-	g->dcount = ndisp;
-	g->width = glong + add;
-	g->shortest = gshort + add;
-	if ((g->cols = columns / g->width) > g->dcount)
-	    g->cols = g->dcount;
-	if (g->cols) {
-	    i = g->cols * g->width - add;
-	    if (i > max)
-		max = i;
-	}
-    }
-    if (!onlyexpl) {
-	for (g = amatches; g; g = g->next) {
-	    char **pp;
-	    int glines = 0;
-
-	    zfree(g->widths, 0);
-	    g->widths = NULL;
-
-	    if ((pp = g->ylist)) {
-		if (!(g->flags & CGF_LINES)) {
-		    if (g->cols) {
-			glines += (arrlen(pp) + g->cols - 1) / g->cols;
-			if (g->cols > 1)
-			    g->width += (max - (g->width * g->cols - add)) / g->cols;
-		    } else {
-			g->cols = 1;
-			g->width = 1;
-			
-			while (*pp)
-			    glines += 1 + (strlen(*pp++) / columns);
+		    if (nth < num) {
+			widths[tcol++] = maxlen;
+			width += maxlen;
 		    }
+		    if (!count && width < columns)
+			break;
 		}
+		if (tcols > ncols)
+		    tlines = maxlines;
 	    } else {
-		if (g->cols) {
-		    glines += (g->dcount + g->cols - 1) / g->cols;
-		    if (g->cols > 1)
-			g->width += (max - (g->width * g->cols - add)) / g->cols;
-		} else if (!(g->flags & CGF_LINES)) {
-		    g->cols = 1;
-		    g->width = 0;
-		    
-		    for (p = g->matches; (m = *p); p++)
-			if (!(m->flags & CMF_HIDE)) {
-			    if (m->disp) {
-				if (!(m->flags & CMF_DISPLINE))
-				    glines += 1 + (mlens[m->gnum] / columns);
-			    } else if (!(m->flags & CMF_NOLIST))
-				glines += 1 + ((1 + mlens[m->gnum]) / columns);
-			}
-		}
-	    }
-	    g->lins = glines;
-	    nlines += glines;
-	}
-    }
-    if (!onlyexpl && isset(LISTPACKED)) {
-	char **pp;
-	int *ws, tlines, tline, tcols, maxlen, nth, width;
-
-	for (g = amatches; g; g = g->next) {
-	    ws = g->widths = (int *) zalloc(columns * sizeof(int));
-	    memset(ws, 0, columns * sizeof(int));
-	    tlines = g->lins;
-	    tcols = g->cols;
-	    width = 0;
-
-	    if ((pp = g->ylist)) {
-		if (!(g->flags & CGF_LINES)) {
-		    int yl = arrlen(pp), i;
-		    VARARR(int, ylens, yl);
-
-		    for (i = 0; *pp; i++, pp++)
-			ylens[i] = strlen(*pp) + add;
-
-		    if (isset(LISTROWSFIRST)) {
-			int count, tcol, first, maxlines = 0, llines;
-
-			for (tcols = columns / g->shortest; tcols > g->cols;
-			     tcols--) {
-			    for (nth = first = maxlen = width = maxlines =
-				     llines = tcol = 0,
-				     count = g->dcount;
-				 count > 0; count--) {
-				if (ylens[nth] > maxlen)
-				    maxlen = ylens[nth];
-				nth += tcols;
-				tlines++;
-				if (nth >= g->dcount) {
-				    if ((width += maxlen) >= columns)
-					break;
-				    ws[tcol++] = maxlen;
-				    maxlen = 0;
-				    nth = ++first;
-				    if (llines > maxlines)
-					maxlines = llines;
-				    llines = 0;
-				}
-			    }
-			    if (nth < yl) {
-				ws[tcol++] = maxlen;
-				width += maxlen;
-			    }
-			    if (!count && width < columns)
-				break;
-			}
-			if (tcols > g->cols)
-			    tlines = maxlines;
-		    } else {
-			for (tlines = ((g->totl + columns) / columns);
-			     tlines < g->lins; tlines++) {
-			    for (pp = g->ylist, nth = tline = width =
-				     maxlen = tcols = 0;
-				 *pp; nth++, pp++) {
-				if (ylens[nth] > maxlen)
-				    maxlen = ylens[nth];
-				if (++tline == tlines) {
-				    if ((width += maxlen) >= columns)
-					break;
-				    ws[tcols++] = maxlen;
-				    maxlen = tline = 0;
-				}
-			    }
-			    if (tline) {
-				ws[tcols++] = maxlen;
-				width += maxlen;
-			    }
-			    if (nth == yl && width < columns)
+		for (tlines = ((totl + columns) / columns);
+		     tlines < nlines; tlines++) {
+		    for (p = data, nth = tline = width =
+			     maxlen = tcols = 0;
+			 *p; nth++, p++) {
+			if (lens[nth] > maxlen)
+			    maxlen = lens[nth];
+			if (++tline == tlines) {
+			    if ((width += maxlen) >= columns)
 				break;
+			    widths[tcols++] = maxlen;
+			    maxlen = tline = 0;
 			}
 		    }
-		}
-	    } else if (g->width) {
-		if (isset(LISTROWSFIRST)) {
-		    int addlen, count, tcol, maxlines = 0, llines, i;
-		    Cmatch *first;
-
-		    for (tcols = columns / g->shortest; tcols > g->cols;
-			 tcols--) {
-			p = first = skipnolist(g->matches);
-			for (maxlen = width = maxlines = llines = tcol = 0,
-				 count = g->dcount;
-			     count > 0; count--) {
-			    m = *p;
-			    addlen = mlens[m->gnum] + add;
-			    if (addlen > maxlen)
-				maxlen = addlen;
-			    for (i = tcols; i && *p; i--)
-				p = skipnolist(p + 1);
-
-			    llines++;
-			    if (!*p) {
-				if (llines > maxlines)
-				    maxlines = llines;
-				llines = 0;
-
-				if ((width += maxlen) >= columns)
-				    break;
-				ws[tcol++] = maxlen;
-				maxlen = 0;
-
-				p = first = skipnolist(first + 1);
-			    }
-			}
-			if (tlines) {
-			    ws[tcol++] = maxlen;
-			    width += maxlen;
-			}
-			if (!count && width < columns)
-			    break;
-		    }
-		    if (tcols > g->cols)
-			tlines = maxlines;
-		} else {
-		    int addlen;
-
-		    for (tlines = ((g->totl + columns) / columns);
-			 tlines < g->lins; tlines++) {
-			for (p = g->matches, nth = tline = width =
-				 maxlen = tcols = 0;
-			     (m = *p); p++, nth++) {
-			    if (!(m->flags &
-				  (m->disp ? (CMF_DISPLINE | CMF_HIDE) :
-				   (CMF_NOLIST | CMF_HIDE)))) {
-				addlen = mlens[m->gnum] + add;
-				if (addlen > maxlen)
-				    maxlen = addlen;
-				if (++tline == tlines) {
-				    if ((width += maxlen) >= columns)
-					break;
-				    ws[tcols++] = maxlen;
-				    maxlen = tline = 0;
-				}
-			    }
-			}
-			if (tline) {
-			    ws[tcols++] = maxlen;
-			    width += maxlen;
-			}
-			if (nth == g->dcount && width < columns)
-			    break;
+		    if (tline) {
+			widths[tcols++] = maxlen;
+			width += maxlen;
 		    }
+		    if (nth == num && width < columns)
+			break;
 		}
 	    }
-	    if (tlines == g->lins) {
-		zfree(ws, columns * sizeof(int));
-		g->widths = NULL;
-	    } else {
-		nlines += tlines - g->lins;
-		g->lins = tlines;
-		g->cols = tcols;
-		g->totl = width;
-		width -= add;
-		if (width > max)
-		    max = width;
+	    if ((pack = (tlines < nlines))) {
+		nlines = tlines;
+		ncols = tcols;
 	    }
 	}
-	for (g = amatches; g; g = g->next) {
-	    if (g->widths) {
-		int *p, a = (max - g->totl + add) / g->cols;
-
-		for (i = g->cols, p = g->widths; i; i--, p++)
-		    *p += a;
-	    } else if (g->width && g->cols > 1)
-		g->width += (max - (g->width * g->cols - add)) / g->cols;
-	}
+    } else {
+	nlines = 0;
+	for (p = data; *p; p++)
+	    nlines += 1 + (strlen(*p) / columns);
     }
-    listdat.valid = 1;
-    listdat.hidden = hidden;
-    listdat.nlist = nlist;
-    listdat.nlines = nlines;
-    listdat.menuacc = menuacc;
-    listdat.onlyexpl = onlyexpl;
-    listdat.columns = columns;
-    listdat.lines = lines;
-}
-
-/**/
-int asklist(void)
-{
     /* Set the cursor below the prompt. */
     trashzle();
-    showinglist = listshown = 0;
 
-    clearflag = (isset(USEZLE) && !termflags &&
-		 complastprompt && *complastprompt);
+    tolast = ((zmult == 1) == !!isset(ALWAYSLASTPROMPT));
+    clearflag = (isset(USEZLE) && !termflags && tolast);
 
-    /* Maybe we have to ask if the user wants to see the list. */
-    if ((!minfo.cur || !minfo.asked) &&
-	((complistmax && listdat.nlist > complistmax) ||
-	 (!complistmax && listdat.nlines >= lines))) {
+    max = getiparam("LISTMAX");
+    if ((max && num > max) || (!max && nlines > lines)) {
 	int qup;
+
 	zsetterm();
 	qup = printfmt("zsh: do you wish to see all %n possibilities? ",
-		       listdat.nlist, 1, 1);
+		       num, 1, 1);
 	fflush(shout);
 	if (getzlequery() != 'y') {
 	    if (clearflag) {
@@ -7530,8 +1865,6 @@ int asklist(void)
 		tcmultout(TCUP, TCMULTUP, nlnct);
 	    } else
 		putc('\n', shout);
-	    if (minfo.cur)
-		minfo.asked = 2;
 	    return 1;
 	}
 	if (clearflag) {
@@ -7542,304 +1875,60 @@ int asklist(void)
 	} else
 	    putc('\n', shout);
 	settyinfo(&shttyinfo);
-	if (minfo.cur)
-	    minfo.asked = 1;
     }
-    return 0;
-}
-
-/**/
-int
-printlist(int over, CLPrintFunc printm)
-{
-    Cmgroup g;
-    Cmatch *p, m;
-    Cexpl *e;
-    int pnl = 0, cl = (over ? listdat.nlines : -1);
-    int mc = 0, ml = 0, printed = 0;
-
-    if (cl < 2) {
-	cl = -1;
-	if (tccan(TCCLEAREOD))
-	    tcout(TCCLEAREOD);
-    }
-    g = amatches;
-    while (g) {
-	char **pp = g->ylist;
-
-	if ((e = g->expls)) {
-	    int l;
-
-	    while (*e) {
-		if ((*e)->count) {
-		    if (pnl) {
+    if (ncols) {
+	if (isset(LISTROWSFIRST)) {
+	    for (col = 1, p = data, lenp = lens; *p;
+		 p++, lenp++, col++) {
+		nicezputs(*p, shout);
+		if (col == ncols) {
+		    col = 0;
+		    if (p[1])
 			putc('\n', shout);
-			pnl = 0;
-			ml++;
-			if (cl >= 0 && --cl <= 1) {
-			    cl = -1;
-			    if (tccan(TCCLEAREOD))
-				tcout(TCCLEAREOD);
-			}
-		    }
-		    l = printfmt((*e)->str, (*e)->count, 1, 1);
-		    ml += l;
-		    if (cl >= 0 && (cl -= l) <= 1) {
-			cl = -1;
-			if (tccan(TCCLEAREOD))
-			    tcout(TCCLEAREOD);
-		    }
-		    pnl = 1;
-		}
-		e++;
-	    }
-	}
-	if (!listdat.onlyexpl && pp && *pp) {
-	    if (pnl) {
-		putc('\n', shout);
-		pnl = 0;
-		ml++;
-		if (cl >= 0 && --cl <= 1) {
-		    cl = -1;
-		    if (tccan(TCCLEAREOD))
-			tcout(TCCLEAREOD);
-		}
-	    }
-	    if (g->flags & CGF_LINES) {
-		while (*pp) {
-		    zputs(*pp, shout);
-		    if (*++pp)
-			putc('\n', shout);
-		}
-	    } else {
-		int n = g->lcount, nl, nc, i, a;
-		char **pq;
-
-		nl = nc = g->lins;
-
-		while (n && nl--) {
-		    i = g->cols;
-		    mc = 0;
-		    pq = pp;
-		    while (n && i--) {
-			if (pq - g->ylist >= g->lcount)
-			    break;
-			zputs(*pq, shout);
-			if (i) {
-			    a = (g->widths ? g->widths[mc] : g->width) -
-				strlen(*pq);
-			    while (a--)
-				putc(' ', shout);
-			}
-			pq += (isset(LISTROWSFIRST) ? 1 : nc);
-			mc++;
-			n--;
-		    }
-		    if (n) {
-			putc('\n', shout);
-			ml++;
-			if (cl >= 0 && --cl <= 1) {
-			    cl = -1;
-			    if (tccan(TCCLEAREOD))
-				tcout(TCCLEAREOD);
-			}
-		    }
-		    pp += (isset(LISTROWSFIRST) ? g->cols : 1);
-		}
-	    }
-	} else if (!listdat.onlyexpl && g->lcount) {
-	    int n = g->dcount, nl, nc, i, j, wid;
-	    Cmatch *q;
-
-	    nl = nc = g->lins;
-
-	    if (g->flags & CGF_HASDL) {
-		for (p = g->matches; (m = *p); p++)
-		    if (m->disp && (m->flags & CMF_DISPLINE)) {
-			if (pnl) {
-			    putc('\n', shout);
-			    pnl = 0;
-			    ml++;
-			    if (cl >= 0 && --cl <= 1) {
-				cl = -1;
-				if (tccan(TCCLEAREOD))
-				    tcout(TCCLEAREOD);
-			    }
-			}
-			printed++;
-			printm(g, p, 0, ml, 1, 0, NULL, NULL);
-			pnl = 1;
-		    }
-	    }
-	    if (n && pnl) {
-		putc('\n', shout);
-		pnl = 0;
-		ml++;
-		if (cl >= 0 && --cl <= 1) {
-		    cl = -1;
-		    if (tccan(TCCLEAREOD))
-			tcout(TCCLEAREOD);
+		} else {
+		    if ((i = (pack ? widths[col - 1] : longest) - *lenp + 2) > 0)
+			while (i--)
+			    putc(' ', shout);
 		}
 	    }
-	    for (p = skipnolist(g->matches); n && nl--;) {
-		i = g->cols;
-		mc = 0;
-		q = p;
-		while (n && i--) {
-		    wid = (g->widths ? g->widths[mc] : g->width);
-		    if (!(m = *q)) {
-			printm(g, NULL, mc, ml, (!i), wid, NULL, NULL);
+	} else {
+	    char **f;
+	    int *fl, line;
+
+	    for (f = data, fl = lens, line = 0; line < nlines;
+		 f++, fl++, line++) {
+		for (col = 1, p = f, lenp = fl; *p; col++) {
+		    nicezputs(*p, shout);
+		    if (col == ncols)
 			break;
-		    }
-		    if (!m->disp && (m->flags & CMF_FILE)) {
-			struct stat buf;
-			char *pb;
-
-			pb = (char *) zhalloc((m->prpre ? strlen(m->prpre) : 0) +
-					     3 + strlen(m->str));
-			sprintf(pb, "%s%s", (m->prpre ? m->prpre : "./"),
-				m->str);
-
-			if (ztat(pb, &buf, 1))
-			    printm(g, q, mc, ml, (!i), wid, NULL, NULL);
-			else
-			    printm(g, q, mc, ml, (!i), wid, pb, &buf);
-		    } else
-			printm(g, q, mc, ml, (!i), wid, NULL, NULL);
-
-		    printed++;
-
-		    if (--n)
-			for (j = (isset(LISTROWSFIRST) ? 1 : nc); j && *q; j--)
-			    q = skipnolist(q + 1);
-		    mc++;
+		    if ((i = (pack ? widths[col - 1] : longest) - *lenp + 2) > 0)
+			while (i--)
+			    putc(' ', shout);
+		    for (i = nlines; i && *p; i--, p++, lenp++);
 		}
-		while (i-- > 0)
-		    printm(g, NULL, mc++, ml, (!i),
-			   (g->widths ? g->widths[mc] : g->width), NULL, NULL);
-
-		if (n) {
+		if (line + 1 < nlines)
 		    putc('\n', shout);
-		    ml++;
-		    if (cl >= 0 && --cl <= 1) {
-			cl = -1;
-			if (tccan(TCCLEAREOD))
-			    tcout(TCCLEAREOD);
-		    }
-		    if (nl)
-			for (j = (isset(LISTROWSFIRST) ? g->cols : 1); j && *p; j--)
-			    p = skipnolist(p + 1);
-		}
 	    }
 	}
-	if (g->lcount)
-	    pnl = 1;
-	g = g->next;
+    } else {
+	for (p = data; *p; p++) {
+	    nicezputs(*p, shout);
+	    putc('\n', shout);
+	}
     }
     if (clearflag) {
-	/* Move the cursor up to the prompt, if always_last_prompt *
-	 * is set and all that...                                  */
-	if ((ml = listdat.nlines + nlnct - 1) < lines) {
-	    tcmultout(TCUP, TCMULTUP, ml);
+	if ((nlines += nlnct - 1) < lines) {
+	    tcmultout(TCUP, TCMULTUP, nlines);
 	    showinglist = -1;
 	} else
 	    clearflag = 0, putc('\n', shout);
     } else
 	putc('\n', shout);
-    listshown = (clearflag ? 1 : -1);
-
-    return printed;
-}
-
-static void
-iprintm(Cmgroup g, Cmatch *mp, int mc, int ml, int lastc, int width,
-	char *path, struct stat *buf)
-{
-    Cmatch m;
-    int len = 0;
-
-    if (!mp)
-	return;
-
-    m = *mp;
-    if (m->disp) {
-	if (m->flags & CMF_DISPLINE) {
-	    printfmt(m->disp, 0, 1, 0);
-	    return;
-	}
-	nicezputs(m->disp, shout);
-	len = niceztrlen(m->disp);
-    } else {
-	nicezputs(m->str, shout);
-	len = niceztrlen(m->str);
-
-	if (isset(LISTTYPES)) {
-	    if (buf)
-		putc(file_type(buf->st_mode), shout);
-	    len++;
-	}
-    }
-    if (!lastc) {
-	len = width - len;
-
-	while (len-- > 0)
-	    putc(' ', shout);
-    }
-}
-
-/**/
-int
-ilistmatches(Hookdef dummy, Chdata dat)
-{
-    calclist();
-
-    if (!listdat.nlines) {
-	showinglist = listshown = 0;
-	return 1;
-    }
-    if (asklist())
-	return 0;
-
-    printlist(0, iprintm);
-
-    return 0;
-}
-
-/* This is used to print expansions. */
-
-/**/
-int
-listlist(LinkList l)
-{
-    struct cmgroup dg;
-    int vl = validlist, sm = smatches, nm = nmatches;
-    char *oclp = complastprompt;
-    Cmgroup am = amatches;
-    struct cldata odat;
-
-    memcpy(&odat, &listdat, sizeof(struct cldata));
 
     if (listshown)
 	showagain = 1;
 
-    complastprompt = ((zmult == 1) == !!isset(ALWAYSLASTPROMPT) ? "yes" : NULL);
-    smatches = 1;
-    validlist = 1;
-    memset(&dg, 0, sizeof(struct cmgroup));
-    dg.ylist = (char **) makearray(l, 0, 1, &(dg.lcount), NULL, NULL);
-    nmatches = dg.lcount;
-    amatches = &dg;
-    listdat.valid = 0;
-    ilistmatches(NULL, NULL);
-    amatches = am;
-
-    validlist = vl;
-    smatches = sm;
-    nmatches = nm;
-    complastprompt = oclp;
-    memcpy(&listdat, &odat, sizeof(struct cldata));
-
-    return !dg.lcount;
+    return !num;
 }
 
 /* Expand the history references. */