From ba4f5e80ec9d7e145718e79fed6e57a852c86c12 Mon Sep 17 00:00:00 2001
From: Tanaka Akira <akr@users.sourceforge.net>
Date: Thu, 15 Apr 1999 18:15:04 +0000
Subject: zsh-3.1.5-pws-8

---
 Functions/Completion/.distfiles          |  11 ++
 Functions/Completion/__aliases           |   2 +
 Functions/Completion/__arrays            |   2 +
 Functions/Completion/__autoload          |   2 +
 Functions/Completion/__bg_jobs           |   2 +
 Functions/Completion/__bindkey           |   7 +
 Functions/Completion/__builtin           |   7 +
 Functions/Completion/__cd                |   3 +
 Functions/Completion/__command           |   7 +
 Functions/Completion/__command_names     |   2 +
 Functions/Completion/__compress          |   3 +
 Functions/Completion/__condition         |  10 ++
 Functions/Completion/__configure         |  11 ++
 Functions/Completion/__dd                |  13 ++
 Functions/Completion/__default           |  13 ++
 Functions/Completion/__dirs              |   3 +
 Functions/Completion/__disable           |   6 +
 Functions/Completion/__dvi               |   3 +
 Functions/Completion/__echotc            |   2 +
 Functions/Completion/__enable            |   6 +
 Functions/Completion/__fc                |   7 +
 Functions/Completion/__files             |  10 ++
 Functions/Completion/__find              |  24 +++
 Functions/Completion/__functions         |   2 +
 Functions/Completion/__gunzip            |   3 +
 Functions/Completion/__gzip              |   3 +
 Functions/Completion/__hash              |  13 ++
 Functions/Completion/__hosts             |   2 +
 Functions/Completion/__jobs              |   2 +
 Functions/Completion/__kill              |   8 +
 Functions/Completion/__kill_helper       |   3 +
 Functions/Completion/__limits            |   2 +
 Functions/Completion/__main_complete     |  48 ++++++
 Functions/Completion/__main_key_complete |   6 +
 Functions/Completion/__make              |   3 +
 Functions/Completion/__man               |  11 ++
 Functions/Completion/__mh                |  70 ++++++++
 Functions/Completion/__most_recent_file  |   2 +
 Functions/Completion/__normal            |  54 ++++++
 Functions/Completion/__path_files        | 272 +++++++++++++++++++++++++++++++
 Functions/Completion/__pdf               |   3 +
 Functions/Completion/__precommand        |  15 ++
 Functions/Completion/__ps                |   3 +
 Functions/Completion/__rcs               |   9 +
 Functions/Completion/__rlogin            |   9 +
 Functions/Completion/__sched             |   3 +
 Functions/Completion/__set               |   7 +
 Functions/Completion/__setopt            |   7 +
 Functions/Completion/__source            |   7 +
 Functions/Completion/__strip             |   2 +
 Functions/Completion/__stty              |  16 ++
 Functions/Completion/__subscript         |   4 +
 Functions/Completion/__tar               |  14 ++
 Functions/Completion/__tex               |   3 +
 Functions/Completion/__trap              |   7 +
 Functions/Completion/__uncompress        |   3 +
 Functions/Completion/__unhash            |   6 +
 Functions/Completion/__unsetopt          |   7 +
 Functions/Completion/__vars              |   2 +
 Functions/Completion/__vars_eq           |   2 +
 Functions/Completion/__wait              |   4 +
 Functions/Completion/__which             |   2 +
 Functions/Completion/__x_options         |   5 +
 Functions/Completion/__xfig              |   3 +
 Functions/Completion/__zle               |   7 +
 Functions/Completion/__zmodload          |   9 +
 Functions/Completion/init                | 253 ++++++++++++++++++++++++++++
 Functions/allopt                         |  29 ++++
 68 files changed, 1101 insertions(+)
 create mode 100644 Functions/Completion/.distfiles
 create mode 100644 Functions/Completion/__aliases
 create mode 100644 Functions/Completion/__arrays
 create mode 100644 Functions/Completion/__autoload
 create mode 100644 Functions/Completion/__bg_jobs
 create mode 100644 Functions/Completion/__bindkey
 create mode 100644 Functions/Completion/__builtin
 create mode 100644 Functions/Completion/__cd
 create mode 100644 Functions/Completion/__command
 create mode 100644 Functions/Completion/__command_names
 create mode 100644 Functions/Completion/__compress
 create mode 100644 Functions/Completion/__condition
 create mode 100644 Functions/Completion/__configure
 create mode 100644 Functions/Completion/__dd
 create mode 100644 Functions/Completion/__default
 create mode 100644 Functions/Completion/__dirs
 create mode 100644 Functions/Completion/__disable
 create mode 100644 Functions/Completion/__dvi
 create mode 100644 Functions/Completion/__echotc
 create mode 100644 Functions/Completion/__enable
 create mode 100644 Functions/Completion/__fc
 create mode 100644 Functions/Completion/__files
 create mode 100644 Functions/Completion/__find
 create mode 100644 Functions/Completion/__functions
 create mode 100644 Functions/Completion/__gunzip
 create mode 100644 Functions/Completion/__gzip
 create mode 100644 Functions/Completion/__hash
 create mode 100644 Functions/Completion/__hosts
 create mode 100644 Functions/Completion/__jobs
 create mode 100644 Functions/Completion/__kill
 create mode 100644 Functions/Completion/__kill_helper
 create mode 100644 Functions/Completion/__limits
 create mode 100644 Functions/Completion/__main_complete
 create mode 100644 Functions/Completion/__main_key_complete
 create mode 100644 Functions/Completion/__make
 create mode 100644 Functions/Completion/__man
 create mode 100644 Functions/Completion/__mh
 create mode 100644 Functions/Completion/__most_recent_file
 create mode 100644 Functions/Completion/__normal
 create mode 100644 Functions/Completion/__path_files
 create mode 100644 Functions/Completion/__pdf
 create mode 100644 Functions/Completion/__precommand
 create mode 100644 Functions/Completion/__ps
 create mode 100644 Functions/Completion/__rcs
 create mode 100644 Functions/Completion/__rlogin
 create mode 100644 Functions/Completion/__sched
 create mode 100644 Functions/Completion/__set
 create mode 100644 Functions/Completion/__setopt
 create mode 100644 Functions/Completion/__source
 create mode 100644 Functions/Completion/__strip
 create mode 100644 Functions/Completion/__stty
 create mode 100644 Functions/Completion/__subscript
 create mode 100644 Functions/Completion/__tar
 create mode 100644 Functions/Completion/__tex
 create mode 100644 Functions/Completion/__trap
 create mode 100644 Functions/Completion/__uncompress
 create mode 100644 Functions/Completion/__unhash
 create mode 100644 Functions/Completion/__unsetopt
 create mode 100644 Functions/Completion/__vars
 create mode 100644 Functions/Completion/__vars_eq
 create mode 100644 Functions/Completion/__wait
 create mode 100644 Functions/Completion/__which
 create mode 100644 Functions/Completion/__x_options
 create mode 100644 Functions/Completion/__xfig
 create mode 100644 Functions/Completion/__zle
 create mode 100644 Functions/Completion/__zmodload
 create mode 100644 Functions/Completion/init
 create mode 100644 Functions/allopt

(limited to 'Functions')

diff --git a/Functions/Completion/.distfiles b/Functions/Completion/.distfiles
new file mode 100644
index 000000000..12621da29
--- /dev/null
+++ b/Functions/Completion/.distfiles
@@ -0,0 +1,11 @@
+DISTFILES_SRC='
+    .distfiles
+ __aliases __arrays __autoload __bg_jobs __bindkey __builtin __cd __command
+ __command_names __compress __condition __configure __dd __default __dirs
+ __disable __dvi __echotc __enable __fc __files __find __functions __gunzip
+ __gzip __hash __hosts __jobs __kill __kill_helper __limits __main_complete
+ __main_key_complete __make __man __mh __most_recent_file __normal __path_files
+ __pdf __precommand __ps __rcs __rlogin __sched __set __setopt __source __strip
+ __stty __subscript __tar __tex __trap __uncompress __unhash __unsetopt __vars
+ __vars_eq __wait __which __x_options __xfig __zle __zmodload init 
+'
diff --git a/Functions/Completion/__aliases b/Functions/Completion/__aliases
new file mode 100644
index 000000000..cbf204e51
--- /dev/null
+++ b/Functions/Completion/__aliases
@@ -0,0 +1,2 @@
+#array unalias
+__aliases=(-a)
diff --git a/Functions/Completion/__arrays b/Functions/Completion/__arrays
new file mode 100644
index 000000000..3f6ec8abe
--- /dev/null
+++ b/Functions/Completion/__arrays
@@ -0,0 +1,2 @@
+#array shift
+__arrays=(-A)
diff --git a/Functions/Completion/__autoload b/Functions/Completion/__autoload
new file mode 100644
index 000000000..9c3bb1f4f
--- /dev/null
+++ b/Functions/Completion/__autoload
@@ -0,0 +1,2 @@
+#array autoload
+__autoload=(-s '${^fpath}/*(N:t)')
diff --git a/Functions/Completion/__bg_jobs b/Functions/Completion/__bg_jobs
new file mode 100644
index 000000000..90e3b7ee0
--- /dev/null
+++ b/Functions/Completion/__bg_jobs
@@ -0,0 +1,2 @@
+#array bg
+__bg_jobs=(-z -P '%')
diff --git a/Functions/Completion/__bindkey b/Functions/Completion/__bindkey
new file mode 100644
index 000000000..c9005347a
--- /dev/null
+++ b/Functions/Completion/__bindkey
@@ -0,0 +1,7 @@
+#function bindkey
+
+if [[ -mword 1 -*[DAN]* || -mcurrent -1 -*M ]]; then
+  complist -s '$(bindkey -l)'
+else
+  complist -b
+fi
diff --git a/Functions/Completion/__builtin b/Functions/Completion/__builtin
new file mode 100644
index 000000000..5b4c777f5
--- /dev/null
+++ b/Functions/Completion/__builtin
@@ -0,0 +1,7 @@
+#function builtin
+
+if [[ -position 2 -1 ]]; then
+  compsub
+else
+  complist -eB
+fi
diff --git a/Functions/Completion/__cd b/Functions/Completion/__cd
new file mode 100644
index 000000000..ad5e36386
--- /dev/null
+++ b/Functions/Completion/__cd
@@ -0,0 +1,3 @@
+#function cd
+
+__files -W cdpath -g '*(-/)'
diff --git a/Functions/Completion/__command b/Functions/Completion/__command
new file mode 100644
index 000000000..deaabdb1f
--- /dev/null
+++ b/Functions/Completion/__command
@@ -0,0 +1,7 @@
+#function command
+
+if [[ -position 2 -1 ]]; then
+  compsub
+else
+  complist -em
+fi
diff --git a/Functions/Completion/__command_names b/Functions/Completion/__command_names
new file mode 100644
index 000000000..7a28fa527
--- /dev/null
+++ b/Functions/Completion/__command_names
@@ -0,0 +1,2 @@
+#array --command--
+__command_names=(-c)
diff --git a/Functions/Completion/__compress b/Functions/Completion/__compress
new file mode 100644
index 000000000..d4e71f531
--- /dev/null
+++ b/Functions/Completion/__compress
@@ -0,0 +1,3 @@
+#function compress
+
+__files -g '*~*.Z'
diff --git a/Functions/Completion/__condition b/Functions/Completion/__condition
new file mode 100644
index 000000000..8ceb969b8
--- /dev/null
+++ b/Functions/Completion/__condition
@@ -0,0 +1,10 @@
+#function --condition--
+
+if [[ -current -1 -o ]]; then
+  complist -o -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}'
+elif [[ -current -1 -nt || -current -1 -ot || -current -1 -ef ]]; then
+  files
+else
+  files
+  complist -v
+fi
diff --git a/Functions/Completion/__configure b/Functions/Completion/__configure
new file mode 100644
index 000000000..a4d00e0f2
--- /dev/null
+++ b/Functions/Completion/__configure
@@ -0,0 +1,11 @@
+#function configure
+if [[ $PREFIX = *=* ]]; then
+  # Complete filenames after e.g. --prefix=
+  IPREFIX=${PREFIX%%=*}=
+  PREFIX=${PREFIX#*=}
+  complist -f
+else
+  # Generate a list of options from configure --help
+  complist -s '$($COMMAND --help |
+  sed -n -e '\''s/^ *\(--[-a-z0-9]*\)[    =,].*$/\1/p'\'')'
+fi
diff --git a/Functions/Completion/__dd b/Functions/Completion/__dd
new file mode 100644
index 000000000..c0e04de75
--- /dev/null
+++ b/Functions/Completion/__dd
@@ -0,0 +1,13 @@
+#function dd
+
+if [[ -iprefix conv= ]]; then
+  # If there's a comma present, ignore up to the last one.  The
+  # test alone will have that effect.
+  [[ -string , ]]
+  complist -S, -q \
+  -k '(ascii ebcdic ibm block unblock lcase ucase swab noerror sync)'
+elif [[ -iprefix 'if=' || -iprefix 'of=' ]]; then
+  __files
+else
+  complist -S '=' -k '(if of ibs obs bs cbs skip files seek count conv)'
+fi
diff --git a/Functions/Completion/__default b/Functions/Completion/__default
new file mode 100644
index 000000000..cabe14a36
--- /dev/null
+++ b/Functions/Completion/__default
@@ -0,0 +1,13 @@
+#function --default--
+
+# We first try the `compctl's. This is without first (-T) and default (-D)
+# completion. If you want them add `-T' and/or `-D' to this command.
+# If there is a `compctl' for the command we are working on, we return
+# immediatly. If you want to use new style completion anyway, remove the
+# `|| return'. Also, you may want to use new style completion if the 
+# `compctl' didn't produce any matches. In that case remove the `|| return'
+# and at the line `[[ -nmatches 0 ]] || return' after `compcall'.
+
+compcall || return
+
+__files
diff --git a/Functions/Completion/__dirs b/Functions/Completion/__dirs
new file mode 100644
index 000000000..a838168bc
--- /dev/null
+++ b/Functions/Completion/__dirs
@@ -0,0 +1,3 @@
+#function rmdir df du dircmp
+
+__files -/ '*(-/)'
diff --git a/Functions/Completion/__disable b/Functions/Completion/__disable
new file mode 100644
index 000000000..c56ffb7f7
--- /dev/null
+++ b/Functions/Completion/__disable
@@ -0,0 +1,6 @@
+#function disable
+
+[[ -mcurrent -1 -*a* ]] && complist -ea
+[[ -mcurrent -1 -*f* ]] && complist -eF
+[[ -mcurrent -1 -*r* ]] && complist -ew
+[[ ! -mcurrent -1 -* ]] && complist -eB
diff --git a/Functions/Completion/__dvi b/Functions/Completion/__dvi
new file mode 100644
index 000000000..873d5812a
--- /dev/null
+++ b/Functions/Completion/__dvi
@@ -0,0 +1,3 @@
+#function xdvi dvips dvibook dviconcat dvicopy dvidvi dviselect dvitodvi dvitype
+
+__files -g '*.(dvi|DVI)'
diff --git a/Functions/Completion/__echotc b/Functions/Completion/__echotc
new file mode 100644
index 000000000..d9b7029c1
--- /dev/null
+++ b/Functions/Completion/__echotc
@@ -0,0 +1,2 @@
+#array echotc
+__echotc=(-k '(al dc dl do le up al bl cd ce cl cr dc dl do ho is le ma nd nl se so up)')
diff --git a/Functions/Completion/__enable b/Functions/Completion/__enable
new file mode 100644
index 000000000..b315611df
--- /dev/null
+++ b/Functions/Completion/__enable
@@ -0,0 +1,6 @@
+#function enable
+
+[[ -mcurrent -1 -*a* ]] && complist -da
+[[ -mcurrent -1 -*f* ]] && complist -dF
+[[ -mcurrent -1 -*r* ]] && complist -dw
+[[ ! -mcurrent -1 -* ]] && complist -dB
diff --git a/Functions/Completion/__fc b/Functions/Completion/__fc
new file mode 100644
index 000000000..9185312b0
--- /dev/null
+++ b/Functions/Completion/__fc
@@ -0,0 +1,7 @@
+#function fc
+
+if [[ -mcurrent -1 -*e ]]; then
+  complist -c
+elif [[ -mcurrent -1 -[ARWI]## ]]; then
+  __files
+fi
diff --git a/Functions/Completion/__files b/Functions/Completion/__files
new file mode 100644
index 000000000..dfade8c7f
--- /dev/null
+++ b/Functions/Completion/__files
@@ -0,0 +1,10 @@
+#helper
+
+# Utility function for completing files of a given type or any file.
+# In many cases you will want to call this one instead of __path_files().
+
+local nm=$NMATCHES
+
+__path_files "$@"
+
+[[ $# -ne 0 && -nmatches nm ]] && __path_files
diff --git a/Functions/Completion/__find b/Functions/Completion/__find
new file mode 100644
index 000000000..b16bb09c7
--- /dev/null
+++ b/Functions/Completion/__find
@@ -0,0 +1,24 @@
+#function find
+
+compsave
+
+if [[ -mbetween -(ok|exec) \\\; ]]; then
+  compsub
+elif [[ -iprefix - ]]; then
+  complist -s 'daystart {max,min,}depth follow noleaf version xdev \
+{a,c,}newer {a,c,m}{min,time} empty false {fs,x,}type gid inum links \
+{i,}{l,}name {no,}{user,group} path perm regex size true uid used \
+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
diff --git a/Functions/Completion/__functions b/Functions/Completion/__functions
new file mode 100644
index 000000000..4fd24e379
--- /dev/null
+++ b/Functions/Completion/__functions
@@ -0,0 +1,2 @@
+#array unfunction
+__functions=(-F)
diff --git a/Functions/Completion/__gunzip b/Functions/Completion/__gunzip
new file mode 100644
index 000000000..f14803c62
--- /dev/null
+++ b/Functions/Completion/__gunzip
@@ -0,0 +1,3 @@
+#function gunzip zcat
+
+__files -g '*.[gG][z]'
diff --git a/Functions/Completion/__gzip b/Functions/Completion/__gzip
new file mode 100644
index 000000000..ce4e0787a
--- /dev/null
+++ b/Functions/Completion/__gzip
@@ -0,0 +1,3 @@
+#function gzip
+
+__files -g '*~*.[gG][zZ]'
diff --git a/Functions/Completion/__hash b/Functions/Completion/__hash
new file mode 100644
index 000000000..bd43eb967
--- /dev/null
+++ b/Functions/Completion/__hash
@@ -0,0 +1,13 @@
+#function hash
+
+if [[ -mword 1 -*d* ]]; then
+  if [[ -string 1 '=' ]]; then
+    pfiles -g '*(-/)'
+  else
+    complist -n -q -S '='
+  fi
+elif [[ -string 1 '=' ]]; then
+  files -g '*(*)' '*(-/)'
+else
+  complist -m -q -S '='
+fi
diff --git a/Functions/Completion/__hosts b/Functions/Completion/__hosts
new file mode 100644
index 000000000..a91251581
--- /dev/null
+++ b/Functions/Completion/__hosts
@@ -0,0 +1,2 @@
+#array ftp ncftp ping rwho rup xping traceroute nslookup
+__hosts=(-k hosts)
diff --git a/Functions/Completion/__jobs b/Functions/Completion/__jobs
new file mode 100644
index 000000000..d3e0d7776
--- /dev/null
+++ b/Functions/Completion/__jobs
@@ -0,0 +1,2 @@
+#array fg jobs
+__jobs=(-j -P '%')
diff --git a/Functions/Completion/__kill b/Functions/Completion/__kill
new file mode 100644
index 000000000..09ba248dc
--- /dev/null
+++ b/Functions/Completion/__kill
@@ -0,0 +1,8 @@
+#function kill
+
+if [[ -iprefix '-' ]]; then
+  complist -k "($signals[1,-3])"
+else
+  complist -P '%' -j
+  complist -y __kill_helper -s '`ps 2>/dev/null | tail +2 | cut -c1-5`'
+fi
diff --git a/Functions/Completion/__kill_helper b/Functions/Completion/__kill_helper
new file mode 100644
index 000000000..e1d286938
--- /dev/null
+++ b/Functions/Completion/__kill_helper
@@ -0,0 +1,3 @@
+#helper
+
+reply=( "$(ps 2>/dev/null)" )
diff --git a/Functions/Completion/__limits b/Functions/Completion/__limits
new file mode 100644
index 000000000..e3f97155d
--- /dev/null
+++ b/Functions/Completion/__limits
@@ -0,0 +1,2 @@
+#array limit unlimit
+__limits=(-k "(${(j: :)${(f)$(limit)}%% *})")
diff --git a/Functions/Completion/__main_complete b/Functions/Completion/__main_complete
new file mode 100644
index 000000000..48f2338de
--- /dev/null
+++ b/Functions/Completion/__main_complete
@@ -0,0 +1,48 @@
+#helper
+
+# The main loop of the completion code. This is what is called when 
+# completion is attempted from the command line.
+# The completion code gives us the special variables and the arguments
+# from the command line are given as positional parameters.
+
+local comp name
+
+setopt localoptions nullglob rcexpandparam globdots
+unsetopt markdirs globsubst shwordsplit nounset
+
+# 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--]"
+[[ -z "$comp" ]] || callcomplete comps --first-- "$@" || return 1
+
+# For arguments we use the `__normal' function 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
+  # possible contexts.
+
+  comp=''
+
+  case $CONTEXT in
+  redirect)  name=--redirect--;;
+  math)      name=--math--;;
+  subscript) name=--subscript--;;
+  value)     name=--value--;;
+  condition) name=--condition--;;
+  esac
+
+  # If not, we use default completion, if any.
+
+  comp="$comps[$name]"
+  if [[ -z "$comp" ]]; then
+     name=--default--
+     comp="$comps[--default--]"
+  fi
+  [[ -z "$comp" ]] || callcomplete comps "$name" "$@" || return 1
+fi
diff --git a/Functions/Completion/__main_key_complete b/Functions/Completion/__main_key_complete
new file mode 100644
index 000000000..35fa1a0a3
--- /dev/null
+++ b/Functions/Completion/__main_key_complete
@@ -0,0 +1,6 @@
+#helper
+
+# The widget name looks like `__complete_key_<num>' where <num> can be
+# used as an index into the `keycomps' array to get at the definition.
+
+callcomplete keycomps "$WIDGET" "$@"
diff --git a/Functions/Completion/__make b/Functions/Completion/__make
new file mode 100644
index 000000000..4a2c5a7c8
--- /dev/null
+++ b/Functions/Completion/__make
@@ -0,0 +1,3 @@
+#function make gmake pmake
+
+complist -s "\$(awk '/^[a-zA-Z0-9][^/ 	]+:/ {print \$1}' FS=: [mM]akefile)"
diff --git a/Functions/Completion/__man b/Functions/Completion/__man
new file mode 100644
index 000000000..a0f00f58b
--- /dev/null
+++ b/Functions/Completion/__man
@@ -0,0 +1,11 @@
+#function man
+setopt localoptions rcexpandparam
+
+local rep
+if [[ $2 = (<->*|ln) ]]; then
+  rep=( $manpath/(man|cat)$2/$PREFIX*$SUFFIX.<->*(N:t:r) )
+else
+  rep=( $manpath/(man|cat)*/$PREFIX*$SUFFIX.<->*(N:t:r) )
+fi
+
+(( $#rep )) && compadd -m $rep
diff --git a/Functions/Completion/__mh b/Functions/Completion/__mh
new file mode 100644
index 000000000..2e4738e17
--- /dev/null
+++ b/Functions/Completion/__mh
@@ -0,0 +1,70 @@
+#function folder comp inc mark refile repl scan show next prev rmm pick whom mhn mhpath mhpatch
+
+# Completion for all possible MH commands.
+# Alter the following two to your own mh directory and the directory
+# where standard mh library files live.  (It works anyway, but this
+# will save a little time.)
+local mymhdir=~/Mail
+local mhlib=/usr/lib/mh
+
+# To be on the safe side, check this exists and if not, get it anyway.
+[[ -d $mymhdir ]] || mymhdir=$(mhpath +)
+
+if [[ -iprefix - ]]; then
+  # get list of options, which MH commands can generate themselves
+  # awk is just too icky to use for this, sorry.  send me one if
+  # you come up with it.
+  compadd -m $($COMMAND -help | perl -ne 'if (/^\s*-\(?(\S+)/) {
+    $n = $1;
+    $n =~ s/\)//g;
+    print $n =~ s/^\[([a-z]+)\]// ? "$n\n$1$n\n" : "$n\n";
+  }')
+  return
+elif [[ -iprefix '+' || -iprefix '@' || -current -1 -draftfolder ]]; then
+  # Complete folder names.
+  local mhpath
+  if [[ $IPREFIX != '@' ]]; then
+    [[ $IPREFIX = '+' ]] || IPREFIX=+
+    mhpath=$mymhdir
+  else
+    mhpath=$(mhpath)
+  fi
+
+  # painless, or what?
+  complist -W mhpath -/
+elif [[ -mcurrent -1 -(editor|(whatnow|rmm|show|more)proc) ]]; then
+  complist -c
+elif [[ -current -1 -file ]]; then
+  complist -f
+elif [[ -mcurrent -1 -(form|audit|filter) ]]; then
+  # Need some MH template file, which may be in our own MH directory
+  # or with the standard library.
+  local mhfpath
+  # This is the only place we need mhlib, so leave the test till here.
+  [[ -d $mhlib ]] || { mhlib=$(mhparam mhlproc); mhlib=$mhlib:h; }
+  mhfpath=($mymhdir $mhlib)
+
+  complist -W mhfpath -g '*(.)'
+elif [[ -mcurrent -1 -(no|)cc ]]; then
+  compadd -m all to cc me
+elif [[ -mcurrent -1 -[rw]cache ]]; then
+  compadd -m public private never ask
+else
+  # Generate sequences.
+  local foldnam folddir f
+  for f in $argv; do
+    [[ $f = [@+]* ]] && foldnam=$f
+  done
+  if [[ $foldnam = '+'* ]]; then
+    folddir=$mymhdir/${foldnam#+}
+  elif [[ $foldnam = '@'* ]]; then
+    folddir=$(mhpath)/${foldnam#@}
+  else
+    folddir=$(mhpath)
+    # leaving foldnam empty works here
+  fi
+
+  complist -s '$(mark $foldnam | awk -F: '\''{ print $1 }'\'')'
+  compadd -m reply next cur prev first last all unseen
+  complist -W folddir -g '<->'
+fi
diff --git a/Functions/Completion/__most_recent_file b/Functions/Completion/__most_recent_file
new file mode 100644
index 000000000..cf1f83282
--- /dev/null
+++ b/Functions/Completion/__most_recent_file
@@ -0,0 +1,2 @@
+#key-array expand-or-complete \C-xm
+__most_recent_file=(-g '*(om[1])')
diff --git a/Functions/Completion/__normal b/Functions/Completion/__normal
new file mode 100644
index 000000000..7750563d1
--- /dev/null
+++ b/Functions/Completion/__normal
@@ -0,0 +1,54 @@
+#helper
+
+local comp cmd1 cmd2 pat val name
+
+# 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.
+# a path and the last path name component).
+
+if [[ $CONTEXT == command ]]; then
+  comp="$comps[--command--]"
+  [[ -z "$comp" ]] || callcomplete comps --command-- "$@" || return 1
+  return 0
+elif [[ "$COMMAND[1]" == '=' ]]; then
+  eval cmd1\=$COMMAND
+  cmd2="$COMMAND[2,-1]"
+elif [[ "$COMMAND" == */* ]]; then
+  cmd1="$COMMAND"
+  cmd2="${COMMAND:t}"
+else
+  cmd1="$COMMAND"
+  eval cmd2=$(whence -p $COMMAND)
+fi
+
+# See if there are any matching pattern completions.
+
+if (( $#patcomps )); then
+  for i in "$patcomps[@]"; do
+    pat="${i% *}"
+    val="${i#* }"
+    if [[ "$cmd1" == $~pat || "$cmd2" == $~pat ]]; then
+      callcomplete patcomps "$pat" "$@" || return 1
+    fi
+  done
+fi
+
+# Now look up the two names in the normal completion array.
+
+name="$cmd1"
+comp="$comps[$cmd1]"
+
+if [[ -z "$comp" ]]; then
+  name="$cmd2"
+  comp="$comps[$cmd2]"
+fi
+
+# And generate the matches, probably using default completion.
+
+if [[ -z "$comp" ]]; then
+  name=--default--
+  comp="$comps[--default--]"
+fi
+[[ -z "$comp" ]] || callcomplete comps "$name" "$@" || return 1
+
+return 0
diff --git a/Functions/Completion/__path_files b/Functions/Completion/__path_files
new file mode 100644
index 000000000..f9e7c631a
--- /dev/null
+++ b/Functions/Completion/__path_files
@@ -0,0 +1,272 @@
+#helper
+
+# 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.: __path_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).
+#
+# You may also give the `-W <spec>' option as with `compctl' and `complist',
+# but only as the first argument.
+#
+# This function also accepts an optional `-F <string>' option as its first
+# argument or just after the `-W <spec>'. This can be used to define file
+# name extension (a la `fignore'). Files with such an extension will not
+# be considered possible completions.
+#
+# This function behaves as if you have a matcher definition like:
+#   compctl -M 'r:|[-.,_/]=* r:|=* m:{a-z}={A-Z} m:-=_ m:.=,' \
+#              'm:{a-z}={A-Z} l:|=* r:|=*'
+# so you may want to modify this.
+
+local nm prepaths str linepath realpath donepath patstr prepath testpath rest
+local tmp1 collect tmp2 suffixes i ignore
+
+setopt localoptions nullglob rcexpandparam globdots extendedglob
+unsetopt markdirs globsubst shwordsplit nounset
+
+# Get the optional `-W' option and its argument.
+if [[ "$1" = -W ]]; then
+  tmp1="$2"
+  if [[ "$tmp1[1]" = '(' ]]; then
+    prepaths=( $tmp1[2,-2]/ )
+  else
+    prepaths=( ${(P)${tmp1}} )
+    [[ $#prepaths -eq 0 ]] && prepaths=( $tmp1/ )
+  fi
+  [[ $#prepaths -eq 0 ]] && prepaths=( '' )
+  shift 2
+else
+  prepaths=( '' )
+fi
+
+# Get the optional `-F' option and its argument.
+if [[ "$1" = -F ]]; then
+  ignore=(-F "$2")
+  shift 2
+else
+  ignore=''
+fi
+
+# str holds the whole string from the command line with a `*' between
+# the prefix and the suffix.
+
+str="${PREFIX:q}*${SUFFIX:q}"
+
+# We will first try normal completion called with `complist', but only if we
+# weren't given a `-F' option.
+
+if [[ -z "$ignore" ]]; then
+  # First build an array containing the `-W' option, if there is any and we
+  # want to use it. We don't want to use it if the string from the command line
+  # is a absolute path or relative to the current directory.
+
+  if [[ -z "$tmp1[1]" || "$str[1]" = [~/] || "$str" = (.|..)/* ]]; then
+    tmp1=()
+  else
+    tmp1=(-W "( $ppres )")
+  fi
+
+  # Now call complist.
+
+  nm=$NMATCHES
+  if [[ $# -eq 0 ]]; then
+    complist "$tmp1[@]" -f
+  elif [[ "$1" = -g ]]; then
+    complist "$tmp1[@]" -g "$argv[2,-1]"
+    shift
+  else
+    complist "$tmp1[@]" $1
+    shift
+  fi
+
+  # If this generated any matches, we don't wnat to do in-path completion.
+
+  [[ -nmatches nm ]] || return
+
+  # No `-F' option, so we want to use `fignore'.
+
+  ignore=(-F fignore)
+fi
+
+# If we weren't given any file patterns as arguments, we trick ourselves
+# into believing that we were given the pattern `*'. This is just to simplify
+# the following code.
+
+[[ -z "$1" ]] && 1='*'
+
+# Now let's have a closer look at the string to complete.
+
+if [[ "$str[1]" = \~ ]]; then
+  # It begins with `~', so remember anything before the first slash to be able
+  # to report it to the completion code. Also get an expanded version of it
+  # (in `realpath'), so that we can generate the matches. Then remove that
+  # prefix from the string to complete, set `donepath' to build the correct
+  # paths and make sure that the loop below is run only once with an empty
+  # prefix path by setting `prepaths'.
+  
+  linepath="${str%%/*}/"
+  eval realpath\=path
+  str="${str#*/}"
+  donepath=''
+  prepaths=( '' )
+else
+  # If the string does not start with a `~' we don't remove a prefix from the
+  # string.
+
+  liniepath=''
+  realpath=''
+
+  if [[ "$str[1]" = / ]]; then
+    # If it is a absolut path name, we remove the first slash and put it in
+    # `donepath' meaning that we treat it as the path that was already handled.
+    # Also, we don't use the paths from `-W'.
+
+    str="$str[2,-1]"
+    donepath='/'
+    prepaths=( '' )
+  else
+    # The common case, we just use the string as it is, unless it begins with
+    # `./' or `../' in which case we don't use the paths from `-W'.
+    
+    [[ "$str" = (.|..)/* ]] && prepaths=( '' )
+    donepath=''
+  fi
+fi
+
+# First we skip over all pathname components in `str' which really exist in
+# the file-system, so that `/usr/lib/l<TAB>' doesn't offer you `lib' and
+# `lib5'. Pathname components skipped this way are taken from `str' and added
+# to `donepath'.
+
+while [[ "$str" = */* ]] do
+  [[ -e "$realpath$donepath${str%%/*}" ]] || break
+  donepath="$donepath${str%%/*}/"
+  str="${str#*/}"
+done
+
+# Now build the glob pattern. As noted above, this function behaves as if
+# a global matcher with two matching specifications are given.
+
+if [[ -matcher 1 ]]; then
+  patstr="$str:gs/,/*,/:gs/_/*_/:gs./.*/.:gs/-/*[-_]/:gs/./*[.,]/:gs-*[.,]*[.,]*/-../-:gs.**.*."
+else
+  patstr="${str%/*}/*${str##*/}*"
+  patstr="$patstr:gs./.*/.:gs.**.*."
+fi
+
+# Finally, generate the matches. First we loop over all the paths from `-W'.
+# Note that in this loop `str' is used as a modifyable version of `patstr'
+# and `testpath' is a modifyable version of `donepath'.
+
+for prepath in "$prepaths[@]"; do
+  str="$patstr"
+  testpath="$donepath"
+
+  # The second loop tests the components of the path in `str' to get the
+  # possible matches.
+
+  while [[ "$str" = */* ]] do
+    # `rest' is the pathname after the first slash that is left. In `tmp1'
+    # we get the globbing matches for the pathname component currently
+    # handled.
+
+    rest="${str#*/}"
+    tmp1="${prepath}${realpath}${testpath}(#l)${str%%/*}(-/)"
+    tmp1=( $~tmp1 )
+
+    if [[ $#tmp1 -eq 0 ]]; then
+      # If this didn't produce any matches, we don't need to test this path
+      # any further, so continue with the next `-W' path, if any.
+
+      continue 2
+    elif [[ $#tmp1 -gt 1 ]]; then
+      # If it produced more than one match, we want to remove those which
+      # don't have possible following pathname components matching the 
+      # rest of the string we are completing. (The case with only one
+      # match is handled below.)
+      # In `collect' we will collect those of the produced pathnames that
+      # have a matching possible path-suffix. In `suffixes' we build an
+      # array containing strings build from the rest of the string to 
+      # complete and the glob patterns we were given as arguments.
+
+      collect=()
+      suffixes=( $rest$@ )
+      suffixes=( "${(@)suffixes:gs.**.*.}" )
+
+      # In the loop the prefixes from the `tmp1' array produced above and
+      # the suffixes we just built are used to produce possible matches
+      # via globbing.
+
+      for i in $tmp1; do
+        tmp2=( $~i/(#l)$~suffixes )
+        [[ $#tmp2 -ne 0 ]] && collect=( $collect $i )
+      done
+
+      # If this test showed that none of the matches from the glob in `tmp1'
+      # has a possible sub-path matching what's on the line, we give up and
+      # continue with the next `-W' path.
+
+      if [[ $#collect -eq 0 ]]; then
+        continue 2
+      elif [[ $#collect -ne 1 ]]; then
+        # If we have more than one possible match, this means that the
+	# pathname component currently handled is ambiguous, so we give
+	# it to the completion code.
+	# First we build the full path prefix in `tmp1'.
+
+        tmp1="$prepath$realpath$testpath"
+
+	# Now produce all matching pathnames in `collect'.
+
+        collect=( $~collect/(#l)$~suffixes )
+
+	# And then remove the common path prefix from all these matches.
+
+        collect=( ${collect#$tmp1} )
+
+	# Finally, we add all these matches with the common (unexpanded)
+	# pathprefix (the `-p' option), the path-prefix (the `-W' option)
+	# to allow the completion code to test file type, and the path-
+	# suffix (the `-s' option). We also tell the completion code that
+	# these are file names and that `fignore' should be used as usual
+	# (the `-f' and `-F' options).
+
+        for i in $collect; do
+          compadd -p "$linepath$testpath" -W "$tmp1" -s "/${i#*/}" -f "$ignore[@]" -- "${i%%/*}"
+        done
+
+	# We have just finished handling all the matches from above, so we
+	# can continue with the next `-W' path.
+
+	continue 2
+      fi
+      # We reach this point if only one of the path prefixes in `tmp1'
+      # has a existing path-suffix matching the string from the line.
+      # In this case we accept this match and continue with the next
+      # path-name component.
+
+      tmp1=( "$collect[1]" )
+    fi
+    # This is also reached if the first globbing produced only one match
+    # in this case we just continue with the next pathname component, too.
+
+    tmp1="$tmp1[1]"
+    testpath="$testpath${tmp1##*/}/"
+    str="$rest"
+  done
+
+  # We are here if all pathname components except the last one (which is still
+  # not tested) are unambiguous. So we add matches with the full path prefix, 
+  # no path suffix, the `-W' we are currently handling, all the matches we
+  # can produce in this directory, if any.
+
+  tmp1="$prepath$realpath$testpath"
+  suffixes=( $str$@ )
+  suffixes=( "${(@)suffixes:gs.**.*.}" )
+  tmp2=( $~tmp1(#l)$~suffixes )
+  compadd -p "$linepath$testpath" -W "$prepath$realpath$testpath" -f "$ignore[@]" -- ${tmp2#$tmp1}
+done
diff --git a/Functions/Completion/__pdf b/Functions/Completion/__pdf
new file mode 100644
index 000000000..97f656f40
--- /dev/null
+++ b/Functions/Completion/__pdf
@@ -0,0 +1,3 @@
+function acroread
+
+__files -g '*.(pdf|PDF)'
diff --git a/Functions/Completion/__precommand b/Functions/Completion/__precommand
new file mode 100644
index 000000000..a07cae96a
--- /dev/null
+++ b/Functions/Completion/__precommand
@@ -0,0 +1,15 @@
+#function - nohup nice eval time rusage noglob nocorrect exec
+
+# We just change the special completion parameters, to make the first
+# argument be treated as the command name and removing it from the 
+# positional parameters.
+
+COMMAND="$1"
+shift
+(( CURRENT-- ))
+if [[ CURRENT -eq 0 ]]; then
+  CONTEXT=command
+else
+  CONTEXT=argument
+fi
+compsub
diff --git a/Functions/Completion/__ps b/Functions/Completion/__ps
new file mode 100644
index 000000000..fa7395113
--- /dev/null
+++ b/Functions/Completion/__ps
@@ -0,0 +1,3 @@
+#function  gs ghostview gview psnup psselect pswrap pstops pstruct lpr
+
+__files -g '*([pP][sS]|eps)'
diff --git a/Functions/Completion/__rcs b/Functions/Completion/__rcs
new file mode 100644
index 000000000..8d55cc470
--- /dev/null
+++ b/Functions/Completion/__rcs
@@ -0,0 +1,9 @@
+#function co ci rcs
+
+[[ $COMMAND = ci || $COMMAND = rcs ]] && __files
+
+if [[ $NMATCHES -eq 0 && -d RCS && $COMMAND != ci ]]; then
+  local rep
+  rep=(RCS/$PREFIX*$SUFFIX,v(:t:s/\,v//))
+  (( $#rep )) && compadd -m $rep
+fi
diff --git a/Functions/Completion/__rlogin b/Functions/Completion/__rlogin
new file mode 100644
index 000000000..69fdebe13
--- /dev/null
+++ b/Functions/Completion/__rlogin
@@ -0,0 +1,9 @@
+#function rlogin rsh ssh
+
+if [[ -position 1 ]]; then
+  complist -k hosts
+elif [[ -position 2 ]]; then
+  complist -k '(-l)'
+else
+  complist -u
+fi
diff --git a/Functions/Completion/__sched b/Functions/Completion/__sched
new file mode 100644
index 000000000..dcd7385e1
--- /dev/null
+++ b/Functions/Completion/__sched
@@ -0,0 +1,3 @@
+#function sched
+
+[[ -position 2 -1 ]] && compsub
diff --git a/Functions/Completion/__set b/Functions/Completion/__set
new file mode 100644
index 000000000..e9db6c43a
--- /dev/null
+++ b/Functions/Completion/__set
@@ -0,0 +1,7 @@
+#function  set
+
+if [[ -mcurrent -1 [-+]o ]]; then
+  complist -o
+elif [[ -current -1 -A ]]; then
+  complist -A
+fi
diff --git a/Functions/Completion/__setopt b/Functions/Completion/__setopt
new file mode 100644
index 000000000..8a97befc7
--- /dev/null
+++ b/Functions/Completion/__setopt
@@ -0,0 +1,7 @@
+#function setopt
+
+local nm=$NMATCHES
+
+complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \
+         -s '$({ unsetopt kshoptionprint; unsetopt } 2>/dev/null)'
+[[ -nmatches nm ]] && complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' -o
diff --git a/Functions/Completion/__source b/Functions/Completion/__source
new file mode 100644
index 000000000..3478c9f38
--- /dev/null
+++ b/Functions/Completion/__source
@@ -0,0 +1,7 @@
+#function source
+
+if [[ -position 2 -1 ]]; then
+  compsub
+else
+  __files
+fi
diff --git a/Functions/Completion/__strip b/Functions/Completion/__strip
new file mode 100644
index 000000000..9abd38b63
--- /dev/null
+++ b/Functions/Completion/__strip
@@ -0,0 +1,2 @@
+#function strip
+__files -g '*(*)'
diff --git a/Functions/Completion/__stty b/Functions/Completion/__stty
new file mode 100644
index 000000000..ebf0de68f
--- /dev/null
+++ b/Functions/Completion/__stty
@@ -0,0 +1,16 @@
+#function stty
+
+if [[ -mcurrent -1 \
+  (*erase|discard|status|dsusp|intr|kill|lnext|quit|reprint|start|s*p) ]]
+then
+     compadd -m -Q '^-' '^h' '^?' '^c' '^u'
+else
+  [[ -string '-' || -string '+' ]]
+  compadd -m rows columns intr quit erase kill eof eol \
+    eol2 start stop susp dsusp reprint discard werase lnext \
+    parenb parodd cs8 cstopb hupcl cread clocal parext \
+    ignbrk brkint ignpar parmrk inpck istrip inlcr igncr icrnl iuclc \
+    ixon ixany ixoff imaxbel isig icanon xcase echo echoe echok \
+    echonl noflsh tostop echoctl echoprt echoke flusho pending iexten \
+    opost olcuc onlcr ocrnl onocr onlret ofill ofdel 
+fi
diff --git a/Functions/Completion/__subscript b/Functions/Completion/__subscript
new file mode 100644
index 000000000..a10b1202b
--- /dev/null
+++ b/Functions/Completion/__subscript
@@ -0,0 +1,4 @@
+#function --subscript--
+
+compalso --math-- "$@"
+[[ ${(Pt)${COMMAND}} = assoc* ]] && complist -k "( ${(kP)${COMMAND}} )"
diff --git a/Functions/Completion/__tar b/Functions/Completion/__tar
new file mode 100644
index 000000000..4f8b51a00
--- /dev/null
+++ b/Functions/Completion/__tar
@@ -0,0 +1,14 @@
+#function tar
+
+local nm=$NMATCHES tf="$2"
+compsave
+
+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
diff --git a/Functions/Completion/__tex b/Functions/Completion/__tex
new file mode 100644
index 000000000..7331bb794
--- /dev/null
+++ b/Functions/Completion/__tex
@@ -0,0 +1,3 @@
+#function tex latex slitex
+
+__files -g '*.(tex|TEX|texinfo|texi)'
diff --git a/Functions/Completion/__trap b/Functions/Completion/__trap
new file mode 100644
index 000000000..0171bdc2b
--- /dev/null
+++ b/Functions/Completion/__trap
@@ -0,0 +1,7 @@
+#function trap
+
+if [[ -position 1 ]]; then
+  complist -c
+else
+  complist -k signals
+fi
diff --git a/Functions/Completion/__uncompress b/Functions/Completion/__uncompress
new file mode 100644
index 000000000..91343521e
--- /dev/null
+++ b/Functions/Completion/__uncompress
@@ -0,0 +1,3 @@
+#function uncompress zmore
+
+__files -g '*.Z'
diff --git a/Functions/Completion/__unhash b/Functions/Completion/__unhash
new file mode 100644
index 000000000..73196ca1b
--- /dev/null
+++ b/Functions/Completion/__unhash
@@ -0,0 +1,6 @@
+#function unhash
+
+[[ -mword 1 -*d* ]] && complist -n
+[[ -mword 1 -*a* ]] && complist -a
+[[ -mword 1 -*f* ]] && complist -F
+[[ ! -mword 1 -* ]] && complist -m
diff --git a/Functions/Completion/__unsetopt b/Functions/Completion/__unsetopt
new file mode 100644
index 000000000..c9a074d9b
--- /dev/null
+++ b/Functions/Completion/__unsetopt
@@ -0,0 +1,7 @@
+#function unsetopt
+
+local nm=$NMATCHES
+
+complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \
+         -s '$({ unsetopt kshoptionprint; setopt } 2>/dev/null)'
+[[ -nmatches nm ]] && complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' -o
diff --git a/Functions/Completion/__vars b/Functions/Completion/__vars
new file mode 100644
index 000000000..649e347fa
--- /dev/null
+++ b/Functions/Completion/__vars
@@ -0,0 +1,2 @@
+#array --math-- getopts read unset vared
+__vars=(-v)
diff --git a/Functions/Completion/__vars_eq b/Functions/Completion/__vars_eq
new file mode 100644
index 000000000..e0b5d9ae5
--- /dev/null
+++ b/Functions/Completion/__vars_eq
@@ -0,0 +1,2 @@
+#array declare export integer local readonly typeset
+__varseq=(-v -q -S '=')
diff --git a/Functions/Completion/__wait b/Functions/Completion/__wait
new file mode 100644
index 000000000..1c04108f6
--- /dev/null
+++ b/Functions/Completion/__wait
@@ -0,0 +1,4 @@
+#function wait
+
+complist -P '%' -j
+complist -y __kill_helper -s '`ps 2>/dev/null | tail +2 | cut -c1-5`'
diff --git a/Functions/Completion/__which b/Functions/Completion/__which
new file mode 100644
index 000000000..32b95b9c5
--- /dev/null
+++ b/Functions/Completion/__which
@@ -0,0 +1,2 @@
+#array which whence where type
+__which=(-caF)
diff --git a/Functions/Completion/__x_options b/Functions/Completion/__x_options
new file mode 100644
index 000000000..d5f85ea36
--- /dev/null
+++ b/Functions/Completion/__x_options
@@ -0,0 +1,5 @@
+#pattern-function '*/X11/*'
+
+# A simple pattern completion, just as an example.
+
+complist -J options -k '(-display -name -xrm)'
diff --git a/Functions/Completion/__xfig b/Functions/Completion/__xfig
new file mode 100644
index 000000000..7f17c2e42
--- /dev/null
+++ b/Functions/Completion/__xfig
@@ -0,0 +1,3 @@
+#function xfig
+
+__files -g '*.fig'
diff --git a/Functions/Completion/__zle b/Functions/Completion/__zle
new file mode 100644
index 000000000..f677374c8
--- /dev/null
+++ b/Functions/Completion/__zle
@@ -0,0 +1,7 @@
+#function zle
+
+if [[ -word 1 -N && -position 3 ]]; then
+  complist -F
+else
+  complist -b
+fi
diff --git a/Functions/Completion/__zmodload b/Functions/Completion/__zmodload
new file mode 100644
index 000000000..78c7393a3
--- /dev/null
+++ b/Functions/Completion/__zmodload
@@ -0,0 +1,9 @@
+#function zmodload
+
+if [[ -mword 1 -*(a*u|u*a)* || -mword 1 -*a* && -position 3 -1 ]]; then
+  complist -B
+elif [[ -mword 1 -*u* ]]; then
+  complist -s '$(zmodload)'
+else
+  complist -s '${^module_path}/*(N:t:r)'
+fi
diff --git a/Functions/Completion/init b/Functions/Completion/init
new file mode 100644
index 000000000..a40c5f61b
--- /dev/null
+++ b/Functions/Completion/init
@@ -0,0 +1,253 @@
+# Initialisation for new style completion. This mainly contains some helper
+# function and aliases. Everything else is split into different files in this
+# directory that will automatically be made autoloaded (see the end of this
+# file).
+# The names of the files that will be considered for autoloading have to
+# start with two underscores (like `__setopt).
+# The first line of these files will be read and has to say what should be
+# done with its contents:
+#
+#   `#function <names ...>'
+#     if the first line looks like this, the file is
+#     autoloaded as a function and that function will
+#     be called to generate the matches when completing
+#     for one of the commands whose <name> is given
+#
+#   `#array <names ...>'
+#     with a first line like this, the filename is taken as
+#     the name of an array; when trying to generate matches
+#     for the command <name>, the file will be sourced and
+#     should define this array, the builtin `complist' will
+#     then be called with the elements of this array as its
+#     arguments; this is intended for simple definitions
+#     for which you don't need a shell function
+#
+#   `#pattern-function <pattern>'
+#     this defines a function that should be called to generate
+#     matches for commands whose name matches <pattern>; note
+#     that only one pattern may be given
+#
+#   `#pattern-array <pattern>'
+#     like `#pattern-function' but defining an array
+#
+#   `#key-function <style> [ <key-sequence> ... ]
+#     this is used to bind special completions to all the given
+#     <key-sequence>(s). The <style> is the name of one of the built-in
+#     completion widgets (complete-word, delete-char-or-list,
+#     expand-or-complete, expand-or-complete-prefix, list-choices,
+#     menu-complete, menu-expand-or-complete, or reverse-menu-complete).
+#     This creates a widget behaving like <style> so that the
+#     completions are chosen as given in the the rest of the file,
+#     rather than by the context.  The widget has the same name as
+#     the autoload file and can be bound using bindkey in the normal way.
+#
+#   `#key-array <style> [ <key-sequence> ... ]
+#     like `#key-function', but defining an array instead
+#
+#   `#helper'
+#     this is for helper functions that are not used to
+#     generate matches, but should automatically be loaded
+#     when they are called
+#
+# Note that no white space is allowed between the `#' and the rest of
+# the string.
+
+
+# An associative array for completions definitions. The keys of the entries
+# are the names of the command, the values are names of functions or variables
+# that are to be used to generate the matches.
+# Pattern completions will be stored in an normal array named `patcomps'.
+# Completion definitions bound directly to keys are stored in an assoc array
+# named `keycomps'.
+
+typeset -A comps
+typeset -A keycomps
+
+
+# This may be used to define completion handlers. The first argument is the
+# name of the function or 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.
+# If given the `-a' option, the function is defined as being autoloaded.
+
+defcomp() {
+  local name autol=''
+
+  if [[ "$1" = -a ]]; then
+    shift
+    autol=yes
+  fi
+  if [[ $# -eq 1 ]]; then
+    comps[$1]="__$1"
+    [[ -z "$autol" ]] || autoload "__$1"
+  else
+    name="$1"
+    shift
+    for i; do
+      comps[$i]="$name"
+    done
+    [[ -z "$autol" ]] || autoload "$name"
+  fi
+}
+
+
+# Almost like `defcomp', but this always gets two arguments: the name of a
+# variable or function describing what should be completed and the pattern
+# that will be compared to the command names for which completion is attempted.
+
+defpatcomp() {
+  if [[ "$1" = -a ]]; then
+    shift
+    autoload "$1"
+  fi
+  if (( $+patcomps )) then
+    patcomps=("$patcomps[@]" "$2 $1" )
+  else
+    patcomps=( "$2 $1" )
+  fi
+}
+
+
+# This is used to define completion handlers directly bound to keys. The
+# first argument is as for `defcomp', giving the handler. The second
+# argument is the name of one of the built-in completion widgets. Any
+# remaining arguments are used as key sequences to bind the widget.
+# Typing that key sequence will complete the word the cursor is on
+# according to the completion definition given and will behave as if the
+# built-in completion widget was used.
+
+defkeycomp() {
+  local name
+
+  if [[ "$1" = -a ]]; then
+    shift
+    autoload "$1"
+    name="$1"
+  elif [[ "${1[1]}" = ' ' ]]; then
+    name="${1:t}"
+  else
+    name="$1"
+  fi
+  keycomps[$name]="$1"
+  shift
+  zle -C "$name" "$1" __main_key_complete
+  shift
+  while (( $# )); do
+    bindkey "$1" "$name"
+    shift
+  done
+}
+
+# These can be used to easily save and restore the state of the special
+# variables used by the completion code.
+
+alias compsave='local _oprefix _oiprefix _oargv _ocurrent; \
+                _oprefix="$PREFIX"; \
+                _oiprefix="$IPREFIX"; \
+                _oargv=( "$@" ); \
+                _ocurrent="$CURRENT"'
+alias compreset='PREFIX="$_oprefix"; \
+                 IPREFIX="$_oiprefix"; \
+                 argv=( "$_oargv[@]" ); \
+		 CURRENT="$_ocur"'
+
+
+# This is an easy way to get completion for sub-commands.
+
+alias compsub='__normal "$@" || return 1'
+
+
+# This searches $1 in the array for normal completions and calls the result.
+
+compalso() {
+  local tmp
+
+  tmp="$comps[$1]"
+  [[ -z "$tmp" ]] || callcomplete comps "$1" "$@"
+}
+
+
+# This generates matches. The first argument is the name of one of the
+# arrays containing completion definitions. The second argument is the index
+# into this array. The other arguments are the positional parameters to give
+# to the completion function (containing the arguments from the command line).
+
+callcomplete() {
+  local file def
+
+  # Get the definition from the array.
+
+  eval "def=\$${1}[${2}]"
+
+  # If the definition starts with a space then this means that we should
+  # source a file to get the definition for an array.
+
+  if [[ "$def[1]" = ' ' ]]; then
+    # The definition starts with a space, so source the file and change
+    # the definition.
+
+    file="$def[2,-1]"
+    builtin . "$file"
+    def="${file:t}"
+    eval "${1}[${2}]=$def"
+  fi
+
+  # Get rid of the array-name and -index.
+
+  shift 2
+  if [[ ${(P)+def} -eq 1 ]]; then
+    # It is a parameter name, call complist directly.
+
+    complist "${(@P)def}"
+  else
+    # Otherwise it's a function name, call this function.
+
+    "$def" "$@"
+  fi
+}
+
+
+# Now we make the files automatically autoloaded.
+
+local dir file line func
+
+for dir in $fpath; do
+  [[ $dir = . ]] && continue
+  for file in $dir/__*~*~(N); do
+    read -rA line < $file
+    func=$line[1]
+    shift line
+    if [[ $func = '#function' ]]; then
+      defcomp -a ${file:t} "${line[@]}"
+    elif [[ $func = '#array' ]]; then
+      defcomp " $file" "${line[@]}"
+    elif [[ $func = '#pattern-function' ]]; then
+      defpatcomp -a ${file:t} "${line[@]}"
+    elif [[ $func = '#pattern-array' ]]; then
+      defcomp " $file" "${line[@]}"
+    elif [[ $func = '#key-function' ]]; then
+      defkeycomp -a "${file:t}" "${line[@]}"
+    elif [[ $func = '#key-array' ]]; then
+      defkeycomp " $file" "${line[@]}"
+    elif [[ $func = '#helper' ]]; then
+      autoload ${file:t}
+    fi
+  done
+done
+
+
+# Finally we make all this be called by changing the key bindings.
+
+bindkey | while read -A line; do
+            if [[ "$line[2]" = complete-word ||
+	    	  "$line[2]" = delete-char-or-list ||
+	    	  "$line[2]" = expand-or-complete ||
+	    	  "$line[2]" = expand-or-complete-prefix ||
+	    	  "$line[2]" = list-choices ||
+	    	  "$line[2]" = menu-complete ||
+	    	  "$line[2]" = menu-expand-or-complete ||
+	    	  "$line[2]" = reverse-menu-complete ]]; then
+              zle -C __complete_$line[2] $line[2] __main_complete
+              bindkey "${line[1][2,-2]}" __complete_$line[2]
+            fi
+          done
diff --git a/Functions/allopt b/Functions/allopt
new file mode 100644
index 000000000..604e76198
--- /dev/null
+++ b/Functions/allopt
@@ -0,0 +1,29 @@
+# This function lists options with the no's in front removed for
+# improved comprehension, i.e. `norcs off' becomes `rcs on'.
+# The format is otherwise like that with `kshoptionprint' set,
+# i.e. you can see all options whether on or off.
+# It can take a list of option names or parts thereof to search for
+# via egrep.
+#
+# Written by Sweth Chandramouli with hacks by Bart Schaefer.
+
+listalloptions () {
+   emulate -R zsh
+   builtin setopt localoptions kshoptionprint
+   local OPT_NAME OPT_PAIR OPT_VALUE
+   for OPT_PAIR in "${(f)$(builtin setopt)}" ; do
+      OPT_VALUE=${OPT_PAIR##* }
+      OPT_NAME=${OPT_PAIR%% *}
+      if [[ ${OPT_NAME#no} != ${OPT_NAME} ]] ; then
+         OPT_VALUE=${(L)${${OPT_VALUE:s/on/OFF}:s/off/on}} &&
+            OPT_NAME=${OPT_NAME#no};
+      fi;
+      echo ${(r:21:)OPT_NAME} ${OPT_VALUE}
+   done
+}
+
+if [[ -n $@ ]]; then
+    listalloptions | egrep "${(j.|.)@}"
+else
+    listalloptions
+fi
-- 
cgit 1.4.1