Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
_all_labels	920 B	-rw-r--r--
_all_matches	970 B	-rw-r--r--
_alternative	1.93 KB	-rw-r--r--
_approximate	3.39 KB	-rw-r--r--
_arg_compile	7.39 KB	-rw-r--r--
_arguments	17.09 KB	-rw-r--r--
_bash_completions	1.33 KB	-rw-r--r--
_cache_invalid	707 B	-rw-r--r--
_call_function	737 B	-rw-r--r--
_call_program	853 B	-rw-r--r--
_combination	2.44 KB	-rw-r--r--
_comp_locale	572 B	-rw-r--r--
_complete	3.09 KB	-rw-r--r--
_complete_debug	1 KB	-rw-r--r--
_complete_help	2.59 KB	-rw-r--r--
_complete_help_generic	412 B	-rw-r--r--
_complete_tag	1.98 KB	-rw-r--r--
_correct	518 B	-rw-r--r--
_correct_filename	1.93 KB	-rw-r--r--
_correct_word	388 B	-rw-r--r--
_describe	3.62 KB	-rw-r--r--
_description	3.11 KB	-rw-r--r--
_dispatch	2.01 KB	-rw-r--r--
_expand	7.34 KB	-rw-r--r--
_expand_alias	2.02 KB	-rw-r--r--
_expand_word	307 B	-rw-r--r--
_extensions	1018 B	-rw-r--r--
_external_pwds	1.04 KB	-rw-r--r--
_generic	328 B	-rw-r--r--
_guard	177 B	-rw-r--r--
_history	1.44 KB	-rw-r--r--
_history_complete_word	3.37 KB	-rw-r--r--
_ignored	1.61 KB	-rw-r--r--
_list	822 B	-rw-r--r--
_main_complete	11.02 KB	-rw-r--r--
_match	2.37 KB	-rw-r--r--
_menu	558 B	-rw-r--r--
_message	840 B	-rw-r--r--
_most_recent_file	883 B	-rw-r--r--
_multi_parts	8.59 KB	-rw-r--r--
_next_label	600 B	-rw-r--r--
_next_tags	3.38 KB	-rw-r--r--
_normal	1.1 KB	-rw-r--r--
_nothing	90 B	-rw-r--r--
_oldlist	1.87 KB	-rw-r--r--
_pick_variant	1.15 KB	-rw-r--r--
_prefix	1.58 KB	-rw-r--r--
_read_comp	3.76 KB	-rw-r--r--
_regex_arguments	2.44 KB	-rw-r--r--
_regex_words	936 B	-rw-r--r--
_requested	268 B	-rw-r--r--
_retrieve_cache	732 B	-rw-r--r--
_sep_parts	3.72 KB	-rw-r--r--
_sequence	1.32 KB	-rw-r--r--
_set_command	815 B	-rw-r--r--
_setup	2.19 KB	-rw-r--r--
_store_cache	1.88 KB	-rw-r--r--
_sub_commands	136 B	-rw-r--r--
_tags	1.43 KB	-rw-r--r--
_user_expand	3.68 KB	-rw-r--r--
_values	3.73 KB	-rw-r--r--
_wanted	183 B	-rw-r--r--

Code Editor : _arguments

#autoload

# Complete the arguments of the current command according to the
# descriptions given as arguments to this function.

local long cmd="$words[1]" descr odescr mesg subopts opt opt2 usecc autod
local oldcontext="$curcontext" hasopts rawret optarg singopt alwopt
local setnormarg start rest
local -a match mbegin mend

subopts=()
singopt=()
while [[ "$1" = -([AMO]*|[CRSWnsw]) ]]; do
  case "$1" in
  -C)  usecc=yes; shift ;;
  -O)  subopts=( "${(@P)2}" ); shift 2 ;;
  -O*) subopts=( "${(@P)${1[3,-1]}}" ); shift ;;
  -R)  rawret=yes; shift;;
  -n)  setnormarg=yes; NORMARG=-1; shift;;
  -w)  optarg=yes; shift;;
  -W)  alwopt=arg; shift;;
  -[Ss])  singopt+=( $1 ); shift;;
  -[AM])  singopt+=( $1 $2 ); shift 2 ;;
  -[AM]*) singopt+=( $1 ); shift ;;
  esac
done

[[ $1 = ':' ]] && shift
singopt+=( ':' )  # always end with ':' to indicate the end of options

[[ "$PREFIX" = [-+] ]] && alwopt=arg

long=$argv[(I)--]
if (( long )); then
  local name tmp tmpargv

tmpargv=( "${(@)argv[1,long-1]}" )  # optspec's before --, if any

name=${~words[1]} 2>/dev/null
  [[ "$name" = [^/]*/* ]] && name="$PWD/$name"

name="_args_cache_${name}"
  name="${name//[^a-zA-Z0-9_]/_}"

if (( ! ${(P)+name} )); then
    local iopts sopts lflag pattern tmpo dir cur cache
    typeset -Ua lopts

cache=()

# We have to build a new long-option cache, get the `-i' and
    # `-s' options.

set -- "${(@)argv[long+1,-1]}"

iopts=()
    sopts=()
    while [[ "$1" = -[lis]* ]]; do
      if [[ "$1" = -l ]]; then
	lflag='-l'
	shift
	continue
      fi
      if [[ "$1" = -??* ]]; then
        tmp="${1[3,-1]}"
        cur=1
      else
        tmp="$2"
	cur=2
      fi
      if [[ "$tmp[1]" = '(' ]]; then
	tmp=( ${=tmp[2,-2]} )
      else
	tmp=( "${(@P)tmp}" )
      fi
      if [[ "$1" = -i* ]]; then
        iopts+=( "$tmp[@]" )
      else
        sopts+=( "$tmp[@]" )
      fi
      shift cur
    done

# Now get the long option names by calling the command with `--help'.
    # The parameter expansion trickery first gets the lines as separate
    # array elements. Then we select all lines whose first non-blank
    # character is a hyphen. Since some commands document more than one
    # option per line, separated by commas, we convert commas into
    # newlines and then split the result again at newlines after joining 
    # the old array elements with newlines between them. Then we select
    # those elements that start with two hyphens, remove anything up to
    # those hyphens and anything from the space or tab after the
    # option up to the end.

tmp=()
   _call_program $lflag options ${~words[1]} --help 2>&1 |
     while IFS= read -r opt; do
     if (( ${#tmp} )); then
       # Previous line had no comment.  Is the current one suitable?
       # It's hard to be sure, but if it there was nothing on the
       # previous line and the current one is indented more than
       # a couple of spaces (and isn't completely whitespace or punctuation)
       # there's a pretty good chance.
       if [[ $opt = [[:space:]][[:space:]][[:space:]]*[[:alpha:]]* ]]; then
	 # Assume so.
	 opt=${opt##[[:space:]]##}
	 # Same substitution as below.
	 lopts+=("${^tmp[@]}":${${${opt//:/-}//\[/(}//\]/)})
	 tmp=()
	 # Finished with this line.
	 continue
       else
	 # Still no comment, add the previous options anyway.
         # Add a ':' after the option anyways, to make the matching of
         # the options lateron work as intended.
         # It will be removed again later.
	 lopts+=("${^tmp[@]}":)
	 tmp=()
       fi
     fi
     while [[ $opt = [,[:space:]]#(#b)(-[^,[:space:]]#)(*) ]]; do
       # We used to remove the brackets from "[=STUFF]",
       # but later the code appears to handle it with the brackets
       # present.  Maybe the problem was that the intervening code
       # didn't.  If it's buggy without removing them, the problem
       # probably is later, not here.
       start=${match[1]}
       rest=${match[2]}
       if [[ -z ${tmp[(r)${start%%[^a-zA-Z0-9_-]#}]} ]]; then
	 # variant syntax seen in fetchmail:
	 # --[fetch]all  means --fetchall or --all.
	 # maybe needs to be more general
	 if [[ $start = (#b)(*)\[(*)\](*) ]]; then
	   tmp+=("${match[1]}${match[2]}${match[3]}" "${match[1]}${match[3]}")
	 else
	   tmp+=($start)
	 fi
       fi
       opt=$rest
     done
     # If there's left over text, assume it's a description; it
     # may be truncated but if it's too long it's no use anyway.
     # There's one hiccup: we sometimes get descriptions like
     # --foo fooarg   Do some foo stuff with foo arg
     # and we need to remove fooarg.  Use whitespace for hints.
     opt=${opt## [^[:space:]]##  }
     opt=${opt##[[:space:]]##}
     if [[ -n $opt ]]; then
       # Add description after a ":", converting any : in the description
       # to a -.  Use RCQUOTES to append this to all versions of the option.
       lopts+=("${^tmp[@]}":${${${opt//:/-}//\[/(}//\]/)})
       tmp=()
       # If there's no comment, we'll see if there's one on the
       # next line.
     fi
   done
   # Tidy up any remaining uncommented options.
   if (( ${#tmp} )); then
     lopts+=("${^tmp[@]}":)
   fi

# Remove options also described by user-defined specs.

tmp=()
    # Ignore any argument and description information when searching
    # the long options array here and below.
    for opt in "${(@)${(@)lopts:#--}%%[\[:=]*}"; do

# Using (( ... )) gives a parse error.

let "$tmpargv[(I)(|$[^$]#\))(|\*)${opt}(|[-+]|=(|-))(|\[*\])(|:*)]" ||
          tmp+=( "$lopts[(r)$opt(|[\[:=]*)]" )
    done
    lopts=( "$tmp[@]" )

# Now remove all ignored options ...

while (( $#iopts )); do
      lopts=( ${lopts:#$~iopts[1](|[\[:=]*)} )
      shift iopts
    done

# ... and add "same" options

while (( $#sopts )); do
      # This implements adding things like --disable-* based
      # on the existence of --enable-*.
      # TODO: there's no anchoring here, is that correct?
      # If it's not, careful with the [\[:=]* stuff.
      lopts+=( ${lopts/$~sopts[1]/$sopts[2]} )
      shift 2 sopts
    done

# Then we walk through the descriptions plus a few builtin ones.
    # The last one matches all options; the `special' description and action
    # makes those options be completed without an argument description.

argv+=(
      '*=FILE*:file:_files'
      '*=(DIR|PATH)*:directory:_files -/'
      '*=*:=: '
      '*: :  '
    )

while (( $# )); do

# First, we get the pattern and the action to use and take them
      # from the positional parameters.

# This is the first bit of the arguments in the special form
      # for converting --help texts, taking account of any quoting
      # of colons.
      pattern="${${${(M)1#*[^\\]:}[1,-2]}//\\\\:/:}"
      # Any action specifications that go with it.
      descr="${1#${pattern}}"
      if [[ "$pattern" = *$-$ ]]; then
	# This is the special form to disallow arguments
	# in the next word.
        pattern="$pattern[1,-4]"
	dir=-
      else
        dir=
      fi
      shift

# We get all options matching the pattern and take them from the
      # list we have built. If no option matches the pattern, we
      # continue with the next.

# Ignore :descriptions at the ends of lopts for matching this;
      # they aren't in the patterns.
      tmp=("${(@M)lopts:##$~pattern:*}")
      lopts=("${(@)lopts:##$~pattern:*}")

(( $#tmp )) || continue

opt=''

# Clean suffix ':' added earlier
      tmp=("${(@)tmp%:}")

# If there are option strings with a `[=', we take these to get an
      # optional argument.

tmpo=("${(@M)tmp:#[^:]##\[\=*}")
      if (( $#tmpo )); then
        tmp=("${(@)tmp:#[^:]##\[\=*}")

for opt in "$tmpo[@]"; do
	  # Look for --option:description and turn it into
	  # --option[description].  We didn't do that above
	  # since it could get confused with the [=ARG] stuff.
	  if [[ $opt = (#b)(*):([^:]#) ]]; then
	    opt=$match[1]
	    odescr="[${match[2]}]"
	  else
	    odescr=
	  fi
	  if [[ $opt = (#b)(*)\[\=* ]]; then
	    opt2=${${match[1]}//[^a-zA-Z0-9_-]}=-${dir}${odescr}
	  else
	    opt2=${${opt}//[^a-zA-Z0-9_-]}=${dir}${odescr}
	  fi
	  if [[ "$descr" = :\=* ]]; then
	    cache+=( "${opt2}::${(L)${opt%\]}#*\=}: " )
	  elif [[ "$descr" = ::* ]]; then
	    cache+=( "${opt2}${descr}" )
	  else
	    cache+=( "${opt2}:${descr}" )
	  fi
	done
      fi

# Descriptions with `=': mandatory argument.
      # Basically the same as the foregoing.
      # TODO: could they be combined?

tmpo=("${(@M)tmp:#[^:]##\=*}")
      if (( $#tmpo )); then
        tmp=("${(@)tmp:#[^:]##\=*}")

for opt in "$tmpo[@]"; do
	  if [[ $opt = (#b)(*):([^:]#) ]]; then
	    opt=$match[1]
	    odescr="[${match[2]}]"
	  else
	    odescr=
	  fi
	  opt2="${${opt%%\=*}//[^a-zA-Z0-9_-]}=${dir}${odescr}"
	  if [[ "$descr" = :\=* ]]; then
	    cache+=( "${opt2}:${(L)${opt%\]}#*\=}: " )
	  else
	    cache+=( "${opt2}${descr}" )
	  fi
	done
      fi

# Everything else is just added as an option without arguments or
      # as described by $descr.

if (( $#tmp )); then
        tmp=(
	  # commands with a description of the option (as opposed
	  # to the argument, which is what descr contains): needs to be
	  # "option[description]".
	  # Careful: \[ on RHS of substitution keeps the backslash,
	  # I discovered after about half an hour, so don't do that.
	  "${(@)^${(@)tmp:#^*:*}//:/[}]"
	  # commands with no description
	  "${(@)${(@)tmp:#*:*}//[^a-zA-Z0-9_-]}")
        if [[ -n "$descr" && "$descr" != ': :  ' ]]; then
	  cache+=( "${(@)^tmp}${descr}" )
        else
	  cache+=( "$tmp[@]" )
        fi
      fi
    done
    set -A "$name" "${(@)cache:# #}"
  fi
  set -- "$tmpargv[@]" "${(@P)name}"
fi

zstyle -s ":completion:${curcontext}:options" auto-description autod

if (( $# )) && comparguments -i "$autod" "$singopt[@]" "$@"; then
  local action noargs aret expl local tried ret=1
  local next direct odirect equal single matcher matched ws tmp1 tmp2 tmp3
  local opts subc tc prefix suffix descrs actions subcs anum
  local origpre="$PREFIX" origipre="$IPREFIX" nm="$compstate[nmatches]"

if comparguments -D descrs actions subcs; then
    if comparguments -O next direct odirect equal; then
      opts=yes
      _tags "$subcs[@]" options
    else
      _tags "$subcs[@]"
    fi
  else
    if comparguments -a; then
      noargs='no more arguments'
    else
      noargs='no arguments'
    fi
    if comparguments -O next direct odirect equal; then
      opts=yes
      _tags options
    elif [[ $? -eq 2 ]]; then
        compadd -Q - "${PREFIX}${SUFFIX}"
        return 0
    else
      _message "$noargs"
      return 1
    fi
  fi

comparguments -M matcher

context=()
  state=()
  state_descr=()

while true; do
    while _tags; do
      anum=1
      if [[ -z "$tried" ]]; then
        while [[ anum -le  $#descrs ]]; do

action="$actions[anum]"
	  descr="$descrs[anum]"
	  subc="$subcs[anum++]"

if [[ $subc = argument* && -n $setnormarg ]]; then
	    comparguments -n NORMARG
	  fi

if [[ -n "$matched" ]] || _requested "$subc"; then

curcontext="${oldcontext%:*}:$subc"

_description "$subc" expl "$descr"

if [[ "$action" = \=\ * ]]; then
              action="$action[3,-1]"
              words=( "$subc" "$words[@]" )
	      (( CURRENT++ ))
            fi

if [[ "$action" = -\>* ]]; then
	      action="${${action[3,-1]##[ 	]#}%%[ 	]#}"
	      if (( ! $state[(I)$action] )); then
                comparguments -W line opt_args
                state+=( "$action" )
                state_descr+=( "$descr" )
	        if [[ -n "$usecc" ]]; then
	          curcontext="${oldcontext%:*}:$subc"
	        else
	          context+=( "$subc" )
	        fi
                compstate[restore]=''
                aret=yes
              fi
            else
              if [[ -z "$local" ]]; then
                local line
                typeset -A opt_args
                local=yes
              fi

comparguments -W line opt_args

if [[ "$action" = \ # ]]; then

# An empty action means that we should just display a message.

_message -e "$subc" "$descr"
	        mesg=yes
	        tried=yes
                alwopt=${alwopt:-yes}
              elif [[ "$action" = $\(*$\) ]]; then

# ((...)) contains literal strings with descriptions.

eval ws\=$ "${action[3,-3]}" $

_describe -t "$subc" "$descr" ws -M "$matcher" "$subopts[@]" ||
                    alwopt=${alwopt:-yes}
	        tried=yes

elif [[ "$action" = $*$ ]]; then

# Anything inside `(...)' is added directly.

eval ws\=$ "${action[2,-2]}" $

_all_labels "$subc" expl "$descr" compadd "$subopts[@]" -a - ws ||
                    alwopt=${alwopt:-yes}
	        tried=yes
              elif [[ "$action" = \{*\} ]]; then

# A string in braces is evaluated.

while _next_label "$subc" expl "$descr"; do
                  eval "$action[2,-2]" && ret=0
                done
                (( ret )) && alwopt=${alwopt:-yes}
	        tried=yes
              elif [[ "$action" = \ * ]]; then

# If the action starts with a space, we just call it.

eval "action=( $action )"
                while _next_label "$subc" expl "$descr"; do
                  "$action[@]" && ret=0
                done
                (( ret )) && alwopt=${alwopt:-yes}
	        tried=yes
              else

# Otherwise we call it with the description-arguments.

eval "action=( $action )"
                while _next_label "$subc" expl "$descr"; do
                  "$action[1]" "$subopts[@]" "$expl[@]" "${(@)action[2,-1]}" && ret=0
	        done
                (( ret )) && alwopt=${alwopt:-yes}
	        tried=yes
              fi
            fi
          fi
        done
      fi
      if _requested options &&
         [[ -z "$hasopts" &&
            -z "$matched" &&
            ( -z "$aret" || "$PREFIX" = "$origpre" ) ]] &&
          { ! zstyle -T ":completion:${oldcontext%:*}:options" prefix-needed ||
            [[ "$origpre" = [-+]* || -z "$aret$mesg$tried" ]] } ; then
	local prevpre="$PREFIX" previpre="$IPREFIX" prevcontext="$curcontext"

curcontext="${oldcontext%:*}:options"

hasopts=yes

PREFIX="$origpre"
	IPREFIX="$origipre"

if [[ -z "$alwopt" || -z "$tried" || "$alwopt" = arg ]] &&
           comparguments -s single; then

if [[ "$single" = direct ]]; then
            _all_labels options expl option \
	        compadd -QS '' - "${PREFIX}${SUFFIX}"
          elif [[ -z "$optarg" && "$single" = next ]]; then
            _all_labels options expl option \
	        compadd -Q - "${PREFIX}${SUFFIX}"
          elif [[ "$single" = equal ]]; then
            _all_labels options expl option \
	        compadd -QqS= - "${PREFIX}${SUFFIX}"
          else

tmp1=( "$next[@]" "$direct[@]" "$odirect[@]" "$equal[@]" )

[[ "$PREFIX" = [-+]* ]] && tmp1=( "${(@M)tmp1:#${PREFIX[1]}*}" )

[[ "$single" = next ]] &&
                tmp1=( "${(@)tmp1:#[-+]${PREFIX[-1]}((#e)|:*)}" )

[[ "$PREFIX" != --* ]] && tmp1=( "${(@)tmp1:#--*}" )
	    tmp3=( "${(M@)tmp1:#[-+]?[^:]*}" )
	    tmp1=( "${(M@)tmp1:#[-+]?(|:*)}" )
	    tmp2=( "${PREFIX}${(@M)^${(@)${(@)tmp1%%:*}#[-+]}:#?}" )

_describe -O option \
                      tmp1 tmp2 -Q -S '' -- \
		      tmp3 -Q

[[ -n "$optarg" && "$single" = next && nm -eq $compstate[nmatches] ]] &&
                _all_labels options expl option \
	            compadd -Q - "${PREFIX}${SUFFIX}"

fi
          single=yes
        else
          next+=( "$odirect[@]" )
          _describe -O option \
                    next -Q -M "$matcher" -- \
                    direct -QS '' -M "$matcher" -- \
                    equal -QqS= -M "$matcher"
        fi
	PREFIX="$prevpre"
	IPREFIX="$previpre"
        curcontext="$prevcontext"
      fi
      [[ -n "$tried" && "${${alwopt:+$origpre}:-$PREFIX}" != [-+]* ]] && break
    done
    if [[ -n "$opts" && -z "$aret" &&
          -z "$matched" &&
          ( -z "$tried" || -n "$alwopt" ) &&
          nm -eq compstate[nmatches] ]]; then

PREFIX="$origpre"
      IPREFIX="$origipre"

prefix="${PREFIX#*\=}"
      suffix="$SUFFIX"
      PREFIX="${PREFIX%%\=*}"
      SUFFIX=''

compadd -M "$matcher" -D equal - "${(@)equal%%:*}"

if [[ $#equal -eq 1 ]]; then
        PREFIX="$prefix"
	SUFFIX="$suffix"
	IPREFIX="${IPREFIX}${equal[1]%%:*}="
	matched=yes

comparguments -L "${equal[1]%%:*}" descrs actions subcs

_tags "$subcs[@]"

continue
      fi
    fi
    break
  done

[[ -z "$aret" || -z "$usecc" ]] && curcontext="$oldcontext"

if [[ -n "$aret" ]]; then
    [[ -n $rawret ]] && return 300

### Returning non-zero would allow the calling function to add its own
### completions if we generated only options and have to use a ->state
### action.  But if that then doesn't generate matches, the calling
### function's return value would be wrong unless it compares
### $compstate[nmatches] to its previous value.  Ugly.
###
###    return 1
  else
    [[ -n "$noargs" && nm -eq "$compstate[nmatches]" ]] && _message "$noargs"
  fi
  # Set the return value.

[[ nm -ne "$compstate[nmatches]" ]]
else
  return 1
fi

${this.title}

Code Editor : _arguments