moved from Completion/Core/compinstall

1 files changed, 1830 insertions, 0 deletions

diff --git a/Completion/compinstall b/Completion/compinstall
new file mode 100644
index 000000000..ebae5bc43
--- /dev/null
+++ b/Completion/compinstall
@@ -0,0 +1,1830 @@
+emulate -L zsh
+setopt extendedglob
+
+local key
+local compcontext=-default-
+
+__ci_tidyup() {
+  unfunction -m __ci_\* 2>/dev/null
+  unfunction compinstall
+  autoload -U compinstall
+}
+
+__ci_newline() {
+  read -k \
+    key"?${1:---- Hit newline to continue or \`q' to exit without saving --- }"
+  print
+  if [[ $key = [qQ] ]]; then
+    print "compinstall aborted."
+    __ci_tidyup
+    return 1
+  else
+    return 0
+  fi
+}
+
+typeset startline='# The following lines were added by compinstall'
+typeset endline='# End of lines added by compinstall'
+typeset ifile line fpath_line compinit_args
+typeset -A styles
+typeset match mbegin mend warn_unknown warn_old warn_comment
+integer lines_found
+
+#
+# Check the user's .zshrc, if any.
+#
+# This relies on the stuff we find being only minimally edited from
+# the stuff we originally saved.  A better way of doing this would
+# almost certainly be to use the style mechanism directly:  save the
+# current styles in a variable, delete all styles, read in and evaluate
+# any styles found, manipulate styles directly using zstyle, write out
+# using zstyle -L, and if necessary restore the original styles.  One
+# day I may even do that.
+#
+
+__ci_test_ifile() {
+  [[ -f $1 ]] && grep "$endline" $1 >/dev/null 2>&1
+}
+
+local foundold=false
+if zstyle -s :compinstall filename ifile &&
+  __ci_test_ifile $ifile; then
+  foundold=true
+else
+  ifile=${ZDOTDIR:-~}/.zshrc
+  if __ci_test_ifile ${ZDOTDIR:-~}/.compinstall; then
+    ifile=${ZDOTDIR:-~}/.compinstall
+    foundold=true
+  elif __ci_test_ifile $ifile; then
+    foundold=true
+  fi
+fi
+
+local newifile=$ifile
+if [[ $foundold = true ]]; then
+  print "I have found completion definitions in $ifile.
+If you want me to read these, just hit return.  Otherwise, edit the file
+name to look for definitions somewhere else, or delete the whole line
+in order not to use existing definitions."
+  vared -ch -p 'file> ' newifile
+  [[ -z $newifile ]] && foundold=false
+else
+  print "I haven't found any existing completion definitions.
+If you have some already defined by compinstall, edit the name of the
+file where these can be found.  Note that this will only work if they
+are exactly the form in which compinstall inserted them.  If you leave
+the line as it is, or empty, I won't search."
+  while true;  do
+    vared -ch -p 'file> ' newifile || break
+    if [[ -n $newifile && $ifile != $newifile ]]; then
+      if __ci_test_ifile $newifile; then
+        foundold=true
+	break
+      fi
+      print "I couldn't find any definitions there.  Edit a new filename, or
+leave the line blank to ignore it."
+    else
+      break
+    fi
+  done
+fi
+ifile=$newifile
+
+if [[ $foundold = true ]]; then
+  sed -n "/^[ 	]*$startline/,/^[ 	]*$endline/p" $ifile |
+  # Use the default read behaviour to handle any continuation lines.
+  while read line; do
+    (( lines_found++ ))
+    if [[ $line = *'$fpath'* ]]; then
+      fpath_line=$line
+      if [[ $line != *\) ]]; then
+        while read -r line; do
+          fpath_line="$fpath_line
+$line"
+          [[ $line = *\) ]] && break
+        done
+      fi
+    elif [[ $line = (#b)[[:blank:]]#zstyle[[:blank:]]##(\'[^\']#\')\
+[[:blank:]]##([^[:blank:]]##)[[:blank:]]##(*) ]]; then
+      styles[$match[2]]="${styles[$match[2]]:+${styles[$match[2]]}
+}${(Q)match[1]}
+${match[3]}"
+    elif [[ $line = [[:blank:]]#compconf* ]]; then
+      warn_old=1
+    elif [[ $line == $startline || $line == $endline ]]; then
+      # no-op
+    elif [[ $line = [[:blank:]]#\#* ]]; then
+      warn_comment=1
+    elif [[ $line = [[:blank:]]#compinit[[:blank:]]##(#b)([^[:blank:]]*) ]]
+    then
+      compinit_args=$match[1]
+    elif [[ $line != [[:blank:]]# &&
+      $line != [[:blank:]]#'autoload -U compinit' &&
+      $line != [[:blank:]]#compinit &&
+      $line != [[:blank:]]#zstyle[[:blank:]]#:compinstall* ]]; then
+      warn_unknown="${warn_unknown:+$warn_unknown
+}$line"
+    fi
+  done
+fi
+
+#
+# Print warnings about what we found in .zshrc.
+#
+
+if [[ -n $warn_old ]]; then
+  print "\
+WARNING: your configuration appears to contain commands for the 3.1.6
+configuration system.  You will have to reconfigure from scratch and the
+existing configuration commands will be overwritten.  If you wish to preserve
+the old commands, you should quit, copy them somewhere else, then rerun
+compinstall.  Sorry."
+elif [[ -n $warn_unknown ]]; then
+  print "\
+WARNING: your configuration contains bits not understood by compinstall,
+which will not be retained (shown below).  If you wish to retain these, you
+should quit, copy them somewhere else, and then rerun compinstall.
+
+$warn_unknown"
+elif [[ -n $warn_comment ]]; then
+  print "All the comments in your configuration section will be lost.
+If you want to keep them, you should copy them somewhere else first."
+elif (( ! $lines_found )); then
+  print "Starting a new completion configuration from scratch."
+  if [[ -n $ifile && ! -d $ifile ]]; then
+    print -n "This will be "
+    if [[ ! -f $ifile ]]; then
+      print "written to the new file $ifile."
+    elif [[ ! -w $ifile ]]; then
+      print "written to the file ~/.compinstall for copying to $ifile."
+      ifile=$HOME/.compinstall
+    else
+      print "appended to the file $ifile.  It is up to you to ensure
+that these lines are actually executed.  They will not be if your .zshrc
+usually returns before the end."
+    fi
+  fi
+fi
+print "Note that you will be given a chance to save the new setup
+somewhere else at the end."
+
+
+__ci_newline || return 1
+
+
+typeset d compdir subdirs lines
+
+#
+# Make sure we have the completion functions in $fpath.
+#
+
+__ci_set_compdir() {
+  for d in $*; do
+    # If we find both the functions more than once, assume the later
+    # one is the standard set.
+    if [[ -f $d/compinit && -f $d/compdump ]]; then
+      compdir=$d
+    fi
+  done
+}
+
+__ci_set_compdir $fpath
+
+if [[ $compdir = */Core && -d $compdir/../Base ]]; then
+  subdirs=1
+  compdir=${compdir:h}
+fi
+
+if [[ -z $compdir ]]; then
+  # Start up a new zsh and get its default fpath.  If some swine has
+  # tinkered with this in /etc/zshenv we're out of luck.
+  lines=${(f)"$(zsh -fc 'print -l $ZSH_VERSION $fpath')"}
+  lines=$lines[1]
+  shift lines
+  # If the zsh in that path isn't right, maybe the user's shell is elsewhere.
+  if [[ $line != $ZSH_VERSION && -x $SHELL ]]; then
+    lines=${(f)"$($SHELL -fc 'print -l $ZSH_VERSION $fpath' 2>/dev/null)"}
+    lines=$lines[1]
+    shift lines
+  fi
+  if [[ $line != $ZSH_VERSION ]]; then
+    print "Hmmm, the zsh in your path is not what's running, nor is \$SHELL.
+That's bad.
+"
+  fi
+  __ci_set_compdir $lines
+  if [[ -n $compdir ]]; then
+    print "\
+I've found the completion directories and will add them to your \$fpath,
+but they should already be there at shell startup, so something (probably
+an unconditional assignment in a startup file) is taking them out.  You
+might want to check this, although what I'm doing should work."
+    if [[ -n $fpath_line ]]; then
+      print "\
+
+What's more, there is already an \$fpath assignment in your completion
+setup.  This gives me cause for concern.  I will override this, but don't
+be surprised if it doesn't go according to plan.  If you have not
+initialised completion in this shell, you should do so, then run
+compinstall again."
+    fi
+  fi
+  if [[ -n $subdirs ]]; then
+    fpath_line=($compdir/[A-Z]*)
+    fpath_line="fpath=($fpath ${(F)fpath_line})"
+  fi
+else
+  if [[ -n $subdirs ]]; then
+    print "Completion directories $compdir/*
+are already in your \$fpath, good."
+  else
+    print "Completion directory $compdir
+is already in your \$fpath, good."
+  fi
+  if [[ -n $fpath_line ]]; then
+    print "I shall keep the existing \$fpath=( ... ) assignment."
+  fi
+fi
+
+if [[ -z $compdir ]]; then
+  print "\
+The zsh in your path doesn't seem to have completion directories in the
+function autoload path (\$fpath).  This suggests the shell wasn't installed
+for completion.  If you want to use it, you will need to locate all the
+completion functions yourself and install them in your \$fpath.  I will
+continue, but don't expect this to have much effect until you do.
+
+If you are planning to continue using the old compctl system for
+completion, compinstall won't do you any good anyway."
+fi
+
+__ci_newline || return 1
+
+
+#
+# Code for changing styles
+#
+
+typeset defcontext=":completion:*"
+typeset curcontext=$defcontext
+
+#
+# Utility functions
+#
+
+#
+# Get the style $1 for $curcontext into $2.
+#
+__ci_get_this_style() {
+  typeset -A tassoc
+  local style=$1 scalar=$2
+
+  tassoc=(${(f)styles[$style]})
+  eval "$scalar=\${tassoc[\$curcontext]}"
+}
+
+#
+# Set the style $1 for $curcontext using scalar $2 for the value for this
+# context.  If $2 is null, delete the context (this may not be correct for
+# all styles).  Don't do any extra quotation.
+# $2 gives the name of the scalar for symmetry with __ci_get_this_style.
+#
+__ci_set_this_style() {
+  local style=$1 scalar=$2 k
+  typeset -A tassoc
+  tassoc=(${(f)styles[$style]})
+
+  if [[ -n ${(P)scalar} ]]; then
+    tassoc[$curcontext]=${(P)scalar}
+  else
+    unset "tassoc[$curcontext]"
+  fi
+
+  styles[$style]=
+  for k in ${(ko)tassoc}; do
+    styles[$style]="${styles[$style]:+$styles[$style]
+}$k
+${tassoc[$k]}"
+  done
+}
+
+#
+# Functions displaying menus
+#
+
+__ci_change_context() {
+  clear
+  print "\
+             *** compinstall: change context ***
+
+The context tells the completion system under what circumstances your
+value will be used.  It has this form:
+  :completion:<function-name>:<completer>:<command>:<argument>:<tag>
+See the documentation for more detail on each of these components.  The
+default context \`$defcontext' matches everywhere in completion, unless you
+define a more specific pattern which matches the completion context being
+used. \`More specific' means either a string instead of a pattern, or a
+longer pattern instead of a shorter pattern.
+
+Edit a new context, or leave the line blank to reset the context to the
+default value.  Note that you do not require quotes around the context,
+which will automatically be added later.  Line editing and history are
+available.
+"
+
+  vared -eh -p 'context> ' curcontext
+  [[ -z $curcontext ]] && curcontext=$defcontext
+}
+
+
+__ci_toggle_completer() {
+  # used locally within __ci_do_completers
+  if [[ -n $completers[$1] ]]; then
+    completers[$1]=
+  else
+    completers[$1]=1
+  fi
+}
+
+__ci_do_minor_completer_options() {
+  # Set the options for the minor completers.
+  local key cond word olist omenu moriginal aspace tmparr
+  __ci_get_this_style condition cond
+  [[ -n $cond ]] && cond=${(Q)cond}
+  __ci_get_this_style word word
+  __ci_get_this_style old-list olist
+  __ci_get_this_style old-menu omenu
+  __ci_get_this_style match-original moriginal
+  __ci_get_this_style add-space aspace
+
+  while true; do
+
+    # insert-unambiguous can be handled somewhere else.
+    clear
+    print "\
+              *** compinstall: minor completer options ***
+
+Current context: $curcontext
+
+l.     Set options for _list: condition for delay and comparison.
+o.     Set options for _oldlist: when to keep old list.
+m.     Set options for _match: whether to assume a \`*' at the cursor.
+p.     Set options for _prefix: whether to add a space before the suffix.
+
+q.     Return to the without saving.
+0.     Done setting completer options.
+"
+
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      [lL]) print "\
+You can set a condition under which the _list completer will delay completion
+until the second keypress.  It should evaluate to a number; a non-zero value
+turns this behaviour on.  It can include parameters, in particular NUMERIC
+to refer to a numeric argument.  For example, \`NUMERIC != 1' forces the
+delay unless you give an argument 1 to the command.  Leave it blank to
+assume the condition is true."
+            vared -eh -c -p 'condition> ' cond
+	    print -n "
+_list will usually compare the contents of the entire line with its previous
+contents to decided if it has been changed since the last keypress.  You
+can instead perform this comparison on just the current word, ignoring
+the rest of the command line.  Do you want to do this? (y/n) [n] "
+	    word=
+            read -q key && word=true
+	    print
+	    ;;
+      [oO]) print "\
+_oldlist can keep a generated completion list for reshowing in the usual
+way, e.g. with ^D, even if the list was generated by some special completion
+command.  The default behaviour of _oldlist is to show this list if it was
+not already visible, otherwise to generate the standard completion listing,
+but you can force it always to be shown, or make it never shown.
+Alternatively, you can specify a list of completers for which _oldlist will
+be used.  Choose:
+
+d.    Default behaviour.
+a.    Always show old list.
+n.    Never show old list.
+s.    Specify a list of completers.
+"
+
+            while true; do
+	      read -k key'?--- Hit selection --- '
+	      print
+	      case $key in
+		[dD]) olist=
+		   ;;
+		[aA]) olist=always
+		      ;;
+		[nN]) olist=never
+		      ;;
+		[sS]) olist=
+		      tmparr=(_complete _approximate _correct _match _expand)
+		      while true; do 
+			clear
+			print "\
+     *** compinstall:  choosing completers to have _oldlist behaviour ***
+
+Type any of:
+
+1.  _complete
+2.  _approximate
+3.  _correct
+4.  _match
+5.  _expand
+
+or 0 to end, or - to delete the last choice."
+			if [[ -n $olist ]]; then
+			  print "\
+Current choices:
+  $olist"
+			fi
+			read -k key'?--- Hit selection --- '
+			print
+			case $key in
+			  0) break
+			     ;;
+			  -) olist=(${olist[1,-2]})
+			     ;;
+			  [1-5]) olist=($olist $tmparr[$key])
+			         ;;
+			esac
+                      done
+		      ;;
+		*) print "Type one of d, a, n or s."
+		   continue
+		   ;;
+	      esac
+	      break
+	    done
+
+	    print -n "
+_oldlist can keep the old completion list for use in menu completion, e.g. by
+repeatedly hitting tab, even if the list was generated by some special
+completion command.  This is the default behaviour of _oldlist, but
+you can turn it off, so that hitting tab would use the standard completion
+list.
+
+Do you want to turn it off? (y/n) [n] "
+            omenu=
+	    read -q key && omenu=false
+	    ;;
+      [mM]) print "\
+The _match completer will usually assume there is a \`*' at the cursor
+position when trying pattern matches.  For example, \`f*n<TAB>e' would
+be able to complete to \`filename', not just to patterns matching \`f*ne'.
+(Note that this assumes you have the option COMPLETE_IN_WORD set, else all
+completion takes place at the end of the word.)  You can tell _match not
+to assume there is a \`*', or to try first without the \`*', then with it.
+Type one of:
+
+a.     Always assume \`*' at cursor position.
+n.     Never assume \`*' at cursor position.
+w.     Try without the \`*', then with it if that fails."
+            while true; do
+	      read -k key'?--- Hit selection --- '
+	      print
+	      case $key in
+		a) moriginal=
+		   ;;
+		n) moriginal=only
+		   ;;
+		w) moriginal=both
+		   ;;
+		*) print "Type one of a, n or w."
+		   continue
+		   ;;
+	      esac
+	      break
+	    done
+            ;;
+      [pP]) print -n "\
+The _prefix completer completes only what is behind the cursor, ignoring
+completely what is after, even if there is no space at the cursor position.
+However, you can force it to add a space between the resulting completion
+and the part ignored.  For example, \`f<TAB>bar' might expand to \`filebar'
+without this, and to \`file bar' with it.  Do wish _prefix to add the
+space? (y/n) [n] "
+            aspace=
+            read -q key && aspace=true
+	    ;;
+      [qQ]) return 1
+	    ;;
+    esac
+
+  done
+
+  [[ -n $cond && $cond != [[:alnum:]]## ]] && cond=${(qq)cond}
+  __ci_set_this_style condition cond
+  __ci_set_this_style word word
+  __ci_set_this_style old-list olist
+  __ci_set_this_style old-menu omenu
+  __ci_set_this_style match-original moriginal
+  __ci_set_this_style add-space aspace
+
+  return 0
+}
+
+__ci_do_minor_completers() {
+  # Set the minor completers not handled by __ci_do_completers.
+  # Called within __ci_do_completers, so inherits the environment.
+  # It's only divided off to keep the menus short.
+
+  local key
+
+  while true; do
+
+    clear
+    print "\
+              *** compinstall: minor completer menu ***
+
+Current context: $curcontext
+
+The following completers are available.  Those marked \`(*)' are already
+set for the context shown above.  Note none of these are required for
+normal completion behaviour.
+
+1. ${${completers[_ignored]:+(*)}:-   } _ignored: $ckeys[_ignored]
+2. ${${completers[_list]:+(*)}:-   } _list:    $ckeys[_list]
+3. ${${completers[_oldlist]:+(*)}:-   } _oldlist: $ckeys[_oldlist]
+4. ${${completers[_match]:+(*)}:-   } _match:   $ckeys[_match]
+5. ${${completers[_prefix]:+(*)}:-   } _prefix:  $ckeys[_prefix]
+
+o.     Set options for the completers above.
+q.     Return without saving.
+0.     Done setting minor completers.
+"
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) __ci_toggle_completer _ignored
+	 if [[ -n $completers[_ignored] ]]; then
+	   print "\
+I am inserting the \`ignored' completer immediately after normal
+completion.  You can move it later in the list by hand, if you prefer, so
+that ignored completions are only used after, for example, approximations.
+To do this, edit $ifile, look for the zstyle ... completers line, and
+move \`_ignored' to where you want it.  This will be retained if you use
+compinstall again provided you don't go into the completers menu.
+"
+	   # TODO: we could be more careful about keeping the user's
+	   # order, particularly with multiple completers.
+           read -k key'?--- Hit any key to continue --- '
+	   print
+	 fi
+	 ;;
+      2) __ci_toggle_completer _list
+	 ;;
+      3) __ci_toggle_completer _oldlist
+	 ;;
+      4) __ci_toggle_completer _match
+	 ;;
+      5) __ci_toggle_completer _prefix
+	 ;;
+      o) __ci_do_minor_completer_options
+	 ;;
+      q) return 1
+	 ;;
+    esac
+
+  done
+
+  return 0
+}
+
+__ci_do_completer_options() {
+  # Set options for the main completers; called from __ci_do_completers.
+
+  local maxe errors prompt glob subst compl cond
+
+  __ci_get_this_style max-errors errors
+  __ci_get_this_style prompt prompt
+  [[ -n $prompt ]] && prompt=${(Q)prompt}
+  __ci_get_this_style glob glob
+  [[ -n $glob ]] && glob=${(Q)glob}
+  __ci_get_this_style substitute subst
+  [[ -n $subst ]] && subst=${(Q)subst}
+  __ci_get_this_style completions compl
+  [[ -n $compl ]] && compl=${(Q)compl}
+
+  while true; do
+
+    clear
+    print "\
+              *** compinstall: completer options ***
+
+Current context: $curcontext
+
+The following options are available.  Note that these require the relevant
+completers to be present, as set in the menu above this one.
+
+a.     Set options for approximation or correction.
+e.     Set options for expansion.
+q.     Return without saving.
+
+0.     Done setting options.
+"
+
+    read -k key'?--- Hit selection --- '
+    print
+
+    # We handle approximation and correction together to avoid having
+    # to be too particular about context.
+    case $key in
+      a) clear
+         print "\
+Approximation and correction can correct the errors in what you have typed,
+up to a maximum number of errors which you can specify.  Each \`error'
+is the omission of a character, the addition of a superfluous character,
+the substitution of one character by an incorrect one, or transposition of
+two different characters.
+
+Current context: $curcontext
+
+To have different values for approximation and correction, you should
+change the context appropriately.  For approximation, use
+\`:completion:*:approximate:*' and for correction use
+\`:completion:*:correct:*'.
+
+Enter maximum number of errors allowed:
+"
+         maxe=
+	 while true; do
+	   vared -eh -c -p "number> " maxe
+	   [[ $maxe = [[:digit:]]## ]] && break
+	   print "Please enter a number"
+	   maxe=
+	 done
+	 while true; do
+	   print "\nSelect behaviour of numeric prefix.
+
+1.     Numeric prefix is not used by approximation or completion.
+2.     Numeric prefix, if provided, gives max number of errors allowed,
+       replacing the number you just typed for that one completion.
+3.     Numeric prefix, if provided, prevents approximation or completion
+       from taking place at all for that one completion.
+"
+           read -k -- key'?--- Hit selection --- '
+	   print
+	   [[ $key = [123] ]] || continue
+	   case $key in
+             2) maxe="$maxe numeric"
+		;;
+	     3) maxe="$maxe not-numeric"
+		;;
+	   esac
+	   print "
+You can edit a prompt which will appear above lists of corrections.  The
+string \`%e' inside the prompt will be replaced with the number of errors
+found.  Leave blank for no prompt.  Quotation marks will be added
+automatically."
+	   vared -eh -c -p "prompt> " prompt
+	   break
+	 done
+	 errors=$maxe
+	 ;;
+      e) while true; do
+           clear
+           print "\
+The _expand completer can be tuned to perform any of globbing (filename
+generation), substitution (anything with a \`\$' or backquote), or
+normal completion (which is useful for inserting all possible completions
+into the command line).  For each feature, a 1 turns it on, while a 0 turns
+it off; if the feature is unset, that expansion will *not* be performed.
+
+You can also give more complicated mathematical expressions, which can use
+the parameter NUMERIC to refer to the numeric argument.  For example, the
+expression \`NUMERIC == 2' means that the expansion takes effect if you
+type ESC-2 (Emacs mode) or 2 (Vi command mode) before the expansion.
+Quotes will be added automatically as needed.
+
+g.     Set condition to perform globbing: ${glob:-unset}
+s.     Set condition to perform substitution: ${subst:-unset}
+c.     Set condition to perform completion: ${compl:-unset}
+0.     Done setting conditions (will not be saved until you leave options)
+"
+           read -k key'?--- Enter selection --- '
+	   print
+
+	   case $key in
+	     g) vared -eh -c -p 'globbing condition> ' glob
+		;;
+	     s) vared -eh -c -p 'substitution condition> ' subst
+		;;
+	     c) vared -eh -c -p 'completion condition> ' compl
+		;;
+	   esac
+
+	   [[ $key = 0 ]] && break
+
+         done
+	 ;;
+      q) return 1
+	 ;;
+    esac
+
+    [[ $key = 0 ]] && break
+  done
+
+  __ci_set_this_style max-errors errors
+  [[ -n $prompt ]] && prompt=${(qq)prompt}
+  __ci_set_this_style prompt prompt
+  [[ -n $glob && $glob != [[:alnum:]]## ]] && glob=${(qq)glob}
+  __ci_set_this_style glob glob
+  [[ -n $subst && $subst != [[:alnum:]]## ]] && subst=${(qq)subst}
+  __ci_set_this_style substitute subst
+  [[ -n $compl && $compl != [[:alnum:]]## ]] && compl=${(qq)compl}
+  __ci_set_this_style completions compl
+
+  key=
+  return 0
+}
+
+__ci_do_completers() {
+  # Set the completers for the current context.
+  # This is mostly done via a series of toggles.
+
+  typeset -A completers ckeys
+  local c clist newc
+  __ci_get_this_style completer newc
+  for c in ${=newc}; do
+    completers[$c]=1
+  done
+  clist=(_list _oldlist _menu _expand _complete _ignored 
+         _match _correct _approximate _prefix)
+
+  # TODO: these are a bit brief, so could provide some more detailed help.
+  ckeys=(_complete 'Basic completion.'
+         _approximate
+'Approximate completion:  completion with correction of existing word.'
+         _correct
+'Correction:  correct existing word, no completion.'
+         _expand
+'Expansion: use globbing and parameter substitution, if possible.'
+
+	 _ignored
+'Use patterns that were previously ignored if no matches so far.'
+         _list
+'Only list matches until the second time you hit TAB.'
+         _oldlist
+'Keep matches generated by special completion functions.'
+        _match
+'If completion fails, retry with pattern matching.'
+         _prefix
+'If completion fails, retry ignoring the part after the cursor.'
+         )
+
+  # TODO: You'll need to handle the bindkey to make _expand work.
+  # TODO: _prefix completer should make sure completeinword is set.
+
+  while true; do
+
+    clear
+    print "\
+              *** compinstall: completer menu ***
+
+Current context: $curcontext
+
+The following completers are available.  Those marked \`(*)' are already
+set for the context shown above.  If none are selected, the completers will
+not be set for this context at all.
+
+1. ${${completers[_complete]:+(*)}:-   } $ckeys[_complete]
+2. ${${completers[_approximate]:+(*)}:-   } $ckeys[_approximate]
+3. ${${completers[_correct]:+(*)}:-   } $ckeys[_correct]
+4. ${${completers[_expand]:+(*)}:-   } $ckeys[_expand]
+
+o.     Set options for the completers above.
+m.     Set completers that modify the behaviour of the four main ones above.
+q.     Return without saving.
+0.     Done setting completers.
+"
+    read -k key'?--- Hit selection --- '
+    print
+
+    case $key in
+      1) __ci_toggle_completer _complete
+	 ;;
+      2) __ci_toggle_completer _approximate
+	 ;;
+      3) __ci_toggle_completer _correct
+	 ;;
+      4) __ci_toggle_completer _expand
+	 ;;
+      [mM]) __ci_do_minor_completers || return
+            continue
+	    ;;
+      [oO]) __ci_do_completer_options || return
+            continue
+	    ;;
+      q) return 1
+	 ;;
+    esac
+
+    [[ $key = 0 ]] && break
+  done
+
+  newc=
+  for c in $clist; do
+    [[ -n $completers[$c] ]] && newc="${newc:+$newc }$c"
+  done
+  [[ -z $newc ]] && newc="''"
+  __ci_set_this_style completer newc
+}
+
+__ci_toggle_matcher() {
+  # Toggle on/off the matcher in array $1 for element $2
+  if [[ ${${(P)1}[$2]} = ' ' ]]; then
+    # toggle on
+    eval "${1}[$2]=$2"
+    if [[ $1 = n* ]]; then
+      # no matcher turned on, turn off the others
+      c_list[$2]=' '
+      C_list[$2]=' '
+      p_list[$2]=' '
+      s_list[$2]=' '
+    else
+      # something else turned on, turn off no matcher
+      n_list[$2]=' '
+    fi
+    return 0
+  else
+    # toggle off
+    eval "${1}[$2]=' '"
+    if [[ $c_list[$2] == ' ' && $C_list[$2] == ' ' && \
+	  $p_list[$2] == ' ' && $s_list[$2] == ' ' ]]; then
+      a_or_r[$2]=' '
+    fi
+    return 1
+  fi
+}
+
+__ci_do_matchers() {
+  # Set matchers via the matcher-list style.
+  # We just offer a pre-programmed set of possible matchers, but these
+  # cover the most common usages for matchers in a general context.
+  # More specific use of matchers is usually covered by completion functions.
+
+  local mlist m_ci m_pw m_sub c_list C_list p_list s_list pw_seps key key2 elt
+  local pw_dstar a_or_r i
+  integer eltcnt lastnz
+
+  __ci_get_this_style matcher-list mlist
+  # $mlist is the once and future list of matchers.  We don't quote it
+  # until the end; the eval effectively does de-quoting.
+  eval "mlist=($mlist)"
+  # ?_list say whether the four possible matchers are set for passes 1,
+  # 2, 3, 4, in an easy-to-read manner, i.e. the Nth part of the string
+  # is one of N (on) or space (off).
+  a_or_r="    "                 # replace by default
+  n_list="    "			# null completion, i.e. standard
+  c_list="    "			# case match one way
+  C_list="    "			# case match both ways
+  p_list="    "			# partial word completion
+  s_list="    "			# substring completion
+  # $pw_seps gives the separators used for partial-word completion
+  # by element of the matcher list; these can be edited separately.
+  pw_seps=('._-' '._-' '._-' '._-')
+  pw_dstar=('' '' '' '')
+
+  # See what's in the matcher initially.  If these have been edited,
+  # we're in trouble, but that's pretty much true of everything.
+  for (( eltcnt = 1; eltcnt <= $#mlist; eltcnt++ )); do
+    [[ $mlist[eltcnt] == "+"* ]] && a_or_r[$eltcnt]='+'
+    [[ -z $mlist[$eltcnt] ]] && n_list[$eltcnt]=$eltcnt
+    [[ $mlist[$eltcnt] = *"m:{a-z}={A-Z}"* ]] && c_list[$eltcnt]=$eltcnt
+    [[ $mlist[$eltcnt] = *"m:{a-zA-Z}={A-Za-z}"* ]] && C_list[$eltcnt]=$eltcnt
+    # For partial word stuff, we use backreferences to find out what
+    # the set of separators was.
+    if [[ $mlist[$eltcnt] = (#b)*"r:|["([^\]]#)"]=*"#" r:|=*"* ]]; then
+      p_list[$eltcnt]=$eltcnt
+      pw_seps[$eltcnt]=${match[1]}
+      [[ $mlist[$eltcnt] = *"=**"* ]] && pw_dstar[$eltcnt]='*'
+    fi
+    # Just look for the left matcher for substring, since the right matcher
+    # might have been handled as part of a partial-word spec.
+    [[ $mlist[$eltcnt] = *"l:|=*"* ]] && s_list[$eltcnt]=$eltcnt
+  done
+
+  while true; do
+    clear
+    print "\
+              *** compinstall: matcher menu ***
+
+\`Matchers' compare the completion code with the possible matches in some
+special way.  Numbers in parentheses show matchers to be tried and the order.
+The same number can be assigned to different matchers, meaning apply at the
+same time.  Omit a sequence number to try normal matching at that point.
+A \`+' in the first line indicates the element is added to preceding matchers
+instead of replacing them; toggle this with \`t'.  You don't need to set
+all four, or indeed any matchers --- then the style will not be set.
+
+   ($a_or_r)\
+   \`+' indicates add to previous matchers, else replace
+n. ($n_list)\
+ No matchers; you may want to try this as the first choice.
+c. ($c_list)\
+ Case-insensitive completion (lowercase matches uppercase)
+C. ($C_list)\
+ Case-insensitive completion (lower/uppercase match each other)
+p. ($p_list)\
+ Partial-word completion:  expand 'f.b' to 'foo.bar', etc., in one go.
+          You can choose the separators (here \`.') used each time.
+s. ($s_list)\
+ Substring completion:  complete on substrings, not just initial
+          strings.  Warning: it is recommended this not be used for element 1.
+
+t.        Toggle replacing previous matchers (\` ' at top) or add (\`+')
+q.        Return without saving.
+0.        Done setting matchers.
+"
+
+    read -k key'?--- Hit selection --- '
+    print
+
+    if [[ $key = [nNcCpPsS] ]]; then
+      while true; do
+	read -k key2'?Set/unset for element number (1234)? '
+	print
+	[[ $key2 = [1234] ]] && break
+	print "Only 1, 2, 3 and 4 are handled."
+      done
+    fi
+
+    case $key in
+      [nN]) __ci_toggle_matcher n_list $key2
+         if [[ $n_list[$key2] != ' ' ]]; then
+	 fi
+         ;;
+      c) __ci_toggle_matcher c_list $key2
+	 ;;
+      C) __ci_toggle_matcher C_list $key2
+	 ;;
+      [pP]) if __ci_toggle_matcher p_list $key2; then
+	      print "\
+Edit the set of characters which terminate partial words.  Typically
+these are punctuation characters, such as \`.', \`_' and \`-'.
+The expression will automatically be quoted.
+"
+              vared -eh -p 'characters> ' -c 'pw_seps['$key2']'
+	      # Paranoia: we don't know if there's a ']' in that string,
+	      # which will wreck the spec unless it's at the start.  Other
+	      # quotes are OK, since they are picked up at the ${(qq)...}
+	      # step.
+	      if [[ $pw_seps[$key2] = *']'* ]]; then
+		pw_seps[$key2]="]${pw_seps[$key2]//\\\]}"
+	      fi
+	      print -n "
+You can allow the partial-word terminators to be matched in the pattern,
+too:  then  for example \`c.u' would expand to \`comp.source.unix', whereas
+usually you would need to type an extra intervening dot.  Do you wish the
+terminators to be matched in this way? (y/n) [n] "
+              pw_dstar[$key2]=
+	      read -q key && pw_dstar[$key2]='*'
+	    fi
+	    ;;
+      [tT])
+	    read -k key2'?Toggle augment/replace for elements number (1234)? '
+	    if [[ $key2 == [1234] ]]; then
+	      if [[ $a_or_r[$key2] == ' ' ]]; then
+	        a_or_r[$key2]='+'
+	      else
+	        a_or_r[$key2]=' '
+	      fi
+	    else
+	      print "Only 1, 2, 3 and 4 are handled."
+	    fi
+	    ;;
+      [sS]) __ci_toggle_matcher s_list $key2
+	    ;;
+      [qQ]) return 1
+	 ;;
+    esac
+
+    [[ $key = 0 ]] && break
+  done
+
+  # Keep track of the last element which was non-empty; all the rest
+  # are junked.
+  lastnz=0
+
+  # Now we just reverse the first for-loop, looking for set matchers
+  # and reconstructing the elements of the matcher array.
+  for (( eltcnt = 1; eltcnt <= 4; eltcnt++ )); do
+    elt=
+    [[ $c_list[$eltcnt] != ' ' ]] && elt="${elt:+$elt }m:{a-z}={A-Z}"
+    [[ $C_list[$eltcnt] != ' ' ]] && elt="${elt:+$elt }m:{a-zA-Z}={A-Za-z}"
+    [[ $p_list[$eltcnt] != ' ' ]] &&
+      elt="${elt:+$elt }r:|[${pw_seps[$eltcnt]}]=*${pw_dstar[$eltcnt]}\
+ r:|=*${pw_dstar[$eltcnt]}"
+    if [[ $s_list[$eltcnt] != ' ' ]]; then
+      if [[ $elt = *"r:|=*"* ]]; then
+	elt="${elt:+$elt }l:|=*"
+      else
+	elt="${elt:+$elt }l:|=* r:|=*"
+      fi
+    fi
+    [[ $a_or_r[$eltcnt] != ' ' ]] && elt="+$elt"
+    [[ -n $elt || $n_list[$eltcnt] != ' ' ]] && lastnz=$eltcnt
+    mlist[$eltcnt]=$elt
+  done
+
+  if (( ! $lastnz )); then
+    # No matchers set, so just make the style empty: __ci_set_this_style
+    # will omit it completely.
+    mlist=
+  else
+    # Quote the entire list: this correctly quotes element by element,
+    # praise be to Sven.
+    mlist=(${(qq)mlist[1,$lastnz]})
+    # Make it a scalar just for safety's sake.
+    mlist="$mlist"
+  fi
+  __ci_set_this_style matcher-list mlist
+
+  return 0
+}
+
+__ci_do_list_format() {
+  local key format groupn verbose listp autod haslistp
+  __ci_get_this_style format format
+  [[ -n $format ]] && format=${(Q)format}
+  __ci_get_this_style group-name groupn
+  __ci_get_this_style verbose verbose
+  __ci_get_this_style list-prompt listp
+  [[ -n $listp ]] && haslistp=1
+  listp=${(Q)listp}
+  __ci_get_this_style auto-description autod
+  [[ -n $autod ]] && autod=${(Q)autod}
+
+  while true; do
+    clear
+    print "\
+       *** compinstall: order and descriptions in completion lists ***
+Type the appropriate number for more information on how this would affect
+listings.
+
+1.  Print a message above completion lists describing what is being
+    completed.
+
+2.  Make different types of completion appear in separate lists.
+
+3.  Make completion verbose, using option descriptions etc. (on by default).
+
+4.  Make single-valued options display the value's description as
+    part of the option's description.
+
+q.  Return without saving.
+0.  Done setting options for formatting of completion lists.
+"
+
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) print "\
+You can set a string which is displayed on a line above the list of matches
+for completions.  A \`%d' in this string will be replaced by a brief
+description of the type of completion.  For example, if you set the
+string to \`Completing %d', and type ^D to show a list of files, the line
+\`Completing files' will appear above that list.  Enter an empty line to
+turn this feature off.  If you enter something which doesn't include \`%d',
+then \`%d' will be appended.  Quotation will be added automatically.
+"
+         vared -eh -p 'description> ' -c format
+	 if [[ -n $format && $format != *%d* ]]; then
+	   [[ $format = *[[:blank:]] ]] || format="$format "
+	   format="$format%d"
+	 fi
+	 ;;
+      2) print "\
+Normally, all possible completions are listed together in a single list, and
+if you have set a description with 1) above, the descriptions are listed
+together above that.  However, you can specify that different types of
+completion appear in separate lists; any description appears above its
+own list.  For example, external commands and shell functions would appear
+in separate lists when you are completing a command name.  Do you
+want to turn this on?
+"
+         while true; do
+           read -k key'?[y]es, [n]o, [k]eep old setting? '
+	   print
+	   [[ $key = [yYnNkK] ]] && break
+	 done
+	 case $key in
+	   [yY]) groupn="''"
+		 ;;
+	   [nN]) groupn=
+		 ;;
+	 esac
+	 ;;
+      3) print "By default, completion uses a \`verbose' setting.  This
+affects different completions in different ways.  For example,  many
+well-known commands have short, uninformative option names; in some cases,
+completion will indicate what the options do when offering to complete them.
+If you prefer shorter listings you can turn this off.  What setting to
+you want?
+"
+          while true; do
+            read -k key'?[v]erbose, [n]ot verbose, [k]eep old setting? '
+            print
+            [[ $key = [vVnNkK] ]] && break
+          done
+          case $key in
+	    # might as well be explicit, particularly since it's
+	    # the only way to override an existing `false' value.
+	    [vV]) verbose=true
+		  ;;
+	    [nN]) verbose=false
+		  ;;
+          esac
+	 ;;
+      4) print "\
+Many commands have options which take a single argument.  In some cases,
+completion is not set up to describe the option even though it has a
+description for the argument.  You can enter a string containing \`%d',
+which will be replaced by the description for the option.  For
+example, if you enter the string \`specify: %d', and an option -ifile
+exists which has an argument whose description is \`input file', then the
+description \`specify: input file' will appear when the option itself
+is listed.  As this long explanation suggests, this is only occasionally
+useful.  Enter an empty line to turn this feature off.  If you enter
+something which doesn't include \`%d', then \`%d' will be appended.
+Quotation will be added automatically.
+"
+         vared -eh -p 'auto-description> ' -c autod
+         if [[ -n $autod && $autod != *%d* ]]; then
+	   [[ $autod = *[[:blank:]] ]] || autod="$autod "
+	   autod="$autod%d"
+         fi
+	 ;;
+      q) return 1
+	 ;;
+    esac
+  done
+
+  [[ -n $format ]] && format=${(qq)format}
+  __ci_set_this_style format format
+  __ci_set_this_style group-name groupn
+  __ci_set_this_style verbose verbose
+  [[ -n $autod ]] && autod=${(qq)autod}
+  __ci_set_this_style auto-description autod
+}
+
+__ci_do_insertion() {
+  local key insertu original # sort
+
+  __ci_get_this_style insert-unambiguous insertu
+  __ci_get_this_style original original
+
+  while true; do
+    clear
+    print "\
+          *** compinstall: options for inserting completions ***
+
+1.   In completers that change what you have already typed, insert any
+     unambiguous prefix rather than go straight to menu completion.
+
+2.   In completers which correct what you have typed, keep what you
+     originally typed as one of the list of possible completions.
+
+q.   Return with saving.
+0.   Done setting options for insertion.
+"
+    read -k key'?-- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) print "\
+The completers which do pattern matching and correction often alter the
+string which is already on the line, in the first case because it was a
+pattern and in the second case because what you typed was wrong.
+Since the possible completions can bear little or no resemblance to one
+another in those cases, so that typing extra characters to resolve the
+completion doesn't make much sense, menu completion is usually turned on
+straight away to allow you to pick the completion you want.  This style
+tells completion that if there is a common, unambiguous prefix in this
+case, you would prefer that to be inserted rather than going straight
+to menu completion.  Do you want this?
+"
+         while true; do
+           read -k key'?[y]es, [n]o, [k]eep old setting? '
+	   print
+	   [[ $key = [yYnNkK] ]] && break
+	 done
+	 case $key in
+	   [yY]) insertu=true
+	         ;;
+	   [nN]) insertu=false
+		 ;;
+	 esac
+	 ;;
+      2) print "\
+For completers which correct what you have typed, you sometimes want
+to keep the original string instead, so if the correction was ambiguous
+the original string is always listed as a possible completion.  However,
+if there was just one completion it is usually accepted.  You can
+force completion to offer the original string as a possibility even in
+this case.  Do you want this?
+"
+         while true; do
+	   read -k key'?[y]es, [n]o, [k]eep old setting? '
+	   print
+	   [[ $key = [yYnNkK] ]] && break
+	 done
+	 case $key in
+	   [yY]) original=true
+	         ;;
+           [nN]) original=false
+	         ;;
+	 esac
+	 ;;
+      [qQ]) return 1
+	      ;;
+    esac
+
+  done
+
+  __ci_set_this_style insert-unambiguous insertu
+  __ci_set_this_style original original
+  # __ci_set_this_style sort sort
+
+  return 0;
+}
+
+
+__ci_do_selection() {
+  local key listc menu select amenu elt listp selectp haslistp hasselectp
+  integer num
+
+  __ci_get_this_style list-colors listc
+  __ci_get_this_style menu menu
+  __ci_get_this_style list-prompt listp
+  [[ -n $listp ]] && haslistp=1
+  listp=${(Q)listp}
+  __ci_get_this_style select-prompt selectp
+  [[ -n $selectp ]] && hasselectp=1
+  selectp=${(Q)selectp}
+
+  while true; do
+    clear
+    print "\
+     *** compinstall: options for colouring and selecting in lists ***
+
+1.   Use coloured lists for listing completions.
+
+2.   Use cursor keys to select completions from completion lists.
+
+3.   Allow scrolling of long selection lists and set the prompt.
+
+q.   Return without saving.
+0.   Done setting options for insertion.
+"
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) print "\
+Zsh can produce coloured completion listings where different file types
+etc. appear in different colours.  If you want to tailor that to your
+own needs, you will have to edit ~/.zshrc.  Here you have the choice of:
+
+1.  Using the default colours.
+2.  Using the colours already set up for GNU ls via the \$LS_COLORS
+    environment variable.  Note this must be set before the completion
+    configuration code is executed.
+3.  Turn colouring off.
+0.  Leave the setting the way it is.  Choose this if you have a custom
+    setting and you don't want to lose it.
+"
+         while true; do
+	   read -k key'?Enter 1, 2, 3, 0: '
+	   print
+	   [[ $key = [1230] ]] && break
+	 done
+	 case $key in
+	   1) listc="''"
+	      ;;
+	   2) listc='${(s.:.)LS_COLORS}'
+	      ;;
+	   3) listc=
+	      ;;
+	 esac
+	 ;;
+      2) print "\
+If you use zsh's menu completion and the feature that all short completion
+lists appear below the line on which you are editing, you can enable
+\`menu selection', which lets you pick a completion with the cursor keys:
+the choice is highlighted, and hitting return accepts it.  Note that
+this only happens when you are already using menu completion.  This
+feature can be set so that it is only enabled when there are a certain
+number of completions.  Please enter:
+
+- 0 or 1, to turn this feature on unconditionally
+- a higher number to turn this feature on when there are that many
+  completions
+- an \`l' for \`long' to turn it on for listings which don't fit on the
+  screen.
+- an \`ll' for \`long list' to turn it on for completions which don't fit
+  on the screen, even for commands which only do listing of completions.
+  This may be combined with a number which will be used in ordinary selection.
+- a negative number to turn this feature off
+- an empty line to leave the setting the way it is.
+"
+	 # Better to parse and display the current setting.
+         while true; do
+           vared -eh -p 'value> ' select
+	   [[ -z $select || $select = ((-|)<->|l|<->#ll<->#) ]] && break;
+	   print "Type a number, l, ll, ll<num>, or an empty line." >&2
+	 done
+	 amenu=(${=menu})
+	 elt=${amenu[(i)*select*]}
+	 [[ $elt -gt $#amenu ]] && elt=
+	 case $select in
+	   <->) if [[ -n $elt ]]; then
+		  amenu[$elt]="select=$select"
+		else
+		  amenu=($amenu "select=$select")
+	        fi
+		menu="$amenu"
+		;;
+	   *ll*) num=${(RS)select##ll}
+	         select="select=long-list"
+		 [[ -n $num ]] && select="$select select=$num"
+		 if [[ -n $elt ]]; then
+		   amenu[$elt]=$select
+		 else
+		   amenu=($amenu $select)
+		 fi
+		 menu="$amenu"
+		 ;;
+	   l#) if [[ -n $elt ]]; then
+                 amenu[$elt]="select=long"
+               else
+                 amenu=($amenu "select=long")
+               fi
+	       menu="$amenu"
+               ;;
+	   -<->) if [[ -n $elt ]]; then
+		    # i never liked the way indexing was done anyway
+		    if [[ $elt -eq 1 ]]; then
+		      amenu=($amenu[$elt+1,-1])
+		    else
+		      amenu=($amenu[1,$elt-1] $amenu[$elt+1,-1])
+		    fi
+		 fi
+		 menu="$amenu"
+		 ;;
+	 esac
+	 if [[ $menu = *select* ]]; then
+	   print "\
+You can also set a prompt to use for menu selection when it would scroll
+off the screen.  Unless this is set, you won't see a prompt, but the feature
+is still enabled.
+
+Edit a prompt below.  It can contain \`%l' to show the number of matches
+as \`current_number/total_number', \`%p' to show the fraction of
+the way down the list, or font-control sequences such as %B, %U, %S and
+the corresponding %b, %u, %s; quotes will be added automatically.  Delete
+the whole line to turn it off.  Hit return to keep the current value.
+"
+	   [[ -z $hasselectp ]] &&
+	     selectp='%SScrolling active: current selection at %p%s'
+	   vared -eh -p 'prompt> ' -c selectp
+	   [[ -z $selectp ]] && hasselectp=
+	 fi
+         ;;
+      3) print "\
+You can make completion lists scroll when they don't fit on the screen.
+Note this is different from scrolling in menu selection --- a more basic
+pager is used which should work even with fairly stupid terminals.
+
+To enable this, edit a prompt to show when scrolling is active; an empty 
+string turns this feature off.  It can contain \`%l' to show the number of
+matches as \`current_number/total_number', \`%p' to show the fraction of
+the way down the list, or font-control sequences such as %B, %U, %S and the
+corresponding %b, %u, %s; quotes will be added automatically.  Delete the
+whole line to turn this behaviour off, in which case the display of
+completions which don't fit on the screen is controlled by the LISTMAX
+parameter (currently ${LISTMAX:-unset}), which specifies the maximum number
+to show without asking.  Hit return to keep the current value.
+"
+         [[ -z $haslistp ]] &&
+	   listp='%SAt %p: Hit TAB for more, or the character to insert%s'
+	 vared -eh -p 'prompt> ' -c listp
+	 [[ -z $listp ]] && haslistp=
+	 ;;
+      q) return 1
+         ;;
+    esac
+  done
+
+  __ci_set_this_style list-colors listc
+  __ci_set_this_style menu menu
+  [[ -n $haslistp ]] && listp=${(qq)listp}
+  __ci_set_this_style list-prompt listp
+  [[ -n $hasselectp ]] && selectp=${(qq)selectp}
+  __ci_set_this_style select-prompt selectp
+
+  return 0
+}
+
+
+__ci_do_display() {
+  local key usec
+
+  __ci_get_this_style use-compctl usec
+
+  while true; do
+    clear
+    print "\
+         *** compinstall: display and insertion options ***
+
+1.  Change appearance of completion lists:  allows descriptions of
+    completions to appear and sorting of different types of completions.
+
+2.  Change how completions are inserted: includes options for sorting,
+    and keeping the original or an unambiguous prefix with correction etc.
+
+3.  Configure coloured/highlighted completion lists, selection of items
+    and scrolling.
+
+4.  Change whether old-style \`compctl' completions will be used.
+
+q.  Return without saving.
+0.  Done setting display and insertion options.
+"
+
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) __ci_do_list_format
+	 ;;
+      2) __ci_do_insertion
+	 ;;
+      3)  __ci_do_selection
+	 ;;
+      4) print "\
+Completions defined by the new completion system (the one you are
+configuring) always take precedence over the old sort defined with compctl.
+You can choose whether or not you want to search for a compctl-defined
+completion if no new completion was found for a command.  The default
+behaviour is only to check for compctl-defined completions if the required
+library, zsh/compctl, is already loaded.  (If not, this implies that
+compctl has not been called.)  Do you want to test for compctl-defined
+completions?
+"
+         while true; do
+	   read -k key'?[y]es, [n]o, if [l]oaded, [k]eep old setting? '
+	   print
+	   [[ $key = [yYnNlLkK] ]] && break
+	 done
+	 case $key in
+	   [yY]) usec=true
+	         ;;
+	   [nN]) usec=false
+	         ;;
+	   [lL]) usec=
+	         ;;
+	 esac
+	 ;;
+      q) return 1
+	 ;;
+    esac
+
+  done
+
+  __ci_set_this_style use-compctl usec
+
+  return 0
+}
+
+
+#       file-sort, special-dirs, ignore-parents,
+#       squeeze-slashes,
+__ci_do_file_styles() {
+  local key files cursor expand speciald ignorep squeezes select
+
+  __ci_get_this_style file-sort files
+  __ci_get_this_style ignore-parents ignorep
+  __ci_get_this_style special-dirs speciald
+  __ci_get_this_style squeeze-slashes squeezes
+
+  while true; do
+    clear
+    print "\
+      *** compinstall: options for filename completion ***
+
+1.  Choose how to sort the displayed list of filename matches.
+
+2.  In expressions with .., don't include directories already implied.
+
+3.  Allow completion of . and .. for the bone idle.
+
+4.  When expanding paths, \`foo//bar' is treated as \`foo/bar'.
+
+q.  Return without saving.
+0.  Done setting options for filename completion.
+"
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      (1) print "\
+Filenames listed as possible completions are usually displayed in
+alphabetical order.  You can alternatively choose:
+  s  File size
+  l  Number of (hard) links
+  m  Modification time
+  a  Access time
+  i  Inode change time
+  n  File name
+  k  Keep the current setting
+You can also specify the reverse of any of the above orders (except \`k'):  to
+do this, type the appropriate letter in upper case.
+"
+         while true; do
+           read -k key'?--- Hit selection --- '
+	   print
+	   [[ $key = [sSlLmMaAiInNkK] ]] && break
+	 done
+	 case $key in
+	   ([sS]) files=size;;
+	   ([lL]) files=links;;
+	   ([mM]) files=modification;;
+	   ([aA]) files=access;;
+	   ([iI]) files=inode;;
+	   ([nN]) files=name;;
+	 esac
+	 if [[ $key = [SLAMIN] ]]; then
+	   # slam it into reverse
+	   files="$files reverse"
+	 fi
+	 ;;
+      (2) print "\
+When you type an expression containing \`..', you may usually not want to
+be offered certain directories for completion.
+  p   Don't offer parents:  in \`foo/bar/../', don't make \`bar' a completion.
+  c   Don't offer the current directory, e.g. after \`../'.
+  o   Only perform the two tests if there is a real \`..' in the word so far.
+  d   Only perform the two tests when completing directory names.
+  0   None of the above; use normal completion.
+  k   Keep the current settings.
+You may specify any combination of p, c, o, d including at least one of p
+and c, or you may specify either 0 or k.  Note that the _ignored completer
+functions in the normal way, i.e. you would be able to complete the
+directories in question if nothing else matched.
+"
+          while true; do
+	    vared -eh -p 'selection> ' select
+	    [[ ( $select = [pPcCoOdD]# && $select = *[pPcC]* )
+		    || $select = [0kK] ]] && break
+	    print "Type any combination of p, c, o, d, or type 0 or k"
+	  done
+	  case $select in
+	    (0) ignorep=
+		;;
+	    ([pPcCoOdD]#)
+		ignorep=()
+		[[ $select = *[pP]* ]] && ignorep=($ignorep parent)
+		[[ $select = *[cC]* ]] && ignorep=($ignorep pwd)
+		[[ $select = *[oO]* ]] && ignorep=($ignorep ..)
+		[[ $select = *[dD]* ]] && ignorep=($ignorep directory)
+		;;
+	  esac
+	  ;;
+      (3) print "\
+Filename completion does not usually offer the directory names \`.' and
+\`..' as choices.  However, some immensely lazy people can't even be
+bothered to type these.  Do you wish to be offered \`.' and \`..' as
+choices ([y]es, [n]o, [k]eep current setting)?
+"
+          while true; do
+            read -k key'?--- Hit selection --- '
+	    [[ $key = [yYnNkK] ]] && break
+	    print "Type y, n or k."
+	  done
+	  case $key in
+	    ([yY]) speciald=true;;
+	    ([nN]) speciald=;;
+	  esac
+	  ;;
+      (4) print "\
+Filename completion can complete sets of path segments at once, for example
+\`/u/X/l/X' to \`/usr/X11R6/lib/X11'.  Normally this means that multiple
+slashes in filenames are treated as matching multiple directories.  For
+example, \`foo//bar' could expand to \`foo/datthe/bar'.  You can, however,
+stick to the usual UNIX convention that multiple slashes are treated as
+a single slash.  Do you wish to treat multiple slashes the same as just
+one ([y]es, [n]o, [k]eep current setting)?
+"
+          while true; do
+	    read -k key'?--- Hit selection --- '
+	    [[ $key = [yYnNkK] ]] && break
+	    print "Type one of y, n or k."
+	  done
+	  case $key in
+	    ([yY]) squeezes=true;;
+	    ([nN]) squeezes=;;
+	  esac
+          ;;
+      (q) return 1
+	 ;;
+    esac
+
+  done
+
+  __ci_set_this_style file-sort files
+  __ci_set_this_style ignore-parents ignorep
+  __ci_set_this_style special-dirs speciald
+  __ci_set_this_style squeeze-slashes squeezes
+
+  return 0
+}
+
+
+# TODO: history completion, jobs, prefix-needed 'n' stuff.
+__ci_do_misc() {
+  local key
+
+  while true; do
+    clear
+    print "\
+      *** compinstall: options for particular types of completion ***
+
+1.  Options for file completion.
+
+q.  Return without saving.
+0.  Done setting options for particular completions.
+"
+    read -k key'?--- Hit selection --- '
+    print
+
+    [[ $key = 0 ]] && break
+
+    case $key in
+      1) __ci_do_file_styles
+	 ;;
+      q) return 1
+	 ;;
+    esac
+
+  done
+
+  return 0;
+}
+
+
+# TODO: it should probably be possible to set completion options via
+#         compinstall, even though they've been around for years.
+
+while true; do
+  clear
+  print "\
+               *** compinstall: main menu ***
+Note that hitting \`q' in menus does not abort the set of changes from
+lower level menus.  However, quitting at top level will ensure that nothing
+at all is actually written out.
+
+1.  Completers:  choose completion behaviour for tasks such as
+    approximation, spell-checking, expansion.
+
+2.  Matching control: set behaviour for case-insensitive matching,
+    extended (partial-word) matching and substring matching.
+
+3.  Styles for changing the way completions are displayed and inserted.
+
+4.  Styles for particular completions.
+
+c.  Change context (plus more information on contexts).
+
+q.  Return without saving.
+0.  Save and exit.
+"
+
+  __ci_newline \
+    "--- Hit choice --- " || return 1
+
+  # note this is a string test:  we require the `0' to have been typed.
+  [[ $key = 0 ]] && break
+
+  case $key in
+    1) __ci_do_completers
+       ;;
+    2) __ci_do_matchers
+       ;;
+    3) __ci_do_display
+       ;;
+    4) __ci_do_misc
+       ;;
+    c) __ci_change_context
+       ;;
+  esac
+done
+
+
+local output
+
+if (( $#styles )); then
+  typeset style stylevals context values
+  for style in ${(ko)styles}; do
+    stylevals=(${(f)styles[$style]})
+    while (( $#stylevals )); do
+      output="$output
+zstyle ${(qq)stylevals[1]} $style $stylevals[2]"
+      shift 2 stylevals
+    done
+  done
+fi
+
+if [[ -z $ifile || -d $ifile ]] ||
+  ! read -q key"?Save new settings to $ifile? "; then
+   print "Enter file to save in (~ will be expanded), or return to abort:"
+   ifile=
+   vared -ch -p 'file> ' ifile
+   ifile=${~ifile}
+fi
+
+local tmpout=${TMPPREFIX:-/tmp/zsh}compinstall$$
+#
+# Assemble the complete set of lines to
+# insert.
+#
+{ print -r "$startline
+$output"
+  if [[ -n $ifile ]]; then
+    line="zstyle :compinstall filename ${(qq)ifile}"
+    print -r "$line"
+    eval "$line"
+  fi
+
+  [[ -n $fpath_line ]] && print -r "$fpath_line"
+
+  print -r "
+autoload -U compinit
+compinit${compinit_args:+ $compinit_args}"
+
+  print -r "$endline"
+} >$tmpout
+
+if [[ -n $ifile ]]; then
+  if [[ $ifile != *(zshrc|zlogin|zshenv) ]]; then 
+    print "\
+If you want this file to be run automatically, you should add
+  . $ifile
+to your .zshrc.  compinstall will remember the name of this file for
+future use."
+    __ci_newline || return 1
+  fi
+  #
+  # Now use sed to update the file.
+  #
+  if [[ -f $ifile ]]; then
+    cp $ifile ${ifile}\~ &&
+    print "Copied old file to ${ifile}~."
+  else
+    touch $ifile
+  fi
+  if { { grep "$endline" $ifile >/dev/null 2>&1 &&
+         sed -e "/^[ 	]*$endline/r $tmpout
+/^[ 	]*$startline/,/^[ 	]*$endline/d" $ifile >${tmpout}2 } || 
+        { cp $ifile ${tmpout}2 && cat $tmpout >>${tmpout}2 } } &&
+  cp ${tmpout}2 $ifile && rm -f ${tmpout}2; then
+    print "\nSuccessfully added compinstall lines to $ifile."
+    rm -f $tmpout
+  else
+    print "\nFailure adding lines to $ifile.  Lines left in \`$tmpout'"
+  fi
+  rm -f ${tmpout}2
+elif read -q key'?Print them to stdout instead? '; then
+  cat $tmpout
+  rm -f $tmpout
+fi
+
+if read -q key'?Set new styles for immediate use? '; then
+  eval $output
+  print "The new settings are now in effect.  Note this will not remove old
+styles you have deleted until you restart the shell."
+fi
+
+__ci_tidyup
+return 0