mirrors/zsh
1
0
Fork 0
mirror of git://git.code.sf.net/p/zsh/code synced 2025-10-31 06:00:54 +01:00
Code Releases Activity
zsh/Src/Zle/complist.c

3594 lines
84 KiB
C
Raw Blame History

/*
* complist.c - completion listing enhancements
*
* 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 "complist.mdh"
#include "complist.pro"
/* Information about the list shown. */
/*
* noselect: 1 if complistmatches indicated we shouldn't do selection;
* -1 if interactive mode needs to reset the selection list.
* Tested in domenuselect, and in complistmatches to skip redraw.
* mselect: Local copy of the index of the currently selected match.
* Initialised to the gnum entry of the current match for
* each completion.
* inselect: 1 if we already selecting matches; tested in complistmatches()
* mcol: The column for the selected completion. As we never scroll
* horizontally this applies both the screen and the logical array.
* mline: The line for the selected completion in the logical array of
* all matches, not all of which may be on screen at once.
* mcols: Local copy of columns used in sizing arrays.
* mlines: The number of lines in the logical array of all matches,
* initialised from listdat.nlines.
*/
static int noselect, mselect, inselect, mcol, mline, mcols, mlines;
/*
* selected: Used to signal between domenucomplete() and menuselect()
* that a selected entry has been found. Or something.
* mlbeg: The first line of the logical array of all matches that
* fits on screen. Setting this to -1 forces a redraw.
* mlend: The line after the last that fits on screen.
* mscroll: 1 if the scrolling prompt is shown on screen.
* mrestlines: The number of screen lines remaining to be processed.
*/
static int selected, mlbeg = -1, mlend = 9999999, mscroll, mrestlines;
/*
* mnew: 1 if a new selection menu is being displayed.
* mlastcols: stored value of mcols for use in calculating mnew.
* mlastlines: stored value of mlines for use in calculating mnew.
* mhasstat: Indicates if the status line is present (but maybe not
* yet printed).
* mfirstl: The first line of the logical array of all matches to
* be shown on screen, -1 if this has not yet been determined.
* mlastm: The index of the selected match in some circumstances; used
* if an explicit number for a match is passed to compprintfmt();
* initialised from the total number of matches. I realise this
* isn't very illuminating.
*/
static int mnew, mlastcols, mlastlines, mhasstat, mfirstl, mlastm;
/*
* mlprinted: Used to signal the number of additional lines printed
* when outputting matches (as argument passing is a bit
* screwy within the completion system).
* molbeg: The last value of mlbeg; -1 if invalid, -42 if, er, very
* invalid. Used in calculations of how much to draw.
* mocol: The last value of mcol.
* moline: The last value of mline.
* mstatprinted: Indicates that the status line has now been printed,
* c.f. mhasstat.
*/
static int mlprinted, molbeg = -2, mocol = 0, moline = 0, mstatprinted;
/*
* mstatus: The message printed when scrolling.
* mlistp: The message printed when merely listing.
*/
static char *mstatus, *mlistp;
/*
* mtab is the logical array of all matches referred to above. It
* contains mcols*mlines entries. These entries contain a pointer to
* the match structure which is in use at a particular point. Note
* that for multiple line entries lines after the first contain NULL.
*
* mmtabp is a pointer to the selected entry in mtab.
*/
static Cmatch **mtab, **mmtabp;
/*
* Used to indicate that the list has changed and needs redisplaying.
*/
static int mtab_been_reallocated;
/*
* Array and pointer for the match group in exactly the same layout
* as mtab and mmtabp.
*/
static Cmgroup *mgtab, *mgtabp;
#ifdef DEBUG
/*
* Allow us to keep track of pointer arithmetic for mgtab; could
* just as well have been for mtab but wasn't.
*/
static int mgtabsize;
#endif
/*
* Used in mtab/mgtab, for explanations.
*
* UUUUUUUUUUUUUUURRRRGHHHHHHHHHH!!!!!!!!! --- pws
*/
#define MMARK ((unsigned long) 1)
#define mmarked(v) (((unsigned long) (v)) & MMARK)
#define mtmark(v) ((Cmatch *) (((unsigned long) (v)) | MMARK))
#define mtunmark(v) ((Cmatch *) (((unsigned long) (v)) & ~MMARK))
#define mgmark(v) ((Cmgroup) (((unsigned long) (v)) | MMARK))
#define mgunmark(v) ((Cmgroup) (((unsigned long) (v)) & ~MMARK))
/* Information for in-string colours. */
/* Maximum number of in-string colours supported. */
#define MAX_POS 11
static int nrefs;
static int begpos[MAX_POS], curisbeg;
static int endpos[MAX_POS];
static int sendpos[MAX_POS], curissend; /* sorted end positions */
static char **patcols, *curiscols[MAX_POS];
static int curiscol;
/* The last color used. */
static char *last_cap;
/* We use the parameters ZLS_COLORS and ZLS_COLOURS in the same way as
* the color ls does. It's just that we don't support the `or' file
* type. */
/*
* menu-select widget: used to test if it's already loaded.
*/
static Widget w_menuselect;
/*
* Similarly for the menuselect and listscroll keymaps.
*/
static Keymap mskeymap, lskeymap;
/* Indixes into the terminal string arrays. */
#define COL_NO 0
#define COL_FI 1
#define COL_DI 2
#define COL_LN 3
#define COL_PI 4
#define COL_SO 5
#define COL_BD 6
#define COL_CD 7
#define COL_OR 8
#define COL_MI 9
#define COL_SU 10
#define COL_SG 11
#define COL_TW 12
#define COL_OW 13
#define COL_ST 14
#define COL_EX 15
#define COL_LC 16
#define COL_RC 17
#define COL_EC 18
#define COL_TC 19
#define COL_SP 20
#define COL_MA 21
#define COL_HI 22
#define COL_DU 23
#define COL_SA 24
#define NUM_COLS 25
/* Names of the terminal strings. */
static char *colnames[] = {
"no", "fi", "di", "ln", "pi", "so", "bd", "cd", "or", "mi",
"su", "sg", "tw", "ow", "st", "ex",
"lc", "rc", "ec", "tc", "sp", "ma", "hi", "du", "sa", NULL
};
/* Default values. */
static char *defcols[] = {
"0", "0", "1;31", "1;36", "33", "1;35", "1;33", "1;33", NULL, NULL,
"37;41", "30;43", "30;42", "34;42", "37;44", "1;32",
"\033[", "m", NULL, "0", "0", "7", NULL, NULL, "0"
};
/* This describes a terminal string for a file type. */
typedef struct filecol *Filecol;
struct filecol {
Patprog prog; /* group pattern */
char *col; /* color string */
Filecol next; /* next one */
};
/* This describes a terminal string for a pattern. */
typedef struct patcol *Patcol;
struct patcol {
Patprog prog;
Patprog pat; /* pattern for match */
char *cols[MAX_POS + 1];
Patcol next;
};
/* This describes a terminal string for a filename extension. */
typedef struct extcol *Extcol;
struct extcol {
Patprog prog; /* group pattern or NULL */
char *ext; /* the extension */
char *col; /* the terminal color string */
Extcol next; /* the next one in the list */
};
/* This holds all terminal strings. */
typedef struct listcols *Listcols;
/* values for listcol flags */
enum {
/* ln=target: follow symlinks to determine highlighting */
LC_FOLLOW_SYMLINKS = 0x0001
};
struct listcols {
Filecol files[NUM_COLS]; /* strings for file types */
Patcol pats; /* strings for patterns */
Extcol exts; /* strings for extensions */
int flags; /* special settings, see above */
};
/*
* Contains information about the colours to be used for entries.
* Sometimes mcolors is passed as an argument even though it's
* available to all the functions.
*/
static struct listcols mcolors;
/* Combined length of LC and RC, maximum length of capability strings. */
static int lr_caplen, max_caplen;
/* This parses the value of a definition (the part after the `=').
* The return value is a pointer to the character after it. */
static char *
getcolval(char *s, int multi)
{
char *p, *o = s;
for (p = s; *s && *s != ':' && (!multi || *s != '='); p++, s++) {
if (*s == '\\' && s[1]) {
switch (*++s) {
case 'a': *p = '\007'; break;
case 'n': *p = '\n'; break;
case 'b': *p = '\b'; break;
case 't': *p = '\t'; break;
case 'v': *p = '\v'; break;
case 'f': *p = '\f'; break;
case 'r': *p = '\r'; break;
case 'e': *p = '\033'; break;
case '_': *p = ' '; break;
case '?': *p = '\177'; break;
default:
if (*s >= '0' && *s <= '7') {
int i = STOUC(*s);
if (*++s >= '0' && *s <= '7') {
i = (i * 8) + STOUC(*s);
if (*++s >= '0' && *s <= '7')
i = (i * 8) + STOUC(*s);
}
*p = (char) i;
} else
*p = *s;
}
} else if (*s == '^') {
if ((s[1] >= '@' && s[1] <= '_') ||
(s[1] >= 'a' && s[1] <= 'z'))
*p = (char) (STOUC(*s) & ~0x60);
else if (s[1] == '?')
*p = '\177';
else {
*p++ = *s;
*p = s[1];
}
s++;
} else
*p = *s;
}
if (p != s)
*p = '\0';
if ((s - o) > max_caplen)
max_caplen = s - o;
return s;
}
/* This parses one definition. Return value is a pointer to the
* character after it. */
static char *
getcoldef(char *s)
{
Patprog gprog = NULL;
if (*s == '(') {
char *p;
int l = 0;
for (p = s + 1, l = 0; *p && (*p != ')' || l); p++)
if (*p == '\\' && p[1])
p++;
else if (*p == '(')
l++;
else if (*p == ')')
l--;
if (*p == ')') {
char sav = p[1];
p[1] = '\0';
s = metafy(s, -1, META_USEHEAP);
tokenize(s);
gprog = patcompile(s, 0, NULL);
p[1] = sav;
s = p + 1;
}
}
if (*s == '*') {
Extcol ec, eo;
char *n, *p;
/* This is for an extension. */
n = ++s;
while (*s && *s != '=')
s++;
if (!*s)
return s;
*s++ = '\0';
p = getcolval(s, 0);
ec = (Extcol) zhalloc(sizeof(*ec));
ec->prog = gprog;
ec->ext = n;
ec->col = s;
ec->next = NULL;
if ((eo = mcolors.exts)) {
while (eo->next)
eo = eo->next;
eo->next = ec;
} else
mcolors.exts = ec;
if (*p)
*p++ = '\0';
return p;
} else if (*s == '=') {
char *p = ++s, *t, *cols[MAX_POS];
int ncols = 0;
int nesting = 0;
Patprog prog;
/* This is for a pattern. */
while (*s && (nesting || *s != '=')) {
switch (*s++) {
case '\\':
if (*s)
s++;
break;
case '(':
nesting++;
break;
case ')':
nesting--;
break;
}
}
if (!*s)
return s;
*s++ = '\0';
while (1) {
t = getcolval(s, 1);
if (ncols < MAX_POS)
cols[ncols++] = s;
s = t;
if (*s != '=')
break;
*s++ = '\0';
}
p = metafy(p, -1, META_USEHEAP);
tokenize(p);
if ((prog = patcompile(p, 0, NULL))) {
Patcol pc, po;
int i;
pc = (Patcol) zhalloc(sizeof(*pc));
pc->prog = gprog;
pc->pat = prog;
for (i = 0; i < ncols; i++)
pc->cols[i] = cols[i];
pc->cols[i] = NULL;
pc->next = NULL;
if ((po = mcolors.pats)) {
while (po->next)
po = po->next;
po->next = pc;
} else
mcolors.pats = pc;
}
if (*t)
*t++ = '\0';
return t;
} else {
char *n = s, *p, **nn;
int i;
/* This is for a file type. */
while (*s && *s != '=')
s++;
if (!*s)
return s;
*s++ = '\0';
for (i = 0, nn = colnames; *nn; i++, nn++)
if (!strcmp(n, *nn))
break;
/*
* special case: highlighting link targets
*/
if (i == COL_LN && strpfx("target", s) &&
(s[6] == ':' || !s[6])) {
mcolors.flags |= LC_FOLLOW_SYMLINKS;
p = s + 6;
} else {
p = getcolval(s, 0);
if (*nn) {
Filecol fc, fo;
fc = (Filecol) zhalloc(sizeof(*fc));
fc->prog = (i == COL_EC || i == COL_LC || i == COL_RC ?
NULL : gprog);
fc->col = s;
fc->next = NULL;
if ((fo = mcolors.files[i])) {
while (fo->next)
fo = fo->next;
fo->next = fc;
} else
mcolors.files[i] = fc;
}
if (*p)
*p++ = '\0';
}
return p;
}
}
static Filecol
filecol(char *col)
{
Filecol fc;
fc = (Filecol) zhalloc(sizeof(*fc));
fc->prog = NULL;
fc->col = col;
fc->next = NULL;
return fc;
}
/*
* This initializes the given terminal color structure.
*/
static void
getcols(void)
{
char *s;
int i, l;
max_caplen = lr_caplen = 0;
mcolors.flags = 0;
queue_signals();
if (!(s = getsparam_u("ZLS_COLORS")) &&
!(s = getsparam_u("ZLS_COLOURS"))) {
for (i = 0; i < NUM_COLS; i++)
mcolors.files[i] = filecol("");
mcolors.pats = NULL;
mcolors.exts = NULL;
if ((s = tcstr[TCSTANDOUTBEG]) && s[0]) {
mcolors.files[COL_MA] = filecol(s);
mcolors.files[COL_EC] = filecol(tcstr[TCSTANDOUTEND]);
} else
mcolors.files[COL_MA] = filecol(defcols[COL_MA]);
lr_caplen = 0;
if ((max_caplen = strlen(mcolors.files[COL_MA]->col)) <
(l = strlen(mcolors.files[COL_EC]->col)))
max_caplen = l;
unqueue_signals();
return;
}
/* Reset the global color structure. */
memset(&mcolors, 0, sizeof(mcolors));
s = dupstring(s);
while (*s)
if (*s == ':')
s++;
else
s = getcoldef(s);
unqueue_signals();
/* Use default values for those that aren't set explicitly. */
for (i = 0; i < NUM_COLS; i++) {
if (!mcolors.files[i] || !mcolors.files[i]->col)
mcolors.files[i] = filecol(defcols[i]);
if (mcolors.files[i] && mcolors.files[i]->col &&
(l = strlen(mcolors.files[i]->col)) > max_caplen)
max_caplen = l;
}
lr_caplen = strlen(mcolors.files[COL_LC]->col) +
strlen(mcolors.files[COL_RC]->col);
/* Default for orphan is same as link. */
if (!mcolors.files[COL_OR] || !mcolors.files[COL_OR]->col)
mcolors.files[COL_OR] = mcolors.files[COL_LN];
/* Default for missing files: currently not used */
if (!mcolors.files[COL_MI] || !mcolors.files[COL_MI]->col)
mcolors.files[COL_MI] = mcolors.files[COL_FI];
return;
}
static void
zlrputs(char *cap)
{
if (!*last_cap || strcmp(last_cap, cap)) {
VARARR(char, buf, lr_caplen + max_caplen + 1);
strcpy(buf, mcolors.files[COL_LC]->col);
strcat(buf, cap);
strcat(buf, mcolors.files[COL_RC]->col);
tputs(buf, 1, putshout);
strcpy(last_cap, cap);
}
}
static void
zcputs(char *group, int colour)
{
Filecol fc;
for (fc = mcolors.files[colour]; fc; fc = fc->next)
if (fc->col &&
(!fc->prog || !group || pattry(fc->prog, group))) {
zlrputs(fc->col);
return;
}
zlrputs("0");
}
/* Turn off colouring. */
static void
zcoff(void)
{
if (mcolors.files[COL_EC] && mcolors.files[COL_EC]->col) {
tputs(mcolors.files[COL_EC]->col, 1, putshout);
*last_cap = '\0';
} else
zcputs(NULL, COL_NO);
}
/* Clear to end of line, if possible and necessary. */
static void
cleareol()
{
if (mlbeg >= 0 && tccan(TCCLEAREOL)) {
if (*last_cap)
zcoff(); /* If we used colors, prevent them from bleeding. */
tcout(TCCLEAREOL);
}
}
static void
initiscol(void)
{
int i;
zlrputs(patcols[0]);
curiscols[curiscol = 0] = *patcols++;
curisbeg = curissend = 0;
for (i = 0; i < nrefs; i++)
sendpos[i] = 0xfffffff;
for (; i < MAX_POS; i++)
begpos[i] = endpos[i] = sendpos[i] = 0xfffffff;
}
static void
doiscol(int pos)
{
int fi;
while (pos > sendpos[curissend]) {
curissend++;
if (curiscol) {
zcputs(NULL, COL_NO);
zlrputs(curiscols[--curiscol]);
}
}
while (((fi = (endpos[curisbeg] < begpos[curisbeg] ||
begpos[curisbeg] == -1)) ||
pos == begpos[curisbeg]) && *patcols) {
if (!fi) {
int i, j, e = endpos[curisbeg];
/* insert e in sendpos */
for (i = curissend; sendpos[i] <= e; ++i)
;
for (j = MAX_POS - 1; j > i; --j)
sendpos[j] = sendpos[j-1];
sendpos[i] = e;
zcputs(NULL, COL_NO);
zlrputs(*patcols);
curiscols[++curiscol] = *patcols;
}
++patcols;
++curisbeg;
}
}
/* Stripped-down version of printfmt(). But can do in-string colouring. */
static int
clprintfmt(char *p, int ml)
{
int cc = 0, i = 0, ask, beg;
initiscol();
while (*p) {
convchar_t chr;
int chrlen = MB_METACHARLENCONV(p, &chr);
doiscol(i++);
cc++;
if (*p == '\n') {
cleareol();
cc = 0;
}
if (ml == mlend - 1 && (cc % zterm_columns) == zterm_columns - 1)
return 0;
while (chrlen) {
if (*p == Meta) {
p++;
chrlen--;
putc(*p ^ 32, shout);
} else
putc(*p, shout);
chrlen--;
p++;
}
if ((beg = !(cc % zterm_columns)))
ml++;
if (mscroll && !(cc % zterm_columns) &&
!--mrestlines && (ask = asklistscroll(ml)))
return ask;
}
cleareol();
return 0;
}
/*
* Local version of nicezputs() with in-string colouring
* and scrolling.
*/
static int
clnicezputs(int do_colors, char *s, int ml)
{
int i = 0, col = 0, ask, oml = ml;
char *t;
ZLE_CHAR_T cc;
#ifdef MULTIBYTE_SUPPORT
/*
* ums is the untokenized, unmetafied string (length umlen)
* uptr is a pointer into it
* sptr is the start of the nice character representation
* wptr is the point at which the wide character itself starts
* (but may be the end of the string if the character was fully
* prettified).
* ret is the return status from the conversion to a wide character
* umleft is the remaining length of the unmetafied string to output
* umlen is the full length of the unmetafied string
* width is the full printing width of a prettified character,
* including both ASCII prettification and the wide character itself.
* mbs is the shift state of the conversion to wide characters.
*/
char *ums, *uptr, *sptr, *wptr;
int umleft, umlen, eol = 0;
size_t width;
mbstate_t mbs;
memset(&mbs, 0, sizeof mbs);
ums = ztrdup(s);
untokenize(ums);
uptr = unmetafy(ums, &umlen);
umleft = umlen;
if (do_colors)
initiscol();
mb_charinit();
while (umleft > 0) {
size_t cnt = eol ? MB_INVALID : mbrtowc(&cc, uptr, umleft, &mbs);
switch (cnt) {
case MB_INCOMPLETE:
eol = 1;
/* FALL THROUGH */
case MB_INVALID:
/* This handles byte values that aren't valid wide-character
* sequences. */
sptr = nicechar(*uptr);
/* everything here is ASCII... */
width = strlen(sptr);
wptr = sptr + width;
cnt = 1;
/* Get mbs out of its undefined state. */
memset(&mbs, 0, sizeof mbs);
break;
case 0:
/* This handles a '\0' in the input (which is a real char
* to us, not a terminator). */
cnt = 1;
/* FALL THROUGH */
default:
sptr = wcs_nicechar(cc, &width, &wptr);
break;
}
umleft -= cnt;
uptr += cnt;
if (do_colors) {
/*
* The code for the colo[u]ri[s/z]ation is obscure (surprised?)
* but if we do it for every input character, as we do in
* the simple case, we shouldn't go too far wrong.
*/
while (cnt--)
doiscol(i++);
}
/*
* Loop over characters in the output of the nice
* representation. This will often correspond to one input
* (possibly multibyte) character.
*/
for (t = sptr; *t; t++) {
/* Input is metafied... */
int nc = (*t == Meta) ? STOUC(*++t ^ 32) : STOUC(*t);
/* Is the screen full? */
if (ml == mlend - 1 && col == zterm_columns - 1) {
mlprinted = ml - oml;
free(ums);
return 0;
}
if (t < wptr) {
/* outputting ASCII, so single-width */
putc(nc, shout);
col++;
width--;
} else {
/* outputting a single wide character, do the lot */
putc(nc, shout);
/* don't check column until finished */
if (t[1])
continue;
/* now we've done the entire rest of the representation */
col += width;
}
/*
* There might be problems with characters of printing width
* greater than one here.
*/
if (col > zterm_columns) {
ml++;
if (mscroll && !--mrestlines && (ask = asklistscroll(ml))) {
mlprinted = ml - oml;
free(ums);
return ask;
}
col -= zterm_columns;
if (do_colors)
fputs(" \010", shout);
}
}
}
free(ums);
#else
if (do_colors)
initiscol();
while ((cc = *s++)) {
if (do_colors)
doiscol(i++);
if (itok(cc)) {
if (cc <= Comma)
cc = ztokens[cc - Pound];
else
continue;
}
if (cc == Meta)
cc = *s++ ^ 32;
for (t = nicechar(cc); *t; t++) {
int nc = (*t == Meta) ? STOUC(*++t ^ 32) : STOUC(*t);
if (ml == mlend - 1 && col == zterm_columns - 1) {
mlprinted = ml - oml;
return 0;
}
putc(nc, shout);
if (++col > zterm_columns) {
ml++;
if (mscroll && !--mrestlines && (ask = asklistscroll(ml))) {
mlprinted = ml - oml;
return ask;
}
col = 0;
if (do_colors)
fputs(" \010", shout);
}
}
}
#endif
mlprinted = ml - oml;
return 0;
}
/* Get the terminal color string for the given match. */
static int
putmatchcol(char *group, char *n)
{
Patcol pc;
for (pc = mcolors.pats; pc; pc = pc->next) {
nrefs = MAX_POS - 1;
if ((!pc->prog || !group || pattry(pc->prog, group)) &&
pattryrefs(pc->pat, n, -1, -1, NULL, 0, &nrefs, begpos, endpos)) {
if (pc->cols[1]) {
patcols = pc->cols;
return 1;
}
zlrputs(pc->cols[0]);
return 0;
}
}
zcputs(group, COL_NO);
return 0;
}
/* Get the terminal color string for the file with the given name and
* file modes. */
static int
putfilecol(char *group, char *filename, mode_t m, int special)
{
int colour = -1;
Extcol ec;
Patcol pc;
int len;
for (pc = mcolors.pats; pc; pc = pc->next) {
nrefs = MAX_POS - 1;
if ((!pc->prog || !group || pattry(pc->prog, group)) &&
pattryrefs(pc->pat, filename, -1, -1, NULL,
0, &nrefs, begpos, endpos)) {
if (pc->cols[1]) {
patcols = pc->cols;
return 1;
}
zlrputs(pc->cols[0]);
return 0;
}
}
if (special != -1) {
colour = special;
} else if (S_ISDIR(m)) {
if (m & S_IWOTH)
if (m & S_ISVTX)
colour = COL_TW;
else
colour = COL_OW;
else if (m & S_ISVTX)
colour = COL_ST;
else
colour = COL_DI;
} else if (S_ISLNK(m))
colour = COL_LN;
else if (S_ISFIFO(m))
colour = COL_PI;
else if (S_ISSOCK(m))
colour = COL_SO;
else if (S_ISBLK(m))
colour = COL_BD;
else if (S_ISCHR(m))
colour = COL_CD;
else if (m & S_ISUID)
colour = COL_SU;
else if (m & S_ISGID)
colour = COL_SG;
else if (S_ISREG(m) && (m & S_IXUGO))
colour = COL_EX;
if (colour != -1) {
zcputs(group, colour);
return 0;
}
for (ec = mcolors.exts; ec; ec = ec->next)
if (strsfx(ec->ext, filename) &&
(!ec->prog || !group || pattry(ec->prog, group))) {
zlrputs(ec->col);
return 0;
}
/* Check for suffix alias */
len = strlen(filename);
/* shortest valid suffix format is a.b */
if (len > 2) {
char *suf = filename + len - 1;
while (suf > filename+1) {
if (suf[-1] == '.') {
if (sufaliastab->getnode(sufaliastab, suf)) {
zcputs(group, COL_SA);
return 0;
}
break;
}
suf--;
}
}
zcputs(group, COL_FI);
return 0;
}
static Cmgroup last_group;
/**/
static int
asklistscroll(int ml)
{
Thingy cmd;
int i, ret = 0;
compprintfmt(NULL, 1, 1, 1, ml, NULL);
fflush(shout);
zsetterm();
menuselect_bindings(); /* sanity in case deleted by user */
selectlocalmap(lskeymap);
if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak))
ret = 1;
else if (cmd == Th(z_acceptline) ||
cmd == Th(z_downhistory) ||
cmd == Th(z_downlineorhistory) ||
cmd == Th(z_downlineorsearch) ||
cmd == Th(z_vidownlineorhistory))
mrestlines = 1;
else if (cmd == Th(z_completeword) ||
cmd == Th(z_expandorcomplete) ||
cmd == Th(z_expandorcompleteprefix) ||
cmd == Th(z_menucomplete) ||
cmd == Th(z_menuexpandorcomplete) ||
!strcmp(cmd->nam, "menu-select") ||
!strcmp(cmd->nam, "complete-word") ||
!strcmp(cmd->nam, "expand-or-complete") ||
!strcmp(cmd->nam, "expand-or-complete-prefix") ||
!strcmp(cmd->nam, "menu-complete") ||
!strcmp(cmd->nam, "menu-expand-or-complete"))
mrestlines = zterm_lines - 1;
else if (cmd == Th(z_acceptsearch))
ret = 1;
else {
ungetkeycmd();
ret = 1;
}
selectlocalmap(NULL);
settyinfo(&shttyinfo);
putc('\r', shout);
for (i = zterm_columns - 1; i-- > 0; )
putc(' ', shout);
putc('\r', shout);
return ret;
}
#define dolist(X) ((X) >= mlbeg && (X) < mlend)
#define dolistcl(X) ((X) >= mlbeg && (X) < mlend + 1)
#define dolistnl(X) ((X) >= mlbeg && (X) < mlend - 1)
/**/
static int
compprintnl(int ml)
{
int ask;
cleareol();
putc('\n', shout);
if (mscroll && !--mrestlines && (ask = asklistscroll(ml)))
return ask;
return 0;
}
/* This is used to print the strings (e.g. explanations). *
* It returns the number of lines printed. */
/**/
static int
compprintfmt(char *fmt, int n, int dopr, int doesc, int ml, int *stop)
{
char *p, nc[2*DIGBUFSIZE + 12], nbuf[2*DIGBUFSIZE + 12];
int l = 0, cc = 0, b = 0, s = 0, u = 0, m, ask, beg, stat;
if ((stat = !fmt)) {
if (mlbeg >= 0) {
if (!(fmt = mstatus)) {
mlprinted = 0;
return 0;
}
cc = -1;
} else
fmt = mlistp;
}
MB_METACHARINIT();
for (p = fmt; *p; ) {
convchar_t cchar;
int len, width;
len = MB_METACHARLENCONV(p, &cchar);
#ifdef MULTIBYTE_SUPPORT
if (cchar == WEOF) {
cchar = (wchar_t)(*p == Meta ? p[1] ^ 32 : *p);
width = 1;
}
else
#endif
width = WCWIDTH_WINT(cchar);
if (doesc && cchar == ZWC('%')) {
p += len;
if (*p) {
int arg = 0, is_fg;
zattr atr;
if (idigit(*p))
arg = zstrtol(p, &p, 10);
len = MB_METACHARLENCONV(p, &cchar);
#ifdef MULTIBYTE_SUPPORT
if (cchar == WEOF)
cchar = (wchar_t)(*p == Meta ? p[1] ^ 32 : *p);
#endif
p += len;
m = 0;
switch (cchar) {
case ZWC('%'):
if (dopr == 1)
putc('%', shout);
cc++;
break;
case ZWC('n'):
if (!stat) {
sprintf(nc, "%d", n);
if (dopr == 1)
fputs(nc, shout);
/* everything here is ASCII... */
cc += strlen(nc);
}
break;
case ZWC('B'):
b = 1;
if (dopr)
tcout(TCBOLDFACEBEG);
break;
case ZWC('b'):
b = 0; m = 1;
if (dopr)
tcout(TCALLATTRSOFF);
break;
case ZWC('S'):
s = 1;
if (dopr)
tcout(TCSTANDOUTBEG);
break;
case ZWC('s'):
s = 0; m = 1;
if (dopr)
tcout(TCSTANDOUTEND);
break;
case ZWC('U'):
u = 1;
if (dopr)
tcout(TCUNDERLINEBEG);
break;
case ZWC('u'):
u = 0; m = 1;
if (dopr)
tcout(TCUNDERLINEEND);
break;
case ZWC('F'):
case ZWC('K'):
is_fg = (cchar == ZWC('F'));
/* colours must be ASCII */
if (*p == '{') {
p++;
atr = match_colour((const char **)&p, is_fg, 0);
if (*p == '}')
p++;
} else
atr = match_colour(NULL, is_fg, arg);
if (atr != TXT_ERROR && dopr)
set_colour_attribute(atr, is_fg ? COL_SEQ_FG :
COL_SEQ_BG, 0);
break;
case ZWC('f'):
if (dopr)
set_colour_attribute(TXTNOFGCOLOUR, COL_SEQ_FG, 0);
break;
case ZWC('k'):
if (dopr)
set_colour_attribute(TXTNOBGCOLOUR, COL_SEQ_BG, 0);
break;
case ZWC('{'):
if (arg)
cc += arg;
for (; *p && (*p != '%' || p[1] != '}'); p++)
if (dopr)
putc(*p == Meta ? *++p ^ 32 : *p, shout);
if (*p)
p += 2;
break;
case ZWC('m'):
if (stat) {
sprintf(nc, "%d/%d", (n ? mlastm : mselect),
listdat.nlist);
m = 2;
}
break;
case ZWC('M'):
if (stat) {
sprintf(nbuf, "%d/%d", (n ? mlastm : mselect),
listdat.nlist);
sprintf(nc, "%-9s", nbuf);
m = 2;
}
break;
case ZWC('l'):
if (stat) {
sprintf(nc, "%d/%d", ml + 1, listdat.nlines);
m = 2;
}
break;
case ZWC('L'):
if (stat) {
sprintf(nbuf, "%d/%d", ml + 1, listdat.nlines);
sprintf(nc, "%-9s", nbuf);
m = 2;
}
break;
case ZWC('p'):
if (stat) {
if (ml == listdat.nlines - 1)
strcpy(nc, "Bottom");
else if (n ? mfirstl : (mlbeg > 0 || ml != mfirstl))
sprintf(nc, "%d%%",
((ml + 1) * 100) / listdat.nlines);
else
strcpy(nc, "Top");
m = 2;
}
break;
case ZWC('P'):
if (stat) {
if (ml == listdat.nlines - 1)
strcpy(nc, "Bottom");
else if (n ? mfirstl : (mlbeg > 0 || ml != mfirstl))
sprintf(nc, "%2d%% ",
((ml + 1) * 100) / listdat.nlines);
else
strcpy(nc, "Top ");
m = 2;
}
break;
}
if (m == 2 && dopr == 1) {
/* nc only contains ASCII text */
int l = strlen(nc);
if (l + cc > zterm_columns - 2)
nc[l -= l + cc - (zterm_columns - 2)] = '\0';
fputs(nc, shout);
cc += l;
} else if (dopr && m == 1) {
if (b)
tcout(TCBOLDFACEBEG);
if (s)
tcout(TCSTANDOUTBEG);
if (u)
tcout(TCUNDERLINEBEG);
}
} else
break;
} else {
cc += width;
if ((cc >= zterm_columns - 2 || cchar == ZWC('\n')) && stat)
dopr = 2;
if (cchar == ZWC('\n')) {
if (dopr == 1)
cleareol();
l += 1 + ((cc - 1) / zterm_columns);
cc = 0;
}
if (dopr == 1) {
if (ml == mlend - 1 && (cc % zterm_columns) ==
zterm_columns - 1) {
dopr = 0;
p += len;
continue;
}
while (len--) {
if (*p == Meta) {
len--;
p++;
putc(*p++ ^ 32, shout);
} else
putc(*p++, shout);
}
/*
* TODO: the following doesn't allow for
* character widths greater than 1.
*/
if ((beg = !(cc % zterm_columns)) && !stat) {
ml++;
fputs(" \010", shout);
}
if (mscroll && beg && !--mrestlines && (ask = asklistscroll(ml))) {
*stop = 1;
if (stat && n)
mfirstl = -1;
mlprinted = l + (cc ? ((cc-1) / zterm_columns) : 0);
return mlprinted;
}
}
else
p += len;
}
}
if (dopr) {
if (!(cc % zterm_columns))
fputs(" \010", shout);
cleareol();
}
if (stat && n)
mfirstl = -1;
/*
* *Not* subtracting 1 from cc at this point appears to be
* correct. C.f. printfmt in zle_tricky.c.
*/
mlprinted = l + (cc / zterm_columns);
return mlprinted;
}
/* This is like zputs(), but allows scrolling. */
/**/
static int
compzputs(char const *s, int ml)
{
int c, col = 0, ask;
while (*s) {
if (*s == Meta)
c = *++s ^ 32;
else if(itok(*s)) {
s++;
continue;
} else
c = *s;
s++;
putc(c, shout);
if (c == '\n')
cleareol();
if (mscroll && (++col == zterm_columns || c == '\n')) {
ml++;
if (!--mrestlines && (ask = asklistscroll(ml)))
return ask;
col = 0;
}
}
return 0;
}
/**/
static int
compprintlist(int showall)
{
static int lasttype = 0, lastbeg = 0, lastml = 0, lastinvcount = -1;
static int lastn = 0, lastnl = 0, lastnlnct = -1;
static Cmgroup lastg = NULL;
static Cmatch *lastp = NULL;
static Cexpl *lastexpl = NULL;
Cmgroup g;
Cmatch *p, m;
Cexpl *e;
int pnl = 0, cl, mc = 0, ml = 0, printed = 0, stop = 0, asked = 1;
int lastused = 0;
mfirstl = -1;
if (mnew || lastinvcount != invcount || lastbeg != mlbeg || mlbeg < 0) {
lasttype = 0;
lastg = NULL;
lastexpl = NULL;
lastml = 0;
lastnlnct = -1;
}
cl = (listdat.nlines > zterm_lines - nlnct - mhasstat ?
zterm_lines - nlnct - mhasstat :
listdat.nlines) - (lastnlnct > nlnct);
lastnlnct = nlnct;
mrestlines = zterm_lines - 1;
lastinvcount = invcount;
if (cl < 2) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
} else if (mlbeg >= 0 && !tccan(TCCLEAREOL) && tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
g = ((lasttype && lastg) ? lastg : amatches);
while (g && !errflag) {
char **pp = g->ylist;
#ifdef ZSH_HEAP_DEBUG
if (memory_validate(g->heap_id)) {
HEAP_ERROR(g->heap_id);
}
#endif
if ((e = g->expls)) {
if (!lastused && lasttype == 1) {
e = lastexpl;
ml = lastml;
lastused = 1;
}
while (*e && !errflag) {
if (((*e)->count || (*e)->always) &&
(!listdat.onlyexpl ||
(listdat.onlyexpl & ((*e)->always > 0 ? 2 : 1)))) {
if (pnl) {
if (dolistnl(ml) && compprintnl(ml))
goto end;
pnl = 0;
ml++;
if (dolistcl(ml) && cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
}
if (mlbeg < 0 && mfirstl < 0)
mfirstl = ml;
(void)compprintfmt((*e)->str,
((*e)->always ? -1 : (*e)->count),
dolist(ml), 1, ml, &stop);
if (mselect >= 0) {
int mm = (mcols * ml), i;
for (i = mcols; i-- > 0; ) {
DPUTS(mm+i >= mgtabsize, "BUG: invalid position");
mtab[mm + i] = mtmark(NULL);
mgtab[mm + i] = mgmark(NULL);
}
}
if (stop)
goto end;
if (!lasttype && ml >= mlbeg) {
lasttype = 1;
lastg = g;
lastbeg = mlbeg;
lastml = ml;
lastexpl = e;
lastp = NULL;
lastused = 1;
}
ml += mlprinted;
if (dolistcl(ml) && cl >= 0 && (cl -= mlprinted) <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
pnl = 1;
}
e++;
if (!mnew && ml > mlend)
goto end;
}
}
if (!listdat.onlyexpl && mlbeg < 0 && pp && *pp) {
if (pnl) {
if (dolistnl(ml) && compprintnl(ml))
goto end;
pnl = 0;
ml++;
if (cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
}
if (mlbeg < 0 && mfirstl < 0)
mfirstl = ml;
if (g->flags & CGF_LINES) {
while (*pp) {
if (compzputs(*pp, ml))
goto end;
if (*++pp && compprintnl(ml))
goto end;
}
} else {
int n = g->lcount, nl, nc, i, a;
char **pq;
nl = nc = g->lins;
while (n && nl-- && !errflag) {
i = g->cols;
mc = 0;
pq = pp;
while (n && i-- && !errflag) {
if (pq - g->ylist >= g->lcount)
break;
if (compzputs(*pq, mscroll))
goto end;
if (i) {
a = (g->widths ? g->widths[mc] : g->width) -
strlen(*pq);
while (a--)
putc(' ', shout);
}
pq += ((g->flags & CGF_ROWS) ? 1 : nc);
mc++;
n--;
}
if (n) {
if (compprintnl(ml))
goto end;
ml++;
if (cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
}
pp += ((g->flags & CGF_ROWS) ? g->cols : 1);
}
}
} else if (!listdat.onlyexpl &&
(g->lcount || (showall && g->mcount))) {
int n = g->dcount, nl, nc, i, j, wid;
Cmatch *q;
nl = nc = g->lins;
if ((g->flags & CGF_HASDL) &&
(lastused || !lasttype || lasttype == 2)) {
if (!lastused && lasttype == 2) {
p = lastp;
ml = lastml;
n = lastn;
nl = lastnl;
lastused = 1;
pnl = 0;
} else
p = g->matches;
for (; (m = *p); p++) {
if (m->disp && (m->flags & CMF_DISPLINE) &&
(showall || !(m->flags & (CMF_HIDE|CMF_NOLIST)))) {
if (pnl) {
if (dolistnl(ml) && compprintnl(ml))
goto end;
pnl = 0;
ml++;
if (dolistcl(ml) && cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
}
if (!lasttype && ml >= mlbeg) {
lasttype = 2;
lastg = g;
lastbeg = mlbeg;
lastml = ml;
lastp = p;
lastn = n;
lastnl = nl;
lastused = 1;
}
if (mfirstl < 0)
mfirstl = ml;
if (dolist(ml))
printed++;
if (clprintm(g, p, 0, ml, 1, 0))
goto end;
ml += mlprinted;
if (dolistcl(ml) && (cl -= mlprinted) <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
pnl = 1;
}
if (!mnew && ml > mlend)
goto end;
}
}
if (n && pnl) {
if (dolistnl(ml) && compprintnl(ml))
goto end;
pnl = 0;
ml++;
if (dolistcl(ml) && cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
}
if (!lastused && lasttype == 3) {
p = lastp;
n = lastn;
nl = lastnl;
ml = lastml;
lastused = 1;
} else
p = skipnolist(g->matches, showall);
while (n && nl-- && !errflag) {
if (!lasttype && ml >= mlbeg) {
lasttype = 3;
lastg = g;
lastbeg = mlbeg;
lastml = ml;
lastp = p;
lastn = n;
lastnl = nl + 1;
lastused = 1;
}
i = g->cols;
mc = 0;
q = p;
while (n && i-- && !errflag) {
wid = (g->widths ? g->widths[mc] : g->width);
if (!(m = *q)) {
if (clprintm(g, NULL, mc, ml, (!i), wid))
goto end;
break;
}
if (clprintm(g, q, mc, ml, (!i), wid))
goto end;
if (dolist(ml))
printed++;
ml += mlprinted;
if (dolistcl(ml) && (cl -= mlprinted) < 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
if (mfirstl < 0)
mfirstl = ml;
if (--n)
for (j = ((g->flags & CGF_ROWS) ? 1 : nc);
j && *q; j--)
q = skipnolist(q + 1, showall);
mc++;
}
while (i-- > 0) {
if (clprintm(g, NULL, mc, ml, (!i),
(g->widths ? g->widths[mc] : g->width)))
goto end;
mc++;
}
if (n) {
if (dolistnl(ml) && compprintnl(ml))
goto end;
ml++;
if (dolistcl(ml) && cl >= 0 && --cl <= 1) {
cl = -1;
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
}
if (nl)
for (j = ((g->flags & CGF_ROWS) ? g->cols : 1);
j && *p; j--)
p = skipnolist(p + 1, showall);
}
if (!mnew && ml > mlend)
goto end;
}
}
if (g->lcount || (showall && g->mcount))
pnl = 1;
g = g->next;
}
asked = 0;
end:
mstatprinted = 0;
lastlistlen = 0;
if (nlnct <= 1)
mscroll = 0;
if (clearflag) {
int nl;
/* Move the cursor up to the prompt, if always_last_prompt *
* is set and all that... */
if (mlbeg >= 0) {
if ((nl = listdat.nlines + nlnct) >= zterm_lines) {
if (mhasstat) {
putc('\n', shout);
compprintfmt(NULL, 0, 1, 1, mline, NULL);
mstatprinted = 1;
}
nl = zterm_lines - 1;
} else
nl--;
tcmultout(TCUP, TCMULTUP, nl);
showinglist = -1;
lastlistlen = listdat.nlines;
} else if ((nl = listdat.nlines + nlnct - 1) < zterm_lines) {
cleareol();
tcmultout(TCUP, TCMULTUP, nl);
showinglist = -1;
lastlistlen = listdat.nlines;
} else {
clearflag = 0;
if (!asked) {
mrestlines = (ml + nlnct > zterm_lines);
compprintnl(ml);
}
}
} else if (!asked) {
mrestlines = (ml + nlnct > zterm_lines);
compprintnl(ml);
}
listshown = (clearflag ? 1 : -1);
mnew = 0;
return printed;
}
/**/
static int
clprintm(Cmgroup g, Cmatch *mp, int mc, int ml, int lastc, int width)
{
Cmatch m;
int len, subcols = 0, stop = 0, ret = 0;
DPUTS2(mselect >= 0 && ml >= mlines,
"clprintm called with ml too large (%d/%d)",
ml, mlines);
if (g != last_group)
*last_cap = '\0';
last_group = g;
if (!mp) {
if (dolist(ml)) {
zcputs(g->name, COL_SP);
len = width - 2;
while (len-- > 0)
putc(' ', shout);
zcoff();
}
mlprinted = 0;
return 0;
}
m = *mp;
if ((m->flags & CMF_ALL) && (!m->disp || !m->disp[0]))
bld_all_str(m);
mlastm = m->gnum;
if (m->disp && (m->flags & CMF_DISPLINE)) {
if (mselect >= 0) {
int mm = (mcols * ml), i;
if (m->flags & CMF_DUMMY) {
for (i = mcols; i-- > 0; ) {
DPUTS(mm+i >= mgtabsize, "BUG: invalid position");
mtab[mm + i] = mtmark(mp);
mgtab[mm + i] = mgmark(g);
}
} else {
for (i = mcols; i-- > 0; ) {
DPUTS(mm+i >= mgtabsize, "BUG: invalid position");
mtab[mm + i] = mp;
mgtab[mm + i] = g;
}
}
}
if (!dolist(ml)) {
mlprinted = printfmt(m->disp, 0, 0, 0);
return 0;
}
if (m->gnum == mselect) {
int mm = (mcols * ml);
DPUTS(mm >= mgtabsize, "BUG: invalid position");
mline = ml;
mcol = 0;
mmtabp = mtab + mm;
mgtabp = mgtab + mm;
zcputs(g->name, COL_MA);
} else if ((m->flags & CMF_NOLIST) &&
mcolors.files[COL_HI] && mcolors.files[COL_HI]->col)
zcputs(g->name, COL_HI);
else if (mselect >= 0 && (m->flags & (CMF_MULT | CMF_FMULT)) &&
mcolors.files[COL_DU] && mcolors.files[COL_DU]->col)
zcputs(g->name, COL_DU);
else
subcols = putmatchcol(g->name, m->disp);
if (subcols)
ret = clprintfmt(m->disp, ml);
else {
compprintfmt(m->disp, 0, 1, 0, ml, &stop);
if (stop)
ret = 1;
}
zcoff();
} else {
int mx, modec;
if (g->widths) {
int i;
for (i = mx = 0; i < mc; i++)
mx += g->widths[i];
} else
mx = mc * g->width;
if (mselect >= 0) {
int mm = mcols * ml, i;
if (m->flags & CMF_DUMMY) {
for (i = (width ? width : mcols); i-- > 0; ) {
DPUTS(mx+mm+i >= mgtabsize, "BUG: invalid position");
mtab[mx + mm + i] = mtmark(mp);
mgtab[mx + mm + i] = mgmark(g);
}
} else {
for (i = (width ? width : mcols); i-- > 0; ) {
DPUTS(mx+mm+i >= mgtabsize, "BUG: invalid position");
mtab[mx + mm + i] = mp;
mgtab[mx + mm + i] = g;
}
}
}
if (!dolist(ml)) {
int nc = ZMB_nicewidth(m->disp ? m->disp : m->str);
if (nc)
mlprinted = (nc-1) / zterm_columns;
else
mlprinted = 0;
return 0;
}
if (m->gnum == mselect) {
int mm = mcols * ml;
DPUTS(mx+mm >= mgtabsize, "BUG: invalid position");
mcol = mx;
mline = ml;
mmtabp = mtab + mx + mm;
mgtabp = mgtab + mx + mm;
zcputs(g->name, COL_MA);
} else if (m->flags & CMF_NOLIST)
zcputs(g->name, COL_HI);
else if (mselect >= 0 && (m->flags & (CMF_MULT | CMF_FMULT)))
zcputs(g->name, COL_DU);
else if (m->mode) {
/*
* Symlink is orphaned if we read the mode with lstat
* but couldn't read one with stat. That's the
* only way they can be different so the following
* test should be enough.
*/
int orphan_colour = (m->mode && !m->fmode) ? COL_OR : -1;
if (mcolors.flags & LC_FOLLOW_SYMLINKS) {
subcols = putfilecol(g->name, m->str, m->fmode, orphan_colour);
} else {
subcols = putfilecol(g->name, m->str, m->mode, orphan_colour);
}
}
else
subcols = putmatchcol(g->name, (m->disp ? m->disp : m->str));
ret = clnicezputs(subcols,
(m->disp ? m->disp : m->str), ml);
if (ret) {
zcoff();
return 1;
}
len = ZMB_nicewidth(m->disp ? m->disp : m->str);
mlprinted = len ? (len-1) / zterm_columns : 0;
modec = (mcolors.flags & LC_FOLLOW_SYMLINKS) ? m->fmodec : m->modec;
if ((g->flags & CGF_FILES) && modec) {
if (m->gnum != mselect) {
zcoff();
zcputs(g->name, COL_TC);
}
putc(modec, shout);
len++;
}
if ((len = width - len - 2) > 0) {
if (m->gnum != mselect) {
zcoff();
zcputs(g->name, COL_SP);
}
while (len-- > 0)
putc(' ', shout);
}
zcoff();
if (!lastc) {
zcputs(g->name, COL_SP);
fputs(" ", shout);
zcoff();
}
}
return ret;
}
static int
singlecalc(int *cp, int l, int *lcp)
{
int c = *cp, n, j, first = 1;
Cmatch **p, *op, *mp = mtab[l * zterm_columns + c];
for (n = 0, j = c, p = mtab + l * zterm_columns + c, op = NULL;
j >= 0;
j--, p--) {
if (*p == mp)
c = j;
if (!first && *p != op)
n++;
op = *p;
first = 0;
}
*cp = c;
*lcp = 1;
for (p = mtab + l * zterm_columns + c; c < zterm_columns; c++, p++)
if (*p && mp != *p)
*lcp = 0;
return n;
}
static void
singledraw(void)
{
Cmgroup g;
int mc1, mc2, ml1, ml2, md1, md2, mcc1, mcc2, lc1, lc2, t1, t2;
t1 = mline - mlbeg;
t2 = moline - molbeg;
if (t2 < t1) {
mc1 = mocol; ml1 = moline; md1 = t2;
mc2 = mcol; ml2 = mline; md2 = t1;
} else {
mc1 = mcol; ml1 = mline; md1 = t1;
mc2 = mocol; ml2 = moline; md2 = t2;
}
mcc1 = singlecalc(&mc1, ml1, &lc1);
mcc2 = singlecalc(&mc2, ml2, &lc2);
if (md1)
tc_downcurs(md1);
if (mc1)
tcmultout(TCRIGHT, TCMULTRIGHT, mc1);
DPUTS(ml1 * zterm_columns + mc1 >= mgtabsize, "BUG: invalid position");
g = mgtab[ml1 * zterm_columns + mc1];
clprintm(g, mtab[ml1 * zterm_columns + mc1], mcc1, ml1, lc1,
(g->widths ? g->widths[mcc1] : g->width));
if (mlprinted)
(void) tcmultout(TCUP, TCMULTUP, mlprinted);
putc('\r', shout);
if (md2 != md1)
tc_downcurs(md2 - md1);
if (mc2)
tcmultout(TCRIGHT, TCMULTRIGHT, mc2);
DPUTS(ml2 * zterm_columns + mc2 >= mgtabsize, "BUG: invalid position");
g = mgtab[ml2 * zterm_columns + mc2];
clprintm(g, mtab[ml2 * zterm_columns + mc2], mcc2, ml2, lc2,
(g->widths ? g->widths[mcc2] : g->width));
if (mlprinted)
(void) tcmultout(TCUP, TCMULTUP, mlprinted);
putc('\r', shout);
if (mstatprinted) {
int i = zterm_lines - md2 - nlnct;
tc_downcurs(i - 1);
compprintfmt(NULL, 0, 1, 1, mline, NULL);
tcmultout(TCUP, TCMULTUP, zterm_lines - 1);
} else
tcmultout(TCUP, TCMULTUP, md2 + nlnct);
showinglist = -1;
listshown = 1;
}
static int
complistmatches(UNUSED(Hookdef dummy), Chdata dat)
{
static int onlnct = -1;
static int extendedglob;
Cmgroup oamatches = amatches;
amatches = dat->matches;
#ifdef ZSH_HEAP_DEBUG
if (memory_validate(amatches->heap_id)) {
HEAP_ERROR(amatches->heap_id);
}
#endif
if (noselect > 0)
noselect = 0;
if ((minfo.asked == 2 && mselect < 0) || nlnct >= zterm_lines ||
errflag) {
showinglist = 0;
amatches = oamatches;
return (noselect = 1);
}
/*
* There's a lot of memory allocation from this function
* for setting up the color display which isn't needed
* after the function exits, so it's worthwhile pushing
* another heap. As this is called from a hook in the main
* completion handler nothing temporarily allocated from here can be
* useful outside.
*/
pushheap();
extendedglob = opts[EXTENDEDGLOB];
opts[EXTENDEDGLOB] = 1;
getcols();
mnew = ((calclist(mselect >= 0) || mlastcols != zterm_columns ||
mlastlines != listdat.nlines) && mselect >= 0);
if (!listdat.nlines || (mselect >= 0 &&
!(isset(USEZLE) && !termflags &&
complastprompt && *complastprompt))) {
showinglist = listshown = 0;
noselect = 1;
amatches = oamatches;
popheap();
opts[EXTENDEDGLOB] = extendedglob;
return 1;
}
if (inselect || mlbeg >= 0)
clearflag = 0;
mscroll = 0;
mlistp = NULL;
queue_signals();
if (mselect >= 0 || mlbeg >= 0 ||
(mlistp = dupstring(getsparam("LISTPROMPT")))) {
unqueue_signals();
if (mlistp && !*mlistp)
mlistp = "%SAt %p: Hit TAB for more, or the character to insert%s";
trashzle();
showinglist = listshown = 0;
lastlistlen = 0;
if (mlistp) {
clearflag = (isset(USEZLE) && !termflags && dolastprompt);
mscroll = 1;
} else {
clearflag = 1;
minfo.asked = (listdat.nlines + nlnct <= zterm_lines);
}
} else {
unqueue_signals();
mlistp = NULL;
if (asklist()) {
amatches = oamatches;
popheap();
opts[EXTENDEDGLOB] = extendedglob;
return (noselect = 1);
}
}
if (mlbeg >= 0) {
mlend = mlbeg + zterm_lines - nlnct - mhasstat;
while (mline >= mlend)
mlbeg++, mlend++;
} else
mlend = 9999999;
if (mnew) {
int i;
mtab_been_reallocated = 1;
i = zterm_columns * listdat.nlines;
free(mtab);
mtab = (Cmatch **) zalloc(i * sizeof(Cmatch *));
memset(mtab, 0, i * sizeof(Cmatch *));
free(mgtab);
mgtab = (Cmgroup *) zalloc(i * sizeof(Cmgroup));
#ifdef DEBUG
mgtabsize = i;
#endif
memset(mgtab, 0, i * sizeof(Cmgroup));
mlastcols = mcols = zterm_columns;
mlastlines = mlines = listdat.nlines;
mmtabp = 0;
}
last_cap = (char *) zhalloc(max_caplen + 1);
*last_cap = '\0';
if (!mnew && inselect &&
onlnct == nlnct && mlbeg >= 0 && mlbeg == molbeg) {
if (!noselect)
singledraw();
} else if (!compprintlist(mselect >= 0) || !clearflag)
noselect = 1;
onlnct = nlnct;
molbeg = mlbeg;
mocol = mcol;
moline = mline;
amatches = oamatches;
popheap();
opts[EXTENDEDGLOB] = extendedglob;
return (noselect < 0 ? 0 : noselect);
}
static int
adjust_mcol(int wish, Cmatch ***tabp, Cmgroup **grp)
{
Cmatch **matchtab = *tabp;
int p, n, c;
matchtab -= mcol;
for (p = wish; p >= 0 && (!matchtab[p] || mmarked(matchtab[p])); p--);
for (n = wish; n < mcols && (!matchtab[n] || mmarked(matchtab[n])); n++);
if (n == mcols)
n = -1;
if (p < 0) {
if (n < 0)
return 1;
c = n;
} else if (n < 0)
c = p;
else
c = ((mcol - p) < (n - mcol) ? p : n);
*tabp = matchtab + c;
if (grp)
*grp = *grp + c - mcol;
mcol = c;
return 0;
}
typedef struct menustack *Menustack;
struct menustack {
Menustack prev;
char *line;
Brinfo brbeg;
Brinfo brend;
int nbrbeg, nbrend;
int cs, acc, nmatches, mline, mlbeg, nolist;
struct menuinfo info;
Cmgroup amatches, pmatches, lastmatches, lastlmatches;
/*
* Status for how line looked like previously.
*/
char *origline;
int origcs, origll;
/*
* Status for interactive mode. status is the line
* printed above the matches saying what the interactive
* completion prefix is. mode says whether we are in
* interactive or some search mode.
* typed.
*/
char *status;
int mode;
};
typedef struct menusearch *Menusearch;
struct menusearch {
Menusearch prev;
char *str;
int line;
int col;
int back;
int state;
Cmatch **ptr;
};
#define MS_OK 0
#define MS_FAILED 1
#define MS_WRAPPED 2
#define MAX_STATUS 128
static char *
setmstatus(char *status, char *sline, int sll, int scs,
int *csp, int *llp, int *lenp)
{
char *p, *s, *ret = NULL;
int pl, sl, max;
METACHECK();
if (csp) {
*csp = zlemetacs;
*llp = zlemetall;
*lenp = lastend - wb;
ret = dupstring(zlemetaline);
p = (char *) zhalloc(zlemetacs - wb + 1);
strncpy(p, zlemetaline + wb, zlemetacs - wb);
p[zlemetacs - wb] = '\0';
if (lastend < zlemetacs)
s = "";
else {
s = (char *) zhalloc(lastend - zlemetacs + 1);
strncpy(s, zlemetaline + zlemetacs, lastend - zlemetacs);
s[lastend - zlemetacs] = '\0';
}
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(sll);
memcpy(zlemetaline, sline, sll);
zlemetacs = scs;
} else {
p = complastprefix;
s = complastsuffix;
}
pl = strlen(p);
sl = strlen(s);
max = (zterm_columns < MAX_STATUS ? zterm_columns : MAX_STATUS) - 14;
if (max > 12) {
int h = (max - 2) >> 1;
strcpy(status, "interactive: ");
if (pl > h - 3) {
strcat(status, "...");
strcat(status, p + pl - h - 3);
} else
strcat(status, p);
strcat(status, "[]");
if (sl > h - 3) {
strncat(status, s, h - 3);
strcat(status, "...");
} else
strcat(status, s);
}
return ret;
}
static Menusearch msearchstack;
static char *msearchstr = NULL;
static int msearchstate;
static void
msearchpush(Cmatch **p, int back)
{
Menusearch s = (Menusearch) zhalloc(sizeof(struct menusearch));
s->prev = msearchstack;
msearchstack = s;
s->str = dupstring(msearchstr);
s->line = mline;
s->col = mcol;
s->back = back;
s->state = msearchstate;
s->ptr = p;
}
static Cmatch **
msearchpop(int *backp)
{
Menusearch s = msearchstack;
if (!s)
return NULL;
if (s->prev)
msearchstack = s->prev;
msearchstr = s->str;
mline = s->line;
mcol = s->col;
msearchstate = s->state;
*backp = s->back;
return s->ptr;
}
static Cmatch **
msearch(Cmatch **ptr, char *ins, int back, int rep, int *wrapp)
{
Cmatch **p, *l = NULL, m;
int x = mcol, y = mline;
int ex, ey, wrap = 0, owrap = (msearchstate & MS_WRAPPED);
msearchpush(ptr, back);
if (ins)
msearchstr = dyncat(msearchstr, ins);
if (back) {
ex = mcols - 1;
ey = -1;
} else {
ex = 0;
ey = listdat.nlines;
}
p = mtab + (mline * mcols) + mcol;
if (rep)
l = *p;
while (1) {
if (!rep && mtunmark(*p) && *p != l) {
l = *p;
m = *mtunmark(*p);
if (strstr((m->disp ? m->disp : m->str), msearchstr)) {
mcol = x;
mline = y;
return p;
}
}
rep = 0;
if (back) {
p--;
if (--x < 0) {
x = mcols - 1;
y--;
}
} else {
p++;
if (++x == mcols) {
x = 0;
y++;
}
}
if (x == ex && y == ey) {
if (back) {
x = mcols - 1;
y = listdat.nlines - 1;
p = mtab + (y * mcols) + x;
} else {
x = y = 0;
p = mtab;
}
ex = mcol;
ey = mline;
if (wrap || (x == ex && y == ey)) {
msearchstate = MS_FAILED | owrap;
break;
}
msearchstate |= MS_WRAPPED;
wrap = 1;
*wrapp = 1;
}
}
return NULL;
}
/*
* Values to assign to mode: interactive, etc.
*/
#define MM_INTER 1
#define MM_FSEARCH 2
#define MM_BSEARCH 3
static int
domenuselect(Hookdef dummy, Chdata dat)
{
static Chdata fdat = NULL;
static char *lastsearch = NULL;
Cmatch **p;
Cmgroup *pg;
Thingy cmd = 0;
int do_last_key = 0;
Menustack u = NULL;
int i = 0, acc = 0, wishcol = 0, setwish = 0, oe = onlyexpl, wasnext = 0;
int space, lbeg = 0, step = 1, wrap, pl = nlnct, broken = 0, first = 1;
int nolist = 0, mode = 0, modecs, modell, modelen, wasmeta;
char *s;
char status[MAX_STATUS], *modeline = NULL;
msearchstack = NULL;
msearchstr = "";
msearchstate = MS_OK;
status[0] = '\0';
queue_signals();
if (fdat || (dummy && (!(s = getsparam("MENUSELECT")) ||
(dat && dat->num < atoi(s))))) {
if (fdat) {
fdat->matches = dat->matches;
fdat->num = dat->num;
fdat->nmesg = dat->nmesg;
}
unqueue_signals();
return 0;
}
/*
* Lots of the logic here doesn't really make sense if the
* line isn't metafied, but the evidence was that it only used
* to be metafied locally in a couple of places.
* It's horrifically difficult to work out where the line
* is metafied, so I've resorted to the following.
* Unfortunately we need to unmetafy in zrefresh() when
* we want to display something. Maybe this function can
* be done better.
*/
if (zlemetaline != NULL)
wasmeta = 1;
else {
wasmeta = 0;
metafy_line();
}
if ((s = getsparam("MENUSCROLL"))) {
if (!(step = mathevali(s)))
step = (zterm_lines - nlnct) >> 1;
else if (step < 0)
if ((step += zterm_lines - nlnct) < 0)
step = 1;
}
if ((s = getsparam("MENUMODE"))) {
if (!strcmp(s, "interactive")) {
int l = strlen(origline);
/*
* In interactive completion mode we don't insert
* the completion onto the command line, instead
* we show just what the user has typed and
* the match so far underneath (stored in "status").
* So put the command line back to how it
* was before completion started.
*/
mode = MM_INTER;
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(l);
strncpy(zlemetaline, origline, l);
zlemetacs = origcs;
setmstatus(status, NULL, 0 , 0, NULL, NULL, NULL);
} else if (strpfx("search", s)) {
mode = (strstr(s, "back") ? MM_BSEARCH : MM_FSEARCH);
}
}
if ((mstatus = dupstring(getsparam("MENUPROMPT"))) && !*mstatus)
mstatus = "%SScrolling active: current selection at %p%s";
unqueue_signals();
mhasstat = (mstatus && *mstatus);
fdat = dat;
menuselect_bindings(); /* sanity in case deleted by user */
selectlocalmap(mskeymap);
noselect = 1;
while ((menuacc &&
!hasbrpsfx(*(minfo.cur), minfo.prebr, minfo.postbr)) ||
((*minfo.cur)->flags & CMF_DUMMY) ||
(((*minfo.cur)->flags & (CMF_NOLIST | CMF_MULT)) &&
(!(*minfo.cur)->str || !*(*minfo.cur)->str)))
do_menucmp(0);
mselect = (*(minfo.cur))->gnum;
mline = 0;
mlines = 999999;
mlbeg = 0;
molbeg = -42;
mtab_been_reallocated = 0;
for (;;) {
METACHECK();
if (mline < 0 || mtab_been_reallocated) {
int x, y;
Cmatch **p = mtab;
for (y = 0; y < mlines; y++) {
for (x = mcols; x > 0; x--, p++)
if (*p && !mmarked(*p) && **p && mselect == (**p)->gnum)
break;
if (x) {
mcol = mcols - x;
break;
}
}
if (y < mlines)
mline = y;
}
mtab_been_reallocated = 0;
DPUTS(mline < 0,
"BUG: mline < 0 after re-scanning mtab in domenuselect()");
while (mline < mlbeg)
if ((mlbeg -= step) < 0) {
mlbeg = 0;
/* Crude workaround for BUG above */
if (mline < 0)
break;
}
if (mlbeg && lbeg != mlbeg) {
Cmatch **p = mtab + ((mlbeg - 1) * zterm_columns), **q;
int c;
while (mlbeg) {
for (q = p, c = zterm_columns; c > 0; q++, c--)
if (*q && !mmarked(*q))
break;
if (c)
break;
p -= zterm_columns;
mlbeg--;
}
}
if ((space = zterm_lines - pl - mhasstat) > 0)
while (mline >= mlbeg + space)
if ((mlbeg += step) + space > mlines)
mlbeg = mlines - space;
if (lbeg != mlbeg) {
Cmatch **p = mtab + (mlbeg * zterm_columns), **q;
int c;
while (mlbeg < mlines) {
for (q = p, c = zterm_columns; c > 0; q++, c--)
if (*q)
break;
if (c)
break;
p += zterm_columns;
mlbeg++;
}
}
lbeg = mlbeg;
onlyexpl = 0;
showinglist = -2;
if (first && !listshown && isset(LISTBEEP))
zbeep();
if (first) {
/*
* remember the original data that we will use when
* performing interactive completion to restore the
* command line when a menu completion is inserted.
* this is because menu completion will insert
* the next match in the loop; for interactive
* completion we don't want that, we always want to
* be able to type the next character.
*/
modeline = dupstring(zlemetaline);
modecs = zlemetacs;
modell = zlemetall;
modelen = minfo.len;
}
first = 0;
if (mode == MM_INTER)
statusline = status;
else if (mode) {
int l = sprintf(status, "%s%sisearch%s: ",
((msearchstate & MS_FAILED) ? "failed " : ""),
((msearchstate & MS_WRAPPED) ? "wrapped " : ""),
(mode == MM_FSEARCH ? "" : " backward"));
strncat(status, msearchstr, MAX_STATUS - l - 1);
statusline = status;
} else {
statusline = NULL;
}
if (noselect < 0) {
showinglist = clearlist = 0;
clearflag = 1;
}
zrefresh();
statusline = NULL;
inselect = 1;
selected = 1;
if (noselect) {
if (noselect < 0) {
/* no selection until after processing keystroke */
noselect = 0;
goto getk;
}
broken = 1;
break;
}
if (!i) {
i = mcols * mlines;
while (i--)
if (mtab[i])
break;
if (!i)
break;
i = 1;
}
p = mmtabp;
pg = mgtabp;
if (!p) /* selected match not in display, find line */
continue;
minfo.cur = *p;
minfo.group = *pg;
if (setwish)
wishcol = mcol;
else if (mcol > wishcol) {
while (mcol > 0 && p[-1] == minfo.cur)
mcol--, p--, pg--;
} else if (mcol < wishcol) {
while (mcol < mcols - 1 && p[1] == minfo.cur)
mcol++, p++, pg++;
}
setwish = wasnext = 0;
getk:
if (!do_last_key) {
zmult = 1;
cmd = getkeycmd();
/*
* On interrupt, we'll exit due to cmd being empty.
* Don't propagate the interrupt any further, which
* can screw up redrawing.
*/
errflag &= ~ERRFLAG_INT;
if (mtab_been_reallocated) {
do_last_key = 1;
continue;
}
}
do_last_key = 0;
if (!cmd || cmd == Th(z_sendbreak)) {
zbeep();
molbeg = -1;
break;
} else if (nolist && cmd != Th(z_undo) &&
(!mode || (cmd != Th(z_backwarddeletechar) &&
cmd != Th(z_selfinsert) &&
cmd != Th(z_selfinsertunmeta)))) {
ungetkeycmd();
break;
} else if (cmd == Th(z_acceptline) || cmd == Th(z_acceptsearch)) {
if (mode == MM_FSEARCH || mode == MM_BSEARCH) {
mode = 0;
continue;
}
acc = 1;
break;
} else if (cmd == Th(z_viinsert)) {
if (mode == MM_INTER)
mode = 0;
else {
int l = strlen(origline);
/*
* Entering interactive completion mode:
* same code as when we enter it on menu selection
* start.
*/
mode = MM_INTER;
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(l);
strncpy(zlemetaline, origline, l);
zlemetacs = origcs;
setmstatus(status, NULL, 0, 0, NULL, NULL, NULL);
continue;
}
} else if (cmd == Th(z_acceptandinfernexthistory) ||
(mode == MM_INTER && (cmd == Th(z_selfinsert) ||
cmd == Th(z_selfinsertunmeta)))) {
char *saveline = NULL;
int savell = 0;
int savecs = 0;
Menustack s = (Menustack) zhalloc(sizeof(*s));
s->prev = u;
u = s;
s->line = dupstring(zlemetaline);
s->cs = zlemetacs;
s->mline = mline;
s->mlbeg = mlbeg;
memcpy(&(s->info), &minfo, sizeof(struct menuinfo));
s->amatches = amatches;
#ifdef ZSH_HEAP_DEBUG
if (memory_validate(amatches->heap_id)) {
HEAP_ERROR(amatches->heap_id);
}
#endif
s->pmatches = pmatches;
s->lastmatches = lastmatches;
s->lastlmatches = lastlmatches;
s->nolist = nolist;
s->acc = menuacc;
s->brbeg = dupbrinfo(brbeg, NULL, 1);
s->brend = dupbrinfo(brend, NULL, 1);
s->nbrbeg = nbrbeg;
s->nbrend = nbrend;
s->nmatches = nmatches;
s->origline = dupstring(origline);
s->origcs = origcs;
s->origll = origll;
s->status = dupstring(status);
/*
* with just the slightest hint of a note of infuriation:
* mode here is the menu mode, not the file mode, despite
* the fact we're in a file dealing with file highlighting;
* but that's OK, because s is a menu stack entry, despite
* the fact we're in a function declaring s as char *.
* anyway, in functions we really mean *mode* it's
* called m, to be clear.
*/
s->mode = mode;
menucmp = menuacc = hasoldlist = 0;
minfo.cur = NULL;
fixsuffix();
handleundo();
validlist = 0;
amatches = pmatches = lastmatches = NULL;
invalidate_list();
iforcemenu = 1;
comprecursive = 1;
if (cmd != Th(z_acceptandinfernexthistory)) {
int l = strlen(origline);
/*
* Interactive mode: we need to restore the
* line, add the character, then remember how
* this new line looks in order to keep
* the command line as it is with just the
* characters typed by the user.
*/
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(l);
strncpy(zlemetaline, origline, l);
zlemetacs = origcs;
/*
* Horrible quick fix:
* we shouldn't need to metafy and unmetafy
* quite as much. If we kept unmetafied through
* here we could fix up setmstatus to use unmetafied
* as well. This is the only use of setmstatus which
* restores the line so that should be doable.
*/
unmetafy_line();
if (cmd == Th(z_selfinsert))
selfinsert(zlenoargs);
else
selfinsertunmeta(zlenoargs);
metafy_line();
minfo.len++;
minfo.end++;
saveline = (char *) zhalloc(zlemetall);
memcpy(saveline, zlemetaline, zlemetall);
savell = zlemetall;
savecs = zlemetacs;
iforcemenu = -1;
} else
mode = 0;
/* Nested completion assumes line is unmetafied */
unmetafy_line();
menucomplete(zlenoargs);
metafy_line();
iforcemenu = 0;
if (cmd != Th(z_acceptandinfernexthistory))
modeline = setmstatus(status, saveline, savell, savecs,
&modecs, &modell, &modelen);
if (nmatches < 1 || !minfo.cur || !*(minfo.cur)) {
nolist = 1;
if (mode == MM_INTER) {
statusline = status;
} else {
/* paranoia */
statusline = NULL;
}
if (nmessages) {
showinglist = -2;
zrefresh();
noselect = -1;
} else {
trashzle();
zsetterm();
if (tccan(TCCLEAREOD))
tcout(TCCLEAREOD);
fputs("no matches\r", shout);
fflush(shout);
tcmultout(TCUP, TCMULTUP, nlnct);
showinglist = clearlist = 0;
clearflag = 1;
zrefresh();
showinglist = clearlist = 0;
}
statusline = NULL;
goto getk;
}
clearlist = listshown = 1;
mselect = (*(minfo.cur))->gnum;
setwish = wasnext = 1;
mline = 0;
molbeg = -42;
continue;
} else if (cmd == Th(z_acceptandhold) ||
cmd == Th(z_acceptandmenucomplete)) {
Menustack s = (Menustack) zhalloc(sizeof(*s));
int ol;
if (mode == MM_INTER)
do_single(*minfo.cur);
mode = 0;
s->prev = u;
u = s;
s->line = dupstring(zlemetaline);
s->cs = zlemetacs;
s->mline = mline;
s->mlbeg = mlbeg;
memcpy(&(s->info), &minfo, sizeof(struct menuinfo));
s->amatches = s->pmatches =
s->lastmatches = s->lastlmatches = NULL;
s->nolist = nolist;
s->acc = menuacc;
s->brbeg = dupbrinfo(brbeg, NULL, 1);
s->brend = dupbrinfo(brend, NULL, 1);
s->nbrbeg = nbrbeg;
s->nbrend = nbrend;
s->nmatches = nmatches;
s->origline = dupstring(origline);
s->origcs = origcs;
s->origll = origll;
s->status = dupstring(status);
/* see above */
s->mode = mode;
accept_last();
handleundo();
comprecursive = 1;
do_menucmp(0);
mselect = (*(minfo.cur))->gnum;
p -= mcol;
mcol = 0;
ol = mline;
do {
for (mcol = 0; mcol < mcols; mcol++, p++)
if (*p == minfo.cur)
break;
if (mcol != mcols)
break;
if (++mline == mlines) {
mline = 0;
p -= mlines * mcols;
}
} while (mline != ol);
if (*p != minfo.cur) {
noselect = clearlist = listshown = 1;
onlyexpl = 0;
zrefresh();
break;
}
setwish = 1;
continue;
} else if (cmd == Th(z_undo) ||
(mode == MM_INTER && cmd == Th(z_backwarddeletechar))) {
int l;
if (!u)
break;
handleundo();
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(l = strlen(u->line));
strncpy(zlemetaline, u->line, l);
zlemetacs = u->cs;
menuacc = u->acc;
memcpy(&minfo, &(u->info), sizeof(struct menuinfo));
p = &(minfo.cur);
mline = u->mline;
mlbeg = u->mlbeg;
if (u->lastmatches && lastmatches != u->lastmatches) {
if (lastmatches)
freematches(lastmatches, 0);
amatches = u->amatches;
#ifdef ZSH_HEAP_DEBUG
if (memory_validate(amatches->heap_id)) {
HEAP_ERROR(amatches->heap_id);
}
#endif
pmatches = u->pmatches;
lastmatches = u->lastmatches;
lastlmatches = u->lastlmatches;
nmatches = u->nmatches;
hasoldlist = validlist = 1;
}
freebrinfo(brbeg);
freebrinfo(brend);
brbeg = dupbrinfo(u->brbeg, &lastbrbeg, 0);
brend = dupbrinfo(u->brend, &lastbrend, 0);
nbrbeg = u->nbrbeg;
nbrend = u->nbrend;
zsfree(origline);
origline = ztrdup(u->origline);
origcs = u->origcs;
origll = u->origll;
strcpy(status, u->status);
mode = u->mode;
nolist = u->nolist;
u = u->prev;
clearlist = 1;
setwish = 1;
listdat.valid = 0;
molbeg = -42;
if (nolist) {
if (mode == MM_INTER) {
statusline = status;
} else {
/* paranoia */
statusline = NULL;
}
zrefresh();
statusline = NULL;
goto getk;
}
if (mode)
continue;
} else if (cmd == Th(z_redisplay)) {
redisplay(zlenoargs);
molbeg = -42;
continue;
} else if (cmd == Th(z_clearscreen)) {
clearscreen(zlenoargs);
molbeg = -42;
continue;
} else if (cmd == Th(z_downhistory) ||
cmd == Th(z_downlineorhistory) ||
cmd == Th(z_downlineorsearch) ||
cmd == Th(z_vidownlineorhistory)) {
int omline;
Cmatch **op;
mode = 0;
wrap = 0;
down:
omline = mline;
op = p;
do {
if (mline == mlines - 1) {
if (wrap & 2) {
mline = omline;
p = op;
break;
}
p -= mline * mcols;
mline = 0;
wrap |= 1;
} else {
mline++;
p += mcols;
}
if (adjust_mcol(wishcol, &p, NULL))
continue;
} while (!*p || mmarked(*p));
if (wrap == 1)
goto right;
} else if (cmd == Th(z_uphistory) ||
cmd == Th(z_uplineorhistory) ||
cmd == Th(z_uplineorsearch) ||
cmd == Th(z_viuplineorhistory)) {
int omline;
Cmatch **op;
mode = 0;
wrap = 0;
up:
omline = mline;
op = p;
do {
if (!mline) {
if (wrap & 2) {
mline = omline;
p = op;
break;
}
mline = mlines - 1;
p += mline * mcols;
wrap |= 1;
} else {
mline--;
p -= mcols;
}
if (adjust_mcol(wishcol, &p, NULL))
continue;
} while (!*p || mmarked(*p));
if (wrap == 1) {
if (mcol == wishcol)
goto left;
wishcol = mcol;
}
} else if (cmd == Th(z_emacsforwardword) ||
cmd == Th(z_viforwardword) ||
cmd == Th(z_viforwardwordend) ||
cmd == Th(z_forwardword)) {
int i = zterm_lines - pl - 1, oi = i, ll = 0;
Cmatch **lp = NULL;
mode = 0;
if (mline == mlines - 1)
goto top;
while (i > 0) {
if (mline == mlines - 1) {
if (i != oi && lp)
break;
goto top;
} else {
mline++;
p += mcols;
}
if (adjust_mcol(wishcol, &p, NULL))
continue;
if (*p && !mmarked(*p)) {
i--;
lp = p;
ll = mline;
}
}
p = lp;
mline = ll;
} else if (cmd == Th(z_emacsbackwardword) ||
cmd == Th(z_vibackwardword) ||
cmd == Th(z_backwardword)) {
int i = zterm_lines - pl - 1, oi = i, ll = 0;
Cmatch **lp = NULL;
mode = 0;
if (!mline)
goto bottom;
while (i > 0) {
if (!mline) {
if (i != oi && lp)
break;
goto bottom;
} else {
mline--;
p -= mcols;
}
if (adjust_mcol(wishcol, &p, NULL))
continue;
if (*p || !mmarked(*p)) {
i--;
lp = p;
ll = mline;
}
}
p = lp;
mline = ll;
} else if (cmd == Th(z_beginningofhistory)) {
int ll;
Cmatch **lp;
mode = 0;
top:
ll = mline;
lp = p;
while (mline) {
mline--;
p -= mcols;
if (adjust_mcol(wishcol, &p, NULL))
continue;
if (*p && !mmarked(*p)) {
lp = p;
ll = mline;
}
}
mline = ll;
p = lp;
} else if (cmd == Th(z_endofhistory)) {
int ll;
Cmatch **lp;
mode = 0;
bottom:
ll = mline;
lp = p;
while (mline < mlines - 1) {
mline++;
p += mcols;
if (adjust_mcol(wishcol, &p, NULL))
continue;
if (*p && !mmarked(*p)) {
lp = p;
ll = mline;
}
}
mline = ll;
p = lp;
} else if (cmd == Th(z_forwardchar) || cmd == Th(z_viforwardchar)) {
int omcol;
Cmatch **op;
mode = 0;
wrap = 0;
right:
omcol = mcol;
op = p;
do {
if (mcol == mcols - 1) {
if (wrap & 1) {
p = op;
mcol = omcol;
break;
}
p -= mcol;
mcol = 0;
wrap |= 2;
} else {
mcol++;
p++;
}
} while (!*p || mmarked(*p) || (mcol != omcol && *p == *op));
wishcol = mcol;
if (wrap == 2)
goto down;
} else if (cmd == Th(z_backwardchar) || cmd == Th(z_vibackwardchar)) {
int omcol;
Cmatch **op;
mode = 0;
wrap = 0;
left:
omcol = mcol;
op = p;
do {
if (!mcol) {
if (wrap & 1) {
p = op;
mcol = omcol;
break;
}
mcol = mcols - 1;
p += mcol;
wrap |= 2;
} else {
mcol--;
p--;
}
} while (!*p || mmarked(*p) || (mcol != omcol && *p == *op));
wishcol = mcol;
if (wrap == 2) {
p += mcols - 1 - mcol;
wishcol = mcol = mcols - 1;
adjust_mcol(wishcol, &p, NULL);
goto up;
}
} else if (cmd == Th(z_beginningofbufferorhistory) ||
cmd == Th(z_beginningofline) ||
cmd == Th(z_beginningoflinehist) ||
cmd == Th(z_vibeginningofline)) {
mode = 0;
p -= mcol;
mcol = 0;
while (!*p || mmarked(*p)) {
mcol++;
p++;
}
wishcol = 0;
} else if (cmd == Th(z_endofbufferorhistory) ||
cmd == Th(z_endofline) ||
cmd == Th(z_endoflinehist) ||
cmd == Th(z_viendofline)) {
mode = 0;
p += mcols - mcol - 1;
mcol = mcols - 1;
while (!*p || mmarked(*p)) {
mcol--;
p--;
}
wishcol = mcols - 1;
} else if (cmd == Th(z_viforwardblankword) ||
cmd == Th(z_viforwardblankwordend)) {
Cmgroup g = *pg;
int ol = mline;
mode = 0;
do {
if (mline == mlines - 1) {
p -= mline * mcols;
pg -= mline * mcols;
mline = 0;
} else {
mline++;
p += mcols;
pg += mcols;
}
if (adjust_mcol(wishcol, &p, &pg))
continue;
} while (ol != mline && (*pg == g || !*pg || mmarked(*pg)));
} else if (cmd == Th(z_vibackwardblankword)) {
Cmgroup g = *pg;
int ol = mline;
mode = 0;
do {
if (!mline) {
mline = mlines - 1;
p += mline * mcols;
pg += mline * mcols;
} else {
mline--;
p -= mcols;
pg -= mcols;
}
if (adjust_mcol(wishcol, &p, &pg))
continue;
} while (ol != mline && (*pg == g || !*pg || mmarked(*pg)));
} else if (cmd == Th(z_completeword) ||
cmd == Th(z_expandorcomplete) ||
cmd == Th(z_expandorcompleteprefix) ||
cmd == Th(z_menucomplete) ||
cmd == Th(z_menuexpandorcomplete) ||
!strcmp(cmd->nam, "menu-select") ||
!strcmp(cmd->nam, "complete-word") ||
!strcmp(cmd->nam, "expand-or-complete") ||
!strcmp(cmd->nam, "expand-or-complete-prefix") ||
!strcmp(cmd->nam, "menu-complete") ||
!strcmp(cmd->nam, "menu-expand-or-complete")) {
if (mode == MM_INTER) {
/*
* do_menucmp() has inserted the completion onto
* the command line. In interactive mode we
* don't want that, just what the user typed,
* so restore the information.
*/
zsfree(origline);
origline = ztrdup(modeline);
origcs = modecs;
origll = modell;
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
spaceinline(origll);
strncpy(zlemetaline, origline, origll);
zlemetacs = origcs;
minfo.len = modelen;
} else {
mode = 0;
comprecursive = 1;
do_menucmp(0);
mselect = (*(minfo.cur))->gnum;
setwish = 1;
mline = -1;
}
continue;
} else if (cmd == Th(z_reversemenucomplete) ||
!strcmp(cmd->nam, "reverse-menu-complete")) {
mode = 0;
comprecursive = 1;
zmult = -zmult;
do_menucmp(0);
mselect = (*(minfo.cur))->gnum;
setwish = 1;
mline = -1;
continue;
} else if (cmd == Th(z_historyincrementalsearchforward) ||
cmd == Th(z_historyincrementalsearchbackward) ||
((mode == MM_FSEARCH || mode == MM_BSEARCH) &&
(cmd == Th(z_selfinsert) ||
cmd == Th(z_selfinsertunmeta) ||
cmd == Th(z_bracketedpaste)))) {
Cmatch **np, **op = p;
int was = (mode == MM_FSEARCH || mode == MM_BSEARCH);
int ins = (cmd == Th(z_selfinsert) || cmd == Th(z_selfinsertunmeta) ||
cmd == Th(z_bracketedpaste));
int back = (cmd == Th(z_historyincrementalsearchbackward));
int wrap;
do {
char *toins = NULL;
#ifdef MULTIBYTE_SUPPORT
/* MB_CUR_MAX may not be constant */
VARARR(char, insert, MB_CUR_MAX+1);
#else
char insert[2];
#endif
if (was) {
p += wishcol - mcol;
mcol = wishcol;
}
if (!ins) {
if (was) {
if (!*msearchstr && lastsearch &&
back == (mode == MM_BSEARCH)) {
msearchstr = dupstring(lastsearch);
mode = 0;
}
} else {
msearchstr = "";
msearchstack = NULL;
msearchstate = MS_OK;
}
} else {
if (cmd == Th(z_selfinsertunmeta)) {
fixunmeta();
}
if (cmd == Th(z_bracketedpaste)) {
toins = bracketedstring();
} else {
toins = insert;
#ifdef MULTIBYTE_SUPPORT
if (lastchar_wide_valid)
{
mbstate_t mbs;
int len;
memset(&mbs, 0, sizeof(mbs));
len = wcrtomb(toins, lastchar_wide, &mbs);
if (len < 0)
len = 0;
insert[len] = '\0';
} else
#endif
{
insert[0] = lastchar;
insert[1] = '\0';
}
}
}
wrap = 0;
np = msearch(p, toins, (ins ? (mode == MM_BSEARCH) : back),
(was && !ins), &wrap);
if (!ins)
mode = (back ? MM_BSEARCH : MM_FSEARCH);
else if (cmd == Th(z_bracketedpaste))
free(toins);
if (*msearchstr) {
zsfree(lastsearch);
lastsearch = ztrdup(msearchstr);
}
if (np) {
wishcol = mcol;
p = np;
}
adjust_mcol(wishcol, &p, NULL);
} while ((back || cmd == Th(z_historyincrementalsearchforward)) &&
np && !wrap && was && **p == **op);
} else if ((mode == MM_FSEARCH || mode == MM_BSEARCH) &&
cmd == Th(z_backwarddeletechar)) {
int back = 1;
Cmatch **np = msearchpop(&back);
mode = (back ? MM_BSEARCH : MM_FSEARCH);
wishcol = mcol;
if (np) {
p = np;
adjust_mcol(wishcol, &p, NULL);
}
} else if (cmd == Th(z_undefinedkey)) {
mode = 0;
continue;
} else {
ungetkeycmd();
if (cmd->widget && (cmd->widget->flags & WIDGET_NCOMP)) {
acc = 0;
broken = 2;
} else
acc = 1;
break;
}
do_single(**p);
mselect = (**p)->gnum;
}
if (u)
for (; u; u = u->prev)
if (u->lastmatches != lastmatches)
freematches(u->lastmatches, 0);
selectlocalmap(NULL);
mselect = mlastcols = mlastlines = -1;
mstatus = NULL;
inselect = mhasstat = 0;
if (nolist)
clearlist = listshown = 1;
if (acc && validlist && minfo.cur) {
menucmp = lastambig = hasoldlist = 0;
do_single(*(minfo.cur));
}
if (wasnext || broken) {
menucmp = 1;
showinglist = ((validlist && !nolist) ? -2 : 0);
minfo.asked = 0;
if (!noselect) {
int nos = noselect;
zrefresh();
noselect = nos;
}
}
if (!noselect && (!dat || acc)) {
/*
* I added the following because in certain cases the zrefresh()
* here was screwing up the list. Forcing it to redraw the
* screen worked. The case in question (courtesy of
* "Matt Wozniski" <godlygeek@gmail.com>) is in zsh-workers/24756.
*
* *** PLEASE DON'T ASK ME WHY THIS IS NECESSARY ***
*/
mlbeg = -1;
showinglist = ((validlist && !nolist) ? -2 : 0);
onlyexpl = oe;
if (acc && listshown) {
/*
* Clear the list without spending sixteen weeks of
* redrawing it in slightly different states first.
* The following seems to work. I'm not sure what
* the difference is between listshown and showinglist,
* but listshown looks like the traditional thing to
* check for in this file at least.
*
* showinglist has a normally undocumented value of 1,
* and an extra-specially undocumented value of -2, which
* seems to be a force---it appears we need to kick it out
* of that state, though it worries me that in some places
* the code actually forces it back into that state.
*/
clearlist = listshown = showinglist = 1;
} else if (!smatches)
clearlist = listshown = 1;
zrefresh();
}
mlbeg = -1;
fdat = NULL;
if (!wasmeta)
unmetafy_line();
return (broken == 2 ? 3 :
((dat && !broken) ? (acc ? 1 : 2) : (!noselect ^ acc)));
}
/* The widget function. */
static int
menuselect(char **args)
{
int d = 0;
if (!minfo.cur) {
selected = 0;
menucomplete(args);
if ((minfo.cur && minfo.asked == 2) || selected)
return 0;
d = 1;
}
if (minfo.cur && (minfo.asked == 2 || domenuselect(NULL, NULL)) && !d)
menucomplete(args);
return 0;
}
static struct features module_features = {
NULL, 0,
NULL, 0,
NULL, 0,
NULL, 0,
0
};
/**/
int
setup_(UNUSED(Module m))
{
return 0;
}
/**/
int
features_(Module m, char ***features)
{
*features = featuresarray(m, &module_features);
return 0;
}
/**/
int
enables_(Module m, int **enables)
{
return handlefeatures(m, &module_features, enables);
}
/**/
static void
menuselect_bindings(void)
{
if (!(mskeymap = openkeymap("menuselect"))) {
mskeymap = newkeymap(NULL, "menuselect");
linkkeymap(mskeymap, "menuselect", 1);
bindkey(mskeymap, "\t", refthingy(t_completeword), NULL);
bindkey(mskeymap, "\n", refthingy(t_acceptline), NULL);
bindkey(mskeymap, "\r", refthingy(t_acceptline), NULL);
bindkey(mskeymap, "\33[A", refthingy(t_uplineorhistory), NULL);
bindkey(mskeymap, "\33[B", refthingy(t_downlineorhistory), NULL);
bindkey(mskeymap, "\33[C", refthingy(t_forwardchar), NULL);
bindkey(mskeymap, "\33[D", refthingy(t_backwardchar), NULL);
bindkey(mskeymap, "\33OA", refthingy(t_uplineorhistory), NULL);
bindkey(mskeymap, "\33OB", refthingy(t_downlineorhistory), NULL);
bindkey(mskeymap, "\33OC", refthingy(t_forwardchar), NULL);
bindkey(mskeymap, "\33OD", refthingy(t_backwardchar), NULL);
}
if (!(lskeymap = openkeymap("listscroll"))) {
lskeymap = newkeymap(NULL, "listscroll");
linkkeymap(lskeymap, "listscroll", 1);
bindkey(lskeymap, "\t", refthingy(t_completeword), NULL);
bindkey(lskeymap, " ", refthingy(t_completeword), NULL);
bindkey(lskeymap, "\n", refthingy(t_acceptline), NULL);
bindkey(lskeymap, "\r", refthingy(t_acceptline), NULL);
bindkey(lskeymap, "\33[B", refthingy(t_downlineorhistory), NULL);
bindkey(lskeymap, "\33OB", refthingy(t_downlineorhistory), NULL);
}
}
/**/
int
boot_(Module m)
{
mtab = NULL;
mgtab = NULL;
mselect = -1;
inselect = 0;
w_menuselect = addzlefunction("menu-select", menuselect,
ZLE_MENUCMP|ZLE_KEEPSUFFIX|ZLE_ISCOMP);
if (!w_menuselect) {
zwarnnam(m->node.nam,
"name clash when adding ZLE function `menu-select'");
return -1;
}
addhookfunc("comp_list_matches", (Hookfn) complistmatches);
addhookfunc("menu_start", (Hookfn) domenuselect);
menuselect_bindings();
return 0;
}
/**/
int
cleanup_(Module m)
{
free(mtab);
free(mgtab);
deletezlefunction(w_menuselect);
deletehookfunc("comp_list_matches", (Hookfn) complistmatches);
deletehookfunc("menu_start", (Hookfn) domenuselect);
unlinkkeymap("menuselect", 1);
unlinkkeymap("listscroll", 1);
return setfeatureenables(m, &module_features, NULL);
}
/**/
int
finish_(UNUSED(Module m))
{
return 0;
}
View git blame Copy permalink