The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1506 lines
26 KiB
1506 lines
26 KiB
# shellcheck shell=bash |
|
|
|
_get_subprojects_dir() { |
|
# TODO: meson-info/intro-projectinfo.json has the info for the subproject |
|
# directory, but we can't know what the build directory is in these contexts. |
|
# Let's default to subprojects. |
|
|
|
# Get subprojects directory. All subprojects subcommands support --sourcedir, |
|
# so if that argument was passed, use it to find subprojects. |
|
subprojects_dir="subprojects" |
|
for (( i=${#COMP_WORDS[@]} - 1; i >= 0; i-- )); do |
|
# Exit early if we have made our way back to the command |
|
if [[ "${COMP_WORDS[$i]}" = "subprojects" ]]; then |
|
break |
|
fi |
|
|
|
prev=$((i - 1)) |
|
if [[ $prev -gt 0 ]] && [[ "${COMP_WORDS[$prev]}" = "--sourcedir" ]]; then |
|
subprojects_dir="${COMP_WORDS[$i]}" |
|
break |
|
fi |
|
done |
|
|
|
echo "$subprojects_dir" |
|
} |
|
|
|
_subprojects() { |
|
subprojects_dir=$(_get_subprojects_dir) |
|
pushd "$subprojects_dir" &>/dev/null || return |
|
local COMPREPLY=() |
|
_filedir |
|
# _filedir for whatever reason can't reason about symlinks, so -d will them. |
|
# Filter out wrap files with this expresion. |
|
IFS=$'\n' echo "${COMPREPLY[*]}" | grep -vE '\.wrap$' | xargs |
|
popd &>/dev/null |
|
} |
|
|
|
_wraps() { |
|
subprojects_dir=$(_get_subprojects_dir) |
|
db="$subprojects_dir/wrapdb.json" |
|
if [[ ! -f "$db" ]]; then |
|
return |
|
fi |
|
|
|
document=$(cat "$db") |
|
wraps=($(python3 -c 'import sys, json |
|
for wrap in json.load(sys.stdin).keys(): |
|
print(wrap) |
|
' <<< "$document")) |
|
echo "${wraps[@]}" |
|
} |
|
|
|
_meson() { |
|
command="${COMP_WORDS[1]}" |
|
subcommands=( |
|
setup |
|
configure |
|
dist |
|
install |
|
introspect |
|
init |
|
test |
|
wrap |
|
subprojects |
|
help |
|
rewrite |
|
compile |
|
devenv |
|
env2mfile |
|
) |
|
|
|
if [[ " ${subcommands[*]} " =~ " ${command} " ]]; then |
|
"_meson-$command" "${COMP_WORDS[@]:1}" |
|
else |
|
_meson-setup "${COMP_WORDS[@]}" |
|
fi |
|
} && |
|
complete -F _meson meson |
|
|
|
_meson_complete_option() { |
|
option_string=$1 |
|
|
|
if [[ $# -eq 2 ]] && ! [[ "$option_string" == *=* ]]; then |
|
option_string="$option_string=$2" |
|
fi |
|
|
|
if [[ "$option_string" == *=* ]]; then |
|
_meson_complete_option_value "$option_string" |
|
else |
|
_meson_complete_option_name "$option_string" |
|
fi |
|
} |
|
|
|
_meson_complete_option_name() { |
|
option=$1 |
|
options=($(python3 -c 'import sys, json |
|
for option in json.load(sys.stdin): |
|
print(option["name"]) |
|
' <<< "$(_meson_get_options)")) |
|
compopt -o nospace |
|
COMPREPLY=($(compgen -W '${options[@]}' -S= -- "$option")) |
|
} |
|
|
|
_meson_complete_option_value() { |
|
cur=$1 |
|
option_name=${cur%%=*} |
|
option_value=${cur#*=} |
|
|
|
if _meson_complete_filedir "$option_name" "$option_value"; then |
|
return |
|
fi |
|
|
|
options=($(python3 -c 'import sys, json |
|
for option in json.load(sys.stdin): |
|
if option["name"] != "'$option_name'": |
|
continue |
|
choices = [] |
|
if option["type"] == "boolean": |
|
choices.append("true") |
|
choices.append("false") |
|
elif option["type"] == "combo": |
|
for choice in option["choices"]: |
|
choices.append(choice) |
|
elif option["type"] == "feature": |
|
choices.append("auto") |
|
choices.append("enabled") |
|
choices.append("disabled") |
|
for choice in choices: |
|
if choice.startswith("'$cur'"): |
|
print(choice) |
|
' <<< "$(_meson_get_options)")) |
|
COMPREPLY=("${options[@]}") |
|
} |
|
|
|
_meson_get_options() { |
|
local options |
|
for builddir in "${COMP_WORDS[@]}"; do |
|
if [[ -d "$builddir" ]]; then |
|
break |
|
fi |
|
builddir=. |
|
done |
|
options=$(meson introspect "$builddir" --buildoptions 2>/dev/null) && |
|
echo "$options" || |
|
echo '[]' |
|
} |
|
|
|
_meson_complete_filedir() { |
|
_filedir_in() { |
|
pushd "$1" &>/dev/null |
|
local COMPREPLY=() |
|
_filedir |
|
echo "${COMPREPLY[@]}" |
|
popd &>/dev/null |
|
} |
|
|
|
option=$1 |
|
cur=$2 |
|
case $option in |
|
prefix |\ |
|
bindir |\ |
|
datadir |\ |
|
includedir |\ |
|
infodir |\ |
|
libdir |\ |
|
licensedir |\ |
|
libexecdir |\ |
|
localedir |\ |
|
localstatedir |\ |
|
mandir |\ |
|
sbindir |\ |
|
sharedstatedir |\ |
|
sysconfdir |\ |
|
python.platlibdir |\ |
|
python.purelibdir |\ |
|
pkg-config-path |\ |
|
build.pkg-config-path |\ |
|
cmake-prefix-path |\ |
|
build.cmake-prefix-path) |
|
_filedir -d |
|
;; |
|
|
|
cross-file) |
|
_filedir |
|
COMPREPLY+=($(_filedir_in "$XDG_DATA_DIRS"/meson/cross)) |
|
COMPREPLY+=($(_filedir_in /usr/local/share/meson/cross)) |
|
COMPREPLY+=($(_filedir_in /usr/share/meson/cross)) |
|
COMPREPLY+=($(_filedir_in "$XDG_DATA_HOME"/meson/cross)) |
|
COMPREPLY+=($(_filedir_in ~/.local/share/meson/cross)) |
|
;; |
|
|
|
native-file) |
|
_filedir |
|
COMPREPLY+=($(_filedir_in "$XDG_DATA_DIRS"/meson/native)) |
|
COMPREPLY+=($(_filedir_in /usr/local/share/meson/native)) |
|
COMPREPLY+=($(_filedir_in /usr/share/meson/native)) |
|
COMPREPLY+=($(_filedir_in "$XDG_DATA_HOME"/meson/native)) |
|
COMPREPLY+=($(_filedir_in ~/.local/share/meson/native)) |
|
;; |
|
|
|
*) |
|
return 1;; |
|
esac |
|
return 0 |
|
} |
|
|
|
_meson_compgen_options() { |
|
local -r cur=$1 |
|
|
|
if [[ ${cur:0:2} == -- ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- "${cur:2}")) |
|
elif [[ ${cur:0:1} == - ]]; then |
|
if [[ ${#cur} == 1 ]]; then |
|
# Only add longopts if cur not "-something" |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- "")) |
|
fi |
|
|
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}' -- "${cur:1}")) |
|
else |
|
return 1 |
|
fi |
|
|
|
return 0 |
|
} |
|
|
|
_meson_common_setup_configure_longopts=( |
|
help |
|
prefix |
|
bindir |
|
datadir |
|
includedir |
|
infodir |
|
libdir |
|
licensedir |
|
libexecdir |
|
localedir |
|
localstatedir |
|
mandir |
|
sbindir |
|
sharedstatedir |
|
sysconfdir |
|
auto-features |
|
backend |
|
genvslite |
|
buildtype |
|
debug |
|
default-library |
|
errorlogs |
|
install-umask |
|
layout |
|
optimization |
|
prefer-static |
|
stdsplit |
|
strip |
|
unity |
|
unity-size |
|
warnlevel |
|
werror |
|
wrap-mode |
|
force-fallback-for |
|
vsenv |
|
pkgconfig.relocatable |
|
python.bytecompile |
|
python.install-env |
|
python.platlibdir |
|
python.purelibdir |
|
python.allow-limited-api |
|
pkg-config-path |
|
build.pkg-config-path |
|
cmake-prefix-path |
|
build.cmake-prefix-path |
|
clearcache |
|
) |
|
|
|
_meson-setup() { |
|
shortopts=( |
|
h |
|
D |
|
v |
|
) |
|
|
|
longopts=( |
|
${_meson_common_setup_configure_longopts[@]} |
|
native-file |
|
cross-file |
|
version |
|
fatal-meson-warnings |
|
reconfigure |
|
wipe |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
if [[ ${prev:0:2} == -- ]] && _meson_complete_option "${prev:2}" "$cur"; then |
|
return |
|
elif [[ ${prev:0:1} == - ]] && [[ ${prev:1:2} != - ]] && _meson_complete_option "${prev:1}"; then |
|
return |
|
fi |
|
fi |
|
|
|
if _get_comp_words_by_ref -n '=' cur prev &>/dev/null; then |
|
if [[ $prev == -D ]]; then |
|
_meson_complete_option "$cur" |
|
return |
|
fi |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
_filedir -d |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
|
|
if [[ $COMP_CWORD == 1 ]]; then |
|
COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur")) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-configure() { |
|
shortopts=( |
|
h |
|
D |
|
) |
|
|
|
longopts=( |
|
${_meson_common_setup_configure_longopts[@]} |
|
no-pager |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n '=' cur prev &>/dev/null; then |
|
if [[ $prev == -D ]]; then |
|
_meson_complete_option "$cur" |
|
return |
|
fi |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
for dir in "${COMP_WORDS[@]}"; do |
|
if [[ -d "$dir" ]]; then |
|
break |
|
fi |
|
dir=. |
|
done |
|
if [[ ! -d "$dir/meson-private" ]]; then |
|
_filedir -d |
|
fi |
|
|
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-dist() { |
|
shortopts=( |
|
h |
|
C |
|
) |
|
|
|
longopts=( |
|
allow-dirty |
|
help |
|
formats |
|
include-subprojects |
|
no-tests |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then |
|
case $prev in |
|
-C) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--formats) |
|
formats=( |
|
xztar |
|
gztar |
|
zip |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${formats[*]}' -- "$cur")) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-install() { |
|
shortopts=( |
|
h |
|
n |
|
C |
|
) |
|
|
|
longopts=( |
|
help |
|
no-rebuild |
|
only-changed |
|
quiet |
|
destdir |
|
dry-run |
|
skip-subprojects |
|
tags |
|
strip |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then |
|
for i in "${!COMP_WORDS[@]}"; do |
|
opt="${COMP_WORDS[i]}" |
|
dir="${COMP_WORDS[i+1]}" |
|
case "$opt" in |
|
-C) |
|
break |
|
;; |
|
esac |
|
dir=. |
|
done |
|
|
|
case $prev in |
|
-C | --destdir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--tags) |
|
tags=$(meson introspect "$dir" --install-plan | python3 -c 'import sys, json |
|
targets = json.load(sys.stdin)["targets"] |
|
for target, attributes in targets.items(): |
|
print(attributes["tag"]) |
|
' 2> /dev/null) |
|
|
|
if [[ $? == 0 ]]; then |
|
COMPREPLY+=($(compgen -W '${tags[*]}' -- "$cur")) |
|
fi |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-introspect() { |
|
shortopts=( |
|
h |
|
a |
|
i |
|
f |
|
) |
|
|
|
longopts=( |
|
ast |
|
benchmarks |
|
buildoptions |
|
buildsystem-files |
|
dependencies |
|
scan-dependencies |
|
installed |
|
install-plan |
|
projectinfo |
|
targets |
|
tests |
|
backend |
|
all |
|
indent |
|
force-object-output |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
for dir in "${COMP_WORDS[@]}"; do |
|
if [[ -d "$dir" ]]; then |
|
break |
|
fi |
|
dir=. |
|
done |
|
if [[ ! -d "$dir/meson-private" ]]; then |
|
_filedir -d |
|
fi |
|
|
|
if [ -z "$cur" ]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-init() { |
|
shortopts=( |
|
h |
|
C |
|
n |
|
e |
|
d |
|
l |
|
b |
|
f |
|
) |
|
|
|
longopts=( |
|
help |
|
name |
|
executable |
|
deps |
|
language |
|
build |
|
builddir |
|
force |
|
type |
|
version |
|
) |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-test() { |
|
shortopts=( |
|
h |
|
j |
|
q |
|
v |
|
t |
|
C |
|
) |
|
|
|
longopts=( |
|
help |
|
maxfail |
|
repeat |
|
no-rebuild |
|
gdb |
|
gdb-path |
|
interactive |
|
list |
|
wrapper |
|
suite |
|
no-suite |
|
no-stdsplit |
|
print-errorlogs |
|
benchmark |
|
logbase |
|
num-processes |
|
verbose |
|
quiet |
|
timeout-multiplier |
|
setup |
|
max-lines |
|
test-args |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then |
|
case $prev in |
|
--maxfail | --repeat) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
--wrapper) |
|
_command_offset "$COMP_CWORD" |
|
return |
|
;; |
|
|
|
--gdb-path) |
|
_filedir |
|
return |
|
;; |
|
|
|
-C) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--suite | --no-suite) |
|
for i in "${!COMP_WORDS[@]}"; do |
|
opt="${COMP_WORDS[i]}" |
|
dir="${COMP_WORDS[i+1]}" |
|
case "$opt" in |
|
-C) |
|
break |
|
;; |
|
esac |
|
dir=. |
|
done |
|
|
|
suites=$(meson introspect "$dir" --tests | python3 -c 'import sys, json; |
|
for test in json.load(sys.stdin): |
|
for suite in test["suite"]: |
|
print(suite) |
|
' 2> /dev/null) |
|
|
|
if [[ $? == 0 ]]; then |
|
COMPREPLY+=($(compgen -W '${suites[*]}' -- "$cur")) |
|
__ltrim_colon_completions "$cur" |
|
fi |
|
return |
|
;; |
|
|
|
--logbase) |
|
# free string, can't be completed |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
-t | --timeout-multiplier) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
--setup) |
|
# TODO |
|
return |
|
;; |
|
|
|
--test-args) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
for dir in "${COMP_WORDS[@]}"; do |
|
if [[ -d "$dir" ]]; then |
|
break |
|
fi |
|
dir=. |
|
done |
|
|
|
if [[ ! -d "$dir/meson-private" ]]; then |
|
_filedir -d |
|
fi |
|
|
|
for i in "${!COMP_WORDS[@]}"; do |
|
opt="${COMP_WORDS[i]}" |
|
dir="${COMP_WORDS[i+1]}" |
|
case "$opt" in |
|
-C) |
|
break |
|
;; |
|
esac |
|
dir=. |
|
done |
|
|
|
tests=$(meson introspect "$dir" --tests | python3 -c 'import sys, json; |
|
for test in json.load(sys.stdin): |
|
print(test["name"]) |
|
' 2> /dev/null) |
|
|
|
if [[ $? == 0 ]]; then |
|
COMPREPLY+=($(compgen -W '${tests[*]}' -- "$cur")) |
|
fi |
|
|
|
if [ -z "$cur" ]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- "${cur:2}")) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}' -- "${cur:1}")) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-wrap() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
help |
|
) |
|
|
|
subcommands=( |
|
info |
|
install |
|
list |
|
promote |
|
search |
|
status |
|
update |
|
update-db |
|
) |
|
|
|
for i in "$@"; do |
|
if [[ " ${subcommands[*]} " =~ " $i " ]]; then |
|
"_meson-wrap-$i" "${COMP_WORDS[i]:1}" |
|
return |
|
fi |
|
done |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur")) |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-wrap-info() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
read -ra wraps < <(_wraps) |
|
COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur")) |
|
} |
|
|
|
_meson-wrap-install() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
read -ra wraps < <(_wraps) |
|
COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur")) |
|
} |
|
|
|
_meson-wrap-list() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-wrap-promote() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
_filedir |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-wrap-search() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
read -ra wraps < <(_wraps) |
|
COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur")) |
|
} |
|
|
|
_meson-wrap-status() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-wrap-update() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
force |
|
help |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-wrap-update-db() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
) |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-subprojects() { |
|
shortopts=( |
|
h |
|
) |
|
|
|
longopts=( |
|
help |
|
) |
|
|
|
subcommands=( |
|
checkout |
|
download |
|
foreach |
|
packagefiles |
|
purge |
|
update |
|
) |
|
|
|
for i in "$@"; do |
|
if [[ " ${subcommands[*]} " =~ " $i " ]]; then |
|
"_meson-subprojects-$i" "${COMP_WORDS[i]:1}" |
|
return |
|
fi |
|
done |
|
|
|
local cur prev |
|
if ! _get_comp_words_by_ref cur prev &>/dev/null; then |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur")) |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-subprojects-checkout() { |
|
shortopts=( |
|
b |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
num-processes |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-subprojects-download() { |
|
shortopts=( |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
num-processes |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-subprojects-foreach() { |
|
shortopts=( |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
num-processes |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-subprojects-packagefiles() { |
|
shortopts=( |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
apply |
|
help |
|
num-processes |
|
save |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
--apply | --save) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-subprojects-purge() { |
|
shortopts=( |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
confirm |
|
help |
|
include-cache |
|
num-processes |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
--apply | --save) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-subprojects-update() { |
|
shortopts=( |
|
h |
|
j |
|
) |
|
|
|
longopts=( |
|
allow-insecure |
|
help |
|
num-processes |
|
rebase |
|
reset |
|
sourcedir |
|
types |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
case $prev in |
|
--sourcedir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--types) |
|
types=( |
|
file |
|
git |
|
hg |
|
svn |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-j | --num-processes) |
|
# number, can't be completed |
|
return |
|
;; |
|
|
|
--rebase | --reset) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
|
|
COMPREPLY+=($(_subprojects)) |
|
} |
|
|
|
_meson-help() { |
|
longopts=( |
|
setup |
|
configure |
|
dist |
|
install |
|
introspect |
|
init |
|
test |
|
wrap |
|
subprojects |
|
rewrite |
|
compile |
|
devenv |
|
env2mfile |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
COMPREPLY+=($(compgen -W '${longopts[*]}' -- "$cur")) |
|
fi |
|
} |
|
|
|
_meson-rewrite() { |
|
: TODO |
|
} |
|
|
|
_meson-compile() { |
|
shortopts=( |
|
h |
|
C |
|
j |
|
l |
|
v |
|
) |
|
|
|
longopts=( |
|
help |
|
clean |
|
jobs |
|
load-average |
|
verbose |
|
ninja-args |
|
vs-args |
|
xcode-args |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref cur prev &>/dev/null; then |
|
if [[ ${prev:0:2} == -- ]] && _meson_complete_option "${prev:2}" "$cur"; then |
|
return |
|
elif [[ ${prev:0:1} == - ]] && [[ ${prev:1:2} != - ]] && _meson_complete_option "${prev:1}"; then |
|
return |
|
fi |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
_filedir -d |
|
|
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-devenv() { |
|
shortopts=( |
|
h |
|
w |
|
) |
|
|
|
longopts=( |
|
dump |
|
dump-format |
|
help |
|
workdir |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then |
|
case $prev in |
|
-C | -w | --workdir) |
|
_filedir -d |
|
return |
|
;; |
|
|
|
--dump) |
|
_filedir |
|
return |
|
;; |
|
|
|
--dump-format) |
|
dump_formats=( |
|
sh |
|
export |
|
vscode |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${dump_formats[*]}' -- "$cur")) |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
} |
|
|
|
_meson-env2mfile() { |
|
shortopts=( |
|
h |
|
o |
|
) |
|
|
|
longopts=( |
|
cpu |
|
cpu-family |
|
cross |
|
debarch |
|
endian |
|
gccsuffix |
|
help |
|
kernel |
|
native |
|
subsystem |
|
system |
|
) |
|
|
|
local cur prev |
|
if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then |
|
case $prev in |
|
--endian) |
|
endianness=( |
|
big |
|
little |
|
) |
|
|
|
COMPREPLY+=($(compgen -W '${endianness[*]}' -- "$cur")) |
|
return |
|
;; |
|
|
|
-o) |
|
_filedir |
|
return |
|
;; |
|
esac |
|
else |
|
cur="${COMP_WORDS[COMP_CWORD]}" |
|
fi |
|
|
|
if ! _meson_compgen_options "$cur"; then |
|
if [[ -z $cur ]]; then |
|
COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}')) |
|
COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}')) |
|
fi |
|
fi |
|
}
|
|
|