PATCH: User-defined completion listing

PATCH: User-defined completion listing

[Peter Stephenson]

This implements something like the outcome of the recent discussion of
a new option for showing a user-defined list instead of the actual
completions.  First, the bad news: this patch is simply against my own
current adaption of 3.1.2, which probably doesn't correspond to anyone
else's.  In particular, it has my compctl -/ and -W patches in, but it
doesn't have Sven's big patch, which may make a difference.  I could
probably do it against vanilla 3.1.2 if that becomes sensible.

Now the good news:  the syntax (see manual patch for more) is either

  compctl ... -Y '$array'

or

  compctl ... -Y 'func'

In the first case, $array is, err, an array, in the second, func is
called and must set $reply, just like a -K function.  (They're
evaluated at different times, so there's no clash.)  func is also
passed the complete list of matches, with full prefix expansion, so it
can process the matches to produce a display. For example,

  llfn() { reply=("$(ls -fld $*)"); }
  compctl -f -Y llfn foo

foo has ordinary file name completion, but the list of matches will be
made line by line in ls -l format.  read -c and read -l are available
if you want them.

The output is literal in this case, since you have control over what
comes out, though only newline is specially handled; other control
sequences could mess up the formatting and are best avoided (at least
with always_last_prompt set).  Note, however, that all the other
formatting capabilities are retained, so a -Y function like

  func() { reply=($*); }

produces full columnated output just as without the -Y func (assuming
there are no funny characters in the $* which would be massaged in
that case).

So the suggestion for job completion is along the lines of:

  joblist() {
      local jf=/tmp/zjobs$$ line
      jobs >& $jf
      reply=() joblist=()
      while read line; do
  	  joblist=($joblist $line)
  	  reply=($reply ${${line#\[}%%\]*})
      done < $jf
  # The above allows the output to appear in columns.  If you want the
  # exact output of 'jobs', you can instead use:
  #    joblist=("$(<$jf)")
  # It must still be an array, though.
      rm -f $jf
  }
  compctl -P% -K joblist -Y '$joblist' \
      -x 's[-]' -k signals -- kill   # ... and friends

Note that in the current implementation you need a completion list: if
there are no completions, nothing is displayed, so you can't just
display a memo and let the user complete by hand.  That could probably
be remedied.  Obviously, '$joblist' could be a static variable as well.

One thing to check for with the patch is that I haven't somehow gummed
up the logic for displaying other types of completion in my zeal to
get -Y displays to appear OK; I obviously couldn't check everything
directly myself.  (I think I caught the only memory leak, though.)
Also, a -Y func is blindly passed the fully expanded completion
possibilities (necessary for the llfn example above, which needs the
full path to the candidate file): maybe there are occasions where
that's wrong.

Another thing under the `could perhaps be better, but it's time I did
some work' heading:  literal arrays are allowed as with -k, i.e. -Y
'(option1 option2 ...)', but there's no way of getting a literal
string there.  It might be nice to enhance get_user_var() to understand
a double quote at the beginning and return the text as an array with a
single element.  (The name of a real array with just one element is
fine, of course.)

While I'm getting picky:  the fact that the completion function gets
the full path could be something of a memory hog if you are completing
in a full directory with a long path name, but until the Commodore 64
version of zsh appears...

*** Doc/Zsh/compctl.yo.YoY	Thu Sep 18 09:58:39 1997
--- Doc/Zsh/compctl.yo	Wed Nov 19 17:34:51 1997
***************
*** 103,111 ****
    [ tt(-s) var(subststring) ])
  list([ tt(-K) var(function) ] [ tt(-H) var(num pattern) ])
  list([ tt(-Q) ] [ tt(-P) var(prefix) ] [ tt(-S) var(suffix) ])
! liat([ tt(-W) var(file-prefix) ]
  list([ tt(-q) ] [ tt(-X) var(explanation) ])
! list([ tt(-l) var(cmd) ] [ tt(-U) ])
  endlist()
  
  The remaining var(options) specify the type of command arguments
--- 103,111 ----
    [ tt(-s) var(subststring) ])
  list([ tt(-K) var(function) ] [ tt(-H) var(num pattern) ])
  list([ tt(-Q) ] [ tt(-P) var(prefix) ] [ tt(-S) var(suffix) ])
! list([ tt(-W) var(file-prefix) ])
  list([ tt(-q) ] [ tt(-X) var(explanation) ])
! list([ tt(-Y) var(func-or-var) ] [ tt(-l) var(cmd) ] [ tt(-U) ])
  endlist()
  
  The remaining var(options) specify the type of command arguments
***************
*** 360,365 ****
--- 360,385 ----
  options. A `tt(%n)' in this string is replaced by the number of matches.
  The explanation only appears if completion was tried and there was
  no unique match.
+ )
+ item(tt(-Y) var(func-or-var))(
+ The list provided by var(func-or-var) is displayed instead of the list
+ of completions whenever a listing is required; the actual completions
+ to be inserted are not affected.  It can be provided in two
+ ways. Firstly, if var(func-or-var) begins with a tt($) it defines an
+ array variable, or if it begins with a left parenthesis a literal
+ array, which contains the list.  A variable may have been set by a
+ call to a function using the tt(-K) option.  Otherwise it contains the
+ name of a function which will be executed to create the list.  The
+ function will be passed as an argument list all matching completions,
+ including prefixes and suffixes expanded in full, and should set the
+ array var(reply) to the result.  In both cases, the display list will
+ only be retrieved after a complete list of matches has been created.
+ 
+ Note that the returned list does not have to correspond, even in
+ length, to the original set of matches; the use of an array is purely
+ a convenience for formatting.  No special formatting of characters is
+ performed on the output in this case; in particular, newlines are
+ printed literally and if they appear output in columns is suppressed.
  )
  enditem()
  texinode(Alternative Completion)(Extended Completion)(Option Flags)(Programmable Completion)
*** Src/Zle/comp.h.YoY	Thu Sep 18 09:58:39 1997
--- Src/Zle/comp.h	Wed Nov 19 11:45:01 1997
***************
*** 102,107 ****
--- 102,108 ----
      char *str;			/* for -s (expansion)                      */
      char *func;			/* for -K (function)                       */
      char *explain;		/* for -X (explanation)                    */
+     char *ylist;		/* for -Y (user-defined desc. for listing) */
      char *prefix, *suffix;	/* for -P and -S (prefix, suffix)          */
      char *subcmd;		/* for -l (command name to use)            */
      char *withd;		/* for -w (with directory                  */
*** Src/Zle/comp1.c.YoY	Thu Sep 18 09:58:40 1997
--- Src/Zle/comp1.c	Wed Nov 19 12:18:44 1997
***************
*** 80,85 ****
--- 80,86 ----
      zsfree(cc->str);
      zsfree(cc->func);
      zsfree(cc->explain);
+     zsfree(cc->ylist);
      zsfree(cc->prefix);
      zsfree(cc->suffix);
      zsfree(cc->hpat);
*** Src/Zle/compctl.c.YoY	Thu Sep 18 09:59:17 1997
--- Src/Zle/compctl.c	Wed Nov 19 12:18:41 1997
***************
*** 217,222 ****
--- 217,234 ----
  		    *argv = "" - 1;
  		}
  		break;
+ 	    case 'Y':
+ 		if ((*argv)[1]) {
+ 		    cct.ylist = (*argv) + 1;
+ 		    *argv = "" - 1;
+ 		} else if (!argv[1]) {
+ 		    zwarnnam(name, "function/variable expect after -%c",
+ 			     NULL, **argv);
+ 		} else {
+ 		    cct.ylist = *++argv;
+ 		    *argv = "" - 1;
+ 		}
+ 		break;
  	    case 'P':
  		if ((*argv)[1]) {
  		    cct.prefix = (*argv) + 1;
***************
*** 687,693 ****
      Compctl cc;
  
      if (cct->subcmd && (cct->keyvar || cct->glob || cct->str ||
! 			cct->func || cct->explain || cct->prefix)) {
  	zwarnnam(name, "illegal combination of options", NULL, 0);
  	return 1;
      }
--- 699,706 ----
      Compctl cc;
  
      if (cct->subcmd && (cct->keyvar || cct->glob || cct->str ||
! 			cct->func || cct->explain || cct->ylist ||
! 			cct->prefix)) {
  	zwarnnam(name, "illegal combination of options", NULL, 0);
  	return 1;
      }
***************
*** 725,730 ****
--- 738,744 ----
      zsfree(cc->str);
      zsfree(cc->func);
      zsfree(cc->explain);
+     zsfree(cc->ylist);
      zsfree(cc->prefix);
      zsfree(cc->suffix);
      zsfree(cc->subcmd);
***************
*** 740,745 ****
--- 754,760 ----
      cc->str = ztrdup(cct->str);
      cc->func = ztrdup(cct->func);
      cc->explain = ztrdup(cct->explain);
+     cc->ylist = ztrdup(cct->ylist);
      cc->prefix = ztrdup(cct->prefix);
      cc->suffix = ztrdup(cct->suffix);
      cc->subcmd = ztrdup(cct->subcmd);
***************
*** 857,862 ****
--- 872,878 ----
      printif(cc->keyvar, 'k');
      printif(cc->func, 'K');
      printif(cc->explain, 'X');
+     printif(cc->ylist, 'Y');
      printif(cc->prefix, 'P');
      printif(cc->suffix, 'S');
      printif(cc->glob, 'g');
*** Src/Zle/zle_tricky.c.YoY	Thu Sep 18 10:01:00 1997
--- Src/Zle/zle_tricky.c	Wed Nov 19 17:46:32 1997
***************
*** 123,128 ****
--- 123,133 ----
  
  static int nmatches;
  
+ /* A list of user-defined explanations for the completions to be shown *
+  * instead of amatches when listing completions.                       */
+ 
+ static char **aylist;
+ 
  /* !=0 if we have a valid completion list. */
  
  static int validlist;
***************
*** 2996,3003 ****
      ccsuffix = cc->suffix;
  
      validlist = 1;
!     if ((nmatches || expl) && !errflag)
  	return 0;
  
      if ((isf || cc->xor) && !parampre) {
  	/* We found no matches, but there is a xor'ed completion: *
--- 3001,3045 ----
      ccsuffix = cc->suffix;
  
      validlist = 1;
!     if ((nmatches || expl) && !errflag) {
! 	/* generating the user-defined explanations must happen last: *
! 	 * if anything fails, we silently allow the normal completion *
! 	 * list to be used.                                           */
! 	if (cc->ylist) {
! 	    char **yaptr, *uv = NULL;
! 	    List list;
! 
! 	    if (cc->ylist[0] == '$' || cc->ylist[0] == '(') {
! 		/* from variable: must be an array */
! 		uv = cc->ylist + (cc->ylist[0] == '$');
! 	    } else if ((list = getshfunc(cc->ylist)) != &dummy_list) {
! 		/* from function:  pass completions as arg list */
! 		LinkList args = newlinklist();
! 		int addlen = strlen(rpre) + strlen(rsuf) + 1;
! 
! 		addlinknode(args, cc->ylist);
! 		for (yaptr = amatches; *yaptr; yaptr++) {
! 		    /* can't use tricat(). rats. */
! 		    char *ptr = (char *)halloc(addlen + strlen(*yaptr));
! 		    sprintf(ptr, "%s%s%s", rpre, *yaptr, rsuf);
! 		    addlinknode(args, ptr);
! 		}
! 
! 		/* No harm in allowing read -l and -c here, too */
! 		incompctlfunc = 1;
! 		doshfunc(list, args, 0, 1);
! 		incompctlfunc = 0;
! 		uv = "reply";
! 	    } else
! 		return 0;
! 	    if (uv && (yaptr = get_user_var(uv))) {
! 		PERMALLOC {
! 		    aylist = arrdup(yaptr);
! 		} LASTALLOC;
! 	    }
! 	}
  	return 0;
+     }
  
      if ((isf || cc->xor) && !parampre) {
  	/* We found no matches, but there is a xor'ed completion: *
***************
*** 3045,3050 ****
--- 3087,3095 ----
  	listmatches();
      if(validlist) {
  	freearray(amatches);
+ 	if (aylist)
+ 	    freearray(aylist);
+ 	aylist = 0;
  	zsfree(rpre);
  	zsfree(rsuf);
  	zsfree(lpre);
***************
*** 3516,3526 ****
  listmatches(void)
  {
      int longest = 1, fct, fw, colsz, t0, t1, ct, up, cl, xup = 0;
!     int off, boff, nboff;
!     int of = (isset(LISTTYPES) && !(haswhat & HAS_MISC));
      char **arr, **ap, sav;
      int nfpl, nfsl, nlpl, nlsl;
!     int listmax = getiparam("LISTMAX");
  
  #ifdef DEBUG
      /* Sanity check */
--- 3561,3572 ----
  listmatches(void)
  {
      int longest = 1, fct, fw, colsz, t0, t1, ct, up, cl, xup = 0;
!     int off = 0, boff = 0, nboff = 0;
!     int of = (!aylist && isset(LISTTYPES) && !(haswhat & HAS_MISC));
      char **arr, **ap, sav;
      int nfpl, nfsl, nlpl, nlsl;
!     int listmax = getiparam("LISTMAX"), litnl = 0;
!     size_t (*strlenfn) _((char const *));
  
  #ifdef DEBUG
      /* Sanity check */
***************
*** 3538,3549 ****
  
      /* Calculate the lengths of the prefixes/suffixes we have to ignore
         during printing. */
!     off = ispattern && ppre && *ppre &&
! 	!(haswhat & (HAS_MISC | HAS_PATHPAT)) ? strlen(ppre) : 0;
!     boff = ispattern && psuf && *psuf &&
! 	!(haswhat & (HAS_MISC | HAS_PATHPAT)) ? strlen(psuf) : 0;
!     nboff = ispattern && psuf && *psuf &&
! 	!(haswhat & (HAS_MISC | HAS_PATHPAT)) ? niceztrlen(psuf) : 0;
  
      /* When called from expandorcompleteprefix, we probably have to
         remove a space now. */
--- 3584,3597 ----
  
      /* Calculate the lengths of the prefixes/suffixes we have to ignore
         during printing. */
!     if (ispattern && !aylist && !(haswhat & (HAS_MISC | HAS_PATHPAT))) {
! 	if (ppre && *ppre)
! 	    off = strlen(ppre);
! 	if (psuf && *psuf) {
! 	    boff = strlen(psuf);
! 	    nboff = niceztrlen(psuf);
! 	}
!     }
  
      /* When called from expandorcompleteprefix, we probably have to
         remove a space now. */
***************
*** 3558,3595 ****
  
      /* Set the cursor below the prompt. */
      trashzle();
-     ct = nmatches;
      showinglist = 0;
  
      clearflag = (isset(USEZLE) && !termflags &&
  		 (isset(ALWAYSLASTPROMPT) && zmult == 1)) ||
  	(unset(ALWAYSLASTPROMPT) && zmult != 1);
  
!     arr = amatches;
  
!     /* Calculate the column width, the number of columns and the number
!        of lines. */
!     for (ap = arr; *ap; ap++)
! 	if ((cl = niceztrlen(*ap + off) - nboff +
! 	     (ispattern ? 0 :
! 	      (!(haswhat & HAS_MISC) ? nfpl + nfsl : nlpl + nlsl))) > longest)
! 	    longest = cl;
!     if (of)
! 	longest++;
! 
!     fw = longest + 2;
!     fct = (columns + 1) / fw;
!     if (fct == 0) {
! 	fct = 1;
! 	colsz = ct;
! 	up = colsz + nlnct - clearflag;
  	for (ap = arr; *ap; ap++)
! 	    up += (niceztrlen(*ap + off) - nboff + of +
! 		(ispattern ? 0 :
! 		(!(haswhat & HAS_MISC) ? nfpl + nfsl : nlpl + nlsl))) / columns;
!     } else {
! 	colsz = (ct + fct - 1) / fct;
! 	up = colsz + nlnct - clearflag + (ct == 0);
      }
  
      /* Print the explanation string, if any. */
--- 3606,3683 ----
  
      /* Set the cursor below the prompt. */
      trashzle();
      showinglist = 0;
  
      clearflag = (isset(USEZLE) && !termflags &&
  		 (isset(ALWAYSLASTPROMPT) && zmult == 1)) ||
  	(unset(ALWAYSLASTPROMPT) && zmult != 1);
  
!     /* just to keep gcc happy */
!     fw = colsz = up = 0;
!     if (aylist) {
! 	arr = aylist;
! 	/* If no literal newlines, the remaining code should use strlen() */
! 	strlenfn = (size_t (*) _((char const *)))strlen;
! 
! 	/* The hard bit here is that we are handling newlines literally.   *
! 	 * In fact, we are in principle handling all characters literally, *
! 	 * but it's quite enough work with just newlines.                  *
! 	 * If there are such, we give up trying to print the list as       *
! 	 * columns and print as rows, counting the extra newlines.         */
! 	ct = 0;
! 	for (ap = arr; *ap; ap++) {
! 	    ct++;
! 	    if (strchr(*ap, '\n'))
! 		litnl++;
! 	}
! 	if (litnl) {
! 	    colsz = ct;
! 	    up = colsz + nlnct - clearflag;
! 	    /* Count real newlines, as well as overflowing lines. */
! 	    for (ap = arr; *ap; ap++) {
! 		char *nlptr, *sptr = *ap;
! 		while (sptr && *sptr) {
! 		    up += (nlptr = strchr(sptr, '\n'))
! 			? 1 + (nlptr-sptr)/columns
! 			   : strlen(sptr)/columns;
! 		    sptr = nlptr ? nlptr+1 : NULL;
! 		}
! 	    }
! 	}
!     } else {
! 	arr = amatches;
! 	ct = nmatches;
! 	strlenfn = niceztrlen;
!     }
  
! 
!     if (!litnl) {
! 	/* Calculate the column width, the number of columns and the
! 	   number of lines. */
  	for (ap = arr; *ap; ap++)
! 	    if ((cl = strlenfn(*ap + off) - nboff +
! 		 ((ispattern || aylist) ? 0 :
! 		  (!(haswhat & HAS_MISC) ?
! 		   nfpl + nfsl : nlpl + nlsl))) > longest)
! 		longest = cl;
! 	if (of)
! 	    longest++;
! 
! 	fw = longest + 2;
! 	fct = (columns + 1) / fw;
! 	if (fct == 0) {
! 	    fct = 1;
! 	    colsz = ct;
! 	    up = colsz + nlnct - clearflag;
! 	    for (ap = arr; *ap; ap++)
! 		up += (strlenfn(*ap + off) - nboff + of +
! 		       ((ispattern || aylist) ? 0 :
! 			(!(haswhat & HAS_MISC) ?
! 			 nfpl + nfsl : nlpl + nlsl))) / columns;
! 	} else {
! 	    colsz = (ct + fct - 1) / fct;
! 	    up = colsz + nlnct - clearflag + (ct == 0);
! 	}
      }
  
      /* Print the explanation string, if any. */
***************
*** 3671,3677 ****
  	    while (*ap) {
  		int t2;
  
! 		if (ispattern) {
  		    int cut = strlen(*ap) - boff;
  
  		    sav = ap[0][cut];
--- 3759,3768 ----
  	    while (*ap) {
  		int t2;
  
! 		if (aylist) {
! 		    zputs(*ap, shout);
! 		    t2 = strlen(*ap);		    
! 		} else if (ispattern) {
  		    int cut = strlen(*ap) - boff;
  
  		    sav = ap[0][cut];

-- 
Peter Stephenson <pws@ifh.de>       Tel: +49 33762 77366
WWW:  http://www.ifh.de/~pws/       Fax: +49 33762 77413
Deutsches Elektronen-Synchrotron --- Institut fuer Hochenergiephysik Zeuthen
DESY-IfH, Platanenallee 6, 15738 Zeuthen, Germany.

Re: User-defined completion listing

[Bart Schaefer]

On Nov 19,  6:00pm, Peter Stephenson wrote:
} Subject: PATCH: User-defined completion listing
}
} Now the good news:  the syntax (see manual patch for more) is either
} 
}   compctl ... -Y '$array'
} or
}   compctl ... -Y 'func'
} 
} In the first case, $array is, err, an array, in the second, func is
} called and must set $reply, just like a -K function.

I must confess confusion as to why you'd do it this way.

If you're going to examine the first character and behave differently
when it is '$', you could do that with -X and not need a new option.

If you're going to expand a variable, why does it have to be an array?
The parameter to -X is just a string.

If you're going to substitute a string, why pass it around with $reply?

} Another thing under the `could perhaps be better, but it's time I did
} some work' heading:  literal arrays are allowed as with -k, i.e. -Y
} '(option1 option2 ...)', but there's no way of getting a literal
} string there.

Why do you need to pass a literal string to -Y when you can use -X ?

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

Re: User-defined completion listing

[Peter Stephenson]

"Bart Schaefer" wrote:
> }   compctl ... -Y '$array'
> } or
> }   compctl ... -Y 'func'
> 
> I must confess confusion as to why you'd do it this way.
> 
> If you're going to examine the first character and behave differently
> when it is '$', you could do that with -X and not need a new option.

-X doesn't do the right thing.  It gets displayed with completions,
if there's no unique match, not just listings.  Further, it gets displayed
in addition to a listing, just above.  We want something to be displayed
instead of a listing.  If you simply use -X, there's no way of adapting
the listing at all, and it would be wrong to misuse -X for that
purpose.  Also, -Y *has* to be generated separately for each
completion, because it depends on the actual list; -X doesn't, so
there's no real rationale for making it support $var.

> If you're going to expand a variable, why does it have to be an array?
> The parameter to -X is just a string.

Because -Y replaces a list; it's natural to generate the replacement
list as an array.  As with literal arrays (quoted below), I'd quite
like to alter get_user_var() to turn a scalar into a single element
array, which will solve this problem quite neatly, it just wasn't
a necessary part of yesterday's patch.  I certainly agree it's
desirable.

> If you're going to substitute a string, why pass it around with $reply?

I don't understand this.  The $reply comes only from the function.
The exact $reply array is used for the listing.  There is no more
substitution and $reply has always been for communication back from
functions. Do you mean `why not use $REPLY'?  The answer is because
you can't replace a complete listing with that.  It seems silly
to use both.

In more abstract terms, what gets displayed in a completion listing
is always an array of possibilities.  The whole point of the -Y option
is to allow you to alter that.  It is entirely natural that this altered
list would be an array.  It just so happens you can get away with a one
element array with everything stuck together, if you want.

> } Another thing under the `could perhaps be better, but it's time I did
> } some work' heading:  literal arrays are allowed as with -k, i.e. -Y
> } '(option1 option2 ...)', but there's no way of getting a literal
> } string there.
> 
> Why do you need to pass a literal string to -Y when you can use -X ?

You can't, not for the same thing.  See above.  -X and -Y are
entirely different:  -X gives a single, fixed banner heading for
the listing and for the completion; -Y gives a list of completions
to replace the ones shown when displaying completions.

-- 
Peter Stephenson <pws@ifh.de>       Tel: +49 33762 77366
WWW:  http://www.ifh.de/~pws/       Fax: +49 33762 77413
Deutsches Elektronen-Synchrotron --- Institut fuer Hochenergiephysik Zeuthen
DESY-IfH, Platanenallee 6, 15738 Zeuthen, Germany.

PATCH: allow scalars as completion variables

[Peter Stephenson]

Peter Stephenson wrote:
> "Bart Schaefer" wrote:
> > If you're going to expand a variable, why does it have to be an array?
> > The parameter to -X is just a string.
> 
> Because -Y replaces a list; it's natural to generate the replacement
> list as an array.  As with literal arrays (quoted below), I'd quite
> like to alter get_user_var() to turn a scalar into a single element
> array, which will solve this problem quite neatly, it just wasn't
> a necessary part of yesterday's patch.  I certainly agree it's
> desirable.

Here's the corresponding patch:  with this, any of the usual uses of
variables within completion (including "reply") will allow a scalar,
which is turned internally into a one-element array.  I didn't implement
my other suggestion because it was treated with scorn.  This will work
independently of the -Y patch, apart from the manual entry.

(And I've finally updated my signature.  I was waiting for an account
here, but doomsday's a long way off at the moment, so if it looks oddly
international, that's why.)

*** Doc/Zsh/compctl.yo.YoY2	Wed Nov 19 17:34:51 1997
--- Doc/Zsh/compctl.yo	Thu Nov 20 14:29:42 1997
***************
*** 365,372 ****
  The list provided by var(func-or-var) is displayed instead of the list
  of completions whenever a listing is required; the actual completions
  to be inserted are not affected.  It can be provided in two
! ways. Firstly, if var(func-or-var) begins with a tt($) it defines an
! array variable, or if it begins with a left parenthesis a literal
  array, which contains the list.  A variable may have been set by a
  call to a function using the tt(-K) option.  Otherwise it contains the
  name of a function which will be executed to create the list.  The
--- 365,372 ----
  The list provided by var(func-or-var) is displayed instead of the list
  of completions whenever a listing is required; the actual completions
  to be inserted are not affected.  It can be provided in two
! ways. Firstly, if var(func-or-var) begins with a tt($) it defines a
! variable, or if it begins with a left parenthesis a literal
  array, which contains the list.  A variable may have been set by a
  call to a function using the tt(-K) option.  Otherwise it contains the
  name of a function which will be executed to create the list.  The
***************
*** 376,383 ****
  only be retrieved after a complete list of matches has been created.
  
  Note that the returned list does not have to correspond, even in
! length, to the original set of matches; the use of an array is purely
! a convenience for formatting.  No special formatting of characters is
  performed on the output in this case; in particular, newlines are
  printed literally and if they appear output in columns is suppressed.
  )
--- 376,383 ----
  only be retrieved after a complete list of matches has been created.
  
  Note that the returned list does not have to correspond, even in
! length, to the original set of matches, and may be passed as a scalar
! instead of an array.  No special formatting of characters is
  performed on the output in this case; in particular, newlines are
  printed literally and if they appear output in columns is suppressed.
  )
*** Src/Zle/zle_tricky.c.YoY2	Wed Nov 19 17:46:32 1997
--- Src/Zle/zle_tricky.c	Thu Nov 20 14:16:01 1997
***************
*** 3156,3164 ****
  	while ((*aptr++ = (char *)ugetnode(arrlist)));
  	uarr[count] = NULL;
  	return uarr;
!     } else
  	/* Otherwise it should be a parameter name. */
! 	return getaparam(nam);
  }
  
  /* This is strcmp with ignoring backslashes. */
--- 3156,3172 ----
  	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)) && (val = getsparam(nam))) {
! 	    arr = (char *)ncalloc(2*sizeof(char *));
! 	    arr[0] = val;
! 	    arr[1] = NULL;
! 	}
! 	return arr;
!     }
! 
  }
  
  /* This is strcmp with ignoring backslashes. */

-- 
Peter Stephenson <pws@ifh.de>       Tel: +39 50 911239
WWW:  http://www.ifh.de/~pws/
Dipartimento di Fisica Teorica
Piazza Torricelli 2, 56100 Pisa, Italy

Re: User-defined completion listing

[Bart Schaefer]

On Nov 20, 10:22am, Peter Stephenson wrote:
} Subject: Re: User-defined completion listing
}
} "Bart Schaefer" wrote:
} > }   compctl ... -Y '$array'
} > } or
} > }   compctl ... -Y 'func'
} > 
} > I must confess confusion as to why you'd do it this way.
} 
} We want something to be displayed instead of a listing.

Oh!  *I* didn't want something displayed instead of a listing; I just
wanted to be able to dynamically change the explanation.  It didn't
sink in exactly what it was you were implementing.

Given that, it all makes *much* more sense to me.

On Nov 20,  2:39pm, Peter Stephenson wrote:
} I didn't implement my other suggestion because it was treated with scorn.

I hope it wasn't me you thought was treating your suggestion with scorn.
That wasn't my intention; I was just trying to find out why you chose the
implementation you did, but starting from a misunderstanding of what it
was accomplishing.  Sorry.

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

Re: User-defined completion listing

[Peter Stephenson]

"Bart Schaefer" wrote:
> Oh!  *I* didn't want something displayed instead of a listing; I just
> wanted to be able to dynamically change the explanation.  It didn't
> sink in exactly what it was you were implementing.

Aha, I was thinking of the `jobs' example, which does seem to
be asking for the list of possiblities to be altered (though
if you don't mind the list of numbers at the end you could do it
that way, too).  It's easy to get -X to substitute a variable, too,
when it has a $ in front, but maybe it would be preferable to have
double-quoted expansion instead?  That might break some older explanations.

-- 
Peter Stephenson <pws@ifh.de>       Tel: +39 50 911239
WWW:  http://www.ifh.de/~pws/
Gruppo Teorico, Dipartimento di Fisica
Piazza Torricelli 2, 56100 Pisa, Italy

Re: User-defined completion listing

[Bart Schaefer]

On Nov 21, 10:26am, Peter Stephenson wrote:
} Subject: Re: User-defined completion listing
}
} ...  It's easy to get -X to substitute a variable, too,
} when it has a $ in front, but maybe it would be preferable to have
} double-quoted expansion instead?

My suggestion had been that -X would stay as it is, but -Y would do the
double-quote expansion.  I'd pick some other letter for alteration of
the listing ... what else is not taken yet?  h, i, M, t, V, W, and y.

Good grief, that means there are 44 options to compctl right now (45 if
you count Peter's -Y), plus all the pattern-matching tags for -x.  Eek.

Anyway, I guess I'd go with -Y and one of -y or -W for what we're talking
about now.  Doesn't really matter which means which.  Or you could do all
three; use -y and -Y like -k and -K, except for modifying the listing,
and use -W as an expanding -X.

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

PATCH: completion lists revisted

[Peter Stephenson]

"Bart Schaefer" wrote:
> Anyway, I guess I'd go with -Y and one of -y or -W for what we're talking
> about now.  Doesn't really matter which means which.  Or you could do all
> three; use -y and -Y like -k and -K, except for modifying the listing,
> and use -W as an expanding -X.

Here's the complete thing, incorporating the earlier patches: -y
replaces the list for display with something returned from a function
or variable, -Y does expansion on the explanation string.  (-W was
already taken up with the patch for `with-directory', i.e. `-W ~/Mail
-f' completes files and paths under ~/Mail; you need that patch for a
clean application of this one, although they are functionally
independent.)

-y is handled first, so you can change variables for -Y:  a useless
example is:

fn() {
  reply=();
  local line
  if (( $# )); then
    expl="Select a file from the list"
    ls -fld $*| while read line; do reply=($reply $line); done
    (( $# == 1 ))  && expl="Unique completion\!"
  fi
}
compctl -f -y fn -Y '$expl' foo

(The only real point of using both at once is that the formatting is
done differently for the explanation and the completion list.)

I changed one additional piece of logic: the mere presence of an
explanation string used to force alternative completions not to be
tried.  For example,

compctl -k '(foo bar)' -X 'Yeah.' + -k '(Foo Bar)' foo

would never look at the Foo Bar possibilities (`foo F^D' would just
mindlessly say `Yeah.').  Maybe someone can explain this.


begin 644 compctl_yY_patch.gz
M'XL("+1!?30``UEO65]A;&PN='AT`.T[^W?3R-4_NW_%).T2*9:#'TD<QV7W
MI)!V.1L@)6R!4@Z5Y9&M1I:,'G%,X7_O?<R,1H[":[=\WY[3+!MLS9T[]_W2
ML+N[*QZDP=V_Y_.[0;I8!D6\MT[W7J8O6\_FI;B02]$[$MW1\<'1\6`D>J/1
M\'>=3J=A#\$_3J]$?RAZW>/]X7%_P/"[]1_\#A`#K]?K"7H@X.>5*`JGD[OB
MRL^<O)SD15YD43)SQ6L7`.(H+QR&^8EAPC()BBA-`$!M_I$7DG(AEGY1R"RY
MN?FO%?@Y@R\S&4;7U>,+34+(C]W?;0$"7R-XKDZ/8MDQ6PG$G/&V0O:"H>7U
M,O837Y'KUL%CA@D6TVK?SXIRF4P)$C_#GV=S*3*Y\*,$)$.[TB4B!;'E2QE$
MX5H4`%*LEU*DH0#E+/QD*OQL5BYD4N2D.BUZ^-SY+8@^_ZCHW2^3O5I[^1EZ
M65?,=M*L`Y^K_=]29TWN,S@X\`:'!]I]RER*J,A%NDI$D$4@_\@712JF@'\J
MQ6KN%V+A%\%<YGM"/`SQQ`RVY"))83LZ<2R1*(]H2;-H%B5^+%9I-D6H3!9`
MOYSN`3"R!2<LG%MD[#H`<`[V4]P4\6HN$U%D:Y1$=:B`/WAL4&89<"QR68`D
M`(L2U)XX$?^$T[Y+W!T1(2R0Q";*Q,$)@9R*"4L2C'`B,Y2E9EEIP2(%CHS7
MPE\NI9_E(@IM:E9^#C1&@!#UP)*"9V`<22K*)'I;2L:LI0$*)X'@YT)>1TDZ
ME<Y)C%X`AUU)<=\@=YW3ZP+@`;G]\`DQ*OX<^[/<=<ZS=);Y8`:3N+:7O)<T
M/S+>^VTUWZXTW^`=H/DV"1K-7RRS]"J:LEIN^!%@GD8YJ&,-`%&2%]*?HL8*
MM1L0I;92<C(=>05Z]0G`Z/YM&65R.J:=?E"40+NU#?"`,"82SY!9@3H%[I.T
M$'X8R@`>H%0*$?@)0AF:T<I6*>Q>^6L0W)^C+"_BM8>6<H.7B021`8%1,0?B
M0#9_`/X*T$`(@LN%#U@`+D)M>B!@Q`'+]5VQ#$%B/IH_:`H80RY!F7X,N_TL
M\^'LU3P*YL!<@AK)C:B`@1-S`.AZ+>8^V-Q$@JNA)X'XD83`CV.4A2]T]`;;
M02E2\.'8SOX&")^@E:PBLJW:B8`H\1<4J"Q$3-DJ@A,FZ&8R*%'4<%J02;^0
M-JW/"$FU56U:^GF.V@'.$Q/[V)"0<#+A>M3(/33')(C+*2YP0D!Y@]-R!H$O
MX/)^HA0:EG'L\?(\+>,I28=Y(@F39C&8@&D#Z07%[;R,D>J'8!XI:"KP<YFS
MJRC[91J1#;19C"H3W(<!Y`H9"@NR646W\HTJ-H&R<M85BPH<K2W@S^.4Q.87
MBHZBS,`+>?<TE3G9,"D:I9Q"X,R7:3+U!)R:`+>`(I;)K)A[FA?CVAQ>-0$L
M$32;NA9$#A;C9R1CXYZD&Q`52.1QRND+$(9I!LC()=%IYWX&CB@QKJ+_+66&
M`(!6A?FT+)9E80(YBG2,W\#\BR@HX5!/)'(5L_=DJ)\EIA-BGWP"0S<0'5&\
MT&'<PAND<;E(\'RPA"58!G*%@OU?[M*YBR(1L:2CJ>59>P"/Q9`154.Y!*+:
M$@^GP',$AD)&1C(%"[P.Y+*HC/>&)$.,ID#-5&8S,&7`0VZ:(P-A&L?I2L>E
M,L=XGI4Q6`(8D1)<CH*<IB7&N[<E.`H1K*2D\.BX$H"]HCC`.+0O)FL3?LB^
M*#0""!P`:.QPF.DZ4"G3PUADJ%L@TZAO'7SS;UX08"EXD4$G%DOJQ/;FG^[<
MZO"MYW`R=6V'HH<MVW%O]+&NK>_UND,N.[F7P`='52\AR/_%+FAJW&JU[NZ2
MWCJY<(QN7-'XLWNWA@!59&/X25AMQV=A()N+DG&%XX6H&V(SCK:%8XW>86%X
M*1RHN+(.)_<I)/D\V*,EY4;N)A6<ESR0".6DL4%U3B[:N1".!M%]SVT,06L&
M#8=%32P<W2Y05@9[!.K<#7YL%%ANV!A6PJ$*9`I%5%"DV;I1(HVFL`]=Y/Z1
M90K[^U[OH*M-X?<L(G'__INGIQ?/'URTG-X?_]@?NO6U!P^?7K1XZ8@:IK:]
M>OKB_.3Q`_A]1B"#KGL#\^G3OYT^X-6>ZKB`.0#Q(7/;H3%*PC17W-2<H+<7
M-'O-?K?9:V"#<1OTEOYQ#X#W;W>;HZYW=%!)"K\>VB[S+@\S*9T@Z'P/?N..
M;SY&TV]ZKFP<EMJ;2V2Z37M4Z]RPH@RP864.73T\WQ0=3GX:A3<Z[@V;A4=;
M-J+.8'`,,>16\?6[!UZ_UZT$R`_Z6H2M%MDI5(U7XI[8WA9@C&-Z_H%^3Z"R
MND0)$1S6&V+GY<XQ/F@%0;&W\/-+\?Y>W>#&:$8A%<WS+"UG<W8E"\4+0('H
M(0,[#IWNONJ]=L6_#4F(7&D("%,PHHW4-?+9&WK]?M_BLS?R^H/#7\+G6O%Y
MD\BV1239RB:)[5L.Q.<?A(RQ.P"L6[B\@?/=RL\2"$D.AB5/;.O(?=?T*2`6
M:K]44NY\%VQ[M)WVB\<_GYU!S&1R:D<V$[[;;B/H)XBFWTI*-56>?Y8JV7$^
M1Y.'1T/O<#2HIIN"TC;8/B`:<Y3"'SP/,*/G86@7=^ZH[Y=R#:(2[]\+^CJ+
MTXGY`B$"/D.ITB+SY>!@5K6]Z>_*VQ4OFXJ!*DG.N&6>1+J\#'6]L^TI170I
M)K2X#6&CPY\/9*7#;L\;UFN`_RMFV1QJ\/]=_IN4/^P?>,.!%:Z&^UUON/\;
MB_BL)+?9OIDC*Z4-#PZ]X6&_5@<R;^`N[XIL6BX=K4]SFF9S`Z3&N<7R!MBF
M((P$-N#J4JG$L0&V(:-*.)L,U"56B>H&W$?D=P3B.CKLV_$AQ%(?<"!"3$CZ
M`&I]HY!TPH[BB9W+';=I'24'JS_AZM:-524P#S-7XW9=AT(X;%QGUF']HGD=
M'1=69[A*=<YPX!T==6VC^(9<.OH,<:>>V5WQ`^9_<:P$<1,'F8R'R?._+B>[
MHGH7RS?0X`:7ZYM%5:][W.T==QLJ4GO7QCNX`>SX6#?7AQ*^;Y?P^&`PT`J#
M/WD!,3$0.!!)U$1BS%4Z5$<G9IA5ZXFL%HN[=IJ/6*-<GLCF<YQ9[Z+W[M9F
M3'HR=NMT0C3_4.L&?Q3-W/#L^MS"X1)U!EOWNIB)5I*G9SYT[W$TM1L%'E12
MM5>7`$$RML;R;70T\@;=KG'K%@TG</Q4ALZ=)?PVYO!!G)U</#LY.WMRG^3)
M-@CD_85GDK5YCQH7`<DTU=!3/S(I(I1WXQ;E6KKUK9)O)A<FG&UXQM/31T_^
M=FI%-`-8&;.%R4@!`'K:>ZAPTA:"Z1@I<#'%;\DL0Z]WK03:W:@*G"@/.8=W
MOK].,]ZW]#-_`<+#S$W%\&BT#^+='YER^$O%2]6J(@>/J'(F'`$5`XA_)A.9
MZ8EUO=.WQKW'B,I/U@6-I$,_BG,H5A$%F#*H*8]BF10XI,-Q$0_V<$8:;YJ9
M<H4RI_<0K,J6,MRUORP@"NZ66,9B&8*R;IWA+K;!+>2KQ5658N15][6X=T_L
M_&%'B[/VV-E1G"IC"[-T4;TZX--QB8ZL\FF[\02*G'8CX"BCF,DBGV.0MHH2
M%_Q.W)F6B\7ZC25QFP[=(QP+&D/7(@8.I+,9BZPB\RQ*+DD>L(9)A8?&E_SR
M=:RAT'/]Z10T`B#@2O#!R<BNVN8KV@Y7\RQ4W(=[`!O-[O``S[(7@QS#FT.:
M`N0Z<HT%*V\LZ*]V6W&+!A;XR4Y!;^TP9OM`Z)X`@\N5'[>4]AFAPU_<.=I1
MX"@N#-E\BLO4M'**!Z%#5K/]78[_00&+K'I"6U/&7H+P-_E;4FVF./M@B0+H
M?IQ"W,D6.'DU,]`,(W8GYCE6('#8C&\;4DM%4:)Z?E7G]0S^::J,A',M4]#U
M1,_67'US=UPST&UZ5[/-9JA=`5:PK]`J`5M\@V[\!H?0Y97K6H9W?OKT$84(
MI1U?5X]^1F4<2[<2B!U3U)&6H+XR?A]3YE+[(7I,4WY%P&]I$^Y/?=&I9M8@
M?WJY@J<L9)[/9)4"R`UOY@'-M8X53561CKFY!'(U#A`#$T\/:M+#=X=0XSIW
M:*723%*DES*)WDFG6B#M*)2J1C:++,)OF:=,FOJULE-3,3#H0A<XZ-IMX*`[
M[,.C(U-?M52[97"-K8=O&Y_2JY,%3T20-A*CGO@H&"7:MA$Y)P^U@ZW<[,$=
M]$I/+Q"@<07>"N?/4K#8:WS/&%3=+XBIF?=]Y/V@QOOHR!OTNE7RQ@.4(ARC
M4RB0C=I4QVX1J,#=K^2E^V52Z]IRSS85D>ER0S^(&:)1'KU>#YCOC4QAN)I#
MA4"C)LH/5J@O(6*ID)QQYN132OC^*DC!O5[;:E$FBZO&F2@CXR*$H]J+?/7:
M>X(!A:Q+XN@-)R$Z^RAT0(-/`#@FH?,_F,GZ,XQ._`XS6"SY_D(T@_(&0]S$
M#R[SV,_IM@F@)-7WAEW@OIIX?P/NV72^G'_=,V29.@8R)QCD6`?/+8>7Z@*B
MB("&JXH?:\4*F+Q3<;KK)@$G]?YN#L$R#;4(JE"*/&.U)30%^F'OM5T1?K`4
M9PL"T])7*Z[1C`]ZA][@H'^HS=AVX:LTFF(0_;?V9+R]D28SR?'7$V$`63Y<
M>?AR/G\'=0+D^@*>X^-R"7_'GK@NESK-:QQI&'IB0K\3_*N^A@*-\EP6SMG#
MBV?/7IZ?7G!X=N9^3G>?[H@?3R[>/'IX<=^M,H?1,HV8X?#<OQI;A"?A$JA)
MPAQ_Q_0YSF/[:&;]FA4>L<*WD89')R^V795`?A^%T#V(!Z=_^ODO"COHX<)/
MHF(-1,C@TOC(P=$`1#O:US[RC42+CUB\_"G1'V^*>4O%49#N_T.)>W@U)(EM
MTM&MWA3"V>5J.4Q<\<9A+PN@IRC8U[Y`4<T^,8"\=K!O0GNU_;X?XV46??N)
M+N/D^HZ;OJUTU]Q4T@,)2+/DE5)A@I]IF?$-)QPA)3.KY6=M06?*=VY1$7C=
M!?_>51\P.MC*<;1VQ'M2U/G)LQ_A?Q>G8JJO6%)=<UR)<M)T#E#.Y_"'KSF'
MVB[KG.37/BB)`OGNQF&VEI[CD$E?`,$VE&^,I9F^L*6'?2NZ'3B!3GFM%55I
M"*K6E(9)0'B`S?ZJ2G^'78B:A[V1-57[AA:"6:LF3LN//TN*5NM0,RU79R16
MF6TZ)EW65&>EPDE]C^E);1O85-U&S_7-=-CL]0?H]:.#FUY_H?J_H,SR-(-:
M0P^`X.#%4L\5\:?((-V^BR56OQV.DAC/[3$KA;$Y-=M5#6M."V*H=FF69;+@
MSQ>G?S\[Y8`,"E_PN!U\AEYC*J"3L^<G+R^PF3U_^N31^3,"?[?`ZQ+W()^`
MQM^_QPU.F7P"?.L>M>MFP,8ECF\/BDUC7#=VOJ$'1<B4;BC6;K[IVWOJ!IM:
MT2TR&IR@NX&6E=,8QE]R[SX6D&'&PE^VVZZV1">(ZS8%(`+O&(-9=I3-M;4)
MVA[S@^B*8[.`%6!#GL-(`PD,$&(&@R"#*0R_00Y##_I>YVOC-%7^#F*[-TU#
M`E'+[?:X&BZ$*X#6^]JBK[>%9#:.EEH;5"+N`K2-EF#`>I0/\A:>Q5#-@'30
M1+%%90(_0_H3@.Q4ED95]T>%C2<"CC90]`EIHQY)Y*TF<;>^3M)WM?7<Z`<L
M5IT`!1@2:RRLSV*>YJ!*CK4>V#@_WQQM'O]X:F9L)88^!)%A]^!F8OBZ(/+;
MBQ?`ZK]*GH)?2KD4LR"`N+Q<KBW/7AF5W!,;-6PU`6#]JO"SUN-Q;``?AGCS
M5=T;-M>*/76K6O^KG`!Z3MT>XFQ69297M86Z@D3!F;*RH9QT&5!/D:GIPJ2=
M0=,)_:?^EQ=T,Q9R$=X]G?OXKX6`!'/CV=QQIC<"ZJ7"PT2$/M;S:AM>EP:K
M"B+(;Q4.O*UD7;\VF*J7$Q.\(%WLY.)M"8M")G2S:95FE]P0DCHT*0TOV@P]
M^A^2(#%YB?>)@;(9WFT%):E;TGK&::[_XQR_CL>.]0P+(%FZPFD[MOOZ(K"\
M!DMO($RU[869#M\:G*KJ(U!QM:6-"#OB>>907[+SCV3'I4C6HHY"@9KY,CVT
MD=7#IPI_'PVAU5#]/K*(8W3;,GVL]$"1\#?4(["'A^UVRJM>/=S.J9IE0'RD
MMT@YS\,1BE;5#(8>8X6&'_1..X;'O$^)*"=DEHQ:/X@>QD6"ZQ"2NTJGO`ZH
MCK4[U9;'YBA%&A_U`__=[L$V,^)@\7.\M:M`*[9OEA[:*A+[B>7'57+:&)A8
MP67+5O8O*6$4]=5ZI<S/R:=5`:,9N+5\:=&X6F?3]^^%#I!58KV]B-$:^8):
MIK59R+2L*L8J=$PETVHJ8UH?JV%:#05,5?=4+Y2^WA,_JH"6\H2/BKZJ951<
M^J06;JUOE-M\?I73LMW`%L2M9<ZG15,O=<CE?E&]T]A$'0Y[T!@/AV8JCEA5
M7`(AZ]N7=$1?50U\1=/(UKZAB7!!651])>'H")X:$MDJWOCX]M!?ONJ^?@4;
M7O-EI<'P",@9CLQUI<\GIU:$\#N%95GDG%"PJE`OC&FIZ-<I'/-C#G/5R_1?
,F\7_`%H`3-[H/P``
`
end

-- 
Peter Stephenson <pws@ifh.de>       Tel: +39 50 911239
WWW:  http://www.ifh.de/~pws/
Gruppo Teorico, Dipartimento di Fisica
Piazza Torricelli 2, 56100 Pisa, Italy

Re: PATCH: completion lists revisted

[Sven Wischnowsky]

Peter Stephenson wrote:

> ...
> 
> I changed one additional piece of logic: the mere presence of an
> explanation string used to force alternative completions not to be
> tried.  For example,
> 
> compctl -k '(foo bar)' -X 'Yeah.' + -k '(Foo Bar)' foo
> 
> would never look at the Foo Bar possibilities (`foo F^D' would just
> mindlessly say `Yeah.').  Maybe someone can explain this.
> 

I guess this is just a bug (at least I can't remember implementing it
this way intentionally and this was probably my code).


Bye
 Sven


--
Sven Wischnowsky                         wischnow@informatik.hu-berlin.de