From eae553d33801ace0647d78971ef7f0781705472a Mon Sep 17 00:00:00 2001
From: Sven Wischnowsky <wischnow@users.sourceforge.net>
Date: Mon, 2 Apr 2001 11:01:57 +0000
Subject: moved to Completion/compinit

---
 Completion/Core/compinit | 483 -----------------------------------------------
 1 file changed, 483 deletions(-)
 delete mode 100644 Completion/Core/compinit

diff --git a/Completion/Core/compinit b/Completion/Core/compinit
deleted file mode 100644
index 172fafc03..000000000
--- a/Completion/Core/compinit
+++ /dev/null
@@ -1,483 +0,0 @@
-# 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