From b60c50097dda4abe52d94b383d5650a6f4ab9220 Mon Sep 17 00:00:00 2001
From: Tanaka Akira <akr@users.sourceforge.net>
Date: Wed, 8 Sep 1999 13:11:06 +0000
Subject: Initial revision

---
 Completion/Base/_regex_arguments | 396 +++++++++++++++++++++++++++++++++++++++
 Completion/Debian/_apt_arguments | 230 +++++++++++++++++++++++
 2 files changed, 626 insertions(+)
 create mode 100644 Completion/Base/_regex_arguments
 create mode 100644 Completion/Debian/_apt_arguments

diff --git a/Completion/Base/_regex_arguments b/Completion/Base/_regex_arguments
new file mode 100644
index 000000000..598911bc5
--- /dev/null
+++ b/Completion/Base/_regex_arguments
@@ -0,0 +1,396 @@
+#autoload
+
+## usage: _regex_arguments funcname regex
+
+# _regex_arguments compiles `regex' and emit the result of the state
+# machine into the function `funcname'. `funcname' parses a command line
+# according to `regex' and evaluate appropriate actions in `regex'. Before
+# parsing the command line string is genereted by concatinating `words'
+# (before `PREFIX') and `PREFIX' with a separator NUL ($'\0').
+
+# The `regex' is defined as follows.
+
+## regex word definition:
+
+# elt-pattern = "/" ( pattern | "[]" )	# cutoff
+#	      | "%" pattern		# non-cutoff
+# lookahead = "@" pattern
+# parse-action = "-" zsh-code-to-eval
+# complete-action = "!" zsh-code-to-eval
+
+## regex word sequence definition:
+
+# element = elt-pattern [ lookahead ] [ parse-action ] [ complete-action ]
+#
+# regex = element 
+#	| "(" regex ")"
+#	| regex "#"
+#	| regex regex
+#	| regex "|" regex
+#	| void
+#	| null
+#
+# NOTE: void and null has no explicit representation. However null can
+# be represent with empty words such as \( \).
+
+# example: (in zsh quoted form)
+
+# $'[^\0]#\0' \#	: zero or more words
+
+## auxiliary functions definition:
+
+# fst : a * b -> a
+# snd : a * b -> b
+# fst( (x, y) ) = x
+# snd( (x, y) ) = y
+
+# nullable : regex -> bool
+# first : regex -> list of element
+# match : string * list of element -> element + {bottom}
+# right : string * element -> string
+# left : string * element -> string
+# next : regex * element -> regex + {bottom}
+# trans : string * string * regex -> (string * string * regex) + {bottom}
+
+# nullable(void) = false
+# nullable(null) = true
+# nullable(e) = false
+# nullable(r #) = true
+# nullable(r1 r2) = nullable(r1) and nullable(r2)
+# nullable(r1 | r2) = nullable(r1) or nullable(r2)
+
+# first(void) = {}
+# first(null) = {}
+# first(e) = [ e ]
+# first(r #) = first(r)
+# first(r1 r2) = nullable(r1) ? first(r1) ++ first(r2) : first(r1)
+# first(r1 | r2) = first(r1) ++ first(r2)
+
+# match(s, []) = bottom
+# match(s, [e1, e2, ...]) = e	if [[ $s = $elt-pattern[e]$lookahead[e]* ]]
+#		   	  | match(s, [e2, ...])	otherwise
+
+# right(s, e) = ${s##$elt-pattern[e]}
+# left(s, e) = ${(M)s##$elt-pattern[e]}
+
+### XXX: It can treat lookaheads if zsh provide $1, $2, ... in perl.
+
+# next(void, e) = bottom
+# next(null, e) = bottom
+# next(e1, e0) = e1 eq e0 ? null : bottom	# eq is test operator of identity equality.
+# next(r #, e) = next(r, e) != bottom ? next(r, e) (r #) : bottom
+# next(r1 r2, e) = next(r1, e) != bottom ? next(r1, e) r2 : next(r2, e)
+# next(r1 | r2, e) = next(r1, e) != bottom ? next(r1, e) : next(r2, e)
+
+# trans( (t, s, r) ) = ( (cutoff(e) ? '' : t ++ left(s, e)), right(s, e), next(r, e) )
+#   where e = match(s, first(r))
+
+# NOTE: This `next' definition is slightly different to ordinaly one.
+# This definition uses only one element of first(r) for transition
+# instead of all elements of first(r).
+
+# If _regex_arguments takes the regex r0, the first state of the state
+# machine is r0.  The state of the state machine transit as follows.
+
+# ('', s0, r0) -> trans('', s0, r0) = (t1, s1, r1) -> trans(t1, s1, r1) -> ... 
+
+# If the state is reached to bottom, the state transition is stopped.
+
+# ... -> (tN, sN, rN) -> bottom
+
+# For each transitions (tI, sI, rI) to trans(tI, sI, rI), the state
+# machine evaluate parse-action bound to match(sI, first(rI)).
+
+# In parse-action bound to match(sI, first(rI)) = e, it can refer variables:
+#  _ra_left : tI+1
+#  _ra_match : left(sI, e)
+#  _ra_right : sI+1
+
+# If the state transition is stopped, the state machine evaluate
+# complete-actions bound to first(rN) if tN and sN does not contain NUL.
+# When complete-actions are evaluated, completion focus is restricted to
+# tN ++ sN. (This is reason of tN and sN cannot contain NUL when
+# completion.)
+# Also, if there are last transitions that does not cut off the string
+# (tJ ++ sJ = tJ+1 ++ sJ+1 = ... = tN-1 ++ sN-1 = tN ++ sN),
+# complete-actions bound to them
+# --- match(sJ, first(rJ)), ..., match(sN-1, first(rN-1)) --- are also
+# evaluated before complete-actions bound to first(rN).
+
+# example:
+
+# compdef _tst tst
+
+# _regex_arguments _tst /$'[^\0]#\0' /$'[^\0]#\0' '!compadd aaa'
+#  _tst complete `aaa' for first argument.
+#  First $'[^\0]#\0' is required to match with command name.
+
+# _regex_arguments _tst /$'[^\0]#\0' \( /$'[^\0]#\0' '!compadd aaa' /$'[^\0]#\0' !'compadd bbb' \) \#
+#  _tst complete `aaa' for (2i+1)th argument and `bbb' for (2i)th argument.
+
+# _regex_arguments _tst /$'[^\0]#\0' \( /$'[^\0]#\0' '!compadd aaa' \| /$'[^\0]#\0' !'compadd bbb' \) \#
+#  _tst complete `aaa' or `bbb'.
+
+## Recursive decent regex parser
+
+_ra_parse_elt () {
+  : index=$index "[$regex[$index]]"
+  local state
+  if (( $#regex < index )); then
+    return 1
+  else
+    case "$regex[index]" in
+      [/%]*) state=$index
+          first=($state)
+	  last=($state)
+	  nullable=
+	  case "${regex[index][1]}" in
+	    /) cutoff[$state]=yes ;;
+	    %) cutoff[$state]= ;;
+	  esac
+          pattern[$state]="${regex[index++][2,-1]}"
+	  [[ -n "$pattern[$state]" ]] && pattern[$state]="($pattern[$state])"
+	  if [[ $index -le $#regex && $regex[index] = @* ]]; then
+	    lookahead[$state]="${regex[index++][2,-1]}"
+	    [[ -n "$lookahead[$state]" ]] && lookahead[$state]="($lookahead[$state])"
+	  else
+	    lookahead[$state]=""
+	  fi
+	  if [[ $index -le $#regex && $regex[index] = -* ]]; then
+	    parse_action[$state]="${regex[index++][2,-1]}"
+	  else
+	    parse_action[$state]=""
+	  fi
+	  if [[ $index -le $#regex && $regex[index] = \!* ]]; then
+	    complete_action[$state]="${regex[index++][2,-1]}"
+	  else
+	    complete_action[$state]=""
+	  fi
+	  ;;
+      \() (( index++ ))
+          _ra_parse_alt || return 1
+	  [[ $index -le $#regex && "$regex[$index]" = \) ]] || return 1
+	  (( index++ ))
+	  ;;
+      *)  return 1
+          ;;
+    esac
+  fi
+
+  return 0
+}
+
+_ra_parse_clo () {
+  : index=$index "[$regex[$index]]"
+  _ra_parse_elt || return 1
+
+  if (( index <= $#regex )) && [[ "$regex[$index]" = \# ]]; then
+    (( index++ ))
+    nullable=yes
+
+    for i in $last; do tbl[$i]="$tbl[$i] $first"; done
+  fi
+
+  return 0
+}
+
+_ra_parse_seq () {
+  : index=$index "[$regex[$index]]"
+  local last_seq
+  local first_seq nullable_seq
+  first_seq=()
+  nullable_seq=yes
+
+  _ra_parse_clo || {
+    first=()
+    last=()
+    nullable=yes
+    return 0
+  }
+  first_seq=($first)
+  last_seq=($last)
+  [[ -n "$nullable" ]] || nullable_seq=
+
+  while :; do
+    _ra_parse_clo || break
+    for i in $last_seq; do tbl[$i]="${tbl[$i]} $first"; done
+    [[ -n "$nullable_seq" ]] && first_seq=($first_seq $first)
+    [[ -n "$nullable" ]] || { nullable_seq= last_seq=() }
+    last_seq=($last_seq $last)
+  done
+
+  first=($first_seq)
+  nullable=$nullable_seq
+  last=($last_seq)
+  return 0
+}
+
+_ra_parse_alt () {
+  : index=$index "[$regex[$index]]"
+  local last_alt
+  local first_alt nullable_alt 
+  first_alt=()
+  nullable_alt=
+
+  _ra_parse_seq || return 1
+  first_alt=($first_alt $first)
+  last_alt=($last_alt $last)
+  [[ -n "$nullable" ]] && nullable_alt=yes
+
+  while :; do
+    (( index <= $#regex )) || break
+    [[ "$regex[$index]" = \| ]] || break
+    (( index++ ))
+
+    _ra_parse_seq || break
+    first_alt=($first_alt $first)
+    last_alt=($last_alt $last)
+    [[ -n "$nullable" ]] && nullable_alt=yes
+  done
+
+  first=($first_alt)
+  last=($last_alt)
+  nullable=$nullable_alt
+  return 0
+}
+
+## function generator
+
+_ra_gen_func () {
+  local old new
+  local state next index
+  local start="${(j/:/)first}"
+
+  old=()
+  new=($start)
+
+  print -lr - \
+    "$funcname () {" \
+      'setopt localoptions extendedglob' \
+      'local _ra_state _ra_left _ra_match _ra_right _ra_actions _ra_tmp' \
+      "_ra_state='$start'" \
+      '_ra_left=' \
+      '_ra_right="${(pj:\0:)${(@)words[1,CURRENT - 1]:Q}}"$'\''\0'\''"$PREFIX"' \
+      '_ra_actions=()' \
+      'while :; do' \
+	'case "$_ra_state" in'
+
+  while (( $#new )); do
+    state="$new[1]"
+    shift new
+    old=("$old[@]" "$state")
+
+    print -lr - \
+	"$state)" \
+	  'case "$_ra_right" in'
+
+    for index in ${(s/:/)state}; do
+      if [[ "$pattern[$index]" != "([])" ]]; then
+	next="${(j/:/)${(@)=tbl[$index]}}"
+	print -lr - \
+	      "$pattern[$index]$lookahead[$index]*)"
+	if [[ -n "$pattern[$index]" ]]; then
+	  if [[ -n "$cutoff[$index]" ]]; then
+	    print -lr - \
+		  '_ra_match="${(M)_ra_right##'"$pattern[$index]"'}"' \
+		  '_ra_right="$_ra_right[$#_ra_match + 1, -1]"' \
+		  '_ra_left=' \
+		  'if (( $#_ra_match )); then' \
+		    '_ra_actions=()'
+	    if [[ -n "${complete_action[$index]:q}" ]]; then
+	      print -lr - \
+		  'else' \
+		    '_ra_actions=("$_ra_actions[@]" '"${complete_action[$index]:q}"')'
+	    fi
+	    print -lr - \
+		  'fi'
+	  else
+	    print -lr - \
+		  '_ra_match="${(M)_ra_right##'"$pattern[$index]"'}"' \
+		  '_ra_right="$_ra_right[$#_ra_match + 1, -1]"' \
+		  '_ra_left="$_ra_left$_ra_match"'
+	    if [[ -n "${complete_action[$index]:q}" ]]; then
+	      print -lr - \
+		  '_ra_actions=("$_ra_actions[@]" '"${complete_action[$index]:q}"')'
+	    fi
+	  fi
+	else
+	  print -lr - \
+		'_ra_match=' \
+		'_ra_actions=("$_ra_actions[@]" '"${complete_action[$index]:q}"')'
+	fi
+	print -lr - \
+		"$parse_action[$index]"
+	if [[ -n $next ]]; then
+	  print -lr - \
+		"_ra_state=$next"
+	  (( $old[(I)$next] || $new[(I)$next] )) || new=($next "$new[@]")
+	else
+	  print -lr - \
+		'_message "no arg"' \
+		'break'
+	fi
+	print -lr - \
+		';;'
+      fi
+    done
+
+    print -lr - \
+	    '*)' \
+	      'if [[ "$_ra_left$_ra_right" = *$'\''\0'\''* ]]; then' \
+		'_message "parse failed before current word"' \
+	      'else' \
+		'compset -p $(( $#PREFIX - $#_ra_right - $#_ra_left ))'
+
+    print -lr - \
+		'for _ra_tmp in $_ra_actions; do' \
+		  'eval "$_ra_tmp"' \
+		'done'
+    for index in ${(s/:/)state}; do
+      print -lr - \
+		"$complete_action[$index]"
+    done
+
+    print -lr - \
+	      'fi' \
+	      'break' \
+	      ';;' \
+	  'esac' \
+	  ';;'
+  done
+
+  print -lr - \
+	'esac' \
+      'done' \
+    '}'
+}
+
+_regex_arguments () {
+  setopt localoptions extendedglob
+
+  local funcname="_regex_arguments_tmp"
+  local funcdef
+
+  typeset -A tbl cutoff pattern lookahead parse_action complete_action
+  local regex index first last nullable
+  local i state next
+
+  funcname="$1"
+  shift
+
+  regex=("$@")
+  index=1
+  tbl=()
+  pattern=()
+  lookahead=()
+  parse_action=()
+  complete_action=()
+  _ra_parse_alt
+
+  funcdef="$(_ra_gen_func)"
+
+  unfunction "$funcname" 2>/dev/null
+  eval "${(F)funcdef}"
+}
+
+_regex_arguments "$@"
diff --git a/Completion/Debian/_apt_arguments b/Completion/Debian/_apt_arguments
new file mode 100644
index 000000000..b97a92852
--- /dev/null
+++ b/Completion/Debian/_apt_arguments
@@ -0,0 +1,230 @@
+#autoload
+
+# short_bool=(h v d b s y f u m)
+# short_intlevel=(q)
+# short_configfile=(c)
+# short_arbitem=(o)
+# 
+# long_bool=(help version download-only compile build simulate just-print recon
+#   no-act yes assume-yes fix-broken show-upgraded ignore-missing no-download
+#   fix-missing ignore-hold no-upgrade force-yes print-uris)
+# long_intlevel=(quiet silent)
+# long_configfile=(config-file)
+# long_arbitem=(option)
+
+###
+
+local funcname
+funcname="$1"
+shift
+
+local short_seq false true bool bool_ __bool_ intlevel word word1 nul
+local comp_bool comp_intlevel comp_configfile comp_arbitem comp_long
+local regex_short regex_long regex_message regex_action
+
+regex_action=("$@")
+
+short_seq="(${(j:|:)short_bool}|${(j:|:)short_intlevel})#"
+
+false=(no false without off disable)
+true=(yes true with on enable)
+bool=($false $true)
+
+bool_=(${^bool}-)
+__bool_=(--$^bool_)
+
+intlevel='[0-9]##'
+
+word=$'[^\0]#\0'
+word1=$'[^\0]##\0'
+
+nul=$'\0'
+
+comp_bool='compadd "$expl_bool[@]" '"$bool"
+comp_intlevel= #"_message 'intlevel'"
+comp_configfile='_files "$expl_configfile[@]"'
+comp_arbitem= #"_message 'Foo::Bar=bar'"
+
+comp_long="\
+tmp1=\${(kj:|:)long_to_option[(R)\${(kj:|:)~options[(R)*~0]}]}
+tmp2=(--\${(M)^long_bool:#\$~tmp1} --\${(M)^long_intlevel:#\$~tmp1})
+compadd \"\$expl_opt[@]\" - \$tmp2
+tmp2=(--\${(M)^long_configfile:#\$~tmp1} --\${(M)^long_arbitem:#\$~tmp1})
+compadd \"\$expl_opt[@]\" -S= - \$tmp2
+compadd \"\$expl_opt[@]\" -S '' - $__bool_"
+
+regex_short=(
+  %-
+  \(
+    /"$short_seq(${(j:|:)short_bool})($nul(${(j:|:)bool})|(${(j:|:)bool})|)$nul"
+      -"apt_consume_short \${_ra_match%%($nul(${(j:|:)bool})|(${(j:|:)bool})|)$nul}" \|
+    /"$short_seq(${(j:|:)short_bool})="
+      -"apt_consume_short \${_ra_match%=}"
+      \( /"$word1" !"$comp_bool" \| /"$nul" /"$word" !"$comp_bool" \) \|
+    /"$short_seq(${(j:|:)short_intlevel})($nul$intlevel|$intlevel|)$nul"
+      -"apt_consume_short \${_ra_match%%($nul$intlevel|$intlevel|)$nul}" \|
+    /"$short_seq(${(j:|:)short_intlevel})="
+      -"apt_consume_short \${_ra_match%=}"
+      \( /"$word1" !"$comp_intlevel" \| /"$nul" /"$word" !"$comp_intlevel" \) \|
+    /"$short_seq(${(j:|:)short_configfile})(=|)"
+      -"apt_consume_short \${_ra_match%=}"
+      \( /"$word1" !"$comp_configfile" \| /"$nul" /"$word" !"$comp_configfile" \) \|
+    /"$short_seq(${(j:|:)short_arbitem})(=|)"
+      -"apt_consume_short \${_ra_match%=}"
+      \( /"$word1" !"$comp_arbitem" \| /"$nul" /"$word" !"$comp_arbitem" \) \|
+    /"[]" !"{
+	      if [[ \$PREFIX = -$short_seq ]]; then
+		apt_consume_short \${PREFIX[2,-1]}
+		tmp1=(\${(k)short_to_option[(R)\${(kj:|:)~options[(R)*~0]}]})
+		tmp2=(-\${^tmp1})
+		compadd \"\$expl_opt[@]\" -y \"(\$tmp2)\" - \${PREFIX}\${^tmp1}
+	      fi
+	      $comp_long
+	    }"
+  \)
+)
+
+regex_long=(
+  %--
+  \(
+    /"(${(j:|:)long_bool})="
+      -"apt_consume_long \${_ra_match%=}"
+      \( /"$word1" !"$comp_bool" \| /"$nul" /"$word" !"$comp_bool" \) \|
+    /"(${(j:|:)long_bool})$nul"
+      -"apt_consume_long \${_ra_match%$nul}"
+      /"((${(j:|:)bool})$nul|)" !"$comp_bool" \|
+    /"(${(j:|:)long_intlevel})="
+      -"apt_consume_long \${_ra_match%=}"
+      \( /"$word1" !"$comp_intlevel" \| /"$nul" /"$word" !"$comp_intlevel" \) \|
+    /"(${(j:|:)long_intlevel})$nul"
+      -"apt_consume_long \${_ra_match%$nul}"
+      /"($intlevel$nul|)" !"$comp_intlevel" \|
+    /"(${(j:|:)long_configfile})$nul"
+      -"apt_consume_long \${_ra_match%$nul}"
+      /"$word" !"$comp_configfile" \|
+    /"(${(j:|:)long_configfile})="
+      -"apt_consume_long \${_ra_match%=}"
+      \( /"$word1" !"$comp_configfile" \| /"$nul" /"$word" !"$comp_configfile" \) \|
+    /"(${(j:|:)long_arbitem})$nul"
+      -"apt_consume_long \${_ra_match%$nul}"
+      /"$word" !"$comp_arbitem" \|
+    /"(${(j:|:)long_arbitem})="
+      -"apt_consume_long \${_ra_match%=}"
+      \( /"$word1" !"$comp_arbitem" \| /"$nul" /"$word" !"$comp_arbitem" \) \|
+    %"(${(j:|:)bool})-"
+    \(
+      /"(${(j:|:)long_bool})="
+	-"apt_consume_long \${_ra_match%=}"
+        \( /"$word1" !"$comp_bool" \| /"$nul" /"$word" !"$comp_bool" \) \|
+      /"(${(j:|:)long_bool})$nul"
+	-"apt_consume_long \${_ra_match%$nul}"
+        /"((${(j:|:)bool})$nul|)" !"$comp_bool" \|
+      /"(${(j:|:)long_intlevel})$nul"
+	-"apt_consume_long \${_ra_match%$nul}"
+        /"$intlevel" !"$comp_intlevel" /"$nul" \|
+      /"(${(j:|:)long_intlevel})="
+	-"apt_consume_long \${_ra_match%=}"
+        \( /"$word1" !"$comp_intlevel" \| /"$nul" /"$word" !"$comp_intlevel" \) \|
+      /"(${(j:|:)long_intlevel})$nul"
+	-"apt_consume_long \${_ra_match%$nul}"
+        /"($intlevel$nul|)" !"$comp_intlevel" \|
+      /"(${(j:|:)long_configfile})$nul"
+	-"apt_consume_long \${_ra_match%$nul}"
+        /"$word" !"$comp_configfile" \|
+      /"(${(j:|:)long_configfile})="
+	-"apt_consume_long \${_ra_match%=}"
+        \( /"$word1" !"$comp_configfile" \| /"$nul" /"$word" !"$comp_configfile" \) \|
+      /"(${(j:|:)long_arbitem})$nul"
+	-"apt_consume_long \${_ra_match%$nul}"
+        /"$word" !"$comp_arbitem" \|
+      /"(${(j:|:)long_arbitem})="
+	-"apt_consume_long \${_ra_match%=}"
+        \( /"$word1" !"$comp_arbitem" \| /"$nul" /"$word" !"$comp_arbitem" \) \|
+      /"(${(j:|:)short_bool})="
+	-"apt_consume_short \${_ra_match[-2]}"
+        \( /"$word1" !"$comp_bool" \| /"$nul" /"$word" !"$comp_bool" \) \|
+      /"(${(j:|:)short_bool})$nul"
+	-"apt_consume_short \${_ra_match[-2]}"
+        /"((${(j:|:)bool})$nul|)" !"$comp_bool" \|
+      /"(${(j:|:)short_intlevel})="
+	-"apt_consume_short \${_ra_match[-2]}"
+        \( /"$word1" !"$comp_intlevel" \| /"$nul" /"$word" !"$comp_intlevel" \) \|
+      /"(${(j:|:)short_intlevel})$nul"
+	-"apt_consume_short \${_ra_match[-2]}"
+        /"($intlevel$nul|)" !"$comp_intlevel" \|
+      /"(${(j:|:)short_configfile})$nul"
+	-"apt_consume_short \${_ra_match[-2]}"
+        /"$word" !"$comp_configfile" \|
+      /"(${(j:|:)short_configfile})="
+	-"apt_consume_short \${_ra_match[-2]}"
+        \( /"$word1" !"$comp_configfile" \| /"$nul" /"$word" !"$comp_configfile" \) \|
+      /"(${(j:|:)short_arbitem})$nul"
+	-"apt_consume_short \${_ra_match[-2]}"
+        /"$word" !"$comp_arbitem" \|
+      /"(${(j:|:)short_arbitem})="
+	-"apt_consume_short \${_ra_match[-2]}"
+        \( /"$word1" !"$comp_arbitem" \| /"$nul" /"$word" !"$comp_arbitem" \) \|
+      /"[]" !"{ tmp1=\${(kj:|:)long_to_option[(R)\${(kj:|:)~options[(R)*~0]}]}
+		tmp2=(\$_ra_left\${(M)^long_bool:#\$~tmp1} \$_ra_left\${(M)^long_intlevel:#\$~tmp1})
+		compadd \"\$expl_opt[@]\" - \$tmp2
+		tmp2=(\$_ra_left\${(M)^long_configfile:#\$~tmp1} \$_ra_left\${(M)^long_arbitem:#\$~tmp1})
+		compadd \"\$expl_opt[@]\" -S= - \$tmp2
+		tmp1=\${(kj:|:)short_to_option[(R)\${(kj:|:)~options[(R)*~0]}]}
+		tmp2=(\$_ra_left\${(M)^short_bool:#\$~tmp1} \$_ra_left\${(M)^short_intlevel:#\$~tmp1})
+		compadd \"\$expl_opt[@]\" - \$tmp2
+		tmp2=(\$_ra_left\${(M)^short_configfile:#\$~tmp1} \$_ra_left\${(M)^short_arbitem:#\$~tmp1})
+		compadd \"\$expl_opt[@]\" -S= - \$tmp2
+	      }"
+    \) \|
+    /"[]" !"{
+	      $comp_long
+	    }"
+  \)
+)
+
+regex_message=(
+  /"[]" !"[[ -prefix - || -z \"\$compconfig[option_prefix]\" ]] && {
+	    if [[ \$PREFIX = -$short_seq ]]; then
+	      apt_consume_short \${PREFIX[2,-1]}
+	      tmp1=(\${(k)short_to_option[(R)\${(kj:|:)~options[(R)*~0]}]})
+	      tmp2=(-\${^tmp1})
+	      compadd \"\$expl_opt[@]\" -y \"(\$tmp2)\" - \${PREFIX}\${^tmp1}
+	    elif [[ -z "\$PREFIX" ]]; then
+	      tmp1=(-\${(k)^short_to_option[(R)\${(kj:|:)~options[(R)*~0]}]})
+	      compadd \"\$expl_opt[@]\" - \$tmp1
+	    fi
+	    $comp_long
+	  }"
+)
+
+apt_consume_short () {
+  local short opt
+  for short in ${(s::)1}; do
+    opt="$short_to_option[$short]"
+    (( 0 < options[$opt] && options[$opt]-- ))
+  done
+}
+
+apt_consume_long () {
+  local long opt
+  opt="$long_to_option[$1]"
+  (( 0 < options[$opt] && options[$opt]-- ))
+}
+
+_regex_arguments "${funcname}_sm" /"$word" \( "$regex_long[@]" \| "$regex_short[@]" \| "$regex_message[@]" \) \# "$regex_action[@]"
+
+eval "$funcname () {
+  local short_bool short_intlevel short_configfile short_arbitem
+  local long_bool long_intlevel long_configfile long_arbitem
+  short_bool=($short_bool)
+  short_intlevel=($short_intlevel)
+  short_configfile=($short_configfile)
+  short_arbitem=($short_arbitem)
+  long_bool=($long_bool)
+  long_intlevel=($long_intlevel)
+  long_configfile=($long_configfile)
+  long_arbitem=($long_arbitem)
+
+  ${funcname}_sm
+}"
+
-- 
cgit 1.4.1