commit 2807eea527d518f49f5d2d38ff19440467553c8f Author: ota Date: Sat Dec 16 20:34:09 2023 +0200 add files diff --git a/7za-win/7za.dll b/7za-win/7za.dll new file mode 100644 index 00000000..d0806536 Binary files /dev/null and b/7za-win/7za.dll differ diff --git a/7za-win/7za.exe b/7za-win/7za.exe new file mode 100644 index 00000000..18342b38 Binary files /dev/null and b/7za-win/7za.exe differ diff --git a/7za-win/7zxa.dll b/7za-win/7zxa.dll new file mode 100644 index 00000000..979af375 Binary files /dev/null and b/7za-win/7zxa.dll differ diff --git a/cmake-3.27.7-windows-x86_64/bin/cmake.exe b/cmake-3.27.7-windows-x86_64/bin/cmake.exe new file mode 100644 index 00000000..4980e1a0 Binary files /dev/null and b/cmake-3.27.7-windows-x86_64/bin/cmake.exe differ diff --git a/cmake-3.27.7-windows-x86_64/share/aclocal/cmake.m4 b/cmake-3.27.7-windows-x86_64/share/aclocal/cmake.m4 new file mode 100644 index 00000000..46ce5b83 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/aclocal/cmake.m4 @@ -0,0 +1,44 @@ +dnl Distributed under the OSI-approved BSD 3-Clause License. See accompanying +dnl file Copyright.txt or https://cmake.org/licensing for details. + +AC_DEFUN([CMAKE_FIND_BINARY], +[AC_ARG_VAR([CMAKE_BINARY], [path to the cmake binary])dnl + +if test "x$ac_cv_env_CMAKE_BINARY_set" != "xset"; then + AC_PATH_TOOL([CMAKE_BINARY], [cmake])dnl +fi +])dnl + +# $1: package name +# $2: language (e.g. C/CXX/Fortran) +# $3: The compiler ID, defaults to GNU. +# Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI, +# PathScale, Cray, SCO, MSVC, LCC +# $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8" +# $5: optional path to cmake binary +AC_DEFUN([CMAKE_FIND_PACKAGE], [ +AC_REQUIRE([CMAKE_FIND_BINARY])dnl + +AC_ARG_VAR([$1][_][$2][FLAGS], [$2 compiler flags for $1. This overrides the cmake output])dnl +AC_ARG_VAR([$1][_LIBS], [linker flags for $1. This overrides the cmake output])dnl + +failed=false +AC_MSG_CHECKING([for $1]) +if test -z "${$1[]_$2[]FLAGS}"; then + $1[]_$2[]FLAGS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=COMPILE $4` || failed=true +fi +if test -z "${$1[]_LIBS}"; then + $1[]_LIBS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=LINK $4` || failed=true +fi + +if $failed; then + unset $1[]_$2[]FLAGS + unset $1[]_LIBS + + AC_MSG_RESULT([no]) + $6 +else + AC_MSG_RESULT([yes]) + $5 +fi[]dnl +]) diff --git a/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cmake b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cmake new file mode 100644 index 00000000..94672d1d --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cmake @@ -0,0 +1,202 @@ +# bash completion for cmake(1) -*- shell-script -*- + +_cmake() +{ + local cur prev words cword split=false + if type -t _init_completion >/dev/null; then + _init_completion -n = || return + else + # manual initialization for older bash completion versions + COMPREPLY=() + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[COMP_CWORD-1]}" + fi + + # Workaround for options like -DCMAKE_BUILD_TYPE=Release + local prefix= + if [[ $cur == -D* ]]; then + prev=-D + prefix=-D + cur="${cur#-D}" + elif [[ $cur == -U* ]]; then + prev=-U + prefix=-U + cur="${cur#-U}" + fi + + case "$prev" in + -D) + if [[ $cur == *=* ]]; then + # complete values for variables + local var type value + var="${cur%%[:=]*}" + value="${cur#*=}" + + if [[ $cur == CMAKE_BUILD_TYPE* ]]; then # most widely used case + COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo + MinSizeRel' -- "$value" ) ) + return + fi + + if [[ $cur == *:* ]]; then + type="${cur#*:}" + type="${type%%=*}" + else # get type from cache if it's not set explicitly + type=$( cmake -LA -N 2>/dev/null | grep "$var:" \ + 2>/dev/null ) + type="${type#*:}" + type="${type%%=*}" + fi + case "$type" in + FILEPATH) + cur="$value" + _filedir + return + ;; + PATH) + cur="$value" + _filedir -d + return + ;; + BOOL) + COMPREPLY=( $( compgen -W 'ON OFF TRUE FALSE' -- \ + "$value" ) ) + return + ;; + STRING|INTERNAL) + # no completion available + return + ;; + esac + elif [[ $cur == *:* ]]; then + # complete types + local type="${cur#*:}" + COMPREPLY=( $( compgen -W 'FILEPATH PATH STRING BOOL INTERNAL'\ + -S = -- "$type" ) ) + compopt -o nospace + else + # complete variable names + COMPREPLY=( $( compgen -W '$( cmake -LA -N 2>/dev/null | + tail -n +2 | cut -f1 -d: )' -P "$prefix" -- "$cur" ) ) + compopt -o nospace + fi + return + ;; + -U) + COMPREPLY=( $( compgen -W '$( cmake -LA -N | tail -n +2 | + cut -f1 -d: )' -P "$prefix" -- "$cur" ) ) + return + ;; + esac + + _split_longopt && split=true + + case "$prev" in + -C|-P|--graphviz|--system-information) + _filedir + return + ;; + --build) + # Seed the reply with non-directory arguments that we know are + # allowed to follow --build. _filedir will then prepend any valid + # directory matches to these. + COMPREPLY=( $( compgen -W "--preset --list-presets" -- "$cur" ) ) + _filedir -d + return + ;; + --install|--open) + _filedir -d + return + ;; + -E) + COMPREPLY=( $( compgen -W "$( cmake -E help |& sed -n \ + '/^ [^ ]/{s|^ \([^ ]\{1,\}\) .*$|\1|;p}' 2>/dev/null )" \ + -- "$cur" ) ) + return + ;; + -G) + local IFS=$'\n' + local quoted + printf -v quoted %q "$cur" + COMPREPLY=( $( compgen -W '$( cmake --help 2>/dev/null | sed -n \ + -e "1,/^Generators/d" \ + -e "/^ *[^ =]/{s|^ *\([^=]*[^ =]\).*$|\1|;s| |\\\\ |g;p}" \ + 2>/dev/null )' -- "$quoted" ) ) + return + ;; + --loglevel) + COMPREPLY=( $(compgen -W 'error warning notice status verbose debug trace' -- $cur ) ) + ;; + --help-command) + COMPREPLY=( $( compgen -W '$( cmake --help-command-list 2>/dev/null| + grep -v "^cmake version " )' -- "$cur" ) ) + return + ;; + --help-manual) + COMPREPLY=( $( compgen -W '$( cmake --help-manual-list 2>/dev/null| + grep -v "^cmake version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) + return + ;; + --help-module) + COMPREPLY=( $( compgen -W '$( cmake --help-module-list 2>/dev/null| + grep -v "^cmake version " )' -- "$cur" ) ) + return + ;; + --help-policy) + COMPREPLY=( $( compgen -W '$( cmake --help-policy-list 2>/dev/null | + grep -v "^cmake version " )' -- "$cur" ) ) + return + ;; + --help-property) + COMPREPLY=( $( compgen -W '$( cmake --help-property-list \ + 2>/dev/null | grep -v "^cmake version " )' -- "$cur" ) ) + return + ;; + --help-variable) + COMPREPLY=( $( compgen -W '$( cmake --help-variable-list \ + 2>/dev/null | grep -v "^cmake version " )' -- "$cur" ) ) + return + ;; + --list-presets) + local IFS=$'\n' + local quoted + printf -v quoted %q "$cur" + + if [[ ! "${IFS}${COMP_WORDS[*]}${IFS}" =~ "${IFS}--build${IFS}" ]]; then + COMPREPLY=( $( compgen -W "configure${IFS}build${IFS}test${IFS}all" -- "$quoted" ) ) + fi + return + ;; + --preset) + local IFS=$'\n' + local quoted + printf -v quoted %q "$cur" + + local build_or_configure="configure" + if [[ "${IFS}${COMP_WORDS[*]}${IFS}" =~ "${IFS}--build${IFS}" ]]; then + build_or_configure="build" + fi + + local presets=$( cmake --list-presets="$build_or_configure" 2>/dev/null | + grep -o "^ \".*\"" | sed \ + -e "s/^ //g" \ + -e "s/\"//g" \ + -e 's/ /\\\\ /g' ) + COMPREPLY=( $( compgen -W "$presets" -- "$quoted" ) ) + return + ;; + esac + + $split && return + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) + [[ $COMPREPLY == *= ]] && compopt -o nospace + [[ $COMPREPLY ]] && return + fi + + _filedir +} && +complete -F _cmake cmake + +# ex: ts=4 sw=4 et filetype=sh diff --git a/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cpack b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cpack new file mode 100644 index 00000000..d1648a58 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/cpack @@ -0,0 +1,88 @@ +# bash completion for cpack(1) -*- shell-script -*- + +_cpack() +{ + local cur prev words cword + if type -t _init_completion >/dev/null; then + _init_completion -n = || return + else + # manual initialization for older bash completion versions + COMPREPLY=() + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[COMP_CWORD-1]}" + fi + + case "$prev" in + -G) + COMPREPLY=( $( compgen -W '$( cpack --help 2>/dev/null | + sed -e "1,/^Generators/d" -e "s|^ *\([^ ]*\) .*$|\1|" \ + 2>/dev/null )' -- "$cur" ) ) + return + ;; + -C) + COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo + MinSizeRel' -- "$cur" ) ) + return + ;; + -D) + [[ $cur == *=* ]] && return # no completion for values + COMPREPLY=( $( compgen -W '$( cpack --help-variable-list \ + 2>/dev/null | grep -v "^cpack version " )' -S = -- "$cur" ) ) + compopt -o nospace + return + ;; + -P|-R|--vendor) + # argument required but no completions available + return + ;; + -B) + _filedir -d + return + ;; + --config) + _filedir + return + ;; + --help-command) + COMPREPLY=( $( compgen -W '$( cpack --help-command-list 2>/dev/null| + grep -v "^cpack version " )' -- "$cur" ) ) + return + ;; + --help-manual) + COMPREPLY=( $( compgen -W '$( cpack --help-manual-list 2>/dev/null| + grep -v "^cpack version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) + return + ;; + --help-module) + COMPREPLY=( $( compgen -W '$( cpack --help-module-list 2>/dev/null| + grep -v "^cpack version " )' -- "$cur" ) ) + return + ;; + --help-policy) + COMPREPLY=( $( compgen -W '$( cpack --help-policy-list 2>/dev/null | + grep -v "^cpack version " )' -- "$cur" ) ) + return + ;; + --help-property) + COMPREPLY=( $( compgen -W '$( cpack --help-property-list \ + 2>/dev/null | grep -v "^cpack version " )' -- "$cur" ) ) + return + ;; + --help-variable) + COMPREPLY=( $( compgen -W '$( cpack --help-variable-list \ + 2>/dev/null | grep -v "^cpack version " )' -- "$cur" ) ) + return + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) + [[ $COMPREPLY == *= ]] && compopt -o nospace + [[ $COMPREPLY ]] && return + fi + + _filedir +} && +complete -F _cpack cpack + +# ex: ts=4 sw=4 et filetype=sh diff --git a/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/ctest b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/ctest new file mode 100644 index 00000000..dd2e5c76 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/bash-completion/completions/ctest @@ -0,0 +1,129 @@ +# bash completion for ctest(1) -*- shell-script -*- + +_ctest() +{ + local cur prev words cword + if type -t _init_completion >/dev/null; then + _init_completion -n = || return + else + # manual initialization for older bash completion versions + COMPREPLY=() + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[COMP_CWORD-1]}" + fi + + case "$prev" in + -C|--build-config) + COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo + MinSizeRel' -- "$cur" ) ) + return + ;; + -j|--parallel) + COMPREPLY=( $( compgen -W "{1..$(( $(_ncpus)*2 ))}" -- "$cur" ) ) + return + ;; + -O|--output-log|-A|--add-notes|--extra-submit) + _filedir + return + ;; + -L|--label-regex|-LE|--label-exclude) + COMPREPLY=( $( compgen -W '$( ctest --print-labels 2>/dev/null | + grep "^ " 2>/dev/null | cut -d" " -f 3 )' -- "$cur" ) ) + return + ;; + --track|-I|--tests-information|--max-width|--timeout|--stop-time) + # argument required but no completions available + return + ;; + -R|--tests-regex|-E|--exclude-regex) + COMPREPLY=( $( compgen -W '$( ctest -N 2>/dev/null | + grep "^ Test" 2>/dev/null | cut -d: -f 2 )' -- "$cur" ) ) + return + ;; + -D|--dashboard) + if [[ $cur == @(Experimental|Nightly|Continuous)* ]]; then + local model action + action=${cur#@(Experimental|Nightly|Continuous)} + model=${cur%"$action"} + COMPREPLY=( $( compgen -W 'Start Update Configure Build Test + Coverage Submit MemCheck' -P "$model" -- "$action" ) ) + else + COMPREPLY=( $( compgen -W 'Experimental Nightly Continuous' \ + -- "$cur" ) ) + compopt -o nospace + fi + return + ;; + -M|--test-model) + COMPREPLY=( $( compgen -W 'Experimental Nightly Continuous' -- \ + "$cur" ) ) + return + ;; + -T|--test-action) + COMPREPLY=( $( compgen -W 'Start Update Configure Build Test + Coverage Submit MemCheck' -- "$cur" ) ) + return + ;; + -S|--script|-SP|--script-new-process) + _filedir '@(cmake|ctest)' + return + ;; + --interactive-debug-mode) + COMPREPLY=( $( compgen -W '0 1' -- "$cur" ) ) + return + ;; + + --help-command) + COMPREPLY=( $( compgen -W '$( ctest --help-command-list 2>/dev/null| + grep -v "^ctest version " )' -- "$cur" ) ) + return + ;; + --help-manual) + COMPREPLY=( $( compgen -W '$( ctest --help-manual-list 2>/dev/null| + grep -v "^ctest version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) + return + ;; + --help-module) + COMPREPLY=( $( compgen -W '$( ctest --help-module-list 2>/dev/null| + grep -v "^ctest version " )' -- "$cur" ) ) + return + ;; + --help-policy) + COMPREPLY=( $( compgen -W '$( ctest --help-policy-list 2>/dev/null | + grep -v "^ctest version " )' -- "$cur" ) ) + return + ;; + --help-property) + COMPREPLY=( $( compgen -W '$( ctest --help-property-list \ + 2>/dev/null | grep -v "^ctest version " )' -- "$cur" ) ) + return + ;; + --help-variable) + COMPREPLY=( $( compgen -W '$( ctest --help-variable-list \ + 2>/dev/null | grep -v "^ctest version " )' -- "$cur" ) ) + return + ;; + --preset) + local IFS=$'\n' + local quoted + printf -v quoted %q "$cur" + COMPREPLY=( $( compgen -W '$( ctest --list-presets 2>/dev/null | + grep -o "^ \".*\"" | sed \ + -e "s/^ //g" \ + -e "s/\"//g" \ + -e "s/ /\\\\ /g" )' -- "$quoted" ) ) + return + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) + [[ $COMPREPLY == *= ]] && compopt -o nospace + [[ $COMPREPLY ]] && return + fi + + _filedir +} && +complete -F _ctest ctest + +# ex: ts=4 sw=4 et filetype=sh diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEPRECATED_POLICY_VERSIONS.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEPRECATED_POLICY_VERSIONS.txt new file mode 100644 index 00000000..d8d05af3 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEPRECATED_POLICY_VERSIONS.txt @@ -0,0 +1,15 @@ +.. versionchanged:: 3.27 + + Compatibility with versions of CMake older than 3.5 is deprecated. + Calls to :command:`cmake_minimum_required(VERSION)` or + :command:`cmake_policy(VERSION)` that do not specify at least + 3.5 as their policy version (optionally via ``...``) + will produce a deprecation warning in CMake 3.27 and above. + +.. versionchanged:: 3.19 + + Compatibility with versions of CMake older than 2.8.12 is deprecated. + Calls to :command:`cmake_minimum_required(VERSION)` or + :command:`cmake_policy(VERSION)` that do not specify at least + 2.8.12 as their policy version (optionally via ``...``) + will produce a deprecation warning in CMake 3.19 and above. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEVICE_LINK_OPTIONS.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEVICE_LINK_OPTIONS.txt new file mode 100644 index 00000000..e40b6135 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/DEVICE_LINK_OPTIONS.txt @@ -0,0 +1,12 @@ +Host And Device Specific Link Options +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.18 + When a device link step is involved, which is controlled by + :prop_tgt:`CUDA_SEPARABLE_COMPILATION` and + :prop_tgt:`CUDA_RESOLVE_DEVICE_SYMBOLS` properties and policy :policy:`CMP0105`, + the raw options will be delivered to the host and device link steps (wrapped in + ``-Xcompiler`` or equivalent for device link). Options wrapped with + :genex:`$` generator expression will be used + only for the device link step. Options wrapped with :genex:`$` + generator expression will be used only for the host link step. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX.txt new file mode 100644 index 00000000..98d52041 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX.txt @@ -0,0 +1,252 @@ +A short-hand signature is: + +.. parsed-literal:: + + |FIND_XXX| ( name1 [path1 path2 ...]) + +The general signature is: + +.. parsed-literal:: + + |FIND_XXX| ( + + name | |NAMES| + [HINTS [path | ENV var]... ] + [PATHS [path | ENV var]... ] + [REGISTRY_VIEW (64|32|64_32|32_64|HOST|TARGET|BOTH)] + [PATH_SUFFIXES suffix1 [suffix2 ...]] + [VALIDATOR function] + [DOC "cache documentation string"] + [NO_CACHE] + [REQUIRED] + [NO_DEFAULT_PATH] + [NO_PACKAGE_ROOT_PATH] + [NO_CMAKE_PATH] + [NO_CMAKE_ENVIRONMENT_PATH] + [NO_SYSTEM_ENVIRONMENT_PATH] + [NO_CMAKE_SYSTEM_PATH] + [NO_CMAKE_INSTALL_PREFIX] + [CMAKE_FIND_ROOT_PATH_BOTH | + ONLY_CMAKE_FIND_ROOT_PATH | + NO_CMAKE_FIND_ROOT_PATH] + ) + +This command is used to find a |SEARCH_XXX_DESC|. +A cache entry, or a normal variable if ``NO_CACHE`` is specified, +named by ```` is created to store the result of this command. +If the |SEARCH_XXX| is found the result is stored in the variable +and the search will not be repeated unless the variable is cleared. +If nothing is found, the result will be ``-NOTFOUND``. + +Options include: + +``NAMES`` + Specify one or more possible names for the |SEARCH_XXX|. + + When using this to specify names with and without a version + suffix, we recommend specifying the unversioned name first + so that locally-built packages can be found before those + provided by distributions. + +``HINTS``, ``PATHS`` + Specify directories to search in addition to the default locations. + The ``ENV var`` sub-option reads paths from a system environment + variable. + + .. versionchanged:: 3.24 + On ``Windows`` platform, it is possible to include registry queries as part + of the directories, using a :ref:`dedicated syntax `. + Such specifications will be ignored on all other platforms. + +``REGISTRY_VIEW`` + .. versionadded:: 3.24 + + .. include:: FIND_XXX_REGISTRY_VIEW.txt + +``PATH_SUFFIXES`` + Specify additional subdirectories to check below each directory + location otherwise considered. + +``VALIDATOR`` + .. versionadded:: 3.25 + + Specify a :command:`function` to be called for each candidate item found + (a :command:`macro` cannot be provided, that will result in an error). + Two arguments will be passed to the validator function: the name of a + result variable, and the absolute path to the candidate item. The item + will be accepted and the search will end unless the function sets the + value in the result variable to false in the calling scope. The result + variable will hold a true value when the validator function is entered. + + .. parsed-literal:: + + function(my_check validator_result_var item) + if(NOT item MATCHES ...) + set(${validator_result_var} FALSE PARENT_SCOPE) + endif() + endfunction() + + |FIND_XXX| (result NAMES ... VALIDATOR my_check) + + Note that if a cached result is used, the search is skipped and any + ``VALIDATOR`` is ignored. The cached result is not required to pass the + validation function. + +``DOC`` + Specify the documentation string for the ```` cache entry. + +``NO_CACHE`` + .. versionadded:: 3.21 + + The result of the search will be stored in a normal variable rather than + a cache entry. + + .. note:: + + If the variable is already set before the call (as a normal or cache + variable) then the search will not occur. + + .. warning:: + + This option should be used with caution because it can greatly increase + the cost of repeated configure steps. + +``REQUIRED`` + .. versionadded:: 3.18 + + Stop processing with an error message if nothing is found, otherwise + the search will be attempted again the next time |FIND_XXX| is invoked + with the same variable. + +If ``NO_DEFAULT_PATH`` is specified, then no additional paths are +added to the search. +If ``NO_DEFAULT_PATH`` is not specified, the search process is as follows: + +.. |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in the + :variable:`_ROOT` CMake variable and the + :envvar:`_ROOT` environment variable if + called from within a find module loaded by + :command:`find_package()` + +.. |CMAKE_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in :variable:`CMAKE_PREFIX_PATH` + +.. |ENV_CMAKE_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in :envvar:`CMAKE_PREFIX_PATH` + +.. |SYSTEM_ENVIRONMENT_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ``/[s]bin`` in ``PATH``, and + |entry_XXX_SUBDIR| for other entries in ``PATH`` + +.. |CMAKE_SYSTEM_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in + :variable:`CMAKE_SYSTEM_PREFIX_PATH` + +1. If called from within a find module or any other script loaded by a call to + :command:`find_package()`, search prefixes unique to the + current package being found. See policy :policy:`CMP0074`. + + .. versionadded:: 3.12 + + Specifically, search paths specified by the following variables, in order: + + a. :variable:`_ROOT` CMake variable, + where ```` is the case-preserved package name. + + b. :variable:`_ROOT` CMake variable, + where ```` is the upper-cased package name. + See policy :policy:`CMP0144`. + + .. versionadded:: 3.27 + + c. :envvar:`_ROOT` environment variable, + where ```` is the case-preserved package name. + + d. :envvar:`_ROOT` environment variable, + where ```` is the upper-cased package name. + See policy :policy:`CMP0144`. + + .. versionadded:: 3.27 + + The package root variables are maintained as a stack, so if called from + nested find modules or config packages, root paths from the parent's find + module or config package will be searched after paths from the current + module or package. In other words, the search order would be + ``_ROOT``, ``ENV{_ROOT}``, + ``_ROOT``, ``ENV{_ROOT}``, etc. + This can be skipped if ``NO_PACKAGE_ROOT_PATH`` is passed or by setting + the :variable:`CMAKE_FIND_USE_PACKAGE_ROOT_PATH` to ``FALSE``. + + * |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX| + +2. Search paths specified in cmake-specific cache variables. + These are intended to be used on the command line with a ``-DVAR=value``. + The values are interpreted as :ref:`semicolon-separated lists `. + This can be skipped if ``NO_CMAKE_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_CMAKE_PATH` to ``FALSE``. + + * |CMAKE_PREFIX_PATH_XXX| + * |CMAKE_XXX_PATH| + * |CMAKE_XXX_MAC_PATH| + +3. Search paths specified in cmake-specific environment variables. + These are intended to be set in the user's shell configuration, + and therefore use the host's native path separator + (``;`` on Windows and ``:`` on UNIX). + This can be skipped if ``NO_CMAKE_ENVIRONMENT_PATH`` is passed or + by setting the :variable:`CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH` to ``FALSE``. + + * |ENV_CMAKE_PREFIX_PATH_XXX| + * |ENV_CMAKE_XXX_PATH| + * |ENV_CMAKE_XXX_MAC_PATH| + +4. Search the paths specified by the ``HINTS`` option. + These should be paths computed by system introspection, such as a + hint provided by the location of another item already found. + Hard-coded guesses should be specified with the ``PATHS`` option. + +5. Search the standard system environment variables. + This can be skipped if ``NO_SYSTEM_ENVIRONMENT_PATH`` is passed or by + setting the :variable:`CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH` to ``FALSE``. + + * |SYSTEM_ENVIRONMENT_PATH_XXX| + * |SYSTEM_ENVIRONMENT_PATH_WINDOWS_XXX| + +6. Search cmake variables defined in the Platform files + for the current system. The searching of ``CMAKE_INSTALL_PREFIX`` and + ``CMAKE_STAGING_PREFIX`` can be + skipped if ``NO_CMAKE_INSTALL_PREFIX`` is passed or by setting the + :variable:`CMAKE_FIND_USE_INSTALL_PREFIX` to ``FALSE``. All these locations + can be skipped if ``NO_CMAKE_SYSTEM_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_CMAKE_SYSTEM_PATH` to ``FALSE``. + + * |CMAKE_SYSTEM_PREFIX_PATH_XXX| + * |CMAKE_SYSTEM_XXX_PATH| + * |CMAKE_SYSTEM_XXX_MAC_PATH| + + The platform paths that these variables contain are locations that + typically include installed software. An example being ``/usr/local`` for + UNIX based platforms. + +7. Search the paths specified by the PATHS option + or in the short-hand version of the command. + These are typically hard-coded guesses. + +The :variable:`CMAKE_IGNORE_PATH`, :variable:`CMAKE_IGNORE_PREFIX_PATH`, +:variable:`CMAKE_SYSTEM_IGNORE_PATH` and +:variable:`CMAKE_SYSTEM_IGNORE_PREFIX_PATH` variables can also cause some +of the above locations to be ignored. + +.. versionadded:: 3.16 + Added ``CMAKE_FIND_USE__PATH`` variables to globally disable + various search locations. + +.. |FIND_ARGS_XXX| replace:: NAMES name + +On macOS the :variable:`CMAKE_FIND_FRAMEWORK` and +:variable:`CMAKE_FIND_APPBUNDLE` variables determine the order of +preference between Apple-style and unix-style package components. + +.. include:: FIND_XXX_ROOT.txt +.. include:: FIND_XXX_ORDER.txt diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ORDER.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ORDER.txt new file mode 100644 index 00000000..76c9b633 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ORDER.txt @@ -0,0 +1,12 @@ +The default search order is designed to be most-specific to +least-specific for common use cases. +Projects may override the order by simply calling the command +multiple times and using the ``NO_*`` options: + +.. parsed-literal:: + + |FIND_XXX| (|FIND_ARGS_XXX| PATHS paths... NO_DEFAULT_PATH) + |FIND_XXX| (|FIND_ARGS_XXX|) + +Once one of the calls succeeds the result variable will be set +and stored in the cache so that no call will search again. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_REGISTRY_VIEW.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_REGISTRY_VIEW.txt new file mode 100644 index 00000000..9240da7e --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_REGISTRY_VIEW.txt @@ -0,0 +1,41 @@ +Specify which registry views must be queried. This option is only meaningful +on ``Windows`` platforms and will be ignored on other ones. When not +specified, the |FIND_XXX_REGISTRY_VIEW_DEFAULT| view is used when the +:policy:`CMP0134` policy is ``NEW``. Refer to :policy:`CMP0134` for the +default view when the policy is ``OLD``. + +``64`` + Query the 64-bit registry. On 32-bit Windows, it always returns the string + ``/REGISTRY-NOTFOUND``. + +``32`` + Query the 32-bit registry. + +``64_32`` + Query both views (``64`` and ``32``) and generate a path for each. + +``32_64`` + Query both views (``32`` and ``64``) and generate a path for each. + +``HOST`` + Query the registry matching the architecture of the host: ``64`` on 64-bit + Windows and ``32`` on 32-bit Windows. + +``TARGET`` + Query the registry matching the architecture specified by the + :variable:`CMAKE_SIZEOF_VOID_P` variable. If not defined, fall back to + ``HOST`` view. + +``BOTH`` + Query both views (``32`` and ``64``). The order depends on the following + rules: If the :variable:`CMAKE_SIZEOF_VOID_P` variable is defined, use the + following view depending on the content of this variable: + + * ``8``: ``64_32`` + * ``4``: ``32_64`` + + If the :variable:`CMAKE_SIZEOF_VOID_P` variable is not defined, rely on the + architecture of the host: + + * 64-bit: ``64_32`` + * 32-bit: ``32`` diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ROOT.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ROOT.txt new file mode 100644 index 00000000..87963920 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/FIND_XXX_ROOT.txt @@ -0,0 +1,29 @@ +The CMake variable :variable:`CMAKE_FIND_ROOT_PATH` specifies one or more +directories to be prepended to all other search directories. This +effectively "re-roots" the entire search under given locations. +Paths which are descendants of the :variable:`CMAKE_STAGING_PREFIX` are excluded +from this re-rooting, because that variable is always a path on the host system. +By default the :variable:`CMAKE_FIND_ROOT_PATH` is empty. + +The :variable:`CMAKE_SYSROOT` variable can also be used to specify exactly one +directory to use as a prefix. Setting :variable:`CMAKE_SYSROOT` also has other +effects. See the documentation for that variable for more. + +These variables are especially useful when cross-compiling to +point to the root directory of the target environment and CMake will +search there too. By default at first the directories listed in +:variable:`CMAKE_FIND_ROOT_PATH` are searched, then the :variable:`CMAKE_SYSROOT` +directory is searched, and then the non-rooted directories will be +searched. The default behavior can be adjusted by setting +|CMAKE_FIND_ROOT_PATH_MODE_XXX|. This behavior can be manually +overridden on a per-call basis using options: + +``CMAKE_FIND_ROOT_PATH_BOTH`` + Search in the order described above. + +``NO_CMAKE_FIND_ROOT_PATH`` + Do not use the :variable:`CMAKE_FIND_ROOT_PATH` variable. + +``ONLY_CMAKE_FIND_ROOT_PATH`` + Search only the re-rooted directories and directories below + :variable:`CMAKE_STAGING_PREFIX`. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/GENEX_NOTE.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/GENEX_NOTE.txt new file mode 100644 index 00000000..bf21021b --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/GENEX_NOTE.txt @@ -0,0 +1,6 @@ +.. |more_see_also| replace:: See the :manual:`cmake-buildsystem(7)` manual + for more on defining buildsystem properties. + +Arguments to |command_name| may use generator expressions +with the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` +manual for available expressions. |more_see_also| diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/LINK_OPTIONS_LINKER.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/LINK_OPTIONS_LINKER.txt new file mode 100644 index 00000000..8ad4ac25 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/LINK_OPTIONS_LINKER.txt @@ -0,0 +1,25 @@ +Handling Compiler Driver Differences +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +To pass options to the linker tool, each compiler driver has its own syntax. +The ``LINKER:`` prefix and ``,`` separator can be used to specify, in a portable +way, options to pass to the linker tool. ``LINKER:`` is replaced by the +appropriate driver option and ``,`` by the appropriate driver separator. +The driver prefix and driver separator are given by the values of the +:variable:`CMAKE__LINKER_WRAPPER_FLAG` and +:variable:`CMAKE__LINKER_WRAPPER_FLAG_SEP` variables. + +For example, ``"LINKER:-z,defs"`` becomes ``-Xlinker -z -Xlinker defs`` for +``Clang`` and ``-Wl,-z,defs`` for ``GNU GCC``. + +The ``LINKER:`` prefix can be specified as part of a ``SHELL:`` prefix +expression. + +The ``LINKER:`` prefix supports, as an alternative syntax, specification of +arguments using the ``SHELL:`` prefix and space as separator. The previous +example then becomes ``"LINKER:SHELL:-z defs"``. + +.. note:: + + Specifying the ``SHELL:`` prefix anywhere other than at the beginning of the + ``LINKER:`` prefix is not supported. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/OPTIONS_SHELL.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/OPTIONS_SHELL.txt new file mode 100644 index 00000000..747d14d8 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/OPTIONS_SHELL.txt @@ -0,0 +1,15 @@ +Option De-duplication +^^^^^^^^^^^^^^^^^^^^^ + +The final set of options used for a target is constructed by +accumulating options from the current target and the usage requirements of +its dependencies. The set of options is de-duplicated to avoid repetition. + +.. versionadded:: 3.12 + While beneficial for individual options, the de-duplication step can break + up option groups. For example, ``-option A -option B`` becomes + ``-option A B``. One may specify a group of options using shell-like + quoting along with a ``SHELL:`` prefix. The ``SHELL:`` prefix is dropped, + and the rest of the option string is parsed using the + :command:`separate_arguments` ``UNIX_COMMAND`` mode. For example, + ``"SHELL:-option A" "SHELL:-option B"`` becomes ``-option A -option B``. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/SUPPORTED_LANGUAGES.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/SUPPORTED_LANGUAGES.txt new file mode 100644 index 00000000..b299806e --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/SUPPORTED_LANGUAGES.txt @@ -0,0 +1,25 @@ + +Supported languages are ``C``, ``CXX`` (i.e. C++), ``CSharp`` (i.e. C#), ``CUDA``, +``OBJC`` (i.e. Objective-C), ``OBJCXX`` (i.e. Objective-C++), ``Fortran``, ``HIP``, +``ISPC``, ``Swift``, ``ASM``, ``ASM_NASM``, ``ASM_MARMASM``, ``ASM_MASM``, and ``ASM-ATT``. + + .. versionadded:: 3.8 + Added ``CSharp`` and ``CUDA`` support. + + .. versionadded:: 3.15 + Added ``Swift`` support. + + .. versionadded:: 3.16 + Added ``OBJC`` and ``OBJCXX`` support. + + .. versionadded:: 3.18 + Added ``ISPC`` support. + + .. versionadded:: 3.21 + Added ``HIP`` support. + + .. versionadded:: 3.26 + Added ``ASM_MARMASM`` support. + +If enabling ``ASM``, list it last so that CMake can check whether +compilers for other languages like ``C`` work for assembly too. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/UNSET_NOTE.txt b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/UNSET_NOTE.txt new file mode 100644 index 00000000..cc0669f7 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/UNSET_NOTE.txt @@ -0,0 +1,9 @@ +.. note:: + + When evaluating :ref:`Variable References` of the form ``${VAR}``, CMake + first searches for a normal variable with that name. If no such normal + variable exists, CMake will then search for a cache entry with that name. + Because of this, **unsetting a normal variable can expose a cache variable + that was previously hidden**. To force a variable reference of the form + ``${VAR}`` to return an empty string, use ``set( "")``, which + clears the normal variable but leaves it defined. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_definitions.rst b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_definitions.rst new file mode 100644 index 00000000..a7c60ba0 --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_definitions.rst @@ -0,0 +1,33 @@ +add_compile_definitions +----------------------- + +.. versionadded:: 3.12 + +Add preprocessor definitions to the compilation of source files. + +.. code-block:: cmake + + add_compile_definitions( ...) + +Adds preprocessor definitions to the compiler command line. + +The preprocessor definitions are added to the :prop_dir:`COMPILE_DEFINITIONS` +directory property for the current ``CMakeLists`` file. They are also added to +the :prop_tgt:`COMPILE_DEFINITIONS` target property for each target in the +current ``CMakeLists`` file. + +Definitions are specified using the syntax ``VAR`` or ``VAR=value``. +Function-style definitions are not supported. CMake will automatically +escape the value correctly for the native build system (note that CMake +language syntax may require escapes to specify some values). + +.. versionadded:: 3.26 + Any leading ``-D`` on an item will be removed. + +.. |command_name| replace:: ``add_compile_definitions`` +.. include:: GENEX_NOTE.txt + +See Also +^^^^^^^^ + +* The command :command:`target_compile_definitions` adds target-specific definitions. diff --git a/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_options.rst b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_options.rst new file mode 100644 index 00000000..66868ecb --- /dev/null +++ b/cmake-3.27.7-windows-x86_64/share/cmake-3.27/Help/command/add_compile_options.rst @@ -0,0 +1,67 @@ +add_compile_options +------------------- + +Add options to the compilation of source files. + +.. code-block:: cmake + + add_compile_options(