| # 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 expression. | |
| 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 | |
| q | |
| 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 | |
| } |