From 1e3caef58dab6f2456d5d9b81548359b64d28c3c Mon Sep 17 00:00:00 2001
From: Sven Wischnowsky <wischnow@users.sourceforge.net>
Date: Mon, 2 Apr 2001 11:02:05 +0000
Subject: moved from Completion/Core/compinit

---
 Completion/compinit | 483 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 483 insertions(+)
 create mode 100644 Completion/compinit

(limited to 'Completion/compinit')

diff --git a/Completion/compinit b/Completion/compinit
new file mode 100644
index 000000000..172fafc03
--- /dev/null
+++ b/Completion/compinit
@@ -0,0 +1,483 @@
+# Initialisation for new style completion. This mainly contains some helper
+# functions and aliases. Everything else is split into different files that
+# will automatically be made autoloaded (see the end of this file).  The
+# names of the files that will be considered for autoloading are those that
+# begin with an underscores (like `_setopt').
+#
+# The first line of each of these files is read and must indicate what
+# should be done with its contents:
+#
+#   `#compdef <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 <names> are given.
+#
+#   `#compdef -p <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.
+#
+#   `#compdef -k <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.
+#
+#   `#compdef -K <widget-name> <style> <key-sequence> [ ... ]'
+#     This is similar to -k, except it takes any number of sets of
+#     three arguments.  In each set, the widget <widget-name> will
+#     be defined, which will behave as <style>, as with -k, and will
+#     be bound to <key-sequence>, exactly one of which must be defined.
+#     <widget-name> must be different for each:  this must begin with an
+#     underscore, else one will be added, and should not clash with other
+#     completion widgets (names based on the name of the function are the
+#     clearest), but is otherwise arbitrary.  It can be tested in the
+#     function by the parameter $WIDGET.
+#
+#   `#autoload [ <options> ]'
+#     This is for helper functions that are not used to
+#     generate matches, but should automatically be loaded
+#     when they are called. The <options> will be given to the
+#     autoload builtin when making the function autoloaded. Note
+#     that this need not include `-U'.
+#
+# Note that no white space is allowed between the `#' and the rest of
+# the string.
+#
+# Functions that are used to generate matches should return zero if they
+# were able to add matches and non-zero otherwise.
+#
+# See the file `compdump' for how to speed up initialisation.
+
+# If we got the `-d'-flag, we will automatically dump the new state (at
+# the end).  This takes the dumpfile as an argument.  -d (with the
+# default dumpfile) is now the default; to turn off dumping use -D.
+
+# The -C flag bypasses both the check for rebuilding the dump file and the
+# usual call to compaudit; the -i flag causes insecure directories found by
+# compaudit to be ignored, and the -u flag causes all directories found by
+# compaudit to be used (without security checking).  Otherwise the user is
+# queried for whether to use or ignore the insecure directories (which
+# means compinit should not be called from non-interactive shells).
+
+emulate -L zsh
+setopt extendedglob
+
+typeset _i_dumpfile _i_files _i_line _i_done _i_dir _i_autodump=1
+typeset _i_tag _i_file _i_addfiles _i_fail=ask _i_check=yes _i_name
+
+while [[ $# -gt 0 && $1 = -[dDiuC] ]]; do
+  case "$1" in
+  -d)
+    _i_autodump=1
+    shift
+    if [[ $# -gt 0 && "$1" != -[dfQC] ]]; then
+      _i_dumpfile="$1"
+      shift
+    fi
+    ;;
+  -D)
+    _i_autodump=0
+    shift
+    ;;
+  -i)
+    _i_fail=ign
+    shift
+    ;;
+  -u)
+    _i_fail=use
+    shift
+    ;;
+  -C)
+    _i_check=
+    shift
+    ;;
+  esac
+done
+
+# The associative array containing the definitions for the commands and
+# services.
+# Definitions for patterns will be stored in the associations `_patcomps'
+# and `_postpatcomps'. `_compautos' contains the names and options
+# for autoloaded functions that get options.
+
+typeset -gA _comps _services _patcomps _postpatcomps _compautos
+
+# The associative array use to report information about the last
+# completion to the outside.
+
+typeset -gA _lastcomp
+
+# Remember dumpfile.
+if [[ -n $_i_dumpfile ]]; then
+  # Explicitly supplied dumpfile.
+  _comp_dumpfile="$_i_dumpfile"
+else
+  _comp_dumpfile="${ZDOTDIR:-$HOME}/.zcompdump"
+fi
+
+# The standard options set in completion functions.
+
+_comp_options=(
+       glob
+       bareglobqual
+       nullglob
+       rcexpandparam
+       extendedglob
+       unset
+    NO_markdirs
+    NO_globsubst
+    NO_shwordsplit
+    NO_shglob
+    NO_ksharrays
+    NO_cshnullglob
+    NO_allexport
+    NO_aliases
+)
+
+# These can hold names of functions that are to be called before/after all
+# matches have been generated.
+
+compprefuncs=()
+comppostfuncs=()
+
+# Loading it now ensures that the `funcstack' parameter is always correct.
+
+: $funcstack
+
+# This function is used to register or delete completion functions. For
+# registering completion functions, it is invoked with the name of the
+# function as it's first argument (after the options). The other
+# arguments depend on what type of completion function is defined. If
+# none of the `-p' and `-k' options is given a function for a command is
+# defined. The arguments after the function name are then interpreted as
+# the names of the command for which the function generates matches.
+# With the `-p' option a function for a name pattern is defined. This 
+# function will be invoked when completing for a command whose name 
+# matches the pattern given as argument after the function name (in this
+# case only one argument is accepted).
+# The option `-P' is like `-p', but the function will be called after
+# trying to find a function defined for the command on the line if no
+# such function could be found.
+# With the `-k' option a function for a special completion keys is 
+# defined and immediately bound to those keys. Here, the extra arguments
+# are the name of one of the builtin completion widgets and any number
+# of key specifications as accepted by the `bindkey' builtin.
+# In any case the `-a' option may be given which makes the function
+# whose name is given as the first argument be autoloaded. When defining
+# a function for command names the `-n' option may be given and keeps
+# the definitions from overriding any previous definitions for the
+# commands; with `-k', the `-n' option prevents compdef from rebinding
+# a key sequence which is already bound.
+# For deleting definitions, the `-d' option must be given. Without the
+# `-p' option, this deletes definitions for functions for the commands
+# whose names are given as arguments. If combined with the `-p' option
+# it deletes the definitions for the patterns given as argument.
+# The `-d' option may not be combined with the `-k' option, i.e.
+# definitions for key function can not be removed.
+#
+# Examples:
+#
+#  compdef -a foo bar baz
+#    make the completion for the commands `bar' and `baz' use the
+#    function `foo' and make this function be autoloaded
+#
+#  compdef -p foo 'c*'
+#    make completion for all command whose name begins with a `c'
+#    generate matches by calling the function `foo' before generating
+#    matches defined for the command itself
+#
+#  compdef -k foo list-choices '^X^M' '\C-xm'
+#    make the function `foo' be invoked when typing `Control-X Control-M'
+#    or `Control-X m'; the function should generate matches and will
+#    behave like the `list-choices' builtin widget
+#
+#  compdef -d bar baz
+#   delete the definitions for the command names `bar' and `baz'
+
+compdef() {
+  local opt autol type func delete new i ret=0 cmd svc
+
+  # Get the options.
+
+  if [[ $#* -eq 0 ]]; then
+    echo "$0: I needs arguments"
+    return 1
+  fi
+  
+  while getopts "anpPkKd" opt; do
+    case "$opt" in
+    a)    autol=yes;;
+    n)    new=yes;;
+    [pPkK]) if [[ -n "$type" ]]; then
+            # Error if both `-p' and `-k' are given (or one of them
+	    # twice).
+            echo "$0: type already set to $type"
+	    return 1
+	  fi
+	  if [[ "$opt" = p ]]; then
+	    type=pattern
+	  elif [[ "$opt" = P ]]; then
+	    type=postpattern
+	  elif [[ "$opt" = K ]]; then
+	    type=widgetkey
+	  else
+	    type=key
+	  fi
+	  ;;
+    d) delete=yes;;
+    esac
+  done
+  shift OPTIND-1
+
+  if [[ $#* -eq 0 ]]; then
+    echo "$0: I needs arguments"
+    return 1
+  fi
+  
+  if [[ -z "$delete" ]]; then
+    # If the first word contains an equal sign, all words must contain one
+    # and we define which services to use for the commands.
+
+    if [[ "$1" = *\=* ]]; then
+      for i; do
+        if [[ "$i" = *\=* ]]; then
+	  cmd="${i%%\=*}"
+	  svc="${i#*\=}"
+          func="$_comps[${(k)_services[(R)$svc]:-$svc}]"
+          (( $+_services[$svc] )) && svc=$_services[$svc]
+	  [[ -z "$func" ]] &&
+	    func="${_patcomps[(K)$svc][1]:-${_postpatcomps[(K)$svc][1]}}"
+          if [[ -n "$func" ]]; then
+	    _comps[$cmd]="$func"
+	    _services[$cmd]="$svc"
+	  else
+	    echo "$0: unknown command or service: $svc"
+	    ret=1
+	  fi
+	else
+	  echo "$0: invalid argument: $i"
+	  ret=1
+	fi
+      done
+
+      return ret
+    fi
+
+    # Adding definitions, first get the name of the function name
+    # and probably do autoloading.
+
+    func="$1"
+    [[ -n "$autol" ]] && autoload -U "$func"
+    shift
+
+    case "$type" in
+    pattern)
+      if [[ $# -gt 1 ]]; then
+        echo "$0: only one pattern allowed"
+	return 1
+      fi
+      _patcomps[$1]="$func"
+      ;;
+    postpattern)
+      if [[ $# -gt 1 ]]; then
+        echo "$0: only one pattern allowed"
+	return 1
+      fi
+      _postpatcomps[$1]="$func"
+      ;;
+    widgetkey)
+      while [[ -n $1 ]]; do
+	if [[ $# -lt 3 ]]; then
+	  echo "$0: compdef -K requires <widget> <comp-widget> <key>"
+	  return 1
+	fi
+	[[ $1 = _* ]] || 1="_$1"
+	[[ $2 = .* ]] || 2=".$2"
+        [[ $2 = .menu-select ]] && zmodload -i zsh/complist
+	zle -C "$1" "$2" "$func"
+	if [[ -n $new ]]; then
+	  bindkey "$3" | read -A opt
+	  [[ $opt[-1] = undefined-key ]] && bindkey "$3" "$1"
+	else
+	  bindkey "$3" "$1"
+	fi
+	shift 3
+      done
+      ;;	 
+    key)
+      if [[ $# -lt 2 ]]; then
+        echo "$0: missing keys"
+	return 1
+      fi
+
+      # Define the widget.
+      if [[ $1 = .* ]]; then
+        [[ $1 = .menu-select ]] && zmodload -i zsh/complist
+	zle -C "$func" "$1" "$func"
+      else
+        [[ $1 = menu-select ]] && zmodload -i zsh/complist
+	zle -C "$func" ".$1" "$func"
+      fi
+      shift
+
+      # And bind the keys...
+      for i; do
+        if [[ -n $new ]]; then
+	   bindkey "$i" | read -A opt
+	   [[ $opt[-1] = undefined-key ]] || continue
+	fi
+        bindkey "$i" "$func"
+      done
+      ;;
+    *)
+      # For commands store the function name in the `_comps'
+      # associative array, command names as keys.
+      for i; do
+        if [[ "$i" = *\=* ]]; then
+	  cmd="${i%%\=*}"
+	  svc=yes
+        else
+	  cmd="$i"
+	  svc=
+        fi
+        if [[ -z "$new" || "${+_comps[$i]}" -eq 0 ]]; then
+          _comps[$cmd]="$func"
+	  [[ -n "$svc" ]] && _services[$cmd]="${i#*\=}"
+	fi
+      done
+      ;;
+    esac
+  else
+    # Handle the `-d' option, deleting.
+    case "$type" in
+    pattern)
+      unset "_patcomps[$^@]"
+      ;;
+    postpattern)
+      unset "_postpatcomps[$^@]"
+      ;;
+    key)
+      # Oops, cannot do that yet.
+
+      echo "$0: cannot restore key bindings"
+      return 1v
+      ;;
+    *)
+      unset "_comps[$^@]"
+    esac
+  fi
+}
+
+# Now we automatically make the definition files autoloaded.
+
+typeset _i_wdirs _i_wfiles
+
+_i_wdirs=()
+_i_wfiles=()
+
+autoload -U compaudit
+if [[ -n "$_i_check" ]]; then
+  typeset _i_q
+  if ! eval compaudit; then
+    if [[ -n "$_i_q" ]]; then
+      if [[ "$_i_fail" = ask ]]; then
+        if ! read -q "?There are insecure $_i_q, use them anyway [ny]? "; then
+          unfunction compinit compdef
+          unset _comp_dumpfile _comp_secure compprefuncs comppostfuncs \
+                _comps _patcomps _postpatcomps _compautos _lastcomp
+
+          return 1
+        fi
+        _i_wfiles=()
+	_i_wdirs=()
+      else
+        (( $#_i_wfiles )) && _i_files=( "${(@)_i_files:#(${(j:|:)_i_wfiles%.zwc})}"  )
+        (( $#_i_wdirs ))  && _i_files=( "${(@)_i_files:#(${(j:|:)_i_wdirs%.zwc})/*}" )
+      fi
+    fi
+    _comp_secure=yes
+  fi
+fi
+
+# Make sure compdump is available, even if we aren't going to use it.
+autoload -U compdump compinstall
+
+# If we have a dump file, load it.
+
+_i_done=''
+
+if [[ -f "$_comp_dumpfile" ]]; then
+  if [[ -n "$_i_check" ]]; then
+    read -rA _i_line < "$_comp_dumpfile"
+    if [[ _i_autodump -eq 1 && $_i_line[2] -eq $#_i_files ]]; then
+      builtin . "$_comp_dumpfile"
+      _i_done=yes
+    fi
+  else
+    builtin . "$_comp_dumpfile"
+    _i_done=yes
+  fi
+fi
+if [[ -z "$_i_done" ]]; then
+  typeset -A _i_test
+
+  for _i_dir in $fpath; do
+    [[ $_i_dir = . ]] && continue
+    (( $_i_wdirs[(I)$_i_dir] )) && continue
+    for _i_file in $_i_dir/^([^_]*|*~|*.zwc)(N); do
+      _i_name="${_i_file:t}"
+      (( $+_i_test[$_i_name] + $_i_wfiles[(I)$_i_file] )) && continue
+      _i_test[$_i_name]=yes
+      read -rA _i_line < $_i_file
+      _i_tag=$_i_line[1]
+      shift _i_line
+      case $_i_tag in
+      (\#compdef)
+	if [[ $_i_line[1] = -[pPkK](n|) ]]; then
+	  compdef ${_i_line[1]}na "${_i_name}" "${(@)_i_line[2,-1]}"
+	else
+	  compdef -na "${_i_name}" "${_i_line[@]}"
+	fi
+	;;
+      (\#autoload)
+	autoload -U "$_i_line[@]" ${_i_name}
+	[[ "$_i_line" != \ # ]] && _compautos[${_i_name}]="$_i_line"
+	;;
+      esac
+    done
+  done
+
+  # If autodumping was requested, do it now.
+
+  if [[ $_i_autodump = 1 ]]; then
+    compdump
+  fi
+fi
+
+# Rebind the standard widgets
+for _i_line in complete-word delete-char-or-list expand-or-complete \
+  expand-or-complete-prefix list-choices menu-complete \
+  menu-expand-or-complete reverse-menu-complete; do
+  zle -C $_i_line .$_i_line _main_complete
+done
+zle -la menu-select && zle -C menu-select .menu-select _main_complete
+
+# If the default completer set includes _expand, and tab is bound
+# to expand-or-complete, rebind it to complete-word instead.
+bindkey '^i' | read -A _i_line
+if [[ ${_i_line[2]} = expand-or-complete ]] &&
+  zstyle -a ':completion:' completer _i_line &&
+  (( ${_i_line[(i)_expand]} <= ${#_i_line} )); then
+  bindkey '^i' complete-word
+fi
+
+unfunction compinit compaudit
+autoload -U compinit compaudit
+
+return 0
-- 
cgit 1.4.1