#                                                          -*- shell-script -*-

#

#   bash_completion - programmable completion functions for bash 4.1+

#

#   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>

#             © 2009-2017, Bash Completion Maintainers

#

#   This program is free software; you can redistribute it and/or modify

#   it under the terms of the GNU General Public License as published by

#   the Free Software Foundation; either version 2, or (at your option)

#   any later version.

#

#   This program is distributed in the hope that it will be useful,

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#   GNU General Public License for more details.

#

#   You should have received a copy of the GNU General Public License

#   along with this program; if not, write to the Free Software Foundation,

#   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

#

#   The latest version of this software can be obtained here:

#

#   https://github.com/scop/bash-completion

BASH_COMPLETION_VERSINFO=(2 7)

if [[ $- == *v* ]]; then

    BASH_COMPLETION_ORIGINAL_V_VALUE="-v"

else

    BASH_COMPLETION_ORIGINAL_V_VALUE="+v"

fi

if [[ ${BASH_COMPLETION_DEBUG-} ]]; then

    set -v

else

    set +v

fi

# Blacklisted completions, causing problems with our code.

#

_blacklist_glob='@(acroread.sh)'

# Turn on extended globbing and programmable completion

shopt -s extglob progcomp

# A lot of the following one-liners were taken directly from the

# completion examples provided with the bash 2.04 source distribution

# start of section containing compspecs that can be handled within bash

# user commands see only users

complete -u groups slay w sux

# bg completes with stopped jobs

complete -A stopped -P '"%' -S '"' bg

# other job commands

complete -j -P '"%' -S '"' fg jobs disown

# readonly and unset complete with shell variables

complete -v readonly unset

# set completes with set options

complete -A setopt set

# shopt completes with shopt options

complete -A shopt shopt

# helptopics

complete -A helptopic help

# unalias completes with aliases

complete -a unalias

# type and which complete on commands

complete -c command type which

# builtin completes on builtins

complete -b builtin

# start of section containing completion functions called by other functions

# Check if we're running on the given userland

# @param $1 userland to check for

_userland()

{

    local userland=$( uname -s )

    [[ $userland == @(Linux|GNU/*) ]] && userland=GNU

    [[ $userland == $1 ]]

}

# This function sets correct SysV init directories

#

_sysvdirs()

{

    sysvdirs=( )

    [[ -d /etc/rc.d/init.d ]] && sysvdirs+=( /etc/rc.d/init.d )

    [[ -d /etc/init.d ]] && sysvdirs+=( /etc/init.d )

    # Slackware uses /etc/rc.d

    [[ -f /etc/slackware-version ]] && sysvdirs=( /etc/rc.d )

}

# This function checks whether we have a given program on the system.

#

_have()

{

    # Completions for system administrator commands are installed as well in

    # case completion is attempted via `sudo command ...'.

    PATH=$PATH:/usr/sbin:/sbin:/usr/local/sbin type $1 &>/dev/null

}

# Backwards compatibility for compat completions that use have().

# @deprecated should no longer be used; generally not needed with dynamically

#             loaded completions, and _have is suitable for runtime use.

have()

{

    unset -v have

    _have $1 && have=yes

}

# This function checks whether a given readline variable

# is `on'.

#

_rl_enabled()

{

    [[ "$( bind -v )" == *$1+([[:space:]])on* ]]

}

# This function shell-quotes the argument

quote()

{

    local quoted=${1//\'/\'\\\'\'}

    printf "'%s'" "$quoted"

}

# @see _quote_readline_by_ref()

quote_readline()

{

    local quoted

    _quote_readline_by_ref "$1" ret

    printf %s "$ret"

} # quote_readline()

# This function shell-dequotes the argument

dequote()

{

    eval printf %s "$1" 2> /dev/null

}

# Assign variable one scope above the caller

# Usage: local "$1" && _upvar $1 "value(s)"

# Param: $1  Variable name to assign value to

# Param: $*  Value(s) to assign.  If multiple values, an array is

#            assigned, otherwise a single value is assigned.

# NOTE: For assigning multiple variables, use '_upvars'.  Do NOT

#       use multiple '_upvar' calls, since one '_upvar' call might

#       reassign a variable to be used by another '_upvar' call.

# See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference

_upvar()

{

    if unset -v "$1"; then           # Unset & validate varname

        if (( $# == 2 )); then

            eval $1=\"\$2\"          # Return single value

        else

            eval $1=\(\"\${@:2}\"\)  # Return array

        fi

    fi

}

# Assign variables one scope above the caller

# Usage: local varname [varname ...] &&

#        _upvars [-v varname value] | [-aN varname [value ...]] ...

# Available OPTIONS:

#     -aN  Assign next N values to varname as array

#     -v   Assign single value to varname

# Return: 1 if error occurs

# See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference

_upvars()

{

    if ! (( $# )); then

        echo "${FUNCNAME[0]}: usage: ${FUNCNAME[0]} [-v varname"\

            "value] | [-aN varname [value ...]] ..." 1>&2

        return 2

    fi

    while (( $# )); do

        case $1 in

            -a*)

                # Error checking

                [[ ${1#-a} ]] || { echo "bash: ${FUNCNAME[0]}: \`$1': missing"\

                    "number specifier" 1>&2; return 1; }

                printf %d "${1#-a}" &> /dev/null || { echo "bash:"\

                    "${FUNCNAME[0]}: \`$1': invalid number specifier" 1>&2

                    return 1; }

                # Assign array of -aN elements

                [[ "$2" ]] && unset -v "$2" && eval $2=\(\"\${@:3:${1#-a}}\"\) &&

                shift $((${1#-a} + 2)) || { echo "bash: ${FUNCNAME[0]}:"\

                    "\`$1${2+ }$2': missing argument(s)" 1>&2; return 1; }

                ;;

            -v)

                # Assign single value

                [[ "$2" ]] && unset -v "$2" && eval $2=\"\$3\" &&

                shift 3 || { echo "bash: ${FUNCNAME[0]}: $1: missing"\

                "argument(s)" 1>&2; return 1; }

                ;;

            *)

                echo "bash: ${FUNCNAME[0]}: $1: invalid option" 1>&2

                return 1 ;;

        esac

    done

}

# Reassemble command line words, excluding specified characters from the

# list of word completion separators (COMP_WORDBREAKS).

# @param $1 chars  Characters out of $COMP_WORDBREAKS which should

#     NOT be considered word breaks. This is useful for things like scp where

#     we want to return host:path and not only path, so we would pass the

#     colon (:) as $1 here.

# @param $2 words  Name of variable to return words to

# @param $3 cword  Name of variable to return cword to

#

__reassemble_comp_words_by_ref()

{

    local exclude i j line ref

    # Exclude word separator characters?

    if [[ $1 ]]; then

        # Yes, exclude word separator characters;

        # Exclude only those characters, which were really included

        exclude="${1//[^$COMP_WORDBREAKS]}"

    fi

    # Default to cword unchanged

    printf -v "$3" %s "$COMP_CWORD"

    # Are characters excluded which were former included?

    if [[ $exclude ]]; then

        # Yes, list of word completion separators has shrunk;

        line=$COMP_LINE

        # Re-assemble words to complete

        for (( i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do

            # Is current word not word 0 (the command itself) and is word not

            # empty and is word made up of just word separator characters to

            # be excluded and is current word not preceded by whitespace in

            # original line?

            while [[ $i -gt 0 && ${COMP_WORDS[$i]} == +([$exclude]) ]]; do

                # Is word separator not preceded by whitespace in original line

                # and are we not going to append to word 0 (the command

                # itself), then append to current word.

                [[ $line != [[:blank:]]* ]] && (( j >= 2 )) && ((j--))

                # Append word separator to current or new word

                ref="$2[$j]"

                printf -v "$ref" %s "${!ref}${COMP_WORDS[i]}"

                # Indicate new cword

                [[ $i == $COMP_CWORD ]] && printf -v "$3" %s "$j"

                # Remove optional whitespace + word separator from line copy

                line=${line#*"${COMP_WORDS[$i]}"}

                # Start new word if word separator in original line is

                # followed by whitespace.

                [[ $line == [[:blank:]]* ]] && ((j++))

                # Indicate next word if available, else end *both* while and

                # for loop

                (( $i < ${#COMP_WORDS[@]} - 1)) && ((i++)) || break 2

            done

            # Append word to current word

            ref="$2[$j]"

            printf -v "$ref" %s "${!ref}${COMP_WORDS[i]}"

            # Remove optional whitespace + word from line copy

            line=${line#*"${COMP_WORDS[i]}"}

            # Indicate new cword

            [[ $i == $COMP_CWORD ]] && printf -v "$3" %s "$j"

        done

        [[ $i == $COMP_CWORD ]] && printf -v "$3" %s "$j"

    else

        # No, list of word completions separators hasn't changed;

        for i in ${!COMP_WORDS[@]}; do

            printf -v "$2[i]" %s "${COMP_WORDS[i]}"

        done

    fi

} # __reassemble_comp_words_by_ref()

# @param $1 exclude  Characters out of $COMP_WORDBREAKS which should NOT be

#     considered word breaks. This is useful for things like scp where

#     we want to return host:path and not only path, so we would pass the

#     colon (:) as $1 in this case.

# @param $2 words  Name of variable to return words to

# @param $3 cword  Name of variable to return cword to

# @param $4 cur  Name of variable to return current word to complete to

# @see __reassemble_comp_words_by_ref()

__get_cword_at_cursor_by_ref()

{

    local cword words=()

    __reassemble_comp_words_by_ref "$1" words cword

    local i cur index=$COMP_POINT lead=${COMP_LINE:0:$COMP_POINT}

    # Cursor not at position 0 and not leaded by just space(s)?

    if [[ $index -gt 0 && ( $lead && ${lead//[[:space:]]} ) ]]; then

        cur=$COMP_LINE

        for (( i = 0; i <= cword; ++i )); do

            while [[

                # Current word fits in $cur?

                ${#cur} -ge ${#words[i]} &&

                # $cur doesn't match cword?

                "${cur:0:${#words[i]}}" != "${words[i]}"

            ]]; do

                # Strip first character

                cur="${cur:1}"

                # Decrease cursor position, staying >= 0

                [[ $index -gt 0 ]] && ((index--))

            done

            # Does found word match cword?

            if [[ $i -lt $cword ]]; then

                # No, cword lies further;

                local old_size=${#cur}

                cur="${cur#"${words[i]}"}"

                local new_size=${#cur}

                index=$(( index - old_size + new_size ))

            fi

        done

        # Clear $cur if just space(s)

        [[ $cur && ! ${cur//[[:space:]]} ]] && cur=

        # Zero $index if negative

        [[ $index -lt 0 ]] && index=0

    fi

    local "$2" "$3" "$4" && _upvars -a${#words[@]} $2 "${words[@]}" \

        -v $3 "$cword" -v $4 "${cur:0:$index}"

}

# Get the word to complete and optional previous words.

# This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases

# where the user is completing in the middle of a word.

# (For example, if the line is "ls foobar",

# and the cursor is here -------->   ^

# Also one is able to cross over possible wordbreak characters.

# Usage: _get_comp_words_by_ref [OPTIONS] [VARNAMES]

# Available VARNAMES:

#     cur         Return cur via $cur

#     prev        Return prev via $prev

#     words       Return words via $words

#     cword       Return cword via $cword

#

# Available OPTIONS:

#     -n EXCLUDE  Characters out of $COMP_WORDBREAKS which should NOT be

#                 considered word breaks. This is useful for things like scp

#                 where we want to return host:path and not only path, so we

#                 would pass the colon (:) as -n option in this case.

#     -c VARNAME  Return cur via $VARNAME

#     -p VARNAME  Return prev via $VARNAME

#     -w VARNAME  Return words via $VARNAME

#     -i VARNAME  Return cword via $VARNAME

#

# Example usage:

#

#    $ _get_comp_words_by_ref -n : cur prev

#

_get_comp_words_by_ref()

{

    local exclude flag i OPTIND=1

    local cur cword words=()

    local upargs=() upvars=() vcur vcword vprev vwords

    while getopts "c:i:n:p:w:" flag "$@"; do

        case $flag in

            c) vcur=$OPTARG ;;

            i) vcword=$OPTARG ;;

            n) exclude=$OPTARG ;;

            p) vprev=$OPTARG ;;

            w) vwords=$OPTARG ;;

        esac

    done

    while [[ $# -ge $OPTIND ]]; do

        case ${!OPTIND} in

            cur)   vcur=cur ;;

            prev)  vprev=prev ;;

            cword) vcword=cword ;;

            words) vwords=words ;;

            *) echo "bash: $FUNCNAME(): \`${!OPTIND}': unknown argument" \

                1>&2; return 1

        esac

        let "OPTIND += 1"

    done

    __get_cword_at_cursor_by_ref "$exclude" words cword cur

    [[ $vcur   ]] && { upvars+=("$vcur"  ); upargs+=(-v $vcur   "$cur"  ); }

    [[ $vcword ]] && { upvars+=("$vcword"); upargs+=(-v $vcword "$cword"); }

    [[ $vprev && $cword -ge 1 ]] && { upvars+=("$vprev" ); upargs+=(-v $vprev

        "${words[cword - 1]}"); }

    [[ $vwords ]] && { upvars+=("$vwords"); upargs+=(-a${#words[@]} $vwords

        "${words[@]}"); }

    (( ${#upvars[@]} )) && local "${upvars[@]}" && _upvars "${upargs[@]}"

}

# Get the word to complete.

# This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases

# where the user is completing in the middle of a word.

# (For example, if the line is "ls foobar",

# and the cursor is here -------->   ^

# @param $1 string  Characters out of $COMP_WORDBREAKS which should NOT be

#     considered word breaks. This is useful for things like scp where

#     we want to return host:path and not only path, so we would pass the

#     colon (:) as $1 in this case.

# @param $2 integer  Index number of word to return, negatively offset to the

#     current word (default is 0, previous is 1), respecting the exclusions

#     given at $1.  For example, `_get_cword "=:" 1' returns the word left of

#     the current word, respecting the exclusions "=:".

# @deprecated  Use `_get_comp_words_by_ref cur' instead

# @see _get_comp_words_by_ref()

_get_cword()

{

    local LC_CTYPE=C

    local cword words

    __reassemble_comp_words_by_ref "$1" words cword

    # return previous word offset by $2

    if [[ ${2//[^0-9]/} ]]; then

        printf "%s" "${words[cword-$2]}"

    elif [[ "${#words[cword]}" -eq 0 || "$COMP_POINT" == "${#COMP_LINE}" ]]; then

        printf "%s" "${words[cword]}"

    else

        local i

        local cur="$COMP_LINE"

        local index="$COMP_POINT"

        for (( i = 0; i <= cword; ++i )); do

            while [[

                # Current word fits in $cur?

                "${#cur}" -ge ${#words[i]} &&

                # $cur doesn't match cword?

                "${cur:0:${#words[i]}}" != "${words[i]}"

            ]]; do

                # Strip first character

                cur="${cur:1}"

                # Decrease cursor position, staying >= 0

                [[ $index -gt 0 ]] && ((index--))

            done

            # Does found word matches cword?

            if [[ "$i" -lt "$cword" ]]; then

                # No, cword lies further;

                local old_size="${#cur}"

                cur="${cur#${words[i]}}"

                local new_size="${#cur}"

                index=$(( index - old_size + new_size ))

            fi

        done

        if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then

            # We messed up! At least return the whole word so things

            # keep working

            printf "%s" "${words[cword]}"

        else

            printf "%s" "${cur:0:$index}"

        fi

    fi

} # _get_cword()

# Get word previous to the current word.

# This is a good alternative to `prev=${COMP_WORDS[COMP_CWORD-1]}' because bash4

# will properly return the previous word with respect to any given exclusions to

# COMP_WORDBREAKS.

# @deprecated  Use `_get_comp_words_by_ref cur prev' instead

# @see _get_comp_words_by_ref()

#

_get_pword()

{

    if [[ $COMP_CWORD -ge 1 ]]; then

        _get_cword "${@:-}" 1

    fi

}

# If the word-to-complete contains a colon (:), left-trim COMPREPLY items with

# word-to-complete.

# With a colon in COMP_WORDBREAKS, words containing

# colons are always completed as entire words if the word to complete contains

# a colon.  This function fixes this, by removing the colon-containing-prefix

# from COMPREPLY items.

# The preferred solution is to remove the colon (:) from COMP_WORDBREAKS in

# your .bashrc:

#

#    # Remove colon (:) from list of word completion separators

#    COMP_WORDBREAKS=${COMP_WORDBREAKS//:}

#

# See also: Bash FAQ - E13) Why does filename completion misbehave if a colon

# appears in the filename? - http://tiswww.case.edu/php/chet/bash/FAQ

# @param $1 current word to complete (cur)

# @modifies global array $COMPREPLY

#

__ltrim_colon_completions()

{

    if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then

        # Remove colon-word prefix from COMPREPLY items

        local colon_word=${1%"${1##*:}"}

        local i=${#COMPREPLY[*]}

        while [[ $((--i)) -ge 0 ]]; do

            COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}

        done

    fi

} # __ltrim_colon_completions()

# This function quotes the argument in a way so that readline dequoting

# results in the original argument.  This is necessary for at least

# `compgen' which requires its arguments quoted/escaped:

#

#     $ ls "a'b/"

#     c

#     $ compgen -f "a'b/"       # Wrong, doesn't return output

#     $ compgen -f "a\'b/"      # Good

#     a\'b/c

#

# See also:

# - http://lists.gnu.org/archive/html/bug-bash/2009-03/msg00155.html

# - http://www.mail-archive.com/bash-completion-devel@lists.alioth.\

#   debian.org/msg01944.html

# @param $1  Argument to quote

# @param $2  Name of variable to return result to

_quote_readline_by_ref()

{

    if [[ $1 == \'* ]]; then

        # Leave out first character

        printf -v $2 %s "${1:1}"

    else

        printf -v $2 %q "$1"

    fi

    # If result becomes quoted like this: $'string', re-evaluate in order to

    # drop the additional quoting.  See also: http://www.mail-archive.com/

    # bash-completion-devel@lists.alioth.debian.org/msg01942.html

    [[ ${!2} == \$* ]] && eval $2=${!2}

} # _quote_readline_by_ref()

# This function performs file and directory completion. It's better than

# simply using 'compgen -f', because it honours spaces in filenames.

# @param $1  If `-d', complete only on directories.  Otherwise filter/pick only

#            completions with `.$1' and the uppercase version of it as file

#            extension.

#

_filedir()

{

    local IFS=$'\n'

    _tilde "$cur" || return

    local -a toks

    local x tmp

    x=$( compgen -d -- "$cur" ) &&

    while read -r tmp; do

        toks+=( "$tmp" )

    done <<< "$x"

    if [[ "$1" != -d ]]; then

        local quoted

        _quote_readline_by_ref "$cur" quoted

        # Munge xspec to contain uppercase version too

        # http://thread.gmane.org/gmane.comp.shells.bash.bugs/15294/focus=15306

        local xspec=${1:+"!*.@($1|${1^^})"}

        x=$( compgen -f -X "$xspec" -- $quoted ) &&

        while read -r tmp; do

            toks+=( "$tmp" )

        done <<< "$x"

        # Try without filter if it failed to produce anything and configured to

        [[ -n ${COMP_FILEDIR_FALLBACK:-} && -n "$1" && ${#toks[@]} -lt 1 ]] && \

            x=$( compgen -f -- $quoted ) &&

            while read -r tmp; do

                toks+=( "$tmp" )

            done <<< "$x"

    fi

    if [[ ${#toks[@]} -ne 0 ]]; then

        # 2>/dev/null for direct invocation, e.g. in the _filedir unit test

        compopt -o filenames 2>/dev/null

        COMPREPLY+=( "${toks[@]}" )

    fi

} # _filedir()

# This function splits $cur=--foo=bar into $prev=--foo, $cur=bar, making it

# easier to support both "--foo bar" and "--foo=bar" style completions.

# `=' should have been removed from COMP_WORDBREAKS when setting $cur for

# this to be useful.

# Returns 0 if current option was split, 1 otherwise.

#

_split_longopt()

{

    if [[ "$cur" == --?*=* ]]; then

        # Cut also backslash before '=' in case it ended up there

        # for some reason.

        prev="${cur%%?(\\)=*}"

        cur="${cur#*=}"

        return 0

    fi

    return 1

}

# Complete variables.

# @return  True (0) if variables were completed,

#          False (> 0) if not.

_variables()

{

    if [[ $cur =~ ^(\$(\{[!#]?)?)([A-Za-z0-9_]*)$ ]]; then

        # Completing $var / ${var / ${!var / ${#var

        if [[ $cur == \${* ]]; then

            local arrs vars

            vars=( $( compgen -A variable -P ${BASH_REMATCH[1]} -S '}' -- ${BASH_REMATCH[3]} ) ) && \

            arrs=( $( compgen -A arrayvar -P ${BASH_REMATCH[1]} -S '[' -- ${BASH_REMATCH[3]} ) )

            if [[ ${#vars[@]} -eq 1 && $arrs ]]; then

                # Complete ${arr with ${array[ if there is only one match, and that match is an array variable

                compopt -o nospace

                COMPREPLY+=( ${arrs[*]} )

            else

                # Complete ${var with ${variable}

                COMPREPLY+=( ${vars[*]} )

            fi

        else

            # Complete $var with $variable

            COMPREPLY+=( $( compgen -A variable -P '$' -- "${BASH_REMATCH[3]}" ) )

        fi

        return 0

    elif [[ $cur =~ ^(\$\{[#!]?)([A-Za-z0-9_]*)\[([^]]*)$ ]]; then

        # Complete ${array[i with ${array[idx]}

        local IFS=$'\n'

        COMPREPLY+=( $( compgen -W '$(printf %s\\n "${!'${BASH_REMATCH[2]}'[@]}")' \

            -P "${BASH_REMATCH[1]}${BASH_REMATCH[2]}[" -S ']}' -- "${BASH_REMATCH[3]}" ) )

        # Complete ${arr[@ and ${arr[*

        if [[ ${BASH_REMATCH[3]} == [@*] ]]; then

            COMPREPLY+=( "${BASH_REMATCH[1]}${BASH_REMATCH[2]}[${BASH_REMATCH[3]}]}" )

        fi

        __ltrim_colon_completions "$cur"    # array indexes may have colons

        return 0

    elif [[ $cur =~ ^\$\{[#!]?[A-Za-z0-9_]*\[.*\]$ ]]; then

        # Complete ${array[idx] with ${array[idx]}

        COMPREPLY+=( "$cur}" )

        __ltrim_colon_completions "$cur"

        return 0

    else

        case $prev in

            TZ)

                cur=/usr/share/zoneinfo/$cur

                _filedir

                for i in ${!COMPREPLY[@]}; do

                    if [[ ${COMPREPLY[i]} == *.tab ]]; then

                        unset 'COMPREPLY[i]'

                        continue

                    elif [[ -d ${COMPREPLY[i]} ]]; then

                        COMPREPLY[i]+=/

                        compopt -o nospace

                    fi

                    COMPREPLY[i]=${COMPREPLY[i]#/usr/share/zoneinfo/}

                done

                return 0

                ;;

        esac

    fi

    return 1

}

# Initialize completion and deal with various general things: do file

# and variable completion where appropriate, and adjust prev, words,

# and cword as if no redirections exist so that completions do not

# need to deal with them.  Before calling this function, make sure

# cur, prev, words, and cword are local, ditto split if you use -s.

#

# Options:

#     -n EXCLUDE  Passed to _get_comp_words_by_ref -n with redirection chars

#     -e XSPEC    Passed to _filedir as first arg for stderr redirections

#     -o XSPEC    Passed to _filedir as first arg for other output redirections

#     -i XSPEC    Passed to _filedir as first arg for stdin redirections

#     -s          Split long options with _split_longopt, implies -n =

# @return  True (0) if completion needs further processing,

#          False (> 0) no further processing is necessary.

#

_init_completion()

{

    local exclude= flag outx errx inx OPTIND=1

    while getopts "n:e:o:i:s" flag "$@"; do

        case $flag in

            n) exclude+=$OPTARG ;;

            e) errx=$OPTARG ;;

            o) outx=$OPTARG ;;

            i) inx=$OPTARG ;;

            s) split=false ; exclude+== ;;

        esac

    done

    # For some reason completion functions are not invoked at all by

    # bash (at least as of 4.1.7) after the command line contains an

    # ampersand so we don't get a chance to deal with redirections

    # containing them, but if we did, hopefully the below would also

    # do the right thing with them...

    COMPREPLY=()

    local redir="@(?([0-9])<|?([0-9&])>?(>)|>&)"

    _get_comp_words_by_ref -n "$exclude<>&" cur prev words cword

    # Complete variable names.

    _variables && return 1

    # Complete on files if current is a redirect possibly followed by a

    # filename, e.g. ">foo", or previous is a "bare" redirect, e.g. ">".

    if [[ $cur == $redir* || $prev == $redir ]]; then

        local xspec

        case $cur in

            2'>'*) xspec=$errx ;;

            *'>'*) xspec=$outx ;;

            *'<'*) xspec=$inx ;;

            *)

                case $prev in

                    2'>'*) xspec=$errx ;;

                    *'>'*) xspec=$outx ;;

                    *'<'*) xspec=$inx ;;

                esac

                ;;

        esac

        cur="${cur##$redir}"

        _filedir $xspec

        return 1

    fi

    # Remove all redirections so completions don't have to deal with them.

    local i skip

    for (( i=1; i < ${#words[@]}; )); do

        if [[ ${words[i]} == $redir* ]]; then

            # If "bare" redirect, remove also the next word (skip=2).

            [[ ${words[i]} == $redir ]] && skip=2 || skip=1

            words=( "${words[@]:0:i}" "${words[@]:i+skip}" )

            [[ $i -le $cword ]] && cword=$(( cword - skip ))

        else

            i=$(( ++i ))

        fi

    done

    [[ $cword -le 0 ]] && return 1

    prev=${words[cword-1]}

    [[ ${split-} ]] && _split_longopt && split=true

    return 0

}

# Helper function for _parse_help and _parse_usage.

__parse_options()

{

    local option option2 i IFS=$' \t\n,/|'

    # Take first found long option, or first one (short) if not found.

    option=

    local -a array

    read -a array <<<"$1"

    for i in "${array[@]}"; do

        case "$i" in

            ---*) break ;;

            --?*) option=$i ; break ;;

            -?*)  [[ $option ]] || option=$i ;;

            *)    break ;;

        esac

    done

    [[ $option ]] || return

    IFS=$' \t\n' # affects parsing of the regexps below...

    # Expand --[no]foo to --foo and --nofoo etc

    if [[ $option =~ (\[((no|dont)-?)\]). ]]; then

        option2=${option/"${BASH_REMATCH[1]}"/}

        option2=${option2%%[<{().[]*}

        printf '%s\n' "${option2/=*/=}"

        option=${option/"${BASH_REMATCH[1]}"/"${BASH_REMATCH[2]}"}

    fi

    option=${option%%[<{().[]*}

    printf '%s\n' "${option/=*/=}"

}

# Parse GNU style help output of the given command.

# @param $1  command; if "-", read from stdin and ignore rest of args

# @param $2  command options (default: --help)

#

_parse_help()

{

    eval local cmd=$( quote "$1" )

    local line

    { case $cmd in

        -) cat ;;

        *) LC_ALL=C "$( dequote "$cmd" )" ${2:---help} 2>&1 ;;

      esac } \

    | while read -r line; do

        [[ $line == *([[:blank:]])-* ]] || continue

        # transform "-f FOO, --foo=FOO" to "-f , --foo=FOO" etc

        while [[ $line =~ \

            ((^|[^-])-[A-Za-z0-9?][[:space:]]+)\[?[A-Z0-9]+\]? ]]; do

            line=${line/"${BASH_REMATCH[0]}"/"${BASH_REMATCH[1]}"}

        done

        __parse_options "${line// or /, }"

    done

}

# Parse BSD style usage output (options in brackets) of the given command.

# @param $1  command; if "-", read from stdin and ignore rest of args

# @param $2  command options (default: --usage)

#

_parse_usage()

{

    eval local cmd=$( quote "$1" )

    local line match option i char

    { case $cmd in

        -) cat ;;

        *) LC_ALL=C "$( dequote "$cmd" )" ${2:---usage} 2>&1 ;;

      esac } \

    | while read -r line; do

        while [[ $line =~ \[[[:space:]]*(-[^]]+)[[:space:]]*\] ]]; do

            match=${BASH_REMATCH[0]}

            option=${BASH_REMATCH[1]}

            case $option in

                -?(\[)+([a-zA-Z0-9?]))

                    # Treat as bundled short options

                    for (( i=1; i < ${#option}; i++ )); do

                        char=${option:i:1}

                        [[ $char != '[' ]] && printf '%s\n' -$char

                    done

                    ;;

                *)

                    __parse_options "$option"

                    ;;

            esac

            line=${line#*"$match"}

        done

    done

}

# This function completes on signal names (minus the SIG prefix)

# @param $1 prefix

_signals()

{

    local -a sigs=( $( compgen -P "$1" -A signal "SIG${cur#$1}" ) )

    COMPREPLY+=( "${sigs[@]/#${1}SIG/${1}}" )

}

# This function completes on known mac addresses

#

_mac_addresses()

{

    local re='\([A-Fa-f0-9]\{2\}:\)\{5\}[A-Fa-f0-9]\{2\}'

    local PATH="$PATH:/sbin:/usr/sbin"

    # Local interfaces

    # - ifconfig on Linux: HWaddr or ether

    # - ifconfig on FreeBSD: ether

    # - ip link: link/ether

    COMPREPLY+=( $( \

        { LC_ALL=C ifconfig -a || ip link show; } 2>/dev/null | command sed -ne \

        "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]].*/\1/p" -ne \

        "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]]*$/\1/p" -ne \

        "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]].*|\2|p" -ne \

        "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]]*$|\2|p"

        ) )

    # ARP cache

    COMPREPLY+=( $( { arp -an || ip neigh show; } 2>/dev/null | command sed -ne \

        "s/.*[[:space:]]\($re\)[[:space:]].*/\1/p" -ne \

        "s/.*[[:space:]]\($re\)[[:space:]]*$/\1/p" ) )