From c4b0e2f297a695c32d7ddc1b0b18f656591bd2e0 Mon Sep 17 00:00:00 2001
From: Tanaka Akira <akr@users.sourceforge.net>
Date: Mon, 6 Sep 1999 09:16:29 +0000
Subject: Initial revision

---
 Completion/Base/_values | 367 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 367 insertions(+)
 create mode 100644 Completion/Base/_values

(limited to 'Completion/Base')

diff --git a/Completion/Base/_values b/Completion/Base/_values
new file mode 100644
index 000000000..4be3e8203
--- /dev/null
+++ b/Completion/Base/_values
@@ -0,0 +1,367 @@
+#autoload
+
+setopt localoptions extendedglob
+
+local name arg def descr xor str tmp ret=1 expl nm="$compstate[nmatches]"
+local snames odescr gdescr sep
+typeset -A names onames xors _values
+
+# Probably fill our cache.
+
+if [[ "$*" != "$_vals_cache_args" ]]; then
+  _vals_cache_args="$*"
+
+  unset _vals_cache_{sep,descr,names,onames,snames,xors,odescr}
+
+  typeset -gA _vals_cache_{names,onames,xors}
+  _vals_cache_snames=()
+  _vals_cache_odescr=()
+
+  # Get the separator, if any.
+
+  if [[ "$1" = -s ]]; then
+    _vals_cache_sep="$2"
+    shift 2
+  fi
+
+  # This is the description string for the values.
+
+  _vals_cache_descr="$1"
+  shift
+
+  # Now parse the descriptions.
+
+  while (( $# )); do
+
+    # Get the `name', anything before an unquoted colon.
+
+    if [[ "$1" = *[^\\]:* ]]; then
+      name="${${${(M)1#*[^\\]:}[1,-2]}//\\\\:/:}"
+    else
+      name="$1"
+    fi
+
+    descr=''
+    xor=''
+
+    # Get a description, if any.
+
+    if [[ "$name" = *\[*\] ]]; then
+      descr="${${name#*\[}[1,-2]}"
+      name="${name%%\[*}"
+    fi
+
+    # Get the names of other values that are mutually exclusive with
+    # this one.
+
+    if [[ "$name" = \(*\)* ]]; then
+      xor="${${name[2,-1]}%%\)*}"
+      name="${name#*\)}"
+    fi
+
+    # Finally see if this value may appear more than once.
+
+    if [[ "$name" = \** ]]; then
+      name="$name[2,-1]"
+    else
+      xor="$xor $name"
+    fi
+
+    # Store the information in the cache.
+
+    _vals_cache_odescr=( "$_vals_cache_odescr[@]" "${name}:$descr" )
+    [[ -n "$xor" ]] && _vals_cache_xors[$name]="${${xor##[ 	]#}%%[ 	]#}"
+
+    # Get the description and store that.
+
+    if [[ "$1" = *[^\\]:* ]]; then
+      descr=":${1#*[^\\]:}"
+    else
+      descr=''
+    fi
+
+    if [[ "$descr" = ::* ]]; then
+
+       # Optional argument.
+
+      _vals_cache_onames[$name]="$descr[3,-1]"
+    elif [[ "$descr" = :* ]]; then
+
+      # Mandatory argument.
+
+      _vals_cache_names[$name]="$descr[2,-1]"
+    else
+
+      # No argument.
+
+      _vals_cache_snames=( "$_vals_cache_snames[@]" "$name" )
+    fi
+    shift
+  done
+fi
+
+snames=( "$_vals_cache_snames[@]" )
+names=( "${(@kv)_vals_cache_names}" )
+onames=( "${(@kv)_vals_cache_onames}" )
+xors=( "${(@kv)_vals_cache_xors}" )
+odescr=( "$_vals_cache_odescr[@]" )
+gdescr="$_vals_cache_descr"
+sep="$_vals_cache_sep"
+
+if [[ -n "$sep" ]]; then
+
+  # We have a separator character. We parse the PREFIX and SUFFIX to
+  # see if any of the values that must not appear more than once are
+  # already on the line.
+
+  while [[ "$PREFIX" = *${sep}* ]]; do
+
+    # Get one part, remove it from PREFIX and put it into IPREFIX.
+
+    tmp="${PREFIX%%${sep}*}"
+    PREFIX="${PREFIX#*${sep}}"
+    IPREFIX="${IPREFIX}${tmp}${sep}"
+
+    # Get the value `name'.
+
+    name="${tmp%%\=*}"
+
+    if [[ "$tmp" = *\=* ]]; then
+      _values[$name]="${tmp#*\=}"
+    else
+      _values[$name]=''
+    fi
+
+    # And remove the descriptions for the values this one makes
+    # superfluous.
+
+    if [[ -n "$xors[$name]" ]]; then
+      snames=( "${(@)snames:#(${(j:|:)~${=xors[$name]}})}" )
+      odescr=( "${(@)odescr:#(${(j:|:)~${=xors[$name]}}):*}" )
+      unset {names,onames,xors}\[${^=tmp}\]
+    fi
+  done
+  if [[ "$SUFFIX" =  *${sep}* ]]; then
+
+    # The same for the suffix.
+
+    str="${SUFFIX%%${sep}*}"
+    SUFFIX="${SUFFIX#*${sep}}"
+    while [[ -n "$SUFFIX" ]]; do
+      tmp="${PREFIX%%${sep}*}"
+      if [[ "$SUFFIX" = *${sep}* ]]; then
+        SUFFIX="${SUFFIX#*${sep}}"
+      else
+        SUFFIX=''
+      fi
+      PREFIX="${PREFIX#*${sep}}"
+      IPREFIX="${IPREFIX}${tmp}${sep}"
+
+      name="${tmp%%\=*}"
+
+      if [[ "$tmp" = *\=* ]]; then
+        _values[$name]="${tmp#*\=}"
+      else
+        _values[$name]=''
+      fi
+
+      if [[ -n "$xors[$name]" ]]; then
+        snames=( "${(@)snames:#(${(j:|:)~${=xors[$name]}})}" )
+        odescr=( "${(@)odescr:#(${(j:|:)~${=xors[$name]}}):*}" )
+        unset {names,onames,xors}\[${^=tmp}\]
+      fi
+    done
+    SUFFIX="$str"
+  fi
+fi
+
+descr=''
+str="$PREFIX$SUFFIX"
+
+if [[ "$str" = *\=* ]]; then
+
+  # The string from the line contains a `=', so we get the stuff before
+  # it and after it and see what we can do here...
+
+  name="${str%%\=*}"
+  arg="${str#*\=}"
+
+  if (( $snames[(I)${name}] )); then
+
+    # According to our information, the value doesn't get an argument,
+    # so give up.
+
+    _message "\`${name}' gets no value"
+    return 1
+  elif (( $+names[$name] )); then
+
+    # It has to get an argument, we skip over the name and complete
+    # the argument (below).
+
+    def="$names[$name]"
+    if ! compset -P '*\='; then
+      IPREFIX="${IPREFIX}${name}="
+      PREFIX="$arg"
+      SUFFIX=''
+    fi
+  elif (( $+onames[$name] )); then
+
+    # Gets an optional argument, same as previous case.
+
+    def="$onames[$name]"
+    if ! compset -P '*\='; then
+      IPREFIX="${IPREFIX}${name}="
+      PREFIX="$arg"
+      SUFFIX=''
+    fi
+  else
+    local pre="$PREFIX" suf="$SUFFIX"
+
+    # The part before the `=' isn't a known value name, so we see if
+    # it matches only one of the known names.
+
+    if [[ "$PREFIX" = *\=* ]]; then
+      PREFIX="${PREFIX%%\=*}"
+      pre="${pre#*\=}"
+      SUFFIX=''
+    else
+      SUFFIX="${SUFFIX%%\=*}"
+      pre="${suf#*\=}"
+      suf=''
+    fi
+
+    tmp=( "${(@k)names}" "${(@k)onames}" )
+    compadd -M 'r:|[-_]=* r:|=*' -D tmp - "$tmp[@]"
+
+    if [[ $#tmp -eq 1 ]]; then
+
+      # It does, so we use that name and immediatly start completing
+      # the argument for it.
+
+      IPREFIX="${IPREFIX}${tmp[1]}="
+      PREFIX="$pre"
+      SUFFIX="$suf"
+
+      def="$names[$tmp[1]]"
+      [[ -z "$def" ]] && def="$onames[$tmp[1]]"
+    elif (( $#tmp )); then
+      _message "ambiguous option \`${PREFIX}${SUFFIX}'"
+      return 1
+    else
+      _message "unknown option \`${PREFIX}${SUFFIX}'"
+      return 1
+    fi
+  fi
+else
+
+  # No `=', just complete value names.
+
+  _description expl "$gdescr"
+
+  [[ -n "$sep" && ${#snames}+${#names}+${#onames} -ne 1 ]] &&
+      expl=( "-qS$sep" "$expl[@]" )
+
+  tmp=''
+  if [[ -n "$compconfig[describe_values]" &&
+        "$compconfig[describe_values]" != *\!${words[1]}* ]]; then
+    if _display tmp odescr -M 'r:|[_-]=* r:|=*'; then
+      if (( $#snames )); then
+        compadd "$expl[@]" -y tmp -M 'r:|[_-]=* r:|=*' - \
+                "$snames[@]" && ret=0
+        compadd -n -S= -J "_$gdescr" -M 'r:|[_-]=* r:|=*' - \
+                "${(@k)names}" && ret=0
+        compadd -n -qS= -J "_$gdescr" -M 'r:|[_-]=* r:|=*' - \
+                "${(@k)onames}" && ret=0
+      elif (( $#names )); then
+        compadd -n -S= "$expl[@]" -y tmp -M 'r:|[_-]=* r:|=*' - \
+                "${(@k)names}" && ret=0
+        compadd -n -qS= -J "_$gdescr" -M 'r:|[_-]=* r:|=*' - \
+                "${(@k)onames}" && ret=0
+      else
+        compadd -n -qS= "$expl[@]" -y tmp -M 'r:|[_-]=* r:|=*' - \
+                "${(@k)onames}" && ret=0
+      fi
+    fi
+  fi
+  if [[ -z "$tmp" ]]; then
+    compadd "$expl[@]" -M 'r:|[_-]=* r:|=*' - "$snames[@]" && ret=0
+    compadd -S= "$expl[@]" -M 'r:|[_-]=* r:|=*' - "${(@k)names}" && ret=0
+    compadd -qS= "$expl[@]" -M 'r:|[_-]=* r:|=*' - "${(@k)onames}" && ret=0
+  fi
+  return ret
+fi
+
+if [[ -z "$def" ]]; then
+  _message 'no value'
+  return 1
+else
+  local action
+
+  descr="${${${(M)def#*[^\\]:}[1,-2]}//\\\\:/:}"
+  action="${${def#*[^\\]:}//\\\\:/:}"
+
+  _description expl "$descr"
+
+  # We add the separator character as a autoremovable suffix unless
+  # we have only one possible value left.
+
+  [[ -n "$sep" && ${#snames}+${#names}+${#onames} -ne 1 ]] &&
+      expl=( "-qS$sep" "$expl[@]" )
+
+  if [[ "$action" = -\>* ]]; then
+    values=( "${(@kv)_values}" )
+    state="${${action[3,-1]##[ 	]#}%%[ 	]#}"
+    compstate[restore]=''
+    return 1
+  else
+    typeset -A values
+
+    values=( "${(@kv)_values}" )
+
+    if [[ "$action" = \ # ]]; then
+
+      # An empty action means that we should just display a message.
+
+      _message "$descr"
+      return 1
+
+    elif [[ "$action" = \(\(*\)\) ]]; then
+      local ws
+
+      # ((...)) contains literal strings with descriptions.
+
+      eval ws\=\( "${action[3,-3]}" \)
+
+      if _display tmp ws; then
+        compadd "$expl[@]" -y tmp - "${(@)ws%%:*}"
+      else
+        _message "$descr"
+        return 1
+      fi
+    elif [[ "$action" = \(*\) ]]; then
+
+      # Anything inside `(...)' is added directly.
+
+      compadd "$expl[@]" - ${=action[2,-2]}
+    elif [[ "$action" = \{*\} ]]; then
+
+      # A string in braces is evaluated.
+
+      eval "$action[2,-2]"
+
+    elif [[ "$action" = \ * ]]; then
+
+      # If the action starts with a space, we just call it.
+
+      ${(e)=~action}
+    else
+
+      # Otherwise we call it with the description-arguments built above.
+
+      action=( $=action )
+      ${(e)action[1]} "$expl[@]" ${(e)~action[2,-1]}
+    fi
+  fi
+fi
+
+[[ nm -ne "$compstate[nmatches]" ]]
-- 
cgit 1.4.1