Re: experimental new style completion

Re: experimental new style completion

[Sven Wischnowsky]

Phil Pennock wrote:

> 
> Typing away merrily, Sven Wischnowsky produced the immortal words:
> [...]
> > +         eval b\=\( \$\{b:/\*\(${(j:|:)fignore}\)\} \)
> [...]
> > +         eval c\=\( \$\{c:/\*\(${(j:|:)fignore}\)\} \)
> 
> One has to wonder about a shell where /that/ is valid input.
> 
> Whilst it's nice and understandable to people who're extensively
> familiar, doesn't anyone else think it's time to sit back and try and
> look at this syntax objectively?
> 
> (At least, almost understandable... oh yeah, understandable)

;-)

Btw, this is the simple solution. I first tried to integrate it into
the globbing itself but failed utterly.

Bye
 Sven


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

Re: experimental new style completion

[Bart Schaefer]

On Jan 22,  4:18pm, Phil Pennock wrote:
} Subject: Re: experimental new style completion
}
} Whilst it's nice and understandable to people who're extensively
} familiar, doesn't anyone else think it's time to sit back and try and
} look at this syntax objectively?

It surely is gory, but there's only so much that can be done to clarify
it, particularly with the constraint that it can't conflict with any
syntax used by either the Bourne or Korn shells.  However, it's not as
bad as you imply; there are stylistic issues.

	eval b\=\( \$\{b:/\*\(${(j:|:)fignore}\)\} \)

I wouldn't have used all those backslashes ... I prefer quotes:

	eval 'b=( ${b:/*('${(j:|:)fignore}')} )'

which leaves just two oddities:  The (|) glob alternation syntax and the
admittedly icky parameter flags syntax.  It becomes slightly more readable
if you replace the `:' with matching parens or braces:

	eval 'b=( ${b:/*('${(j(|))fignore}')} )'

Would it help to have written it this way?

	fignore_alternatives="${(j(|))fignore}"
	fignore_glob="*($fignore_alternatives)"
	eval 'b=( ${b:/'$fignore_glob'} )'

The final nasty bit here is the need to "eval" to strip the quoting from
the `|' characters in the alternatives, so that the glob will work right.

For those still confused, the whole mess is the same as:

	b_=()
	for i in "$b[@]"
	do
	    for j in "$fignore[@]"
	    do
	    	case "$i" in
		*${j}) continue 2 ;;
		esac
	    done
	    b_=("$b_[@]" "$i") 
	done
	b=("$b_[@]")

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

Re: experimental new style completion

[Phil Pennock]

Typing away merrily, Sven Wischnowsky produced the immortal words:
[...]
> +         eval b\=\( \$\{b:/\*\(${(j:|:)fignore}\)\} \)
[...]
> +         eval c\=\( \$\{c:/\*\(${(j:|:)fignore}\)\} \)

One has to wonder about a shell where /that/ is valid input.

Whilst it's nice and understandable to people who're extensively
familiar, doesn't anyone else think it's time to sit back and try and
look at this syntax objectively?

(At least, almost understandable... oh yeah, understandable)
-- 
--> Phil Pennock ; GAT d- s+:+ a23 C++(++++) UL++++/I+++/S+++/B++/H+$ P++@$
L+++ E-@ W(+) N>++ o !K w--- O>+ M V !PS PE Y+ PGP+ t-- 5++ X+ R !tv b++>+++
DI+ D+ G+ e+ h* r y?

Re: experimental new style completion

[Sven Wischnowsky]

I wrote:

> ...
>
> Most importantly it contains a
> function showing the use of `compadd': with this function it is easy
> to get partial-path completion for almost anything (including what was 
> previously `-g' patterns).
>
> ...

I forgot to handle fignore inside this function.

Bye
 Sven

*** Src/example.old	Fri Jan 22 15:47:54 1999
--- Src/example	Fri Jan 22 15:48:18 1999
***************
*** 238,243 ****
--- 238,244 ----
        s=( "${(@)s:gs.**.*.}" )
        for i in $a; do
          b=( $~i/(#l)$~s )
+         eval b\=\( \$\{b:/\*\(${(j:|:)fignore}\)\} \)
          [[ $#b -ne 0 ]] && c=( $c $i )
        done
        if [[ $#c -eq 0 ]] then
***************
*** 245,250 ****
--- 246,252 ----
        elif [[ $#c -ne 1 ]] then
          a="$epre$pa"
          c=( $~c/(#l)$~s )
+         eval c\=\( \$\{c:/\*\(${(j:|:)fignore}\)\} \)
  	c=( ${c#$a} )
          for i in $c; do
            compadd -p "$pre$pa" -W "$a" -s "/${i#*/}" -f "${i%%/*}"
***************
*** 261,266 ****
--- 263,269 ----
    s=( $str$@ )
    s=( "${(@)s:gs.**.*.}" )
    b=( $~a(#l)$~s )
+   eval b\=\( \$\{b:/\*\(${(j:|:)fignore}\)\} \)
    compadd -p "$pre$pa" -W "$epre$pa" -f ${b#$a}
  }
  

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

Re: experimental new style completion

[Sven Wischnowsky]

The patch below fixes some small bugs in the new style completion
stuff:

  - a memory problem due to not copying -P/-S strings
  - a problem with the job table (the test for validity was too weak
    if there are functions being executed, maybe we should add this
    even without this new stuff).
  - a problem with resetting compnmatches in the completion wrapper
    function (OK, I admit that this was just wrong)
  - cond_position() failed too often

This patch also modifies the example file. It now contains some more
useful example functions (while keeping the old example functions
which weren't that interesting). Most importantly it contains a
function showing the use of `compadd': with this function it is easy
to get partial-path completion for almost anything (including what was 
previously `-g' patterns).
If you already have played with all this (has anyone?): I changed the
functions `defcomp' and `defpatcomp', they now get the name of the
function/variable as their first arguments and `defcomp' accepts more
than one command name.


Bye
 Sven

*** Src/Zle/zle_tricky.c.old	Fri Jan 22 12:57:16 1999
--- Src/Zle/zle_tricky.c	Fri Jan 22 13:06:24 1999
***************
*** 2776,2783 ****
      cm->str = (ms ? ms : s);
      cm->ipre = (ipre && *ipre ? ipre : NULL);
      cm->ripre = (ripre && *ripre ? ripre : NULL);
!     cm->pre = curcc->prefix;
!     cm->suf = curcc->suffix;
      cm->flags = mflags | isf;
      cm->brpl = bpl;
      cm->brsl = bsl;
--- 2776,2788 ----
      cm->str = (ms ? ms : s);
      cm->ipre = (ipre && *ipre ? ipre : NULL);
      cm->ripre = (ripre && *ripre ? ripre : NULL);
!     if (incompfunc) {
! 	cm->pre = dupstring(curcc->prefix);
! 	cm->suf = dupstring(curcc->suffix);
!     } else {
! 	cm->pre = curcc->prefix;
! 	cm->suf = curcc->suffix;
!     }
      cm->flags = mflags | isf;
      cm->brpl = bpl;
      cm->brsl = bsl;
***************
*** 4471,4477 ****
  	char *j, *jj;
  
  	for (i = 0; i < MAXJOB; i++)
! 	    if (jobtab[i].stat & STAT_INUSE) {
  		int stopped = jobtab[i].stat & STAT_STOPPED;
  
  		j = jj = dupstring(jobtab[i].procs->text);
--- 4476,4483 ----
  	char *j, *jj;
  
  	for (i = 0; i < MAXJOB; i++)
! 	    if ((jobtab[i].stat & STAT_INUSE) &&
! 		jobtab[i].procs && jobtab[i].procs->text) {
  		int stopped = jobtab[i].stat & STAT_STOPPED;
  
  		j = jj = dupstring(jobtab[i].procs->text);
*** Src/Zle/compctl.c.old	Fri Jan 22 12:05:17 1999
--- Src/Zle/compctl.c	Fri Jan 22 13:55:47 1999
***************
*** 1860,1869 ****
  	return 1;
      else {
  	char *octxt, *ocmd, *opre, *osuf, *oipre;
! 	long ocur, onm;
  
  	ocur = compcurrent;
- 	onm = compnmatches;
  	octxt = dupstring(compcontext);
  	ocmd = dupstring(compcommand);
  	opre = dupstring(compprefix);
--- 1860,1868 ----
  	return 1;
      else {
  	char *octxt, *ocmd, *opre, *osuf, *oipre;
! 	long ocur;
  
  	ocur = compcurrent;
  	octxt = dupstring(compcontext);
  	ocmd = dupstring(compcommand);
  	opre = dupstring(compprefix);
***************
*** 1873,1879 ****
  	runshfunc(list, w, name);
  
  	compcurrent = ocur;
- 	compnmatches = onm;
  	zsfree(compcontext);
  	compcontext = ztrdup(octxt);
  	zsfree(compcommand);
--- 1872,1877 ----
***************
*** 1976,1985 ****
  	    b += l;
  	if (e < 0)
  	    e += l;
! 	t = (b >= 0 && b < l && e >= 0 && e < l && i >= b && i <= e && b <= e);
  
! 	if (t && a[1])
  	    restrict_range(b, e);
  	return t;
      }
      return 0;
--- 1974,1988 ----
  	    b += l;
  	if (e < 0)
  	    e += l;
! 	t = (b >= 0 && e >= 0 && i >= b && i <= e && b <= e);
  
! 	if (t && a[1]) {
! 	    if (b > l)
! 		b = l;
! 	    if (e > l)
! 		e = l;
  	    restrict_range(b, e);
+ 	}
  	return t;
      }
      return 0;
*** Src/example.old	Fri Jan 22 12:08:32 1999
--- Src/example	Fri Jan 22 14:04:15 1999
***************
*** 13,33 ****
  typeset -A comps
  
  
! # These may be used to define completion handlers.
  
  defcomp() {
    if [[ $# -eq 1 ]] then
      comps[$1]="__$1"
    else
!     comps[$1]="$2"
    fi
  }
  
  defpatcomp() {
    if [[ ${+patcomps} == 1 ]] then
!     patcomps=("$patcomps[@]" "$1 $2" )
    else
!     patcomps=( "$1 $2" )
    fi
  }
  
--- 13,42 ----
  typeset -A comps
  
  
! # These may be used to define completion handlers. First argument is the
! # name of the function/variable containing the definition, the other
! # arguments are the command names for which this definition should be used.
! # With only one argument the function/variable-name __$1 is used.
  
  defcomp() {
+   local v
+ 
    if [[ $# -eq 1 ]] then
      comps[$1]="__$1"
    else
!     v="$1"
!     shift
!     for i; do
!       comps[$i]="$v"
!     done
    fi
  }
  
  defpatcomp() {
    if [[ ${+patcomps} == 1 ]] then
!     patcomps=("$patcomps[@]" "$2 $1" )
    else
!     patcomps=( "$2 $1" )
    fi
  }
  
***************
*** 157,168 ****
  
  # Do sub-completion for pre-command modifiers.
  
! defcomp - __precmd
! defcomp noglob __precmd
! defcomp nocorrect __precmd
! defcomp exec __precmd
! defcomp command __precmd
! defcomp builtin __precmd
  __precmd() {
    COMMAND="$1"
    shift
--- 166,172 ----
  
  # Do sub-completion for pre-command modifiers.
  
! defcomp __precmd - noglob nocorrect exec command builtin
  __precmd() {
    COMMAND="$1"
    shift
***************
*** 175,192 ****
    compsub
  }
  
  # Simple default, command, and math completion defined with variables.
  
! defcomp --default-- __default
! __default=( -f )
  
! defcomp --command-- __command
  __command=( -c )
  
! defcomp --math-- __math
  __math=( -v )
  
! defcomp --subscr-- __subscr
  __subscr() {
    compalso --math-- "$@"
    # ...probably other stuff
--- 179,295 ----
    compsub
  }
  
+ # Utility function for in-path completion.
+ # First argument should be an complist-option (e.g. -f, -/, -g). The other
+ # arguments should be glob patterns, one per argument.
+ # E.g.: files -g '*.tex' '*.texi'
+ # This is intended as a replacement for `complist -f', `complist -/', and
+ # `complist -g ...' (but don't use it with other options).
+ # This function behaves as if you have a matcher definition like:
+ #   compctl -M 'r:|[-.,_/]=* r:|=* m:{a-z}={A-Z} m:-=_ m:.=,'
+ # so you may want to modify this.
+ 
+ pfiles() {
+   local nm str pa pre epre a b c s rest
+ 
+   setopt localoptions nullglob rcexpandparam globdots extendedglob
+   unsetopt markdirs globsubst shwordsplit nounset
+ 
+   nm=$NMATCHES
+   if [[ $# -eq 0 ]] then
+     complist -f
+   elif [[ "$1" = -g ]] then
+     complist -g "$argv[2,-1]"
+     shift
+   else
+     complist $1
+     shift
+   fi
+   [[ -nmatches nm ]] || return
+ 
+   str="$PREFIX*$SUFFIX"
+ 
+   [[ -z "$1" ]] && 1='*'
+   if [[ $str[1] = \~ ]] then
+     pre="${str%%/*}/"
+     eval epre\=$pre
+     str="${str#*/}"
+     pa=''
+   else
+     pre=''
+     epre=''
+     if [[ $str[1] = / ]] then
+       str="$str[2,-1]"
+       pa='/'
+     else
+       pa=''
+     fi
+   fi
+   str="$str:gs/,/*,/:gs/_/*_/:gs./.*/.:gs/-/*[-_]/:gs/./*[.,]/:gs-*[.,]*[.,]*/-../-:gs.**.*."
+   while [[ "$str" = */* ]] do
+     rest="${str#*/}"
+     a="${epre}${pa}(#l)${str%%/*}(-/)"
+     a=( $~a )
+     if [[ $#a -eq 0 ]] then
+       return
+     elif [[ $#a -gt 1 ]] then
+       c=()
+       s=( $rest$@ )
+       s=( "${(@)s:gs.**.*.}" )
+       for i in $a; do
+         b=( $~i/(#l)$~s )
+         [[ $#b -ne 0 ]] && c=( $c $i )
+       done
+       if [[ $#c -eq 0 ]] then
+         return
+       elif [[ $#c -ne 1 ]] then
+         a="$epre$pa"
+         c=( $~c/(#l)$~s )
+ 	c=( ${c#$a} )
+         for i in $c; do
+           compadd -p "$pre$pa" -W "$a" -s "/${i#*/}" -f "${i%%/*}"
+         done
+ 	return
+       fi
+       a=( "$c[1]" )
+     fi
+     a="$a[1]"
+     pa="$pa${a##*/}/"
+     str="$rest"
+   done
+   a="$epre$pa"
+   s=( $str$@ )
+   s=( "${(@)s:gs.**.*.}" )
+   b=( $~a(#l)$~s )
+   compadd -p "$pre$pa" -W "$epre$pa" -f ${b#$a}
+ }
+ 
+ # Utility function for completing files of a given type or any file.
+ # In many cases you will want to call this one instead of pfiles().
+ 
+ files() {
+   local nm
+ 
+   nm=$NMATCHES
+   pfiles "$@"
+ 
+   [[ $# -ne 0 && -nmatches nm ]] && pfiles
+ }
+ 
  # Simple default, command, and math completion defined with variables.
  
! defcomp __default --default--
! __default() {
!   files
! }
  
! defcomp __command --command--
  __command=( -c )
  
! defcomp __math --math--
  __math=( -v )
  
! defcomp __subscr --subscr--
  __subscr() {
    compalso --math-- "$@"
    # ...probably other stuff
***************
*** 194,200 ****
  
  # A simple pattern completion, just as an example.
  
! defpatcomp '*/X11/*' __x_options
  __x_options() {
    complist -J options -k '(-display -name -xrm)'
  }
--- 297,303 ----
  
  # A simple pattern completion, just as an example.
  
! defpatcomp __x_options '*/X11/*'
  __x_options() {
    complist -J options -k '(-display -name -xrm)'
  }
***************
*** 214,227 ****
  	exec {f,}print{f,0,} ok prune ls'
      compreset
    elif [[ -position 1 ]] then
!     complist -g '. ..' -/
    elif [[ -mcurrent -1 -((a|c|)newer|fprint(|0|f)) ]] then
!     complist -f
    elif [[ -current -1 -fstype ]] then
      complist -k '(ufs 4.2 4.3 nfs tmp mfs S51K S52K)'
    elif [[ -current -1 -group ]] then
!     complist -g groups
    elif [[ -current -1 -user ]] then
      complist -u
    fi
  }
--- 317,450 ----
  	exec {f,}print{f,0,} ok prune ls'
      compreset
    elif [[ -position 1 ]] then
!     complist -g '. ..'
!     files -g '(-/)'
    elif [[ -mcurrent -1 -((a|c|)newer|fprint(|0|f)) ]] then
!     files
    elif [[ -current -1 -fstype ]] then
      complist -k '(ufs 4.2 4.3 nfs tmp mfs S51K S52K)'
    elif [[ -current -1 -group ]] then
!     complist -k groups
    elif [[ -current -1 -user ]] then
      complist -u
+   fi
+ }
+ 
+ # Various completions...
+ 
+ defcomp __gunzip gunzip zcat
+ __gunzip() {
+   files -g '*.[gG][z]'
+ }
+ 
+ defcomp gzip
+ __gzip() {
+   files -g '*~*.[gG][zZ]'
+ }
+ 
+ defcomp xfig
+ __xfig() {
+   files -g '*.fig'
+ }
+ 
+ defcomp __make make gmake
+ __make() {
+   complist -s "\$(awk '/^[a-zA-Z0-9][^/ 	]+:/ {print \$1}' FS=: [mM]akefile)"
+ }
+ 
+ defcomp __ps gs ghostview gview psnup psselect pswrap pstops pstruct lpr
+ __ps() {
+   files -g '*([pP][sS]|eps)'
+ }
+ 
+ defcomp __which which whence
+ __which=( -caF )
+ 
+ defcomp __rlogin rlogin rsh ssh
+ __rlogin() {
+   if [[ -position 1 ]] then
+     complist -k hosts
+   elif [[ -position 2 ]] then
+     complist -k '(-l)'
+   elif [[ -position 3 && -word 1 artus ]] then
+     complist -k '(puck root)'
+   fi
+ }
+ 
+ defcomp __dvi xdvi dvips dvibook dviconcat dvicopy dvidvi dviselect dvitodvi dvitype
+ __dvi() {
+   files -g '*.(dvi|DVI)'
+ }
+ 
+ defcomp __dirs rmdir df du dircmp cd
+ __dirs() {
+   files -/ '*(-/)'
+ }
+ 
+ defcomp __jobs fg bg jobs
+ __jobs=(-j -P '%?')
+ 
+ defcomp kill
+ __kill() {
+   if [[ -iprefix '-' ]] then
+     complist -k signals
+   else
+     complist -P '%?' -j
+   fi
+ }
+ 
+ defcomp __uncompress uncompress zmore
+ __uncompress() {
+   files -g '*.Z'
+ }
+ 
+ defcomp compress
+ __compress() {
+   files -g '*~*.Z'
+ }
+ 
+ defcomp __tex tex latex glatex slitex gslitex
+ __tex() {
+   files -g '*.(tex|TEX|texinfo|texi)'
+ }
+ 
+ defcomp __options setopt unsetopt
+ __options=(-M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' -o)
+ 
+ defcomp __funcs unfunction
+ __funcs=(-F)
+ 
+ defcomp __aliases unalias
+ __aliases=(-a)
+ 
+ defcomp __vars unset
+ __vars=(-v)
+ 
+ defcomp __enabled disable
+ __enabled=(-FBwa)
+ 
+ defcomp __disabled enable
+ __disabled=(-dFBwa)
+ 
+ defcomp __pdf acroread
+ __pdf() {
+   files -g '*.(pdf|PDF)'
+ }
+ 
+ defcomp tar
+ __tar() {
+   local nm tf
+   compsave
+ 
+   tf="$2"
+   nm=$NMATCHES
+   if [[ ( -mword 1 *t*f* || -mword 1 *x*f* ) && -position 3 100000 ]] then
+     complist -k "( $(tar tf $tf) )"
+     compreset
+   elif [[ -mword 1 *c*f* && -position 3 100000 ]] then
+     files
+     compreset
+   elif [[ -mcurrent -1 *f* && -position 2 ]] then
+     files -g '*.(tar|TAR)'
    fi
  }

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

Re: experimental new style completion

[Sven Wischnowsky]

Another small fix to the new style completion stuff. This time it's
a memory problem: with -k you can give the code an array. When
building the things to put into the command line it uses the strings
in it before copying them. The only easy solution I currently see is
to move the call to dupstring() up, although that will sometimes
create copies that aren't needed. Hm.

Bye
 Sven

*** Src/Zle/zle_tricky.c.old	Thu Jan 21 17:02:28 1999
--- Src/Zle/zle_tricky.c	Thu Jan 21 17:03:05 1999
***************
*** 2552,2557 ****
--- 2552,2559 ----
      hn = (HashNode) t;
      pm = (Param) t;
  
+     if (incompfunc)
+ 	s = dupstring(s);
      if (!addwhat) {
  	test = 1;
      } else if (addwhat == -1 || addwhat == -5 || addwhat == -6 ||
***************
*** 2687,2694 ****
      }
      if (!test)
  	return;
-     if (incompfunc)
- 	s = dupstring(s);
      if (!ms && !ispattern && ai->firstm) {
  	if ((test = sl - pfxlen(ai->firstm->str, s)) < ai->prerest)
  	    ai->prerest = test;
--- 2689,2694 ----

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

Re: experimental new style completion

[Sven Wischnowsky]

Here is another little fixlet for the new style completion stuff. The
tokenizing in comp_str() failed for `$'s. Not wanting to change
tokenize() itself I added a little wrapper function in zle_tricky.c
(is there really no better way?).

Bye
 Sven

*** Src/Zle/zle_tricky.c.old	Thu Jan 21 12:59:33 1999
--- Src/Zle/zle_tricky.c	Thu Jan 21 12:58:27 1999
***************
*** 3348,3353 ****
--- 3348,3379 ----
      return 1;
  }
  
+ /* This should probably be moved into tokenize(). */
+ 
+ static char *
+ ctokenize(char *p)
+ {
+     char *r = p;
+     int bslash = 0;
+ 
+     tokenize(p);
+ 
+     for (p = r; *p; p++) {
+ 	if (*p == '\\')
+ 	    bslash = 1;
+ 	else {
+ 	    if (*p == '$') {
+ 		if (bslash)
+ 		    p[-1] = Bnull;
+ 		else
+ 		    *p = String;
+ 	    }
+ 	    bslash = 0;
+ 	}
+     }
+     return r;
+ }
+ 
  /**/
  char *
  comp_str(int *ipl, int *pl)
***************
*** 3358,3368 ****
      char *str;
      int lp, ls, lip;
  
!     tokenize(p);
      remnulargs(p);
!     tokenize(s);
      remnulargs(s);
!     tokenize(ip);
      remnulargs(ip);
      ls = strlen(s);
      lip = strlen(ip);
--- 3384,3394 ----
      char *str;
      int lp, ls, lip;
  
!     ctokenize(p);
      remnulargs(p);
!     ctokenize(s);
      remnulargs(s);
!     ctokenize(ip);
      remnulargs(ip);
      ls = strlen(s);
      lip = strlen(ip);

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

Re: experimental new style completion

[Sven Wischnowsky]

While working on my last patch I found a bug: completion inside
`((...))' reported a wrong CONTEXT.

Bye
 Sven

*** Src/Zle/zle_tricky.c.old	Thu Jan 21 11:48:50 1999
--- Src/Zle/zle_tricky.c	Thu Jan 21 11:49:06 1999
***************
*** 3240,3246 ****
  		zsfree(compcontext);
  		zsfree(compcommand);
  		compcommand = "";
! 		if (lincmd)
  		    compcontext = (insubscr ? "subscript" : "command");
  		else if (linredir)
  		    compcontext = "redirect";
--- 3240,3253 ----
  		zsfree(compcontext);
  		zsfree(compcommand);
  		compcommand = "";
! 		if (inwhat == IN_MATH) {
! 		    if (insubscr) {
! 			compcontext = "subscript";
! 			compcommand = varname ? varname : "";
! 		    } else
! 			compcontext = "math";
! 		    usea = 0;
! 		} else if (lincmd)
  		    compcontext = (insubscr ? "subscript" : "command");
  		else if (linredir)
  		    compcontext = "redirect";
***************
*** 3249,3262 ****
  		    case IN_ENV:
  			compcontext = "value";
  			compcommand = varname;
- 			usea = 0;
- 			break;
- 		    case IN_MATH:
- 			if (insubscr) {
- 			    compcontext = "subscript";
- 			    compcommand = varname ? varname : "";
- 			} else
- 			    compcontext = "math";
  			usea = 0;
  			break;
  		    case IN_COND:
--- 3256,3261 ----

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

Re: experimental new style completion

[Sven Wischnowsky]

Bart Schaefer wrote:

> May I suggest that there's no reason to abbreviate names of this sort.
> 
>  `command' (not `cmd')      we are completing in command position
>  `argument' (not `arg')     we are completing in argument position
>  `redirect' (not `redir')   ... after a redirection operator
>  `math'                     ... in a math environment
>  `subscript' (not `subscr') ... in a subscript
>  `value'                    ... in the value of an variable assignment
>  `condition'                ... inside `[[...]]'
> 

The patch below does this.

> Also ... I may be mistaken, but isn't it possible to be in both the command
> position and after a redirection operator (e.g. readnullcmd) or in both a
> math context and inside a subscript?  Is a single context identifier enough?

This is not changed by the patch. The intended usage is to call a
provided shell function or alias that generates the matches for
`included' context types (see the use of `compalso' in the example
file). Anyway after thinking more about this I see a real use for this 
only with `math' and `subscript' and probaly using the `math' stuff in 
some cases in conditions. `command' and `redirection' are mutually
exclusive as far as I can see.

Bye
 Sven

*** Src/Zle/zle_tricky.c.old	Thu Jan 21 10:47:03 1999
--- Src/Zle/zle_tricky.c	Thu Jan 21 11:03:02 1999
***************
*** 3241,3249 ****
  		zsfree(compcommand);
  		compcommand = "";
  		if (lincmd)
! 		    compcontext = (insubscr ? "subscr" : "cmd");
  		else if (linredir)
! 		    compcontext = "redir";
  		else
  		    switch (inwhat) {
  		    case IN_ENV:
--- 3241,3249 ----
  		zsfree(compcommand);
  		compcommand = "";
  		if (lincmd)
! 		    compcontext = (insubscr ? "subscript" : "command");
  		else if (linredir)
! 		    compcontext = "redirect";
  		else
  		    switch (inwhat) {
  		    case IN_ENV:
***************
*** 3253,3270 ****
  			break;
  		    case IN_MATH:
  			if (insubscr) {
! 			    compcontext = "subscr";
  			    compcommand = varname ? varname : "";
  			} else
  			    compcontext = "math";
  			usea = 0;
  			break;
  		    case IN_COND:
! 			compcontext = "cond";
  			break;
  		    default:
  			if (cmdstr) {
! 			    compcontext = "arg";
  			    compcommand = cmdstr;
  			} else {
  			    compcontext = "value";
--- 3253,3270 ----
  			break;
  		    case IN_MATH:
  			if (insubscr) {
! 			    compcontext = "subscript";
  			    compcommand = varname ? varname : "";
  			} else
  			    compcontext = "math";
  			usea = 0;
  			break;
  		    case IN_COND:
! 			compcontext = "condition";
  			break;
  		    default:
  			if (cmdstr) {
! 			    compcontext = "argument";
  			    compcommand = cmdstr;
  			} else {
  			    compcontext = "value";
*** Src/example.old	Thu Jan 21 10:47:18 1999
--- Src/example	Thu Jan 21 11:25:50 1999
***************
*** 42,47 ****
--- 42,53 ----
  
  alias compsub='do-complete "$@" || return 1'
  
+ # This searches $1 in the array for normal completions and calls the result.
+ 
+ compalso() {
+   1="$comps[$1]"
+   [[ -z "$1" ]] || call-complete "$@"
+ }
  
  # This generates matches. The first argument is something we got from one
  # of the associative arrays above. This is expected to be either the name
***************
*** 81,87 ****
    # For arguments we use the `do-complete' function below called via the
    # convenience alias `compsub'.
  
!   if [[ $CONTEXT == arg || $CONTEXT == cmd ]] then
      compsub
    else
      # Let's see if we have a special completion definition for the other
--- 87,93 ----
    # For arguments we use the `do-complete' function below called via the
    # convenience alias `compsub'.
  
!   if [[ $CONTEXT == argument || $CONTEXT == command ]] then
      compsub
    else
      # Let's see if we have a special completion definition for the other
***************
*** 90,100 ****
      comp=''
  
      case $CONTEXT in
!     redir)  comp="$comps[--redir--]";;
      math)   comp="$comps[--math--]";;
!     subscr) comp="$comps[--subscr--]";;
      value)  comp="$comps[--value--]";;
!     cond)   comp="$comps[--cond--]";;
      esac
  
      # If not, we use default completion, if any.
--- 96,106 ----
      comp=''
  
      case $CONTEXT in
!     redirect)  comp="$comps[--redir--]";;
      math)   comp="$comps[--math--]";;
!     subscript) comp="$comps[--subscr--]";;
      value)  comp="$comps[--value--]";;
!     condition)   comp="$comps[--cond--]";;
      esac
  
      # If not, we use default completion, if any.
***************
*** 114,120 ****
    # two strings we have search in the completion definition arrays (e.g.
    # a path and the last path name component).
  
!   if [[ $CONTEXT == cmd ]] then
      comp="$comps[--command--]"
      [[ -z "$comp" ]] || call-complete "$comp" "$@" || return 1
      return 0
--- 120,126 ----
    # two strings we have search in the completion definition arrays (e.g.
    # a path and the last path name component).
  
!   if [[ $CONTEXT == command ]] then
      comp="$comps[--command--]"
      [[ -z "$comp" ]] || call-complete "$comp" "$@" || return 1
      return 0
***************
*** 162,170 ****
    shift
    (( CURRENT-- ))
    if [[ CURRENT -eq 0 ]] then
!     CONTEXT=cmd
    else
!     CONTEXT=arg
    fi
    compsub
  }
--- 168,176 ----
    shift
    (( CURRENT-- ))
    if [[ CURRENT -eq 0 ]] then
!     CONTEXT=command
    else
!     CONTEXT=argument
    fi
    compsub
  }
***************
*** 178,185 ****
  __command=( -c )
  
  defcomp --math-- __math
- defcomp --subscr-- __math
  __math=( -v )
  
  # A simple pattern completion, just as an example.
  
--- 184,196 ----
  __command=( -c )
  
  defcomp --math-- __math
  __math=( -v )
+ 
+ defcomp --subscr-- __subscr
+ __subscr() {
+   compalso --math-- "$@"
+   # ...probably other stuff
+ }
  
  # A simple pattern completion, just as an example.
  

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

Re: experimental new style completion

[Sven Wischnowsky]

Bart Schaefer wrote:

> 
> On Jan 5,  4:43pm, Sven Wischnowsky wrote:
> } Subject: Re:  experimental new style completion
> }
> } - When completing in subscripts on the left side of an parameter
> }   assignment the CONTEXT is now set to `subscr' (this is still a bit
> }   hackish)
> 
> May I suggest that there's no reason to abbreviate names of this sort.

Yep. As I said, these parameters may change anyway (esp. if we put all 
of them into an associative array).

> Also ... I may be mistaken, but isn't it possible to be in both the command
> position and after a redirection operator (e.g. readnullcmd) or in both a
> math context and inside a subscript?  Is a single context identifier enough?

That's (partly) inherited from the current completion code. One
difference is that math and subscript are distinguished, the normal
code just treats both of them as mathematical environments. I haven't
thought about using multiple context names at once and I could be
convinced to do this for math/subscript and probably others.
But all this is new stuff anyway, the normal completion code doesn't
allow one to separately define completions for conds, math, subscript, 
redir, and value, so I suggest playing with it until we find out what
would be most useful.

Bye
 Sven


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

Re: experimental new style completion

[Bart Schaefer]

On Jan 5,  4:43pm, Sven Wischnowsky wrote:
} Subject: Re:  experimental new style completion
}
} - When completing in subscripts on the left side of an parameter
}   assignment the CONTEXT is now set to `subscr' (this is still a bit
}   hackish)

May I suggest that there's no reason to abbreviate names of this sort.

 `command' (not `cmd')      we are completing in command position
 `argument' (not `arg')     we are completing in argument position
 `redirect' (not `redir')   ... after a redirection operator
 `math'                     ... in a math environment
 `subscript' (not `subscr') ... in a subscript
 `value'                    ... in the value of an variable assignment
 `condition'                ... inside `[[...]]'

Also ... I may be mistaken, but isn't it possible to be in both the command
position and after a redirection operator (e.g. readnullcmd) or in both a
math context and inside a subscript?  Is a single context identifier enough?

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

Re: experimental new style completion

[Sven Wischnowsky]

Below is the first patch that goes on top of my patch for the
experimental new style completion stuff. Of course all this is only
interesting if you have installed that patch.

Things changed:

- The example file now uses a normal array for pattern completions
  (dunno why I used an associative array in the first place... we even 
  had discussed this, sigh).
- The compadd builtin has some new options (to really make everything
  available):
  - `-W <path>' sets the path to use for checking file types. I used
    `-W' since this is one of the things `-W' does for compctl and
    complist.
  - `-a' makes the given completions be stored in the alternative set
    of completions. This has *nothing* to do with xor'ed
    completion. In this case the `alternative set' is the one built
    internally for matches with fignore ignored.
  - `--' ends the list of options. Anything after that will be
    considered to be a match to add (of course, this is important to
    have if all matches you want to add start with a `-').
- When completing in subscripts on the left side of an parameter
  assignment the CONTEXT is now set to `subscr' (this is still a bit
  hackish)
- The file compctl.mdd now contains definitions for complist, compadd, 
  and the conditions.
- The patch also contains some fixes for things that were not yet
  working (namely `compadd -n').

Bye
 Sven

*** Src/Zle/compctl.c.old	Tue Jan  5 14:52:10 1999
--- Src/Zle/compctl.c	Tue Jan  5 15:25:35 1999
***************
*** 1699,1707 ****
  bin_compadd(char *name, char **argv, char *ops, int func)
  {
      char *p, **sp, *e;
!     char *ipre = NULL, *ppre = NULL, *psuf = NULL;
      char *pre = NULL, *suf = NULL, *group = NULL;
!     int f = 0, q = 0, m = 0, ns = 0;
  
      if (!incompfunc) {
  	zerrnam(name, "can only be called from completion function", NULL, 0);
--- 1699,1707 ----
  bin_compadd(char *name, char **argv, char *ops, int func)
  {
      char *p, **sp, *e;
!     char *ipre = NULL, *ppre = NULL, *psuf = NULL, *prpre = NULL;
      char *pre = NULL, *suf = NULL, *group = NULL;
!     int f = 0, q = 0, m = 0, ns = 0, a = 0;
  
      if (!incompfunc) {
  	zerrnam(name, "can only be called from completion function", NULL, 0);
***************
*** 1756,1761 ****
--- 1756,1771 ----
  		sp = &psuf;
  		e = "string expected after -%c";
  		break;
+ 	    case 'W':
+ 		sp = &prpre;
+ 		e = "string expected after -%c";
+ 		break;
+ 	    case 'a':
+ 		a = 1;
+ 		break;
+ 	    case '-':
+ 		argv++;
+ 		goto ca_args;
  	    default:
  		zerrnam(name, "bad option: -%c", NULL, *p);
  		return 1;
***************
*** 1778,1788 ****
  	    }
  	}
      }
      if (!*argv) {
  	zerrnam(name, "missing completions", NULL, 0);
  	return 1;
      }
!     addmatches(ipre, ppre, psuf, pre, suf, group, f, q, m, ns, argv);
      return 0;
  }
  
--- 1788,1800 ----
  	    }
  	}
      }
+  ca_args:
      if (!*argv) {
  	zerrnam(name, "missing completions", NULL, 0);
  	return 1;
      }
!     addmatches(ipre, ppre, psuf, prpre, pre, suf, group,
! 	       f, q, m, ns, a, argv);
      return 0;
  }
  
*** Src/Zle/compctl.mdd.old	Tue Jan  5 14:15:24 1999
--- Src/Zle/compctl.mdd	Tue Jan  5 16:26:44 1999
***************
*** 1,5 ****
  moddeps="comp1"
  
! autobins="compctl"
  
  objects="compctl.o"
--- 1,7 ----
  moddeps="comp1"
  
! autobins="compctl complist compadd"
! 
! autoprefixconds="prefix iprefix position word mword current mcurrent string class words between mbetween after mafter nmatches"
  
  objects="compctl.o"
*** Src/Zle/zle_tricky.c.old	Tue Jan  5 14:19:02 1999
--- Src/Zle/zle_tricky.c	Tue Jan  5 16:11:22 1999
***************
*** 2394,2405 ****
  
  /**/
  void
! addmatches(char *ipre, char *ppre, char *psuf, char *pre, char *suf, char *group,
! 	   int flags, int quote, int menu, int nosort, char **argv)
  {
!     char *s, *t, *prpre;
      int lpl, lsl, i;
!     Aminfo ai = ainfo;
      Cmatch cm;
  
      if (menu && isset(AUTOMENU))
--- 2394,2406 ----
  
  /**/
  void
! addmatches(char *ipre, char *ppre, char *psuf, char *prpre, char *pre,
! 	   char *suf, char *group,
! 	   int flags, int quote, int menu, int nosort, int alt, char **argv)
  {
!     char *s, *t;
      int lpl, lsl, i;
!     Aminfo ai = (alt ? fainfo : ainfo);
      Cmatch cm;
  
      if (menu && isset(AUTOMENU))
***************
*** 2422,2431 ****
  		pre = dupstring(pre);
  	    if (suf)
  		suf = dupstring(suf);
! 	    if ((prpre = ppre)) {
  		singsub(&prpre);
  		untokenize(prpre);
! 	    }
  	    if (group) {
  		endcmgroup(NULL);
  		begcmgroup(group, nosort);
--- 2423,2433 ----
  		pre = dupstring(pre);
  	    if (suf)
  		suf = dupstring(suf);
! 	    if (!prpre && (prpre = ppre)) {
  		singsub(&prpre);
  		untokenize(prpre);
! 	    } else
! 		prpre = dupstring(prpre);
  	    if (group) {
  		endcmgroup(NULL);
  		begcmgroup(group, nosort);
***************
*** 2493,2499 ****
  		cm->flags = flags;
  		cm->brpl = brpl;
  		cm->brsl = brsl;
! 		addlinknode(matches, cm);
  
  		if (expl)
  		    expl->fcount++;
--- 2495,2501 ----
  		cm->flags = flags;
  		cm->brpl = brpl;
  		cm->brsl = brsl;
! 		addlinknode((alt ? fmatches : matches), cm);
  
  		if (expl)
  		    expl->fcount++;
***************
*** 2682,2688 ****
      }
      if (!test)
  	return;
! 
      if (!ms && !ispattern && ai->firstm) {
  	if ((test = sl - pfxlen(ai->firstm->str, s)) < ai->prerest)
  	    ai->prerest = test;
--- 2684,2691 ----
      }
      if (!test)
  	return;
!     if (incompfunc)
! 	s = dupstring(s);
      if (!ms && !ispattern && ai->firstm) {
  	if ((test = sl - pfxlen(ai->firstm->str, s)) < ai->prerest)
  	    ai->prerest = test;
***************
*** 3235,3241 ****
  		zsfree(compcommand);
  		compcommand = "";
  		if (lincmd)
! 		    compcontext = "cmd";
  		else if (linredir)
  		    compcontext = "redir";
  		else
--- 3238,3244 ----
  		zsfree(compcommand);
  		compcommand = "";
  		if (lincmd)
! 		    compcontext = (insubscr ? "subscr" : "cmd");
  		else if (linredir)
  		    compcontext = "redir";
  		else
***************
*** 4842,4851 ****
  	    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
  	    ap = bp;
  	    /* Mark those, that would show the same string in the list. */
! 	    for (; bp[1] && !strcmp((*ap)->str, (bp[1])->str); bp++) {
! 		(bp[1])->flags |= CMF_NOLIST; nl++;
! 	    }
  	}
  	*cp = NULL;
      }
      if (np)
--- 4845,4856 ----
  	    for (bp = ap; bp[1] && matcheq(*ap, bp[1]); bp++, n--);
  	    ap = bp;
  	    /* Mark those, that would show the same string in the list. */
! 	    for (; bp[1] && !strcmp((*ap)->str, (bp[1])->str); bp++)
! 		(bp[1])->flags |= CMF_NOLIST;
  	}
+ 	for (ap = rp; *ap; ap++)
+ 	    if ((*ap)->flags & CMF_NOLIST)
+ 		nl++;
  	*cp = NULL;
      }
      if (np)
***************
*** 5781,5787 ****
  		}
  		if (n) {
  		    putc('\n', shout);
! 		    p = skipnolist(p + 1);
  		}
  	    }
  	}
--- 5786,5793 ----
  		}
  		if (n) {
  		    putc('\n', shout);
! 		    if (n && nl)
! 			p = skipnolist(p + 1);
  		}
  	    }
  	}
*** Src/example.old	Tue Jan  5 13:32:32 1999
--- Src/example	Tue Jan  5 16:28:15 1999
***************
*** 10,16 ****
  
  # One associative array for normal completions and one for patterns.
  
! typeset -A comps patcomps
  
  
  # These may be used to define completion handlers.
--- 10,16 ----
  
  # One associative array for normal completions and one for patterns.
  
! typeset -A comps
  
  
  # These may be used to define completion handlers.
***************
*** 24,30 ****
  }
  
  defpatcomp() {
!   patcomps[$1]="$2"
  }
  
  
--- 24,34 ----
  }
  
  defpatcomp() {
!   if [[ ${+patcomps} == 1 ]] then
!     patcomps=("$patcomps[@]" "$1 $2" )
!   else
!     patcomps=( "$1 $2" )
!   fi
  }
  
  
***************
*** 68,74 ****
  
    # An entry for `--first--' is the replacement for `compctl -T'
    # The `|| return 1' is used throughout: if a function producing matches
!   # non-zero this is interpreted as `do not try to produce more matches'
    # (this is the replacement for `compctl -t').
  
    comp="$comps[--first--]"
--- 72,78 ----
  
    # An entry for `--first--' is the replacement for `compctl -T'
    # The `|| return 1' is used throughout: if a function producing matches
!   # returns non-zero this is interpreted as `do not try to produce more matches'
    # (this is the replacement for `compctl -t').
  
    comp="$comps[--first--]"
***************
*** 104,110 ****
  # arguments).
  
  do-complete() {
!   local comp cmd1 cmd2
  
    # Completing in command position? If not we set up `cmd1' and `cmd2' as
    # two strings we have search in the completion definition arrays (e.g.
--- 108,114 ----
  # arguments).
  
  do-complete() {
!   local comp cmd1 cmd2 pat val
  
    # Completing in command position? If not we set up `cmd1' and `cmd2' as
    # two strings we have search in the completion definition arrays (e.g.
***************
*** 127,135 ****
  
    # See if there are any matching pattern completions.
  
!   for pat in "${(k)patcomps[@]}"; do
      if [[ "$cmd1" == $~pat || "$cmd2" == $~pat ]] then
!       call-complete "$patcomps[$pat]" "$@" || return 1
      fi
    done
  
--- 131,141 ----
  
    # See if there are any matching pattern completions.
  
!   for i in "$patcomps[@]"; do
!     pat="${i% *}"
!     val="${i#* }"
      if [[ "$cmd1" == $~pat || "$cmd2" == $~pat ]] then
!       call-complete "$val" "$@" || return 1
      fi
    done
  
***************
*** 163,175 ****
    compsub
  }
  
! # Simple default and command completion defined with variables.
  
  defcomp --default-- __default
  __default=( -f )
  
  defcomp --command-- __command
  __command=( -c )
  
  # A simple pattern completion, just as an example.
  
--- 169,185 ----
    compsub
  }
  
! # Simple default, command, and math completion defined with variables.
  
  defcomp --default-- __default
  __default=( -f )
  
  defcomp --command-- __command
  __command=( -c )
+ 
+ defcomp --math-- __math
+ defcomp --subscr-- __math
+ __math=( -v )
  
  # A simple pattern completion, just as an example.
  

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

experimental new style completion

[Sven Wischnowsky]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 26658 bytes --]


Hello

Below is a first implementation of the new style completion stuff we
were discussing. This is *very* experimental, it may change
completely, in some places it may be not working, it may be slow,
wrong, not powerful enough or too powerful, it may be... This is just
to give you something to play with over the next two weeks ;-)

Comments:

The thing below contains a patch and a file called `example' which 
will be created in the Src directory. This file contains a first
implementation of the main loop for completion and everything else you 
need to start. There should be more examples for completion functions
for commands, though...
The patch will apply on top of 3.1.5-pws3 plus all recent patches or
on top of 3.1.5-pws4.

To use all this new stuff you define a completion widget (since this
name is already used for Peter's `zle -c' stuff I need a different
name, but during this mail I will use it...), e.g.:

  zle -c my-comp expand-or-complete main-complete

`my-comp' is the name of the widget to be defined, `main-complete' is
the name of a shell function that will be called from the completion
code to generate the matches. The `expand-or-complete' can be the name 
of any the well known names of widgets that call the completion
code. The newly defined widget will behave like the widget thus named, 
except for generating the matches (for which it uses the shell
function, not the compctl's).

[Peter, would this be interesting to use for your `zle -C' stuff?]

In fact the behaviour is inherited by using most of the existing code
(this is one of the reasons why the patch is so relatively small). The 
shell function will generate the matches, anything else, including
displaying the matches, inserting them into the command line, deciding 
to use RECEXACT, AUTOMENU, and whatever else is still done by the
shell itself.

To use the above widget you then use:

  bindkey `\C-i' my-comp

(Or whichever key you like.)

Inside the shell function the completion code sets some variables to
report context information and it makes available two new builtins to
produce the matches and a couple of condition codes.

The variables are:

  PREFIX   the prefix of the current word from the command line
  IPREFIX  an ignored prefix (see below)
  SUFFIX   the suffix of the current word
  COMMAND  the name of the command we are currently completing for
  CONTEXT  the context we are currently completing in, this can be
           any of:

             `cmd'    we are completing in command position
             `arg'    we are completing in argument position
	     `redir'  ... after a redirection operator
	     `math'   ... in a math environment
	     `subscr' ... in a subscript
	     `value'  ... in the value of an variable assignment
	     `cond'   ... inside `[[...]]'

  argv     the positional parameters are set to the *arguments* of the
           command we are completing for (*not* including the command
           name)
  CURRENT  this is the index into `argv' pointing to the current word
  NMATCHES this is the number of matches produced (and accepted) so far

These variables are settable, the example file contains two convenient 
aliases to save and restore them. The completion code uses a wrapper
function to rest them to their old values at the end of each function
executed from the completion widget.

The conditions work on the contents of these variables, probably
changing them, they are modelled directly after the `compctl -x'
condition code:

  -prefix str
     is true if PREFIX starts with str

  -iprefix str
    like `-prefix', but makes the matched portion be
    ignored; this is done by appending the matched
    portion to IPREFIX and removing it from PREFIX

  -position beg [end]
    is true if we are currently in position `beg' (or between `beg'
    and `end' if that is given); if `end' is given COMMAND, CONTEXT,
    CURRENT, and argv are changed so that they contain only the range
    of words between these positions
    (as always when one of these condition takes an integer argument
    an expression may be given, like `-position a+1')

  -word index str
    is true if the `index'th argument is `str'

  -mword index pat
    like `-word' but with pattern matching

  -current index str
  -mcurrent index pat
    like `-word' and `-mword' but the `index' is take relative to the
    current position

  -string str
  -string index str
    true if the current word contains `str'; anything up to the
    `index'th occurrence of `str' is ignored (or anything up to the
    last occurrence if no `index' is given, again this sets IPREFIX
    and PREFIX)

  -class str
  -class index str
    like `-string' but the `str' is taken as a character class

  -words min [max]
    true if we have at least `min' arguments (and less than or equal
    to `max' arguments if that is given)

  -between s1 s2
    true if we are between an argument equal to `s1' and before an
    argument equal to `s2' (if there is such an argument)

  -mbetween p1 p2
    like `-between' but with pattern matching

  -after str
    true if we are after an argument equal to `str'

  -mafter pat
    like `-after' but with pattern matching

  -nmatches num
    true if we have generated `num' matches

Of course, tests can also be done by using the normal condition stuff
and the above variables (probably changing them), but these condition
codes may be faster and/or easier to use.

The builtins are:

complist ...

  This gets almost the same arguments as compctl, except the more
  complicated ones (like xor'ed completions, `-x', `-l', ...).
  When using this builtin the completion code uses the current values
  of the variables above, so that the combination of this builtin and
  the condition codes make life really simple...

compadd [options] matches...

  This allows access to the structure used internally used for storing 
  matches. When using this builtin the variables are not used and the
  completion code does not check if the strings added match what is
  one the command line, so you should know what you are doing.

  Supported options are:

    -q, -Q, -U, -P str, -S str, -J name, -V name
      these are used like the options with the same names in compctl and 
      complist

    -f 
      if this option is given the strings are treated like filenames
      (showing files types with LISTTYPES)

    -n
      this keeps the strings from appearing in the list of matches

    -i str
      this gives an ignored previous to use when inserting the match;
      such a string is not listed and inserted before a prefix given
      with the `-p' option

    -p str
      this gives another prefix that is not listed; but it is inserted 
      and used for testing file types

    -s str
      like `-p' but giving a suffix

  Note that this builtin is the most experimental part. Here, almost
  everything may change and many things may still be not working.

I suggest to have a look at the example file to see how all this can
be used.

Mixed comments:

- I have put the whole thing into the compctl module for now.
- I haven't used an associative array for the variables since I would
  then like to put [LR]BUFFER and so on into it and I didn't want to
  change to many parts of the shell for this first version.
  Also: using separate variables makes handling them so easy...
- When using `complist' the completion code still does normal completion 
  after `~', `=', and `$' (unless that is in IPREFIX, of course).
- Also, when using `complist' the global matches defined by `compctl -M' 
  are used, this at least should be changed one day.
- Later we may add a way to access the matches produced and to control 
  what is done with the collected data (inserting, listing, ...)
- With `complist' you can make functions be called with `-K' and `-y'
  put they can't use `read' to get at the comamnd line data. This is
  because the new style completion uses a different way to store them
  (the above parameters).
- When using conditions that change the parameter values the behavior
  may be irritating since following tests use the changed values. To
  avoid this you have to put the test into a separte function so that
  the previous state is automatically restored by the completion code
  or you have to restore the state by hand. Since I expect that many
  users will want to put all their tests for a command in one function
  (making things better readable) restoring by hand and forgetting to
  do so in the right places will become inconvenient.
- The condition codes behave a bit different from their `compctl -x'
  counterparts since they can only access the arguments (not the
  command name).
- The attentive reader of the patch will notice some hunks in zsh.h
  and in mem.c. This implement a way to re-use older heaps. In fact
  there are functions that allow one to temporarily switch to another
  heap, go back to an older heap, and to temporarily switch to another 
  heap. The patch for zsh.h implements some macros like HEAPALLOC that 
  make it easy to use this mechanism.

Whew.

Ok. Have a look at it, if you like. Play with it if you like. And then 
I would be glad about all comments, suggestions, and criticisms I get.

Like Peter I will now leave for the next two weeks, so...

  fröhliche Weihnachten und einen guten Rutsch ins neue Jahr!

Bye
 Sven

begin 600 newcomp.tar.gz
M'XL("-YT>C8"`VYE=V-O;7`N=&%R`.P]_7?;.([]U?TKF-S;1([EU/)G$D^[
M+YNF<[E-TUR3SLQNKR\KRW*B5UER)3ENT^9_/P#\$"E+;II^S.S<Y75LBP)!
M$@!!``0Y,S?SKIJ1OVAZ\73VX+O\.:U6O]5B#QAC@T&??_>[],V8XPR<EL-8
MO]_I=P?M3KL%99U^O_V`M1[\@+]YFKD)8P\60>I=1?&B$BX*WJ?Q)'OPY_H;
M!Y,):WH)V]Y^=#/^\"A.'_TS]!^A,#C;'CM+//WYX=;65CED[?QJSI[Z'G,&
MS&GOM5M['8<YN[L[#YO-9A%-`;C5V6L/./"6^4?M#=KV8,#H$7'!XVZ7P:_F
M0\8>;6T]@J\@RN`_Q.YEX60>>4,H?-B`UVSM,6NQ8,(6/G,3'Z"8RT#<69I]
M"'V&54(_"^*(837Z`1@;O#+]RG%SQ.(=NPSCD1NR:S<)W%'HIVP2)RR]\L.0
MS=S$G?J9GZ387FEKA4;".+JDU]X\2?PHLZ&,_K`LFN(D]=.A4<6[`KG=HCIQ
ME/GO\SJB<#IUH[%9.$O\2?#>+$OGDZ6R@`,2%9'([/PJ2-50&>!EV96O2):R
MQ)^.TM!-KZPZO7TWCS,_`B+`LP=?;)+$4X[_(7ZPF]"_R)+`>_MAV[/9:)X1
M=V#^L7GJCY%L@IOX.HOC;5;U!\0HDYINMV-WNSNYW'3[+;O;'TC)(>)Z%Y,@
M2;-M&*W''C-05*W6L/ARZJ9OX67YBS:\.3BX.#@X>'%R/A1$U)@"KS5NB"=.
M7?'`Z<\>0]V:1GMX>_+J^%@VFOC9/(EX)VZ1+:5C[N_:W4%7&_/.CMW=W=''
M//9!`OTK8%6&O+0$F>&A+MNZF20^O`@7<3).;08_TN#&!Z;A5SRQN.35%;Q`
MD?CN>)8ET/&)&X8CUWM[H;V1M+E).?:<1/725T2OLE></&5O@NI7G,CU2FJN
M4(,D@X8&HY(*54CO[JX,.?BS).#@.\SI[[5V]CJ=:G78&73LSF"7,UG,3U*"
ML)!E@8?ZZN$:N_0S27W!+YR-MM`:6UONM<T.^'L0:)NT'$DU_QFD8W]2!Z0?
M!<5`!YRZ2>K3O!^Y*30T"=U+KO5RO;;W4,Y*C@T0@;Y%2*CH9E(+1S'J5`;,
M]Z,Q3/<<@4TDDF,4<OL=Q\A_>N'O,]92_NYV[6ZK+?E;"R:6FUQ>OVZ]81L;
M3/S$I\>/V69S$SM>PU[@FT8#);H&(X=9B`5#(%,-9X&BDU?',E`U7ABDJ)X.
M7CP_O7AY^/S%+X<$K<\-_+OE#,"_J3]-_<RRKN-@#`I@P_.`E"U;Z04O0Z5`
M#*1!]"4#O\$@8`FWD$UK'%#TTJ%W?@C,^BA?E0RWQO5VQ8A-C0`%M_<=>AD_
M>ZV>W7-:N5+NM7:A0"GE6NTC?5(727)GPGKA96+@,#XLJ=WX20)B;G%17P_"
MT+\$,R2>D5G1_(NW;M/"84.#2#S2AE`O)YA$?*N:Q28L#OW:>5-GO$.U&=!*
M%+,&UJ12*H`WZ^NLB85E8^YW>W:_YR@9KO&V1K`0O!U*7GLN<&TSW-Q#DM?*
M^\#YEFVG\Y$W'9?UAR9@H4O4(B.I0+1K)&\<*3*@W^O8X&#D#+A;[S@3UD2;
M]^"#K&K(KM[1'S#^4@,;N#7H:1(ZZ/7M0;^7$ZBL@3)R'0"Y&@:Y&O<G5V.)
M7`W%*VR`*UU0)VM7[TUZT3S_)"8Z?#S?/WEJ4*6"#KTNT&%7HP/84X/!SET$
MY>D?8>2THJ$=.ZPBQM/#9_NOCL_+9RTXY3#<5N6LU<=[3A/#_"OO6GE'GAV]
M/#OG2'.F*.";A9M$&M&F03H+70]63XY?<Z2LYGF=%MUU;CH,=CKV8+=3R;/E
M07S?V:T:^%TI4\IN,+)0NG-QW^W;.RTU[07M*@3^^$<*_!H?W*=/S!3X(C5D
M6^!#LA@,^F,Q?M%>JYY/C+RI4MKLM.S!3B^GS4YK8.\XN4%3*W#M^(@SK9Q8
M[^]*K!(KD0Q(<*CBA3\V1O)9HFEJOXI@X(*-`VK%?S_SO0Q:=B>9G^ALXLL^
MK3.27V4DVW$<HE!.LF[;W@$C(#?BJ5M;C0:M)C`3K#7T##\@7_D/L`;;=7@C
MJ;<E%AXP$AN;-'>DZ<B'U6`E)E*!I._C9-,DJ)"2)6(:A%06DO`(SJ_\Q-\$
M"S\"9@"%(G!$KGUF->JZ2P`6;)H&EY&L"+[!0O@"5RZ`IS$XQPD;^>!*^&P:
M7P?1)8,N93'Y#-MYO?*HAM/:Z=I.:S=7TM96A#YT\PFR$G3_E$1/LZ.A[X?P
M!J8#NC.*X4-TGW@4AWP;<EDN8[8(LBL69-O8`V%VZWX6)^H&XH?YBTV3&<S]
M167&YY1D@NM<&I'3:\*"0?Z+2;3!Y]#9Z>'!T?XQH5%T![SN/(16A.?&73`*
MINC!NR`*TBM@,_0:9<]QG%W;<=JY#?,'HA-*W!^#5*4B!KZ)[?3:725B6C?A
M2UJ`#\F)1)-4^-AU=N.AGO(LX11M@?=5'WZ6.NB:.T03KJA*?;@2:H&J(U;W
MP)R'#Q4M^%']O5^72TG>=UHV?/0ER35G5?CAZ56\T`.19'Q]"5GY7TDGC8A8
M'G(4Q$5/SNGG6OQ;]NQK.E=.QDX;.MO1+'BGWQ_8;4T/*&2>IX)_*J2N19<:
M;!1$U'T<;5EX28R%'N)9*L)+\\BK0^6/(@29AY]D4!*A4"J)6A3/ERO86K[+
M():RPDKFP=H31^$'6#X82BX:?1A6+]G$**YM^M+&"2@BU7>9$!(TYSLO,3EO
MC.4.O'?J==$S[K'PRLII%:JOE`Y"J>%C6K6:%_!R2QI?3-VWON0K#I>+FNK]
MDA`VF*E/L.36V(DI%1MW/+ZWU(@P$!K(*7[Z0^,%QKG%]@"\G)E/Z7RBM@X,
M;#I4#@0/ETD\GQ7J4*^0KS9[Q[^F_"M*_R"2B[%8:RA"'[!`YJ8B!A2'(I(H
MND/`.$8.A,$3#+.QF8(@>=:IP$M@E?>N0!AG&A@WZ=\)DWY"+L#S9RJ@V,A]
M`*/"?XL*[Z18EH--BGB?'1VOP!H5P4]><%>DJL(K46&ZNANG`HQHL@'"PT%1
MAM;3+$&SM<1CJ,9W9N`#^?M*?/]EX",1UC!RD4;A^S*LOVA^VAHAJ2LWBR1?
M4.S;MAH88PF^GM@SDWE?CS`U$7X-^X21NE?FJHW<L0@3[)EQ@EFUAZ:Y@*F<
MI=S/S!]+'.UQ/!^A&EK97)EW+='/<A>4NZI$FQD/S,K"F18S;9A!6<TY-U$(
M__BS2*J&YM]U&(I^MP752M*_8OV=!N#CBGP%KKW3NVIM6!5%,H.%<FZS&?\$
MB8)/_$F_:":!'P.K#ZP\N.K83(6*S.T:M1C_!TA6$/GLE_V7UF]UIK9JF+4!
MSV1LB(4:!';N\5`996H4UET<I;X.9A]FZIGCO'83:CA'D;Y^`UR2>#ZR]8-7
M+U\>GIP#74Z?7QR=G!_^?/C2IKYI61YU=FMK55X`V&^BRMG!_O&^7D/LE1=J
M4&B[J@;?0C=JG+X\?';T6WD%L7MNP)^]>E8)+_;4#?BC50T$92V</-\_/_C/
MP[,*2LG<%Z.2$#4N<\3_6S,WAM@D#3W.(!('W<A:DH(M;Z;;@6@R>#.9L4$X
MALR;-9^0?,`O93N<4O49KJ@>Z+K,)VA+PMI4"Z6(?2*R"-^=)@K-M=FT+B<D
M8;$(8YWG$67NJ/D$[.DH'ON6++%53SB:IZ>OSL\0$4Q//AJ,&J8^;3V;A%B7
MUFYM-FT^"?UK/X0FP>I'NPP>AO+5?'OL9BX."IH2(E_C%I$%PSC_Q^FA)4=6
M%Z2@Y4*Q?B\?5?,)=";=]B81(`327^,&>S:)ACK(91'DT@#)%Q+9C!"7Y78"
M0@*SM[H=':2JG5M%BXBP"&D03[IR*_4(4.0P4RNO8DE9X88_K)FZ2*(PB*):
MFHUE'83&XL]X'MC,Q2)Q9S,_L8[15T,7QV;/P++^%8K9PM8T7+%=W88OT^#Y
MFB.<%R_#F!9\3\?X1<I[*R;UO14K(X82VV+0=S8X`%,I>5@@,Z.X*B1@@!"E
M>LI;C9J"%^/YC-L:2]E#M9COCA8A\B2B6LP=(!-"2QBJQ=PI,@%4WA`"!&4H
M]*0CHAMP[0JI:''J`]'5-)4I7F+,@`L),93%<M!8SFE5J\B6JID99C=9`IVR
MB$[UY7H:%<Q<-%5O.EZJII/&R%F3E:!@J9).+CVW356"@J5*0;&I8*FM0#:F
M26;KKM,ON(SBQ+_@2"V<=N&RLQV#Y4$))_E87X=OM/7`*`>XS?]I;<H>Q**>
M2IO,J^1CP6Q'-[.@(2T3$PR[8KI:7!]6-`D=++:XW.`2[<`B#<O;^)PN`5GT
MWBZMF]4.OZ5M)^D>OY[1>3=OOU6T&W5MM(K7B8]3T\LN$C>Z](G9(Z%JC3%@
M^A?0R`>K>F3&2;8HZT7\SB-B5H"6?7TY"1*#-._P8[9D/:"G/T,3%[_YX@M(
M1CS\$,"_9A,,W$8#0<"8P/%OO<LY!QCODAI9.J6E53IZH^`0@9LD[@?Y4KV1
M?8->WB%+D[8H="W6?,S'Q.-YI9II'9;87-!E)*X<%)31^N?%,QK+"2T#:R*I
M;TE6-5&NZRL;",IL`M41%?RV7!1"?7*N<C8J.Q7<IU?ZNIK2S-;[)/4>N;B\
MTZG13WTGU-!U`!WZD97R(.ZR'WA;/LON--!9G-),O\](:5K*<5Z[H:0]KJZ6
M"UXQ^ZOQ#N;='AL)@QGU-R4&TMBD+-L,LSI-FT*ZS))X(_8$FE%67K.I+'#?
M>.-K;T;L)[T.:X"IK%737_KY2Y1G;`[/'FQL,$02X@]?%?FR*,"B$?_U$VHD
M#@^_#,93Y@B2IIYSTE!UH.9\0X=FPZ_@+J9^WY>SN#:!OARS#=S,_ZO!D3V@
M%VL4&+^*KT-M9NCTB`W2QXKT9*AI_",XW$N-D<YAO3`/9"2[EN8Z^G7\1J>C
M&(I3ET))5AJ))=@,*)EKP`AO.N.S,I^YH!#K7\,#Q!I^A2)19`UTPKEFZD11
MW3BYJ@B69BA7&IHK4(:A96)HYJJFAL_@:GDSL(.HWUB%K__X"9,X`)+:.$K%
MP`!/\#2=2AT7?`?=1@<??IAB:SJ?G0&Z.(9*882YFKCO2+GNN+^,D>&3"YI=
MH9KYWM&(?R$Q0A7.Q+U'YBD)+=?@0A+$5`Y63V6"%5/6D%+W=>M-OK4##EPZ
M'UD;:2Y`N!DZPX!!XE]:J2[NJX5=;3&116>:>VCGD=8?LAF^!9!"YI*N8,8Q
MURZX^><A>DV]8!DLY3)BC-0,\G!S5K6?<YM//[F.2.6L=P0#G?JNM.J>0<H:
MIZ/S1NR#%(A8*Z.@N?U:*]<X$I"3D6SB93+"DDE[=D!%%7RK?04)^:J-9&SJ
M4?M,HZ49#RH$SB6)LDRLW[KLUA5;6D.#!;CTCY3TY@"$Z<<L[S+2<&_CV0Q7
ME*T3I5UBA1#\:!Z$&7B&(VC='8D8.L_Y^-NKH^/SHQ/T*6DS?IT"OG)W'0KH
MN>FH.+!<0T3;1GT,Q9@(>'#&N3,&=SPV$4#!BOHR'EW<<8C&F*'MQ?EH19[(
MBY.G3P^?6>M\5>--:5X.-479/':Q1K!4)?AL'6F\Z^V((JK2+JV%RZ)6`Q\)
MM!QZN@+<6087LZ:B0KL$_^H:G>4:/&JGP9.%M6+`7NBF:16\4TZ@M-"?=`7^
MD9\M?%_G`DWV58/^3)624=-V[#)\I6Q,5U8H&;74`UH5660V4SXI,!2TH/`T
M#UT;\^+7E_NGV(@>VZYC1O+M4#L76)X,UL.<NI[*J4/U![H\CO/,I.?Q>![Z
M;,H/_ZT)K6>MP=P6FBFUIK3-8@L5I0Y\\<?Z(YDI)9YY7J>1T[ETW!3STMI.
MIV^WG:XZR/X%O;.^HGOL$QUX`PQ"%^482"GE!]IBHSY_E-610'*C`6I*OMQE
M\.6LZF/>7E\[Y-]V@'OPH8YK>Z'O1O-9!7'TH\WW)8U<M#B6>Y''1%%"H2\]
M?WP3^MM7ZL`P/96<.Z;RNYTYYJ"_^F,.VF=.=Z^]N]=UJL\;=P=V7YTVK@&2
MHRC#+24VB8:8-#V+@8!^@BGL]"-RP_`#"S#4.P7U#$TM@C'F4-,!7N$X3/`0
M`E6G=!F1=,UO3U`7,:`M.`=3LLEW]DU$\D_+L)2'=T4]GJ+MLE^/GOY\>([G
MP$Z7,-RR^5#3)C*'0%0Y.CFO6<Y//X$-R3&+ZD%:-51"7,""#1,:IUXC+&<S
MWPO<4(^'Y_U:4]7_>7QX\?SPY-6!J-Z6O7CZXF3S''H`]E8P=C/C7@G*T5Q"
M\X_]D[\3CDZ]\.;XZ(3RUNAM5[8@X\ETHCD$V&:<!'R$T_B:!KO<R/'^V?G!
MBV.B*V+K%;%-79QJ,#49K*N9%R,%8`D'[GU8QO;WH^-CZE2_KI&4WAP>GO*\
M!'J_:Y(E\;&'J.&@LV+_R>`*HGAU=HB4Y5PA[F+]&!'5271@A'-COP)$BBWC
M.7F1HW$4FF@S`S2"IS8/ER!2D?I4VIV?CU_\C>-IEW0'[QJY4W=R-)W[=^?D
MQ;G(+.&,=+IU0_S3JW@>CL6Y))SZQ,[IF#.17QB278&I%8!S0-@?JG0+*O\@
M#N*":AGD)S3^-*J%=N]IM,J]-L>&F.2`9#W5-1@L[CD)1/G&%,"I;LB1B;I5
M5>C"FD*5`B',JCRC:?AOH!Q%]1,BO5`X2D&6WKAS%Q7;^08JMKM2Q?:^J8KM
M?QL5._A_%?MOI6)U3$=G<@H(3#V!:9[274TXCJH;J.ZFJ:MMTPL4-^URG+RH
MW$H5+TM,U7:IJ5H.WVKM=5O5]FJOW[-[\L(P6!7HE$IZ:<%__%"6V-M6SQ/?
MGUG\5A05J41'RUK@54:@*)M/.%?JS2?\#.`&LW(E^$G39/(\&`;3%ASV,5N(
M:D-U"!9\N(7$9$XW_5P@3C(^NRS>T>6*0G>!7_9)7&1BY0!ZOS`^B;P7XK4&
MO=+/KH$8'*DKTL8Q)O>Z+%W2Q+:Z^8OCT4ZY@AI#8<5W,4BFB,W@`A#13*#+
MT981ZN=D>>MX'5_&.X!BF\-N\\M3B+OYE0S?@[OR3AA6Q6;VR5A__E!<M[1^
M?BKT\L\@!*53?J=O]W8=[8J=G0$4]+3KAUC%O%"CUP@#=!GJQ>C,BVY;QAYH
M&=H3B;=1CK=AXJ43:)S18H]$-+S`!-Q)I(2`%:4@7T)`?$H/Y/=Z]DY?7<+S
MY9%W>#=^ZW_(X]ZB0(^\K_O7[O-P_'3_9)JDQR_750R\@.L:V(K18"9Q40$^
M`QXVT&+H^I_`M6;B@I5AG<,)7%"@GF6_0NC2P?'T^>7/`E;URP@=TD4%O5T@
ME)*6_[.$\CAP.:%66`'<4BC8`;*PPA*0K^]N"Z@:9O2JT]WKKK@MK]WMV^V>
MNDU-LHXV#1?Y>EY<*VGV>1[I9?U$J"R7ZXE<3=9*D,&BP16[6)+$C`9'K'#3
MXD*%%;<6_%9%$22FOBNY_$Y]9R6XE!);,WN/J+87E)Y1]H;R09>7VF].G-)K
M\SH#N]-MYVM`I]N"@OS&EH]L<W]338,+<+G>TI8):^/1$@YPH@'`PF/S2:<!
M'&@`:A^2=@'I>`J">`40U/(VZ\`_A::%\TS!P`H@%`4'(.))(@@M%,]PSS5"
MQS.>4;K];%AQ>V#/[K:TN[PZN[M0L&LNA17"HQ9#.N"6@,838\1K/0N252N\
M%WD\`L1FIR^!Q70M3C%SZ#,B)Q,!9O/,LS894#/-QO$\RY,)Z'+9\0T`I*98
M+H-^,18480V6:;VV1!)!)G8$-)'5KX$H:9%5M$B5-;C2\'L+&*I?']AUNG:W
MW35NNY@0SG76/%A?;O:;,1-/_-R?F=0_CZTO<R(*//]KN5F&XYOP$KMME5"U
MT.!=6-EK@9F:7_)1>JNIJ1<J;A!(C1L$Z"<_MY,O$N?<>\_4C1Q\[Q`0NQY=
M7(1Y5/J-V6+8A:.>W')-6<D!_L65'Z$A2A$LPKFN+'GCNJU\0Y!,\W;+[O5V
M5E[MVEA2H%]*B#R+)2>$V%'FMCB>A5IH"?MHG2?<Q,"CN2EF2:H,>W05,^DG
MRM)YE/@34</,CE^S/&U*Y$&:>OEQ6A%EE*&??_TEW5RGXZ[8B<^>J,6^W9BW
M=BSRG4C5C\?&U/RDN9&?3%]4KTF7KID70VBSBT[#">%??@VCR9/ZBQ0UYV@!
MKOW&H";:TIPT:`L8/&J]4;E<:"M(*''"J$R2>1@<28QB.TM`(>.9=4GOUN?I
M?:<TJ]]M%N<%/VI.K_(+Q/WNIADO"JO\`O&ZQ"_H5/@%LH9^BS8X!:T]I[W"
M+P!SL:V;BU1@W%8G^+D_#:))S%S\M-F$OO/_O0!=C(^'6"CHCI$/?==I:9LE
MP'+<(>&72?/P!MM"V=I:"M%NJ_]+@.A*?N6_F#9R9LJ^8%1]^K_M77ES&[>2
MS[_BIX!E54A:'(67[E4215$2;_SLE*V\I,I2R3R&XCR1,UP.:4F6N)]]^\(U
M,U1B6\GNVQ*K$H\PF$8#:#2`1O</R?1&#</.!`O55I=""_!%&(?33F%)/^'W
MF!4)[;/K'I3P0X0(:?.97*A`D'9T.)>&TQG4!G;(J@)_S<(.(ZE-;]"*@[47
M15[=,';FI:X[S>UVK;GMH#@U=UJUYNYV?LYP`FR-,24;K^8TE[7%>/K'C:3*
MOHXK7J!5IMT7N:CSDC7M4`P%<V-'-'0('7P<@`@@H#0I8=#(+XY/CI>M`%NP
M@F^[J/Z;V[7VUFY>5$4^QGU8W61$=)B,^CGQ-!<ZB-D-.+YD0,(EH@<?:'2$
MY;=KI/-NVIM&DUF6!M^DP:_MU1)'Z%W*`R-4%Z!R*#0+V8C\`=6Q]VJ0"5*/
M);E1PKZ$-#0_0FUF0PR<ALQ`;OD-$O=?)+';;M5VW8LD=K=V:KO;=F,).\EI
MV(^F%$U.3ZXAFGN#M28_NR!#DDG:E6<>^</-IEM-8ZRM@.(C-VL#]ML;74V2
M5.(MD*GP.H7165DB4XWZUFZM4=?HK]8"_!OJBSFT+O0CG=U*9\BP-4[P,F'+
M)1%ON?BSS"I;569U]`X^?OG/-R>PA?C1MS:CONK-IRGHIZL.GAJG43_TNYG`
M-/$LU"V??,21B=EL7T7P33RK/$NK^RI=7_>W/>EEA"[D89Q6GL?=::<'6_Y7
M\YD\?9E6,>X+Y\P4'F8SC$Q*5:"NNH0S3Z[J/.U%,<%X'JCG+\__<7CRDRG%
MXI61'W3YH*SA5E/!E5RYHJ@QI`O\,BI=?7>[UF@TFMXF[F]I?=<_@.*)__+N
MT)$3%%TM44F,=N-$4:\X0:?>8"#0%3,@I-XS9^-'9-R:_*7]7E/.4&Q\NA04
MCLD&HD`VFBT[)M'A)'E[KJZF"*-0B6&YJN)$K<$LZIS5^%JW!K-N"#Q',[EM
M!\E`?W9#TJD(!S(;_J$RS*E&,1U)@SPQ+5*U%R_HJ.KZOB<:%$Z1[JOU=7CZ
M#Y7:UMZO&G3L9Y@+B')O52VD.;8?9C)-'!':&V?7?>KDQ]B_)T[T"K\J'+^+
M3*4.O$HYIV+<9N$89['."*>4:0A#`<_"KLR**G0&"B,35D*<S`2(LM%N0^<Z
M[D[_KIU;4\.8._F)ZVL4=^EV`I+_-SQ_?T-]W5![.KKO66QG-7(4^S0A8?(N
M7+O#$1MGNJ2..#HJ<\E"1M)<^'PM:UIXXB[CM<>ZK!4J2&BN4&UP-#\Q-VID
MROI8615F\M)*@4Z>YM&A3\`1E,&<QJ$;V:1U/*K=.+3A3-P+1O,N5;W%NC?N
M5K.D!)?"BX[Z&X=7\?8._>M;[8:[P=O9@1U>O>W>AJ5A/?-8L+*U<`#++/BF
MWKA/W&="OC%8F_K12650,VDB`MA$RPQ'7I%IF!]Q>\!/<0)S\<R##LT#EV`(
M)N+P3*8"N:,'ZV@RJJE1"O^+=++9RF(0'^]C)9:#ZJAZXPRP)VU5,+2-]BJ'
MOYZ0,Q9'@MF=C+&1O/GM^<G13S\='_[RIJ(WCR*1F'CXXL6K(S_VD8!=6):S
MX#H&\\4:L3%%!'R2S3XQV5>@YHP@Q5&H+ADG#I%SU?T2$)]&EY#%`YH8\)H5
M:%:G!).>+2$M*$'7-\=_MK9(E0,F,WQXQ=%A(/4]A4M.#1*7C<VDM\+X/)XE
MEV$<?0@K3G(NH)&A+X50&/=[8TJA8P&AU`TO=*J@];&X5JUJD@2C+3B[MD@B
M7NF/B%?ZYM7K$X\-I9RE7"<*OC;0=#;BT[0CH0K:/&\G@VOL%">)@`6K9Y[.
M,WV4_;Q^EEV5.AWJ9,SV'4QV^/\]#>CCQ;/N\_I8;D_PH6E7="7)VCIV%3CU
M+8Y5ITZ<*_@:2J905I@KB:MIB`&CW"0K3@IN2O?S%-,_I`A2!CD<@IQ@Z2U,
M?&MJNWSB]0N!=MW$"'O$JM*5#AKP.#U&SK#6W1%KL*VZSSR^BWHP<K]&_>9P
M1XD'F%CT04H?I/X'-#HAL>"#C@B<D[V3ER^=AO4ZRTVI1FJ\[SVYF54+RO9E
M7:.^X&$53SUN)F%0MYH%FUI==>[YRK)2P(D'L)7MN\CK.X?<\G)U;3)=I3_(
M=);)[?>3R>WWE,[M=9+.6]!-2WLI5X_[^F@<S\>X/M1ZH`?[]!DG<.0[`3?R
M1%I50^]$1H?_\DL=*C]F92)ZVTEDA6]1=BE1J_BIR4M'3;1PL$V`:L;>O9JZ
M<<GB<&1)LBG*F5><=S+Z\'$JSY'/I'#C)#';'M?Z[$D\(75R=TK]C_^XB2DG
MZGZ&I1<Z:1#NI8DG[8VMF`I<HB,M^!>4ZO2-O@K'*EBOQSF-:IH!3%#H:T\K
M%@LAS^N;[PZ/?J8U#EN`O2MR@6?TY^?E%%WJ$G*\0#)04H<-1986L7%"'O@&
M399L^C07Y,)>#JJ+WQ-RJ/[>YH0,9#'UKR%&:K3:1@LIW[=;;&)O[M::VZU-
M;6O0%>@G(5M=*>C?W'B)83#!M7H7EXGPNY=E6([/,,HCS1CTG_CG8`;NA1>K
M.,?0A9N0%L7]\%JO;C%!W\7925/79)Y9Y^[+D<!NLP;_V[$W03]8!?XZS@L]
M=NJ;C1K\SWJL]WJ$F'>`IS8X`N@&"K$@]Z!U>Y=%[W`GZ=YMP()1H0T&872.
M4G9?0#KY-1VDD[M0L]&NM5J.:?+3N=$`$OHH4K:Z!IITW[4MC'"?BE$.[SLC
ML@XX&^.*W#R!QY:,K6G(5M%:\65_/A[?G&,NO5-_`=Q007C0FF<0LVB\/^P>
M#'HB*P-PTL$!288.J'A'[_?IM:N2Y`17,V+R%$+GY5YH##]BQ$/PPRE4&SQ&
MU'558V#P$?,(*B]C'=.'$4N_H;?.5R:?ONN`=^NN=870=F'K?OSRGWQ?7@:Y
M;Q6Z;!X*S4QMS(D1O9,&%4N-!JK)EH,F`BF(S0=L]S!&F():<0[-0AX649LQ
MOC%/>Z:A]8IF&6TT3JQ^5`40&J&XI3"L?+7X8P.,;RHN1T?W5!MA%9?669\#
M.G6\AY37A_92-3Y@J)^Q/&5[U[[7Q?`_,H0:6=-8(>)C?J3`</36,>Y]]D4K
MFB?^SA8^+QQ9^O3`O,8J4H_2773$]-V=4ZFJ'47F!A%YJ]9)3WC7B%#5F7>[
MJGJF"ROFL$"EV)>VX8J`>3/I!GO7U`SAHROZ</GYR]]>O?Z^ZH[K;#.G2QN7
M_9T*V%^&.IO/D84"IGWR$Y613&?6I',=:.9D,$AK;&,4#;N$]R_3=`GK^NPI
MM4E,G_<"#U!#89>9S%%+TS]H#),AU]N1U]V%Z,BF)7UH:9;L;V@0X]$P6N(#
M$EI$Q&HXWSBXT[C+T3.AX^\@`YG"<AB2JY=,0CV19H#V)?7E\6]Y2Z!1=DEF
M(J\)6#D/@7K-,+A0KUY\+\OM)VR-RG.@HR,/U&X!]_:H8J$?9*&!2P[N,CL'
MD*7JL]91Q:N\G2:L\G8<C),6N:RW[%VUV=OB?(,T#PN-S8S@:;A8>1:AF9>>
M)@6PUI/[(,^=P78?\+E[\=2]\.<.O=G4-T5CJV$7NQC)UA+I`(:!`(Y0!IQ$
M.XR*\J7Y?%$A02=UE%KKK?U^1-639#>WDVQ3>?<L^WS\=!TSKB/M=<&TDVR]
MR4V%MP_>UVA9H>3BU+2:L<5'LM'%'D>YC2:NEZ1^*885YUL+=[S$8VE=Y:Y$
ML\@'KDA]I'D?H6!1>2.</>EP8+DFO*UXLB*N62347U*N+T<3SXPJ='0[6Q*]
MX&L0P)YL]CDIB6>>W=VM7C*M],@I?(K\R(#&$AW84LTT_NL%[.44Y4<9"M9=
M0X'Q#"173+YQE-J<'0.M+Y1>OB!$`&U=Q3[`EH:1&TAI/AWK+6VA)FIO[=1:
M[>U=QP_=MML=@I]#H^*]?DT,)STZ.C\ZPJMIU)V"Y^^/?[!__')X@G]4JYY_
M*EYU'?=I02,;1+SVSP6'VK>ENLL?-W>&(E04WNHX6[<(?L,EV&/%.0Y\CR99
M>MRD:O:*3C8LM+:W80.,=S];][H';AX'/1]7G@_?6ID"_I[&*W1=;-2W:^U&
MH^6YF8G-S/H=X7@8=2[XENL4MMW:=15OA5;!B.0^Z.F[=EF[N%[/KB]..K`[
MC#<_')WK!;#KZG2$`\=UT'7]F>S:!#IZZ=J$'#';C5:MW6[6/3^N!ZE>]D86
MNZCY7ZQS81>CMVZ[N5._KXM?)C!33L?DS(*-@)9/O_(*K]>&O4^2/$PG>Q6Z
MX;H4U*B`7)+VI'<W=QHU^-_.?;W[J35[X/[]S.H6./&/819ASWUZRKCK4YKG
MH[^Y5]_::]9]'WW.Y@?LUB'G/7!SC>9NK;'9LC<AFQ7,:#XTJ^(`VQ[7'Y-Y
M.L1]ES;ZRO:'_-_1$(TX+&1GQU'(YS"@WNB:<*0B)S.8G4V9MY#HQ%W:%W2'
M-\-*8<.A@W$D6$`\ZZ*3-99*I!EA^D-X/J/;3T"@,*0S$,8/U0?@&G-O%'%2
MQ(0NWV/@S[AVY7DA&MV;69CRS2QT$RLV'I5S#XU<DZ03:A"BTKU1V!?XME)%
M!9=2<`!YF8_F<@D,T=+H->B?V:G\7EVIZ,M4%%[<MZ[\4S-:959-`]*HTT<J
MNAD=[!H;OD",6C]SXH=$(G4_U;@WY*2'LK>]6[`?<V7OHSG0SO*_@LK'0`PN
MEIH]3J[(VYXF"2Z+!1G=]3%?@`59;WQ9MR-U^`>(G1.Q7-`#%X\;%(<%\I2C
MLKW($:>:0V^+H%Z'`09SZ(E#\P3KSHM.%-?H2AD>7%PQD,DTQZOL,>!CX95X
M@S_S_-94G+U#Q]8!F*,:Q;+E0%>$8?`U#0M[!1ZDX)7)J]_]^N.>4V:5$=M0
M0D.IQ*J$B9&I96BCS(?Y6QMTHP$]OX%.PO$DF7:FT>A&V\]!\A-HCZE\5(%*
M='&P4)-5E_4D?^PV$+3G1W4HY%_:GW]R"!3,`I!%`$CI*3,+4%K!+)!!<"C,
MMKW7:-\S"[3JF[5&RXU[EJ2F";R`3=`_.-H)-DB="X%,HQ=%OZ],0,SGS1L2
MT9*;-]8_?]Y8S\\;[M66V7DCRTD1$Y\\;ZP_P+RQ_H#SQOHGSANZ`95Z&@UB
M1%___AB4`_ZMA*`Q7JST$W4KKI<QW8AY#L53]0[DH)V&*!M]JONP[%JVRP;9
MW4%I;;D"W&I#DH6D,`P8"\+YZ^.37U^_5*?D!LQ7&^18^::`%;6GOZ$FEPR3
M<#J6#%6Z">%V7ZSMK!_DXES-AK'8#JN\IH3&T,I:JYDAJQJM5JD)'!+:5BLR
M<#6,1J&JU"&?U<6:&B0NG!P99EQC$_)3R(VG-H<Y;C)F&)<=[\M[.()>$E2F
M!Q`7Z2+Z^YS&PF1]G9@N%J%6"^2EM>.*T.86)&TW_W(1*I(@E^\@J-6K($X/
M+$VGHC.*?@7-]J<DSV?[_C+^'BF]CX,_J.8](OTQ]?PH^8]A86`<9+*3ZA>/
MOW_G'Z[/PNL.FI#_LC(:]?I6O:Z^`+';WM[B?[?:]"_"FC4W6YM*;6VUMMI;
M[>WM-B2UFLW-+U3][VB`.1YJ*O7%593VAK`=6YHOCJ[39##[?];_3V%-SJLJ
MVL$)2D8W'';>X_)W%%V&ZAW'4`?)--#!.&75G<\(TD#V?Z6G]DCC'<*V.EEA
M42=0`Z%Q@BR5/H"6"7IJ?$,Y5;X,Y9$IE0143Y5/CX*HK#\LE:#H[\(1;*0)
M2GDR328)KAGQ:S5*DHG!JR3HD!1CY^(P[",/3]4KK'J:)KVH0X`:=$,J0R8D
M./5YQRM("-?/^-IX#Y9*Z*")5ZT'AWRXC^_H@7@[@>IB7>Q5N-`>HLT=,(8A
M$!^%4Z0'+_%%A4WR,(._?:O6GJH@_"_54&=G6)>X9%P)WJXUS@Y6S\_7&JLE
MI2$DO7=K37PSB$H+HBW<"7G-J\VZ<-A&C!"'[;"3TE87E^C8&!AAD$QYN<Z[
M)@VWSG"90$<[IJ9FN:\/NZ3BO:0?0J4[HZB3,M=`_:!,"Q9U3M=VGW,TP'E"
MSGSG=&DVO0&&?WE]_,/SWU?W.0\D/+<IF/V@HE;7OEU5U7WZ#C(<_?KZ]?'+
MD]6R4^84._"@S)]"'J*^NO_<28@H!6,WB"13?_OM&9(6DI0/"@'2U((,]`%-
M".UVHZY`!&@HS+(XT^F\&\@Y7^HWQ;Q[4.XG=DA05>[NC)M`N61*TD,LM8[&
MZ&?,(#[`ZYSVQ[B;3<8A#06,KKM(9KR1`[D&2M)]N1$!M>@F[\,-4RD8KH2<
M@S4"`0DCLGEHN`:FU+%>R3`485V!(6;H(G?%Z-C1+)5-'E17<Y@:M!`T7R.A
M*8[8'!:$T38YTCVV5[F'K&C\`5)4-5..V;_Z1ZPI\66R07\@0=,%,FQ8/*%^
M)1QT[_GY].!T[?3V='VM<;HP(W=U#=ZL8O1CW1N\V)7N@"4BNN(*":W=-A:G
M;T^_/3TC<CR`GS+,BU%NTF/XH3.>3#^1+SA"U#@`/R>'WT$24*(XR[#/@I(9
MDG3\S(=5=CP[HUF4*E#YPQ:=:F+0MOJ:,:!EXCFQC3U=+VT<CN<CU"G!:[1[
MF$8GK0\KV'"63&:<!@^DH./Y:$1`[M,>SR=4!FUF^LDL+:%7EGPW[DPO^S`V
MZ"6ZCR+H.KGV00?@CHYREFB/=0@C.)Y->5YX%P0TIH*@K*5R&DY&G1X;H"B+
M\3@_*1,!;-]W[K#%+UFI#J?)_&*8S&=[*"^.7,-$UI_W<)C*>"9*L)4+/H33
MQ,`(T5T+T)$X%J%]W\$.A#"8IZ1LF`C("VIIH<,L532!^RLP*U<W2@)J`^J-
MIPK3`F<HP2#CP0?%[U91Q-&'TATRYEU6>W'K_H!`2$:&1#<@5^\<S5>V#=.E
MR5X$^GW4(3%$0KTD?A_&41A#A5F'OA,E6J8ZR$R*9_+'OY_@B(1BD1\W"=W(
M<G/LO.N.U*?J13@K@R(-0Q<(J0@LFR?ZR&AZ,J.CJA1",!S2J$NP3'0@EQ*C
MTMSELOR!BLWP&#%?[.6=ZQA*QH[99P11=%ZNJEPV3'9R:0?K3"Y.=O*1MLX7
M2LE.-O1R+B@4DYU<8=KIE:0=G@]0:FNZ]_6]"2[J.(Z.^$;:)R=S`FWNE"8T
M1$@_2TQ=W:M#3#)3>,?HO$IDG7:TMB-M*?WO:DP<6XZ0>W,+K8I!&AOXOR8/
ME2,IE+$>LJ5\(\V(K8CKT?D$!@`0D)`7)`./K$=F5XF$(*5&@-.P,\4(HSB[
M1'.$6%8#E7#C8H,((3X,WH4C:VQTK.04FJJ1"*PLXEEUR0@L&FZ>R%`5'Z83
M+7@?C68]/0N*^MO&V:J`MW@<\;P,S7AZH+,RI]"<!_;K9BUHG*T6$2:JS[YZ
MYM<3"-JO5UV*MY*X-UOX*_J"3S1SS8.U"L[MH/F"B=)YJBRYU$]O6%FA[N$I
M&083SP@H3;*;<7<[U&&RTT&9`,8JEU6S7?CV;+$J!G"[TD$6J;IK_XU?0?-3
M6M-)<QM!Y?K.[D;@Z6Q)+T*5T-(&"U:JV4N8#6`I=(GR3ML\$&U&B!!)SNWD
M6(K=>>U62L4*G.T%:_;/)M13KP+Z=A\[&YKY%./+DRZLBF[DS"BOO:BHC]99
MGR'LI*R^3_3.PM54L%8(S'5!23\:1-ZN4P7J'"^=A:J;I#BA155!NMPNE'\5
M7H>]?*HN-_="H^R;%_I!5*((-#05[7+3833`&+U*1<G6*P@4^<RQ)$HB;9G]
M5;>HG@,LPQE;.ADT<TD$3$_\U)1O&(U+]RS60=<EJR?I,C'0?V:I[+:M[6&H
MJCR7S!-L+(.!JKKYC0*$_/)<,D^8OX?Y03@U8%A^)-?4O^:X!>2=*-OZ-EQ+
M@"H_^^KW1N.K9V4HY/I<%M,EYUEZP>Q.@O]4>LD=7*IR)>A'L&R&_6U`6C^X
MGHZK96ZY0UBO(4>ZY+WLS/D.O1'+3B/AWU`X_N.4BU8!.X4$^B)<%522RSN4
MMJHZ/3W=7[IVD^]T]$20R\@52U6Y#Q,<!CJHVW'GNC:.XMJB'TZ@1P<)>GB!
MU(_"SD"]AV&#=;CNA^_5:6GEME/KU19Q>`5UI>?QXA8_GD7C<`%[F<D,]@\=
M"G49I+7KVH+B>B^B/JBI^1BW2I<IT8EJB]L14,*6O(T3^`MOJJM1E,&"YU8\
MEH'!?A%>TZ$GK/;QI!1(T9X"B-#PNQW4%@3L#0_UVD*!BIQ,Y[`C&]$>0%G+
MA]M"9LW26-)$%ZJ\H38VRBKXROU.W\>,./9!I=*YZ]U5J37N!L1$Y:Y^-ZA6
MEQ`=N*1<2H.4VJGX*Y2]^2!5[8TF_-=2,3QC9-`8_GVSV?@9_M?\N5I>1IN:
M=&DMZ6VZ[%OLDR6?SO6"\?%XX?'W^'O\/?X>?X^_Q]_C[_'W^'O\/?X>?_]'
+?O\#D`GKB0#(``"?
`
end

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