scripts/west_commands/completion/west-completion.bash - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 # Bash auto-completion for west subcommands and flags. To initialize, run
 #
 #     source west-completion.bash
 #
 # To make it persistent, add it to e.g. your .bashrc.

 __west_previous_extglob_setting=$(shopt -p extglob)
 shopt -s extglob

 # The following function is based on code from:
 #
 #   bash_completion - programmable completion functions for bash 3.2+
 #
 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 #             © 2009-2010, Bash Completion Maintainers
 #                     <bash-completion-devel@lists.alioth.debian.org>
 #
 #   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, see <http://www.gnu.org/licenses/>.
 #
 #   The latest version of this software can be obtained here:
 #
 #   http://bash-completion.alioth.debian.org/
 #
 #   RELEASE: 2.x

 # This function can be used to access a tokenized list of words
 # on the command line:
 #
 #	__git_reassemble_comp_words_by_ref '=:'
 #	if test "${words_[cword_-1]}" = -w
 #	then
 #		...
 #	fi
 #
 # The argument should be a collection of characters from the list of
 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
 # characters.
 #
 # This is roughly equivalent to going back in time and setting
 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 # make option types like --date=<type> and <rev>:<path> easy to
 # recognize by treating each shell word as a single token.
 #
 # It is best not to set COMP_WORDBREAKS directly because the value is
 # shared with other completion scripts.  By the time the completion
 # function gets called, COMP_WORDS has already been populated so local
 # changes to COMP_WORDBREAKS have no effect.
 #
 # Output: words_, cword_, cur_.

 __west_reassemble_comp_words_by_ref()
 {
 	local exclude i j first
 	# Which word separators to exclude?
 	exclude="${1//[^$COMP_WORDBREAKS]}"
 	cword_=$COMP_CWORD
 	if [ -z "$exclude" ]; then
 		words_=("${COMP_WORDS[@]}")
 		return
 	fi
 	# List of word completion separators has shrunk;
 	# re-assemble words to complete.
 	for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 		# Append each nonempty word consisting of just
 		# word separator characters to the current word.
 		first=t
 		while
 			[ $i -gt 0 ] &&
 			[ -n "${COMP_WORDS[$i]}" ] &&
 			# word consists of excluded word separators
 			[ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 		do
 			# Attach to the previous token,
 			# unless the previous token is the command name.
 			if [ $j -ge 2 ] && [ -n "$first" ]; then
 				((j--))
 			fi
 			first=
 			words_[$j]=${words_[j]}${COMP_WORDS[i]}
 			if [ $i = $COMP_CWORD ]; then
 				cword_=$j
 			fi
 			if (($i < ${#COMP_WORDS[@]} - 1)); then
 				((i++))
 			else
 				# Done.
 				return
 			fi
 		done
 		words_[$j]=${words_[j]}${COMP_WORDS[i]}
 		if [ $i = $COMP_CWORD ]; then
 			cword_=$j
 		fi
 	done
 }

 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 _get_comp_words_by_ref ()
 {
 	local exclude cur_ words_ cword_
 	if [ "$1" = "-n" ]; then
 		exclude=$2
 		shift 2
 	fi
 	__west_reassemble_comp_words_by_ref "$exclude"
 	cur_=${words_[cword_]}
 	while [ $# -gt 0 ]; do
 		case "$1" in
 		cur)
 			cur=$cur_
 			;;
 		prev)
 			prev=${words_[$cword_-1]}
 			;;
 		words)
 			words=("${words_[@]}")
 			;;
 		cword)
 			cword=$cword_
 			;;
 		esac
 		shift
 	done
 }
 fi

 if ! type _tilde >/dev/null 2>&1; then
 # Perform tilde (~) completion
 # @return  True (0) if completion needs further processing,
 #          False (> 0) if tilde is followed by a valid username, completions
 #          are put in COMPREPLY and no further processing is necessary.
 _tilde()
 {
     local result=0
     if [[ $1 == \~* && $1 != */* ]]; then
         # Try generate ~username completions
         COMPREPLY=( $( compgen -P '~' -u -- "${1#\~}" ) )
         result=${#COMPREPLY[@]}
         # 2>/dev/null for direct invocation, e.g. in the _tilde unit test
         [[ $result -gt 0 ]] && compopt -o filenames 2>/dev/null
     fi
     return $result
 }
 fi

 if ! type _quote_readline_by_ref >/dev/null 2>&1; then
 # 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 [ -z "$1" ]; then
         # avoid quoting if empty
         printf -v $2 %s "$1"
     elif [[ $1 == \'* ]]; then
         # Leave out first character
         printf -v $2 %s "${1:1}"
     elif [[ $1 == \~* ]]; then
         # avoid escaping first ~
         printf -v $2 \~%q "${1:1}"
     else
         printf -v $2 %q "$1"
     fi

     # Replace double escaping ( \\ ) by single ( \ )
     # This happens always when argument is already escaped at cmdline,
     # and passed to this function as e.g.: file\ with\ spaces
     [[ ${!2} == *\\* ]] && printf -v $2 %s "${1//\\\\/\\}"

     # 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()
 fi

 # This function turns on "-o filenames" behavior dynamically. It is present
 # for bash < 4 reasons. See http://bugs.debian.org/272660#64 for info about
 # the bash < 4 compgen hack.
 _compopt_o_filenames()
 {
     # We test for compopt availability first because directly invoking it on
     # bash < 4 at this point may cause terminal echo to be turned off for some
     # reason, see https://bugzilla.redhat.com/653669 for more info.
     type compopt &>/dev/null && compopt -o filenames 2>/dev/null || \
         compgen -f /non-existing-dir/ >/dev/null
 }

 if ! type _filedir >/dev/null 2>&1; then
 # 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
         COMPREPLY+=( "${toks[@]}" )
     fi
 } # _filedir()
 fi

 # Misc helpers taken from Docker:
 # https://github.com/docker/docker-ce/blob/master/components/cli/contrib/completion/bash/docker

 # __west_pos_first_nonflag finds the position of the first word that is neither
 # option nor an option's argument. If there are options that require arguments,
 # you should pass a glob describing those options, e.g. "--option1|-o|--option2"
 # Use this function to restrict completions to exact positions after the argument list.
 __west_pos_first_nonflag()
 {
 	local argument_flags=$1

 	local counter=$((${subcommand_pos:-${command_pos}} + 1))
 	while [ "$counter" -le "$cword" ]; do
 		if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
 			(( counter++ ))
 			# eat "=" in case of --option=arg syntax
 			[ "${words[$counter]}" = "=" ] && (( counter++ ))
 		else
 			case "${words[$counter]}" in
 				-*)
 					;;
 				*)
 					break
 					;;
 			esac
 		fi

 		# Bash splits words at "=", retaining "=" as a word, examples:
 		# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
 		while [ "${words[$counter + 1]}" = "=" ] ; do
 			counter=$(( counter + 2))
 		done

 		(( counter++ ))
 	done

 	echo $counter
 }

 # __west_map_key_of_current_option returns `key` if we are currently completing the
 # value of a map option (`key=value`) which matches the extglob given as an argument.
 # This function is needed for key-specific completions.
 __west_map_key_of_current_option()
 {
 	local glob="$1"

 	local key glob_pos
 	if [ "$cur" = "=" ] ; then        # key= case
 		key="$prev"
 		glob_pos=$((cword - 2))
 	elif [[ $cur == *=* ]] ; then     # key=value case (OSX)
 		key=${cur%=*}
 		glob_pos=$((cword - 1))
 	elif [ "$prev" = "=" ] ; then
 		key=${words[$cword - 2]}  # key=value case
 		glob_pos=$((cword - 3))
 	else
 		return
 	fi

 	[ "${words[$glob_pos]}" = "=" ] && ((glob_pos--))  # --option=key=value syntax

 	[[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
 }

 # __west_value_of_option returns the value of the first option matching `option_glob`.
 # Valid values for `option_glob` are option names like `--log-level` and globs like
 # `--log-level|-l`
 # Only positions between the command and the current word are considered.
 __west_value_of_option()
 {
 	local option_extglob=$(__west_to_extglob "$1")

 	local counter=$((command_pos + 1))
 	while [ "$counter" -lt "$cword" ]; do
 		case ${words[$counter]} in
 			$option_extglob )
 				echo "${words[$counter + 1]}"
 				break
 				;;
 		esac
 		(( counter++ ))
 	done
 }

 # __west_to_alternatives transforms a multiline list of strings into a single line
 # string with the words separated by `|`.
 # This is used to prepare arguments to __west_pos_first_nonflag().
 __west_to_alternatives()
 {
 	local parts=( $1 )
 	local IFS='|'
 	echo "${parts[*]}"
 }

 # __west_to_extglob transforms a multiline list of options into an extglob pattern
 # suitable for use in case statements.
 __west_to_extglob()
 {
 	local extglob=$( __west_to_alternatives "$1" )
 	echo "@($extglob)"
 }

 __set_comp_dirs()
 {
 	_filedir -d
 }

 __set_comp_files()
 {
 	_filedir
 }

 # Sets completions for $cur, from the possibilities in $1..n
 __set_comp()
 {
 	# "${*:1}" gives a single argument with arguments $1..n
 	COMPREPLY=($(compgen -W "${*:1}" -- "$cur"))
 }


 __west_x()
 {
 	west 2>/dev/null "$@"
 }

 __set_comp_west_projs()
 {
 	__set_comp "$(__west_x list --format={name} "$@")"
 }

 __set_comp_west_boards()
 {
 	__set_comp "$(__west_x boards --format={name} "$@")"
 }

 __comp_west_west()
 {
 	case "$prev" in
 		--zephyr-base|-z)
 			__set_comp_dirs
 			return
 			;;
 		# We don't know how to autocomplete any others
 		$(__west_to_extglob "$global_args_opts") )
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $global_bool_opts $global_args_opts
 			;;
 		*)
 			local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
 			if [ "$cword" -eq "$counter" ]; then
 				__set_comp ${cmds[*]}
 			fi
 			;;
 	esac
 }

 __comp_west_init()
 {
 	local init_args_opts="
 		--manifest -m
 		--manifest-rev --mr
 		--local -l
 	"

 	case "$prev" in
 		--local|-l)
 			__set_comp_dirs
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $init_args_opts
 			;;
 	esac
 }

 __comp_west_update()
 {
 	local update_bool_opts="
 		--keep-descendants -k
 		--rebase -r
 	"

 	case "$cur" in
 		-*)
 			__set_comp $update_bool_opts
 			;;
 		*)
 			__set_comp_west_projs
 			;;
 	esac
 }

 __comp_west_list()
 {
 	local list_args_opts="
 		--format -f
 	"

 	case "$prev" in
 		# We don't know how to autocomplete those
 		$(__west_to_extglob "$list_args_opts") )
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $list_args_opts
 			;;
 		*)
 			__set_comp_west_projs
 			;;
 	esac
 }

 __comp_west_manifest()
 {
 	local manifest_bool_opts="
 		--freeze
 	"
 	local manifest_args_opts="
 		--out -o
 	"

 	case "$prev" in
 		--out|-o)
 			__set_comp_files
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $manifest_bool_opts $manifest_args_opts
 			;;
 	esac
 }

 __comp_west_diff()
 {
 	case "$cur" in
 		*)
 			__set_comp_west_projs
 			;;
 	esac
 }

 __comp_west_status()
 {
 	case "$cur" in
 		*)
 			__set_comp_west_projs
 			;;
 	esac
 }

 __comp_west_forall()
 {
 	local forall_args_opts="
 		-c
 	"

 	case "$prev" in
 		# We don't know how to autocomplete those
 		$(__west_to_extglob "$forall_args_opts") )
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $forall_args_opts
 			;;
 		*)
 			__set_comp_west_projs
 			;;
 	esac
 }

 __comp_west_config()
 {
 	local config_bool_opts="
 		--global
 		--local
 		--system
 	"

 	case "$cur" in
 		-*)
 			__set_comp $config_bool_opts
 			;;
 	esac
 }

 __comp_west_help()
 {
 	case "$cur" in
 		*)
 			local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
 			if [ "$cword" -eq "$counter" ]; then
 				__set_comp ${cmds[*]}
 			fi
 			;;
 	esac
 }

 # Zephyr extension commands
 __comp_west_completion()
 {
 	case "$cur" in
 		*)
 			local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
 			if [ "$cword" -eq "$counter" ]; then
 				__set_comp "bash"
 			fi
 			;;
 	esac
 }

 __comp_west_boards()
 {
 	local boards_args_opts="
 		--format -f --name -n
 		--arch-root --board-root
 	"

 	case "$prev" in
 		--format|-f|--name|-n)
 			# We don't know how to autocomplete these.
 			return
 			;;
 		--arch-root)
 			__set_comp_dirs
 			return
 			;;
 		--board-root)
 			__set_comp_dirs
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $boards_args_opts
 			;;
 	esac
 }

 __comp_west_build()
 {
 	local build_bool_opts="
 		--cmake -c
 		--cmake-only
 		-n --just-print --dry-run --recon
 		--force -f
 	"

 	local build_args_opts="
 		--board -b
 		--build-dir -d
 		--target -t
 		--pristine -p
 		--build-opt -o
 	"

 	case "$prev" in
 		--board|-b)
 			__set_comp_west_boards
 			return
 			;;
 		--build-dir|-d)
 			__set_comp_dirs
 			return
 			;;
 		--pristine|-p)
 			__set_comp "auto always never"
 			return
 			;;
 		# We don't know how to autocomplete those
 		$(__west_to_extglob "$build_args_opts") )
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $build_bool_opts $build_args_opts
 			;;
 		*)
 			__set_comp_dirs
 			;;
 	esac
 }

 __comp_west_sign()
 {
 	local sign_bool_opts="
 		--force -f
 		--bin --no-bin
 		--hex --no-hex
 	"

 	local sign_args_opts="
 		--build-dir -d
 		--tool -t
 		--tool-path -p
 		-B --sbin
 		-H --shex
 	"

 	case "$prev" in
 		--build-dir|-d|--tool-path|-p)
 			__set_comp_dirs
 			return
 			;;
 		--tool|-t)
 			__set_comp "imgtool"
 			return
 			;;
 		-B|--sbin|-H|--shex)
 			__set_comp_files
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $sign_bool_opts $sign_args_opts
 			;;
 	esac
 }

 __comp_west_runner_cmd()
 {
 	# Common arguments for runners
 	local runner_bool_opts="
 		--context -H
 		--skip-rebuild
 	"
 	local runner_args_opts="
 	--build-dir -d
 	--cmake-cache -c
 	--runner -r
 	--board-dir
 	--elf-file
 	--hex-file
 	--bin-file
 	--gdb
 	--openocd
 	--openocd-search
 	"

 	case "$prev" in
 		--build-dir|-d|--cmake-cache|-c|--board-dir|--gdb|--openocd|--openocd-search)
 			__set_comp_dirs
 			return
 			;;
 		--elf-file|--hex-file|--bin-file)
 			__set_comp_files
 			return
 			;;
 	esac

 	case "$cur" in
 		-*)
 			__set_comp $runner_bool_opts $runner_args_opts
 			;;
 	esac
 }

 __comp_west_flash()
 {
 	__comp_west_runner_cmd
 }

 __comp_west_debug()
 {
 	__comp_west_runner_cmd
 }

 __comp_west_debugserver()
 {
 	__comp_west_runner_cmd
 }

 __comp_west_attach()
 {
 	__comp_west_runner_cmd
 }

 __comp_west()
 {
 	local previous_extglob_setting=$(shopt -p extglob)
 	shopt -s extglob
 	# Reset to default, to make sure compgen works properly
 	local IFS=$' \t\n'

 	local builtin_cmds=(
 		init
 		update
 		list
 		manifest
 		diff
 		status
 		forall
 		config
 		help
 	)

 	local zephyr_ext_cmds=(
 		completion
 		boards
 		build
 		sign
 		flash
 		debug
 		debugserver
 		attach
 		zephyr-export
 	)

 	local cmds=(${builtin_cmds[*]} ${zephyr_ext_cmds[*]})

 	# Global options for all commands
 	local global_bool_opts="
 		--help -h
 		--verbose -v
 		--version -V
 	"
 	local global_args_opts="
 		--zephyr-base -z
 	"

 	COMPREPLY=()
 	local cur words cword prev
 	_get_comp_words_by_ref -n : cur words cword prev

 	local command='west' command_pos=0
 	local counter=1
 	while [ "$counter" -lt "$cword" ]; do
 		case "${words[$counter]}" in
 			west)
 				return 0
 				;;
 			$(__west_to_extglob "$global_args_opts") )
 				(( counter++ ))
 				;;
 			-*)
 				;;
 			=)
 				(( counter++ ))
 				;;
 			*)
 				command="${words[$counter]}"
 				command_pos=$counter
 				break
 				;;
 		esac
 		(( counter++ ))
 	done


 	# Construct the function name to be called
 	local completions_func=__comp_west_${command//-/_}
 	#echo "comp_func: ${completions_func}"
 	declare -F $completions_func >/dev/null && $completions_func

 	# Restore the user's extglob setting
 	eval "$previous_extglob_setting"
 	return 0
 }

 eval "$__west_previous_extglob_setting"
 unset __west_previous_extglob_setting

 complete -F __comp_west west
	# Bash auto-completion for west subcommands and flags. To initialize, run
	#
	# source west-completion.bash
	#
	# To make it persistent, add it to e.g. your .bashrc.

	__west_previous_extglob_setting=$(shopt -p extglob)
	shopt -s extglob

	# The following function is based on code from:
	#
	# bash_completion - programmable completion functions for bash 3.2+
	#
	# Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
	# © 2009-2010, Bash Completion Maintainers
	# <bash-completion-devel@lists.alioth.debian.org>
	#
	# 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, see <http://www.gnu.org/licenses/>.
	#
	# The latest version of this software can be obtained here:
	#
	# http://bash-completion.alioth.debian.org/
	#
	# RELEASE: 2.x

	# This function can be used to access a tokenized list of words
	# on the command line:
	#
	# __git_reassemble_comp_words_by_ref '=:'
	# if test "${words_[cword_-1]}" = -w
	# then
	# ...
	# fi
	#
	# The argument should be a collection of characters from the list of
	# word completion separators (COMP_WORDBREAKS) to treat as ordinary
	# characters.
	#
	# This is roughly equivalent to going back in time and setting
	# COMP_WORDBREAKS to exclude those characters. The intent is to
	# make option types like --date=<type> and <rev>:<path> easy to
	# recognize by treating each shell word as a single token.
	#
	# It is best not to set COMP_WORDBREAKS directly because the value is
	# shared with other completion scripts. By the time the completion
	# function gets called, COMP_WORDS has already been populated so local
	# changes to COMP_WORDBREAKS have no effect.
	#
	# Output: words_, cword_, cur_.

	__west_reassemble_comp_words_by_ref()
	{
	local exclude i j first
	# Which word separators to exclude?
	exclude="${1//[^$COMP_WORDBREAKS]}"
	cword_=$COMP_CWORD
	if [ -z "$exclude" ]; then
	words_=("${COMP_WORDS[@]}")
	return
	fi
	# List of word completion separators has shrunk;
	# re-assemble words to complete.
	for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
	# Append each nonempty word consisting of just
	# word separator characters to the current word.
	first=t
	while
	[ $i -gt 0 ] &&
	[ -n "${COMP_WORDS[$i]}" ] &&
	# word consists of excluded word separators
	[ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
	do
	# Attach to the previous token,
	# unless the previous token is the command name.
	if [ $j -ge 2 ] && [ -n "$first" ]; then
	((j--))
	fi
	first=
	words_[$j]=${words_[j]}${COMP_WORDS[i]}
	if [ $i = $COMP_CWORD ]; then
	cword_=$j
	fi
	if (($i < ${#COMP_WORDS[@]} - 1)); then
	((i++))
	else
	# Done.
	return
	fi
	done
	words_[$j]=${words_[j]}${COMP_WORDS[i]}
	if [ $i = $COMP_CWORD ]; then
	cword_=$j
	fi
	done
	}

	if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
	_get_comp_words_by_ref ()
	{
	local exclude cur_ words_ cword_
	if [ "$1" = "-n" ]; then
	exclude=$2
	shift 2
	fi
	__west_reassemble_comp_words_by_ref "$exclude"
	cur_=${words_[cword_]}
	while [ $# -gt 0 ]; do
	case "$1" in
	cur)
	cur=$cur_
	;;
	prev)
	prev=${words_[$cword_-1]}
	;;
	words)
	words=("${words_[@]}")
	;;
	cword)
	cword=$cword_
	;;
	esac
	shift
	done
	}
	fi

	if ! type _tilde >/dev/null 2>&1; then
	# Perform tilde (~) completion
	# @return True (0) if completion needs further processing,
	# False (> 0) if tilde is followed by a valid username, completions
	# are put in COMPREPLY and no further processing is necessary.
	_tilde()
	{
	local result=0
	if [[ $1 == \~* && $1 != / ]]; then
	# Try generate ~username completions
	COMPREPLY=( $( compgen -P '~' -u -- "${1#\~}" ) )
	result=${#COMPREPLY[@]}
	# 2>/dev/null for direct invocation, e.g. in the _tilde unit test
	[[ $result -gt 0 ]] && compopt -o filenames 2>/dev/null
	fi
	return $result
	}
	fi

	if ! type _quote_readline_by_ref >/dev/null 2>&1; then
	# 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 [ -z "$1" ]; then
	# avoid quoting if empty
	printf -v $2 %s "$1"
	elif [[ $1 == \'* ]]; then
	# Leave out first character
	printf -v $2 %s "${1:1}"
	elif [[ $1 == \~* ]]; then
	# avoid escaping first ~
	printf -v $2 \~%q "${1:1}"
	else
	printf -v $2 %q "$1"
	fi

	# Replace double escaping ( \\ ) by single ( \ )
	# This happens always when argument is already escaped at cmdline,
	# and passed to this function as e.g.: file\ with\ spaces
	[[ ${!2} == \\ ]] && printf -v $2 %s "${1//\\\\/\\}"

	# 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()
	fi

	# This function turns on "-o filenames" behavior dynamically. It is present
	# for bash < 4 reasons. See http://bugs.debian.org/272660#64 for info about
	# the bash < 4 compgen hack.
	_compopt_o_filenames()
	{
	# We test for compopt availability first because directly invoking it on
	# bash < 4 at this point may cause terminal echo to be turned off for some
	# reason, see https://bugzilla.redhat.com/653669 for more info.
	type compopt &>/dev/null && compopt -o filenames 2>/dev/null \|\| \
	compgen -f /non-existing-dir/ >/dev/null
	}

	if ! type _filedir >/dev/null 2>&1; then
	# 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
	COMPREPLY+=( "${toks[@]}" )
	fi
	} # _filedir()
	fi

	# Misc helpers taken from Docker:
	# https://github.com/docker/docker-ce/blob/master/components/cli/contrib/completion/bash/docker

	# __west_pos_first_nonflag finds the position of the first word that is neither
	# option nor an option's argument. If there are options that require arguments,
	# you should pass a glob describing those options, e.g. "--option1\|-o\|--option2"
	# Use this function to restrict completions to exact positions after the argument list.
	__west_pos_first_nonflag()
	{
	local argument_flags=$1

	local counter=$((${subcommand_pos:-${command_pos}} + 1))
	while [ "$counter" -le "$cword" ]; do
	if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
	(( counter++ ))
	# eat "=" in case of --option=arg syntax
	[ "${words[$counter]}" = "=" ] && (( counter++ ))
	else
	case "${words[$counter]}" in
	-*)
	;;
	*)
	break
	;;
	esac
	fi

	# Bash splits words at "=", retaining "=" as a word, examples:
	# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
	while [ "${words[$counter + 1]}" = "=" ] ; do
	counter=$(( counter + 2))
	done

	(( counter++ ))
	done

	echo $counter
	}

	# __west_map_key_of_current_option returns `key` if we are currently completing the
	# value of a map option (`key=value`) which matches the extglob given as an argument.
	# This function is needed for key-specific completions.
	__west_map_key_of_current_option()
	{
	local glob="$1"

	local key glob_pos
	if [ "$cur" = "=" ] ; then # key= case
	key="$prev"
	glob_pos=$((cword - 2))
	elif [[ $cur == = ]] ; then # key=value case (OSX)
	key=${cur%=*}
	glob_pos=$((cword - 1))
	elif [ "$prev" = "=" ] ; then
	key=${words[$cword - 2]} # key=value case
	glob_pos=$((cword - 3))
	else
	return
	fi

	[ "${words[$glob_pos]}" = "=" ] && ((glob_pos--)) # --option=key=value syntax

	[[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
	}

	# __west_value_of_option returns the value of the first option matching `option_glob`.
	# Valid values for `option_glob` are option names like `--log-level` and globs like
	# `--log-level\|-l`
	# Only positions between the command and the current word are considered.
	__west_value_of_option()
	{
	local option_extglob=$(__west_to_extglob "$1")

	local counter=$((command_pos + 1))
	while [ "$counter" -lt "$cword" ]; do
	case ${words[$counter]} in
	$option_extglob )
	echo "${words[$counter + 1]}"
	break
	;;
	esac
	(( counter++ ))
	done
	}

	# __west_to_alternatives transforms a multiline list of strings into a single line
	# string with the words separated by `\|`.
	# This is used to prepare arguments to __west_pos_first_nonflag().
	__west_to_alternatives()
	{
	local parts=( $1 )
	local IFS='\|'
	echo "${parts[*]}"
	}

	# __west_to_extglob transforms a multiline list of options into an extglob pattern
	# suitable for use in case statements.
	__west_to_extglob()
	{
	local extglob=$( __west_to_alternatives "$1" )
	echo "@($extglob)"
	}

	__set_comp_dirs()
	{
	_filedir -d
	}

	__set_comp_files()
	{
	_filedir
	}

	# Sets completions for $cur, from the possibilities in $1..n
	__set_comp()
	{
	# "${*:1}" gives a single argument with arguments $1..n
	COMPREPLY=($(compgen -W "${*:1}" -- "$cur"))
	}


	__west_x()
	{
	west 2>/dev/null "$@"
	}

	__set_comp_west_projs()
	{
	__set_comp "$(__west_x list --format={name} "$@")"
	}

	__set_comp_west_boards()
	{
	__set_comp "$(__west_x boards --format={name} "$@")"
	}

	__comp_west_west()
	{
	case "$prev" in
	--zephyr-base\|-z)
	__set_comp_dirs
	return
	;;
	# We don't know how to autocomplete any others
	$(__west_to_extglob "$global_args_opts") )
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $global_bool_opts $global_args_opts
	;;
	*)
	local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
	if [ "$cword" -eq "$counter" ]; then
	__set_comp ${cmds[*]}
	fi
	;;
	esac
	}

	__comp_west_init()
	{
	local init_args_opts="
	--manifest -m
	--manifest-rev --mr
	--local -l
	"

	case "$prev" in
	--local\|-l)
	__set_comp_dirs
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $init_args_opts
	;;
	esac
	}

	__comp_west_update()
	{
	local update_bool_opts="
	--keep-descendants -k
	--rebase -r
	"

	case "$cur" in
	-*)
	__set_comp $update_bool_opts
	;;
	*)
	__set_comp_west_projs
	;;
	esac
	}

	__comp_west_list()
	{
	local list_args_opts="
	--format -f
	"

	case "$prev" in
	# We don't know how to autocomplete those
	$(__west_to_extglob "$list_args_opts") )
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $list_args_opts
	;;
	*)
	__set_comp_west_projs
	;;
	esac
	}

	__comp_west_manifest()
	{
	local manifest_bool_opts="
	--freeze
	"
	local manifest_args_opts="
	--out -o
	"

	case "$prev" in
	--out\|-o)
	__set_comp_files
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $manifest_bool_opts $manifest_args_opts
	;;
	esac
	}

	__comp_west_diff()
	{
	case "$cur" in
	*)
	__set_comp_west_projs
	;;
	esac
	}

	__comp_west_status()
	{
	case "$cur" in
	*)
	__set_comp_west_projs
	;;
	esac
	}

	__comp_west_forall()
	{
	local forall_args_opts="
	-c
	"

	case "$prev" in
	# We don't know how to autocomplete those
	$(__west_to_extglob "$forall_args_opts") )
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $forall_args_opts
	;;
	*)
	__set_comp_west_projs
	;;
	esac
	}

	__comp_west_config()
	{
	local config_bool_opts="
	--global
	--local
	--system
	"

	case "$cur" in
	-*)
	__set_comp $config_bool_opts
	;;
	esac
	}

	__comp_west_help()
	{
	case "$cur" in
	*)
	local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
	if [ "$cword" -eq "$counter" ]; then
	__set_comp ${cmds[*]}
	fi
	;;
	esac
	}

	# Zephyr extension commands
	__comp_west_completion()
	{
	case "$cur" in
	*)
	local counter=$( __west_pos_first_nonflag "$(__west_to_extglob "$global_args_opts")" )
	if [ "$cword" -eq "$counter" ]; then
	__set_comp "bash"
	fi
	;;
	esac
	}

	__comp_west_boards()
	{
	local boards_args_opts="
	--format -f --name -n
	--arch-root --board-root
	"

	case "$prev" in
	--format\|-f\|--name\|-n)
	# We don't know how to autocomplete these.
	return
	;;
	--arch-root)
	__set_comp_dirs
	return
	;;
	--board-root)
	__set_comp_dirs
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $boards_args_opts
	;;
	esac
	}

	__comp_west_build()
	{
	local build_bool_opts="
	--cmake -c
	--cmake-only
	-n --just-print --dry-run --recon
	--force -f
	"

	local build_args_opts="
	--board -b
	--build-dir -d
	--target -t
	--pristine -p
	--build-opt -o
	"

	case "$prev" in
	--board\|-b)
	__set_comp_west_boards
	return
	;;
	--build-dir\|-d)
	__set_comp_dirs
	return
	;;
	--pristine\|-p)
	__set_comp "auto always never"
	return
	;;
	# We don't know how to autocomplete those
	$(__west_to_extglob "$build_args_opts") )
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $build_bool_opts $build_args_opts
	;;
	*)
	__set_comp_dirs
	;;
	esac
	}

	__comp_west_sign()
	{
	local sign_bool_opts="
	--force -f
	--bin --no-bin
	--hex --no-hex
	"

	local sign_args_opts="
	--build-dir -d
	--tool -t
	--tool-path -p
	-B --sbin
	-H --shex
	"

	case "$prev" in
	--build-dir\|-d\|--tool-path\|-p)
	__set_comp_dirs
	return
	;;
	--tool\|-t)
	__set_comp "imgtool"
	return
	;;
	-B\|--sbin\|-H\|--shex)
	__set_comp_files
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $sign_bool_opts $sign_args_opts
	;;
	esac
	}

	__comp_west_runner_cmd()
	{
	# Common arguments for runners
	local runner_bool_opts="
	--context -H
	--skip-rebuild
	"
	local runner_args_opts="
	--build-dir -d
	--cmake-cache -c
	--runner -r
	--board-dir
	--elf-file
	--hex-file
	--bin-file
	--gdb
	--openocd
	--openocd-search
	"

	case "$prev" in
	--build-dir\|-d\|--cmake-cache\|-c\|--board-dir\|--gdb\|--openocd\|--openocd-search)
	__set_comp_dirs
	return
	;;
	--elf-file\|--hex-file\|--bin-file)
	__set_comp_files
	return
	;;
	esac

	case "$cur" in
	-*)
	__set_comp $runner_bool_opts $runner_args_opts
	;;
	esac
	}

	__comp_west_flash()
	{
	__comp_west_runner_cmd
	}

	__comp_west_debug()
	{
	__comp_west_runner_cmd
	}

	__comp_west_debugserver()
	{
	__comp_west_runner_cmd
	}

	__comp_west_attach()
	{
	__comp_west_runner_cmd
	}

	__comp_west()
	{
	local previous_extglob_setting=$(shopt -p extglob)
	shopt -s extglob
	# Reset to default, to make sure compgen works properly
	local IFS=$' \t\n'

	local builtin_cmds=(
	init
	update
	list
	manifest
	diff
	status
	forall
	config
	help
	)

	local zephyr_ext_cmds=(
	completion
	boards
	build
	sign
	flash
	debug
	debugserver
	attach
	zephyr-export
	)

	local cmds=(${builtin_cmds[]} ${zephyr_ext_cmds[]})

	# Global options for all commands
	local global_bool_opts="
	--help -h
	--verbose -v
	--version -V
	"
	local global_args_opts="
	--zephyr-base -z
	"

	COMPREPLY=()
	local cur words cword prev
	_get_comp_words_by_ref -n : cur words cword prev

	local command='west' command_pos=0
	local counter=1
	while [ "$counter" -lt "$cword" ]; do
	case "${words[$counter]}" in
	west)
	return 0
	;;
	$(__west_to_extglob "$global_args_opts") )
	(( counter++ ))
	;;
	-*)
	;;
	=)
	(( counter++ ))
	;;
	*)
	command="${words[$counter]}"
	command_pos=$counter
	break
	;;
	esac
	(( counter++ ))
	done


	# Construct the function name to be called
	local completions_func=__comp_west_${command//-/_}
	#echo "comp_func: ${completions_func}"
	declare -F $completions_func >/dev/null && $completions_func

	# Restore the user's extglob setting
	eval "$previous_extglob_setting"
	return 0
	}

	eval "$__west_previous_extglob_setting"
	unset __west_previous_extglob_setting

	complete -F __comp_west west