(15509)

4 files changed, 226 insertions, 232 deletions

diff --git a/ChangeLog b/ChangeLog
index 527cdbb57..f97228948 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2001-07-27  Sven Wischnowsky  <wischnow@zsh.org>
+
+	* 15509: Completion/Base/Utility/_describe, Src/Zle/compresult.c,
+	Src/Zle/computil.c: improve grouped listings some more, so that
+	TABs walk along the first column first; improve list_packed
+	code
+
 2001-07-27  Peter Stephenson  <pws@csr.com>
 
 	* 15508: Completion/Unix/Command/_cvs: cvs tag told you it was
diff --git a/Completion/Base/Utility/_describe b/Completion/Base/Utility/_describe
index 25ca83486..cd891368a 100644
--- a/Completion/Base/Utility/_describe
+++ b/Completion/Base/Utility/_describe
@@ -78,9 +78,9 @@ while _tags; do
         fi
     
         if [[ -n $_mats ]]; then
-          compadd "$_opts[@]" "$_expl[@]" -O $_strs -D $_mats -s $_strs
+          compadd "$_opts[@]" "${(@)_expl:/-J/-2V}" -O $_strs -D $_mats -s $_strs
         else
-          compadd "$_opts[@]" "$_expl[@]" -O $_strs -a $_strs
+          compadd "$_opts[@]" "${(@)_expl:/-J/-2V}" -O $_strs -a $_strs
         fi
       done
       set - "$_argv[@]"
@@ -97,6 +97,7 @@ while _tags; do
     while compdescribe -g csl2 _args _tmpm _tmpd; do
 
       compstate[list]="$csl $csl2"
+      [[ -n "$csl2" ]] && compstate[list]="${compstate[list]:s/rows//}"
 
       compadd "$_args[@]" -d _tmpd -a _tmpm && _ret=0
     done
diff --git a/Src/Zle/compresult.c b/Src/Zle/compresult.c
index 6b5d7df38..14fa3adca 100644
--- a/Src/Zle/compresult.c
+++ b/Src/Zle/compresult.c
@@ -1588,214 +1588,142 @@ calclist(int showall)
 			ylens[i] = ztrlen(*pp) + add;
 
 		    if (g->flags & CGF_ROWS) {
-			int count, tcol, first, maxlines = 0, llines;
-			int beg = columns / g->shortest, end = g->cols;
-
-			while (1) {
-			    tcols = (beg + end) >> 1;
-
-			    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 &&
-				(tcols <= 0 || beg == end))
-				break;
-
-			    if (beg == end) {
-				beg--;
-				end--;
-			    } else if (width < columns) {
-				if ((end = tcols) == beg - 1)
-				    end++;
-			    } else {
-				if ((beg = tcols) - 1 == end)
-				    end++;
-			    }
-			}
-			if (tcols > g->cols)
-			    tlines = maxlines;
+                        int nth, tcol, len;
+
+                        for (tcols = columns / (g->shortest + add); tcols > g->cols;
+                             tcols--) {
+
+                            memset(ws, 0, tcols * sizeof(int));
+
+                            for (width = nth = tcol = 0, tlines = 1;
+                                 width < columns && nth < g->dcount;
+                                 nth++, tcol++) {
+
+                                m = *p;
+
+                                if (tcol == tcols) {
+                                    tcol = 0;
+                                    tlines++;
+                                }
+                                len = ylens[nth];
+
+                                if (len > ws[tcol]) {
+                                    width += len - ws[tcol];
+                                    ws[tcol] = len;
+                                }
+                            }
+                            if (width < columns)
+                                break;
+                        }
 		    } else {
-			int beg = ((g->totl + columns) / columns);
-			int end = g->lins;
-
-			while (1) {
-			    tlines = (beg + end) >> 1;
-
-			    for (pp = g->ylist, nth = tline = width =
-				     maxlen = tcols = 0;
-				 *pp; pp++) {
-				if (ylens[nth] > maxlen)
-				    maxlen = ylens[nth];
-				if (++tline == tlines) {
-				    if ((width += maxlen) >= columns)
-					break;
-				    ws[tcols++] = maxlen;
-				    maxlen = tline = 0;
-				}
-				nth++;
-			    }
-			    if (tline) {
-				ws[tcols++] = maxlen;
-				width += maxlen;
-			    }
-			    if (nth == yl && width <= columns &&
-				(beg == end || tlines >= g->lins))
-				break;
-
-			    if (beg == end) {
-				beg++;
-				end++;
-			    } else if (width < columns) {
-				if ((end = tlines) == beg + 1)
-				    end--;
-			    } else {
-				if ((beg = tlines) + 1 == end)
-				    end--;
-			    }
-			}
-			if (tlines > g->lins)
-			    tlines = g->lins;
+                        int nth, tcol, tline, len;
+
+                        for (tcols = columns / (g->shortest + add); tcols > g->cols;
+                             tcols--) {
+
+                            if ((tlines = (g->dcount + tcols - 1) / tcols) <= 0)
+                                tlines = 1;
+
+                            memset(ws, 0, tcols * sizeof(int));
+
+                            for (width = nth = tcol = tline = 0;
+                                 width < columns && nth < g->dcount;
+                                 nth++, tline++) {
+
+                                m = *p;
+
+                                if (tline == tlines) {
+                                    tcol++;
+                                    tline = 0;
+                                }
+                                if (tcol == tcols) {
+                                    tcol = 0;
+                                    tlines++;
+                                }
+                                len = ylens[nth];
+
+                                if (len > ws[tcol]) {
+                                    width += len - ws[tcol];
+                                    ws[tcol] = len;
+                                }
+                            }
+                            if (width < columns)
+                                break;
+                        }
 		    }
 		}
 	    } else if (g->width) {
 		if (g->flags & CGF_ROWS) {
-		    int addlen, count, tcol, maxlines = 0, llines, i;
-		    int beg = columns / g->shortest, end = g->cols, fe = 1;
-		    Cmatch *first;
-
-		    while (1) {
-			tcols = (beg + end) >> 1;
-
-			p = first = skipnolist(g->matches, showall);
-			for (maxlen = width = maxlines = llines = tcol = 0,
-				 count = g->dcount;
-			     count > 0; count--) {
-			    m = *p;
-			    addlen = (mlens[m->gnum] +
-                                      (tcol == tcols - 1 ? 0 : add));
-			    if (addlen > maxlen)
-				maxlen = addlen;
-			    for (i = tcols; i && *p; i--)
-				p = skipnolist(p + 1, showall);
-
-			    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, showall);
-			    }
-			}
-			if (tlines) {
-			    ws[tcol++] = maxlen;
-			    width += maxlen;
-			}
-			if (!count && width <= columns &&
-			    (tcols <= 0 || beg == end))
-			    break;
+                    int nth, tcol, len;
+
+                    for (tcols = columns / (g->shortest + add); tcols > g->cols;
+                         tcols--) {
+
+                        memset(ws, 0, tcols * sizeof(int));
 
-			if (beg == end) {
-                            if (fe) {
-                                beg += 2;
-                                end += 2;
-                                fe = 0;
-                            } else {
-                                beg--;
-                                end--;
+                        for (width = nth = tcol = 0, tlines = 1,
+                             p = skipnolist(g->matches, showall);
+                             *p && width < columns && nth < g->dcount;
+                             nth++, p = skipnolist(p + 1, showall), tcol++) {
+
+                            m = *p;
+
+                            if (tcol == tcols) {
+                                tcol = 0;
+                                tlines++;
+                            }
+                            len = (mlens[m->gnum] +
+                                   (tcol == tcols - 1 ? 0 : add));
+
+                            if (len > ws[tcol]) {
+                                width += len - ws[tcol];
+                                ws[tcol] = len;
                             }
-			} else if (width < columns) {
-			    if ((end = tcols) == beg - 1)
-				end++;
-			} else {
-			    if ((beg = tcols) - 1 == end)
-				end++;
                         }
-		    }
-		    if (tcols > g->cols)
-			tlines = maxlines;
+                        if (width < columns)
+                            break;
+                    }
 		} else {
-		    int addlen;
-		    int smask = ((showall ? 0 : (CMF_NOLIST | CMF_MULT)) |
-				 CMF_HIDE);
-		    int beg = ((g->totl + columns) / columns);
-		    int end = g->lins, fe = 1;
-
-		    while (1) {
-			tlines = (beg + end) >> 1;
-
-			for (p = g->matches, nth = tline = width =
-				 maxlen = tcols = 0;
-			     (m = *p); p++) {
-			    if (!(m->flags &
-				  (m->disp ? (CMF_DISPLINE | CMF_HIDE) :
-				   smask))) {
-				addlen = mlens[m->gnum] + add;
-				if (addlen > maxlen)
-				    maxlen = addlen;
-				if (++tline == tlines) {
-				    if ((width += maxlen) >= columns)
-					break;
-				    ws[tcols++] = maxlen;
-				    maxlen = tline = 0;
-				}
-				nth++;
-			    }
-			}
-			if (tline) {
-			    ws[tcols++] = maxlen;
-			    width += maxlen;
-			}
-			if (nth == g->dcount && width <= columns &&
-			    (beg == end || tlines >= g->lins))
-			    break;
+                    int nth, tcol, tline, len;
+
+                    for (tcols = columns / (g->shortest + add); tcols > g->cols;
+                         tcols--) {
+
+                        if ((tlines = (g->dcount + tcols - 1) / tcols) <= 0)
+                            tlines = 1;
+
+                        memset(ws, 0, tcols * sizeof(int));
 
-			if (beg == end) {
-                            if (fe) {
-                                beg -= 2;
-                                end -= 2;
-                                fe = 0;
-                            } else {
-                                beg++;
-                                end++;
+                        for (width = nth = tcol = tline = 0,
+                             p = skipnolist(g->matches, showall);
+                             *p && width < columns && nth < g->dcount;
+                             nth++, p = skipnolist(p + 1, showall), tline++) {
+
+                            m = *p;
+
+                            if (tline == tlines) {
+                                tcol++;
+                                tline = 0;
                             }
-			} else if (width < columns) {
-			    if ((end = tlines) == beg + 1)
-				end--;
-			} else {
-			    if ((beg = tlines) + 1 == end)
-				end--;
-			}
-		    }
-		    if (tlines > g->lins)
-			tlines = g->lins;
+                            if (tcol == tcols) {
+                                tcol = 0;
+                                tlines++;
+                            }
+                            len = (mlens[m->gnum] +
+                                   (tcol == tcols - 1 ? 0 : add));
+
+                            if (len > ws[tcol]) {
+                                width += len - ws[tcol];
+                                ws[tcol] = len;
+                            }
+                        }
+                        if (width < columns)
+                            break;
+                    }
 		}
 	    }
+            if (tcols <= g->cols)
+                tlines = g->lins;
 	    if (tlines == g->lins) {
 		zfree(ws, columns * sizeof(int));
 		g->widths = NULL;
diff --git a/Src/Zle/computil.c b/Src/Zle/computil.c
index a0f7603e2..552f5f745 100644
--- a/Src/Zle/computil.c
+++ b/Src/Zle/computil.c
@@ -74,6 +74,7 @@ struct cdrun {
 #define CRT_DESC   1
 #define CRT_SPEC   2
 #define CRT_DUMMY  3
+#define CRT_EXPL   4
 
 struct cdset {
     Cdset next;			/* guess what */
@@ -199,7 +200,9 @@ cd_prep()
         VARARR(Cdstr, grps, lines);
         VARARR(int, wids, cd_state.maxg);
         Cdstr gs, gp, gn, *gpp;
-        int i, j;
+        int i, j, d;
+        Cdrun expl;
+        Cdstr *strp2;
 
         memset(wids, 0, cd_state.maxg * sizeof(int));
         strp = grps;
@@ -236,22 +239,59 @@ cd_prep()
 
         qsort(grps, lines, sizeof(Cdstr), cd_sort);
 
-        for (i = lines, strp = grps; i; i--, strp++) {
-            for (j = 0, gs = *strp; gs->other; gs = gs->other, j++) {
-                *runp = run = (Cdrun) zalloc(sizeof(*run));
-                runp = &(run->next);
-                run->type = CRT_SPEC;
-                run->strs = gs;
-                gs->run = NULL;
-                run->count = 1;
-            }
+        expl =  (Cdrun) zalloc(sizeof(*run));
+        expl->type = CRT_EXPL;
+        expl->strs = grps[0];
+        expl->count = lines;
+
+        for (i = lines, strp = grps, strp2 = NULL; i; i--, strp++) {
+            str = *strp;
+            *strp = str->other;
+            if (strp2)
+                *strp2 = str;
+            strp2 = &(str->run);
+
             *runp = run = (Cdrun) zalloc(sizeof(*run));
             runp = &(run->next);
-            run->type = CRT_DUMMY + cd_state.maxg - j - 1;
-            run->strs = gs;
-            gs->run = NULL;
+            run->type = CRT_SPEC;
+            run->strs = str;
             run->count = 1;
         }
+        *strp2 = NULL;
+
+        for (i = cd_state.maxg - 1; i; i--) {
+            for (d = 0, j = lines, strp = grps; j; j--, strp++) {
+                if ((str = *strp)) {
+                    if (d) {
+                        *runp = run = (Cdrun) zalloc(sizeof(*run));
+                        runp = &(run->next);
+                        run->type = CRT_DUMMY;
+                        run->strs = expl->strs;
+                        run->count = d;
+                        d = 0;
+                    }
+                    *runp = run = (Cdrun) zalloc(sizeof(*run));
+                    runp = &(run->next);
+                    run->type = CRT_SPEC;
+                    run->strs = str;
+                    run->strs->run = NULL;
+                    run->count = 1;
+
+                    *strp = str->other;
+                } else
+                    d++;
+            }
+            if (d) {
+                *runp = run = (Cdrun) zalloc(sizeof(*run));
+                runp = &(run->next);
+                run->type = CRT_DUMMY;
+                run->strs = expl->strs;
+                run->count = d;
+            }
+        }
+        *runp = expl;
+        runp = &(expl->next);
+
         for (set = cd_state.sets; set; set = set->next) {
             for (i = 0, gs = NULL, gpp = &gs, str = set->strs;
                  str; str = str->next) {
@@ -528,6 +568,7 @@ cd_get(char **params)
                 opts[0] = ztrdup("-l");
                 break;
             }
+
         case CRT_SPEC:
             mats = (char **) zalloc(2 * sizeof(char *));
             dpys = (char **) zalloc(2 * sizeof(char *));
@@ -549,39 +590,56 @@ cd_get(char **params)
                 
             } else
                 opts[0] = ztrdup("-2V-default-");
-            csl = "packed rows";
+            csl = "packed";
             break;
+  
+        case CRT_DUMMY:
+            {
+                char buf[20];
+
+                sprintf(buf, "-E%d", run->count);
 
-        default:
+                mats = (char **) zalloc(sizeof(char *));
+                dpys = (char **) zalloc(sizeof(char *));
+                mats[0] = dpys[0] = NULL;
+
+                opts = cd_arrdup(run->strs->set->opts);
+                opts[0] = ztrdup(buf);
+
+                csl = "packed";
+            }
+            break;
+
+        case CRT_EXPL:
             {
                 int dlen = columns - cd_state.gpre - cd_state.slen;
                 VARARR(char, dbuf, dlen + cd_state.slen);
                 char buf[20];
-                int i = run->type - CRT_DUMMY;
-
-                sprintf(buf, "-E%d", i + 1);
-
-                mats = (char **) zalloc(2 * sizeof(char *));
-                dpys = (char **) zalloc((3 + i) * sizeof(char *));
-                mats[0] = ztrdup(run->strs->match);
-                dpys[0] = ztrdup(run->strs->str);
-                for (dp = dpys + 1; i; i--, dp++)
-                    *dp = ztrdup("");
-                memset(dbuf + cd_state.slen, ' ', dlen - 1);
-                dbuf[dlen + cd_state.slen - 1] = '\0';
-                strcpy(dbuf, cd_state.sep);
-                memcpy(dbuf + cd_state.slen,
-                       run->strs->desc,
-                       (strlen(run->strs->desc) >= dlen ? dlen - 1 :
-                        strlen(run->strs->desc)));
-                *dp++ = ztrdup(dbuf);
-                mats[1] = *dp = NULL;
+                int i = run->count;
+
+                sprintf(buf, "-E%d", i);
+
+                mats = (char **) zalloc(sizeof(char *));
+                dpys = (char **) zalloc((i + 1) * sizeof(char *));
+
+                for (dp = dpys, str = run->strs; str; str = str->run) {
+                    memset(dbuf + cd_state.slen, ' ', dlen - 1);
+                    dbuf[dlen + cd_state.slen - 1] = '\0';
+                    strcpy(dbuf, cd_state.sep);
+                    memcpy(dbuf + cd_state.slen,
+                           str->desc,
+                           (strlen(str->desc) >= dlen ? dlen - 1 :
+                            strlen(str->desc)));
+                    *dp++ = ztrdup(dbuf);
+                }
+                mats[0] = *dp = NULL;
 
                 opts = cd_arrdup(run->strs->set->opts);
                 opts[0] = ztrdup(buf);
 
-                csl = "packed rows";
+                csl = "packed";
             }
+            break;
         }
         setsparam(params[0], ztrdup(csl));
         setaparam(params[1], opts);