Mirror
/
Kitware-CMake
mirror of https://github.com/Kitware/CMake.git
1
0
Fork 0
Code Issues Releases Wiki Activity
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.
67481 Commits
2 Branches
369 Tags
215 MiB
Tree: 773eff6d8e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '773eff6d8e'
${ noResults }
Kitware-CMake/CMakeLists.txt

564 lines
21 KiB
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
9 years ago
​
​
Configure CMake itself with policies through CMake 3.29
1 year ago
AIX: Add -pthread flag to enable std::thread with GCC
8 years ago
​
LCC: Add policy CMP0129 regarding interpreting LCC as GNU Due to MCST LCC compiler identification is now changed to LCC, there should be a way for old projects to still identify it as GNU, as it was before. This commits adds the policy: CMP0129: Compiler id for MCST LCC compilers is now LCC, not GNU. This policy controls such a behavior. OLD behaivior is to treat LCC as GNU, NEW is to treat is as LCC.
4 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
AIX: Add -pthread flag to enable std::thread with GCC
8 years ago
​
ENH: Set CMake Policy CMP0003 to NEW behavior to build without warnings with the upcoming CMake 2.6 release.
18 years ago
Configure CMake itself with policies through CMake 3.15 In particular, set `CMP0091` to `NEW` to enable the MSVC runtime library abstraction so it can be set via `CMAKE_MSVC_RUNTIME_LIBRARY` in the cache.
6 years ago
​
​
​
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
​
Configure CMake itself with policies through CMake 3.15 In particular, set `CMP0091` to `NEW` to enable the MSVC runtime library abstraction so it can be set via `CMAKE_MSVC_RUNTIME_LIBRARY` in the cache.
6 years ago
​
​
​
​
Use find_package for JsonCpp and LibUV instead of include
9 years ago
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
Add option to test CMake itself against its hosting CMake
6 years ago
​
​
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
HP-UX: Drop support for building CMake on HP-UX CMake will soon require both C++11 and libuv to build. Neither of these works on HP-UX, so unfortunately we need to drop support for the platform until someone can get them working. Issue: #17137
8 years ago
​
​
Update links to gitlab.kitware.com repos to add `-/` GitLab now uses a `/-/` component between the `group/project` part of the URL and the `{issues,merge_requests,tree}` part so that it can support `group/subgroup/project` with arbitrary depth.
5 years ago
HP-UX: Drop support for building CMake on HP-UX CMake will soon require both C++11 and libuv to build. Neither of these works on HP-UX, so unfortunately we need to drop support for the platform until someone can get them working. Issue: #17137
8 years ago
​
​
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
Clean up CMake build tree 'bin' directory We re-arrange EXECUTABLE_OUTPUT_PATH settings to avoid putting utility and test executables in the 'bin' directory of the build tree. This makes the directory look like that in the installation tree, except that on multi-configuration generators we still use a per-config subdirectory.
16 years ago
cmake-gui: Reference LGPLv3 when redistributing Qt Download http://www.gnu.org/licenses/lgpl.txt and place it as Licenses/LGPLv3.txt in our source tree. When building cmake-gui, use option CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL to enable notification in the "About" dialog of how the distribution of Qt is licensed. Install the license file as ${CMAKE_ROOT}/Licenses/LGPLv3.txt so that the dialog can display a path to it.
9 years ago
​
​
​
​
​
​
​
​
​
Build CMake with most-recent available language dialect. When CMake is built with CMake 3.1 or later, appropriate -std= options will be added for GNU and Clang compilers while building C and CXX code. This allows taking advantage of 'hidden' language features such as move-constructors, and allows the standard library to enable the use of more-advanced features too, where available. This does not change CMake host compiler requirements.
11 years ago
Add options to build CMake without any language dialects If CMake_NO_<LANG>_STANDARD is set, do not set CMAKE_<LANG>_STANDARD. This will allow users to build with their own -std= flags without CMake adding any itself.
11 years ago
Avoid using C11 to build CMake if _Thread_local support is broken Support for C11's _Thread_local was introduced in GCC in the 4.9 series, even though we make the C11 compiler flags available in CMake with GCC >= 4.6. FreeBSD's runetype.h uses _Thread_local, which causes CMake's own build to fail when using GCC < 4.9 and -std=gnu11: /usr/include/runetype.h:92:22: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'const' extern _Thread_local const _RuneLocale *_ThreadRuneLocale; Add a test for _Thread_local support and only build CMake itself with C11 support if it works. Bug: http://www.cmake.org/Bug/view.php?id=15741
10 years ago
​
​
​
​
​
Add options to build CMake without latest language dialects Set CMAKE_C_STANDARD and CMAKE_CXX_STANDARD only if they are not already defined. This will allow users to add the settings with different values to their local cache (e.g. on the command line).
11 years ago
Add options to build CMake without any language dialects If CMake_NO_<LANG>_STANDARD is set, do not set CMAKE_<LANG>_STANDARD. This will allow users to build with their own -std= flags without CMake adding any itself.
11 years ago
CMakeLists: Remove redundant spaces around CMake command calls
3 years ago
Update SunPro flags used for CMake itself to support C++11
8 years ago
Avoid using C++14 to build CMake if cstdio breaks The GNU 4.8 standard library's cstdio header is not aware that C++14 honors C11's removal of "gets" from stdio.h and results in an error: /.../include/c++/4.8/cstdio:120:11: error: no member named 'gets' in the global namespace Detect this problematic case and default to using C++11 instead of C++14 for building CMake itself.
10 years ago
own CMakeLists: remove unreachable code
3 years ago
Compile CMake as C++17 if supported by the compiler Add a check that a simple source file can compile as C++17 that uses some of the features we need. Do this only when hosted by CMake 3.8 or above because those versions are aware of C++17. Check for unordered_map as we do in bootstrap since commit 375eca7881 (bootstrap: Check support for unordered_map from compiler mode, 2017-11-30). Also maintain the existing C++14 cstdio check.
8 years ago
​
​
​
​
​
​
​
​
Update SunPro flags used for CMake itself to support C++11
8 years ago
Avoid using C++14 to build CMake if cstdio breaks The GNU 4.8 standard library's cstdio header is not aware that C++14 honors C11's removal of "gets" from stdio.h and results in an error: /.../include/c++/4.8/cstdio:120:11: error: no member named 'gets' in the global namespace Detect this problematic case and default to using C++11 instead of C++14 for building CMake itself.
10 years ago
Add options to build CMake without latest language dialects Set CMAKE_C_STANDARD and CMAKE_CXX_STANDARD only if they are not already defined. This will allow users to add the settings with different values to their local cache (e.g. on the command line).
11 years ago
Check for std::unordered_map only if we are building CMake When CMake_TEST_EXTERNAL_CMAKE is set then we are not actually building CMake so we do not need this check.
10 years ago
Choose compiler-specific flags earlier in CMake's own build Add the flags early enough be used in the checks for C++ features.
8 years ago
​
​
​
Make C++ feature checks extensible Turn the feature check for cxx11_unordered_map into a function such that we can use it for other features as well. Drop the 11 suffix, as we may want to check features from other standards.
9 years ago
Require C++11 to build CMake itself CMake can now compile as C++11 on all supported platforms. Check that std::unique_ptr is available and fail early if missing. This will allow us to use C++11 more broadly in CMake's implementation (previously it was restricted to the serve mode implementation). Co-Author: Daniel Pfeifer <daniel@pfeifer-mail.de>
8 years ago
​
​
​
Check for std::unordered_map only if we are building CMake When CMake_TEST_EXTERNAL_CMAKE is set then we are not actually building CMake so we do not need this check.
10 years ago
Build CMake with most-recent available language dialect. When CMake is built with CMake 3.1 or later, appropriate -std= options will be added for GNU and Clang compilers while building C and CXX code. This allows taking advantage of 'hidden' language features such as move-constructors, and allows the standard library to enable the use of more-advanced features too, where available. This does not change CMake host compiler requirements.
11 years ago
STL Support: introduce dedicated configuration file
5 years ago
Build: Simplify `configure_file()` calls
3 years ago
STL Support: introduce dedicated configuration file
5 years ago
Encoding: Remove option to use ANSI code page internally The switch to use UTF-8 encoding has been defaulted to on for quite some time since commit v3.2.0-rc1~116^2 (Encoding: Switch to use UTF-8 internally by default on Windows, 2014-12-26).
9 years ago
​
Encoding: Provide option to configure CMake to use UTF-8 encoding.
12 years ago
CMake: New option CMake_INSTALL_COMPONENTS By default is OFF. Now it's used with CPack IFW himself installer.
10 years ago
​
​
​
​
​
​
​
​
​
​
CMake: Add CMake_INSTALL_DEPENDENCIES option By default this option is ON. Turn OFF to disable installing runtime 3rd-party dependencies.
10 years ago
​
Do not install 3rd-party dependencies by default Disable the CMake_INSTALL_DEPENDENCIES option by default and turn it on explicitly in our packaging scripts. This simplifies packaging in distributions that provide the dependencies for us without having to install them. We only need 3rd-party runtime dependencies to be installed for packaging with redistributable binaries.
10 years ago
CMake: Add CMake_INSTALL_DEPENDENCIES option By default this option is ON. Turn OFF to disable installing runtime 3rd-party dependencies.
10 years ago
​
Added CMake_BUILD_DEVELOPER_REFERENCE option By default is OFF and marked as advanced. It's also add custom cmake-developer-reference (ALL) target Generated output will be installed to ${CMAKE_DOC_DIR}/developer-reference.
9 years ago
​
​
​
​
Add option to build CMake itself with IPO/LTO Create a `CMake_BUILD_LTO` option when building with a CMake that is new enough to support `CheckIPOSupported` everywhere.
7 years ago
own CMakeLists: remove unreachable code
3 years ago
​
​
​
​
​
Add option to build CMake itself with IPO/LTO Create a `CMake_BUILD_LTO` option when building with a CMake that is new enough to support `CheckIPOSupported` everywhere.
7 years ago
​
​
CMake: Add CMake_BUILD_PCH option
2 years ago
​
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
​
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
​
​
LCC: Don't enable debugger on LCC that don't have <future>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
​
​
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
​
ENH: more cleanup of some CMakeLists files
18 years ago
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
ENH: more cleanup of some CMakeLists files
18 years ago
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
​
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
​
​
​
​
​
​
​
​
​
​
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
macOS: Prefer building with system-provided curl Our vendored curl only enables the Secure Transport backend by default (`CURL_SSL_BACKEND=secure-transport`), but it is limited to TLS 1.2. The macOS SDK provides the curl development components, and the corresponding `libcurl.4.dylib` runtime library comes with macOS. On macOS 12 and above, the default `CURL_SSL_BACKEND=openssl` backend seems to be capable of selecting TLS 1.3 at runtime for https connections. Unfortunately the macOS version of curl, even on macOS 14.4, does not accept `CURL_SSLVERSION_TLSv1_3` at runtime to enforce TLS 1.3. However, while our vendored curl accepts the option and passes it to Secure Transport, macOS does not actually enforce it anyway. Fixes: #25870 Fixes: #23701
1 year ago
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
ENH: Simplify decision to use system libraries Previously we disallowed use of system libraries if FindXMLRPC.cmake was not available. Now that CMake 2.4 is required to build, the module is always available. This change simplifies the logic accordingly.
16 years ago
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
cmake: Add debugger - Depends on cppdap and jsoncpp. - Add --debugger argument to enable the Debugger. - Add --debugger-pipe argument for DAP traffics over named pipes. - Support breakpoints by filenames and line numbers. - Support exception breakpoints. - Call stack shows filenames and line numbers. - Show Cache Variables. - Show the state of currently defined targets, tests and directories with their properties. - Add cmakeVersion to DAP initialize response. - Include unit tests. Co-authored-by: Ben McMorran <bemcmorr@microsoft.com>
2 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
​
CTest: Remove submit method 'xmlrpc'
7 years ago
​
ENH: Simplify decision to use system libraries Previously we disallowed use of system libraries if FindXMLRPC.cmake was not available. Now that CMake 2.4 is required to build, the module is always available. This change simplifies the logic accordingly.
16 years ago
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
Add option CMAKE_USE_SYSTEM_LIBARCHIVE (#10923) Finish the implementation of the option from the skeleton left by the initial addition of libarchive.
15 years ago
bootstrap: Granular system library selection (#11431) This adds the ability for packagers to specify that some libraries should use system versions and others should use the CMake versions. This allows a bit of flexibility and means Homebrew (an OSX package manager) no longer has to continue to patch the CMake build process. Inspired-by: Mike McQuaid <mike@mikemcquaid.com>
15 years ago
CMake: Enable use of zstd in libarchive Build zstd as part of CMake or find one on the system. Modify our port of libarchive to use the zstd configured for use with CMake. Issue: #18657
6 years ago
​
CMake: Enable use of liblzma in libarchive (#14504) Build liblzma as part of CMake or find one on the system. Modify our port of libarchive to use the liblzma configured for use with CMake.
11 years ago
​
nghttp2: Build the library within CMake for use by our curl Provide our own minimal `config.h` since the upstream one is much larger to support other parts of its distribution. Compile with warnings disabled since this is third-party code.
5 years ago
​
ccmake: Add CMAKE_USE_SYSTEM_FORM option to use libform instead of cmForm
11 years ago
cppdap: Build as part of CMake or use external installation Add `cm3p/` headers to use the selected copy of the library. Co-authored-by: Glen Chung <kuchung@microsoft.com>
2 years ago
​
Add option to build CMake against a system librhash Create a CMAKE_USE_SYSTEM_LIBRHASH option.
9 years ago
Add option to build CMake against a system libuv Create a CMAKE_USE_SYSTEM_LIBUV option.
9 years ago
ENH: Simplify decision to use system libraries Previously we disallowed use of system libraries if FindXMLRPC.cmake was not available. Now that CMake 2.4 is required to build, the module is always available. This change simplifies the logic accordingly.
16 years ago
Add option to use a system-installed KWIML Do not activate it with the general use-system-libs options for now because KWIML is not commonly distributed or available.
10 years ago
​
​
​
​
ENH: more cleanup of some CMakeLists files
18 years ago
nghttp2: Skip "Using system-installed" message if using system curl We only use the system nghttp2 when `CMAKE_USE_SYSTEM_NGHTTP2` is ON and `CMAKE_USE_SYSTEM_CURL` is OFF.
1 year ago
​
​
​
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
ENH: more cleanup of some CMakeLists files
18 years ago
​
Build: Simplify `configure_file()` calls
3 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
​
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
13 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
​
​
​
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
​
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
​
Build: Simplify `configure_file()` calls
3 years ago
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
​
New USE_FOLDERS property OFF by default. (#3796) Visual Studio Express editions do not support solution folders, so default behavior should be as if USE_FOLDERS global property is OFF. Also, allow folder names to be the same as target names: internally, use a prefix to distinguish folder GUIDs from target GUIDs. Add a target and folder with the same name in the ExternalProject test to exercise this code. For CMake itself, provide a new option CMAKE_USE_FOLDERS that defaults to ON so that Visual Studio users get a nicely organized CMake project. Express edition users will have to turn off the CMAKE_USE_FOLDERS option in order to build CMake in the VS Express IDE.
15 years ago
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
New USE_FOLDERS property OFF by default. (#3796) Visual Studio Express editions do not support solution folders, so default behavior should be as if USE_FOLDERS global property is OFF. Also, allow folder names to be the same as target names: internally, use a prefix to distinguish folder GUIDs from target GUIDs. Add a target and folder with the same name in the ExternalProject test to exercise this code. For CMake itself, provide a new option CMAKE_USE_FOLDERS that defaults to ON so that Visual Studio users get a nicely organized CMake project. Express edition users will have to turn off the CMAKE_USE_FOLDERS option in order to build CMake in the VS Express IDE.
15 years ago
​
clang-tidy: add option CMake_RUN_CLANG_TIDY
8 years ago
​
​
​
​
​
​
​
​
​
clang-tidy: Make .clang-tidy a build-time dependency Currently a change to the clang-tidy configuration remains unnoticed for incremental builds in the way that it won't trigger a rebuild. This can be considered a missing dependency that this patch fixes by introducing a compile time definition (-DCLANG_TIDY_SHA1) that triggers a rebuild upon change. Currently this only applies to the target CMakeLib. Signed-off-by: Matthias Maennich <matthias@maennich.net>
8 years ago
clang-tidy: Add option to load CMake's clang-tidy module Issue: #23912
3 years ago
​
​
​
​
​
​
​
​
​
CMake: add option to export clang-tidy fixes to a directory
3 years ago
​
​
​
​
​
​
​
​
clang-tidy: Clarify comment explaining purpose of CLANG_TIDY_SHA1 Suggested-by: Bill Hoffman <bill.hoffman@kitware.com>
8 years ago
​
​
​
​
​
clang-tidy: Make .clang-tidy a build-time dependency Currently a change to the clang-tidy configuration remains unnoticed for incremental builds in the way that it won't trigger a rebuild. This can be considered a missing dependency that this patch fixes by introducing a compile time definition (-DCLANG_TIDY_SHA1) that triggers a rebuild upon change. Currently this only applies to the target CMakeLib. Signed-off-by: Matthias Maennich <matthias@maennich.net>
8 years ago
​
​
clang-tidy: Add option to load CMake's clang-tidy module Issue: #23912
3 years ago
​
​
​
​
clang-tidy: Make .clang-tidy a build-time dependency Currently a change to the clang-tidy configuration remains unnoticed for incremental builds in the way that it won't trigger a rebuild. This can be considered a missing dependency that this patch fixes by introducing a compile time definition (-DCLANG_TIDY_SHA1) that triggers a rebuild upon change. Currently this only applies to the target CMakeLib. Signed-off-by: Matthias Maennich <matthias@maennich.net>
8 years ago
clang-tidy: add option CMake_RUN_CLANG_TIDY
8 years ago
​
​
​
Add include-what-you-use mapping
8 years ago
​
CMake: Add CMake_BUILD_PCH option
2 years ago
​
​
Add include-what-you-use mapping
8 years ago
​
​
​
​
IWYU: Fix workaround mapping for std::hash It is provided by `functional`, not `utility`. Fix the mapping added by commit 276d3c7afe (IWYU: Add workaround mapping for std::hash, 2018-07-31). Also generalize the workaround from commit v3.12.0-rc1~39^2~1 (IWYU: Define a macro to tell code it is preprocessing for iwyu, 2018-05-25) to allow local builds to configure specific flags. This is needed because iwyu behaves differently in different environments.
7 years ago
CMake: add an option to run IWYU in verbose mode This helps to diagnose places where IWYU asks to include headers for internal stdlib details.
3 years ago
​
​
​
​
IWYU: Fix workaround mapping for std::hash It is provided by `functional`, not `utility`. Fix the mapping added by commit 276d3c7afe (IWYU: Add workaround mapping for std::hash, 2018-07-31). Also generalize the workaround from commit v3.12.0-rc1~39^2~1 (IWYU: Define a macro to tell code it is preprocessing for iwyu, 2018-05-25) to allow local builds to configure specific flags. This is needed because iwyu behaves differently in different environments.
7 years ago
Add include-what-you-use mapping
8 years ago
​
​
New USE_FOLDERS property OFF by default. (#3796) Visual Studio Express editions do not support solution folders, so default behavior should be as if USE_FOLDERS global property is OFF. Also, allow folder names to be the same as target names: internally, use a prefix to distinguish folder GUIDs from target GUIDs. Add a target and folder with the same name in the ExternalProject test to exercise this code. For CMake itself, provide a new option CMAKE_USE_FOLDERS that defaults to ON so that Visual Studio users get a nicely organized CMake project. Express edition users will have to turn off the CMAKE_USE_FOLDERS option in order to build CMake in the VS Express IDE.
15 years ago
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
Require CMake 2.8.4 or greater to build CMake This allows the use of the $<TARGET_FILE:...> generator expression as a replacement for the use of the LOCATION target property. The use of the LOCATION target property is now deprecated for in-build targets. Also drop other checks for older CMake versions: * Simplify cmake_set_target_folder macro. * Use find_package(LibArchive) unconditionally. * Simplify condition for running testVisualStudioSlnParser test. * Convert two macros to functions. * Unconditionally run the CTestTestRerunFailed test.
12 years ago
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
​
​
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Add FOLDER target property, for IDEs (#3796) This work was started from a patch by Thomas Schiffer. Thanks, Thomas! See the newly added documentation of the FOLDER target property for details. Also added global properties, USE_FOLDERS and PREDEFINED_TARGETS_FOLDER. See new docs here, too. By default, the FOLDER target property is used to organize targets into folders in IDEs that have support for such organization. This commit adds "solution folder" support to the Visual Studio generators. Currently works with versions 7 through 10. Also, use the new FOLDER property in the ExternalProject test and in the CMake project itself.
15 years ago
Poison GCC 3.3 on OpenBSD a bit later Move lines from commit 696a0af (Disable gcc 33 on OpenBSD because it crashes CPack by default, 2010-06-25) further down in CMakeLists.txt so that CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS applies. This fixes the code for building with CMake 2.4.
15 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
​
ENH: more cleanup of some CMakeLists files
18 years ago
​
​
​
​
CMakeVersion: Move computation logic to main script
6 years ago
ENH: Centralized setting of CMake version number to top-level CMake listfile.
23 years ago
Tests: Drop use of legacy "Dart" module Use the CTest module directly.
2 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
Apply CMake test-time config to all tests We configure an EnforceConfig.cmake script to load at CTest time. Previously we loaded it from Tests/CTestTestfile.cmake, but now we load it from the top level so it applies to all tests.
16 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Apply CMake test-time config to all tests We configure an EnforceConfig.cmake script to load at CTest time. Previously we loaded it from Tests/CTestTestfile.cmake, but now we load it from the top level so it applies to all tests.
16 years ago
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
COMP: CMake should be build static. Also propagate build_shared_libs to curl
21 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
Test 'install' target of CMake itself We create option CMake_TEST_INSTALL to enable a new CMake.Install test. It tests running the "make install" target to install CMake itself into a test directory. We enable the option by default for dashboard builds.
16 years ago
cmSystemTools: Hard-code try_compile results for Windows All Windows platforms offer `environ` in `stdlib.h` and do not have `unsetenv`.
5 years ago
​
​
​
​
​
​
​
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
ENH: Simplify the test
20 years ago
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
16 years ago
​
​
Update CDash server URL It is now at open.cdash.org and does not start in "/CDash".
11 years ago
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
16 years ago
​
​
​
​
​
​
​
​
Add option to skip CMake tests that need network access
6 years ago
Update CDash server URL It is now at open.cdash.org and does not start in "/CDash".
11 years ago
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
16 years ago
Add option to use a system-installed KWIML Do not activate it with the general use-system-libs options for now because KWIML is not commonly distributed or available.
10 years ago
Port CMake from cmIML to KWIML KWIML no longer uses a configured prefix.
10 years ago
Add option to use a system-installed KWIML Do not activate it with the general use-system-libs options for now because KWIML is not commonly distributed or available.
10 years ago
Port CMake from cmIML to KWIML KWIML no longer uses a configured prefix.
10 years ago
Tests: Build and test KWIML even when testing an external CMake The CMake_TEST_EXTERNAL_CMAKE option added by commit 9608ef6f (Tests: Optionally configure tests exclusively, 2014-03-03) is intended to allow one to run the CMake test suite with a compiler that may not be supported for hosting the build of CMake itself. However, we currently use the CMake test infrastructure to test KWIML everywhere that CMake supports. In order to continue testing KWIML even in places that CMake itself does not build, include it even when testing an external CMake.
11 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
Build: Extract `CMAKE_BUILD_UTILITIES` macro into a separate include The macro was one time used with the comment "Simply to improve readability...". The result file doesn't have a macro anymore and just included into the root `CMakeLists.txt`.
3 years ago
​
​
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
Simplify logic to compute install prefix in OS X CMake.app Also avoid explicitly dereferencing a variable in an if() condition.
10 years ago
Build: Use `string(APPEND…)` in the root `CMakeLists.txt`
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
Build: Use `string(APPEND…)` in the root `CMakeLists.txt`
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
COMP: use RPATH is building QtDialog and the Qt libs are not in /lib or /usr/lib (same logic as for ccmake) Alex
18 years ago
Enable RPATH for CMake's own binaries by default Reconcile the changes made by: * commit ae62f66033 (ENH: CMake does not need RPATHs at all for its own executables, 2006-03-01, v2.4.0~380) * commit a056cffc5b (COMP: enable RPATH if any of the CMAKE_USE_SYSTEM_XXX variables is enabled, 2007-08-28, v2.6.0~1183) * commit c0108d1e07 (COMP: use RPATH is building QtDialog and the Qt libs are not in /lib or /usr/lib, 2007-11-05, v2.6.0~915) The overall goal of those changes was to get the RPATH set for external libraries when needed and also to avoid re-linking or other RPATH editing on installation. We can use a simpler approach to satisfy both goals: always use RPATH entries for libraries found externally. If there are no such libraries we will get no RPATH. If there are such libraries that are not in standard paths we will get a RPATH that points at them. This will work for running either from the build tree or the install tree, so we can use the same for both to avoid editing on installation. Fixes: #20185
6 years ago
​
​
​
​
​
​
COMP: enable RPATH if any of the CMAKE_USE_SYSTEM_XXX variables is enabled or if the curses library is neither in /lib nor in /usr/lib . This makes it build on NetBSD. For more comments see CMakeLists.txt Alex
18 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
Build: Simplify `configure_file()` calls
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
ENH: added some release support
20 years ago
CMakeLists: Remove redundant spaces around CMake command calls
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
ENH: use a safer check for CPack
20 years ago
ENH: more cleanup of some CMakeLists files
18 years ago
​
BUG: allow system information to accept the -G option
19 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
Enable compiler warnings when compiling CMake with Clang I noticed that I wasn't getting any compiler warnings when testing my merge requests locally. Turns out this happens because I am compiling using Clang rather than GCC, so no warning flags are added to the build. d06a9bdf3ab47231cc91b78dac77bd50de390565 enabled warnings by default for GCC > 4.2, but Clang supports them too. This has been the case since at least Clang 3.0 (I couldn't test any older versions on godbolt.org). For AppleClang, we can also assume that the warning flags are supported. According to Wikipedia Clang became the default compiler starting with Xcode 4.2, and the table on https://trac.macports.org/wiki/XcodeVersionInfo, states that XCode 4.2 Clang was based on upstream Clang 3.0, which supports all the warning flags. The warning flags are currently not added when compiling with clang-cl since this exposes some pre-existing warnings that need to be fixed first.
4 years ago
​
​
​
​
LCC: Add dedicated support for MCST LCC compiler Divert LCC compiler as a new one, instead of treating it as GNU. Since old times, Elbrus C/C++/Fortran Compiler (LCC) by MCST has been passing checks for GNU compilers, so it has been identified as GNU. Now, with intent of seriously upstreaming its support, it has been added as a separate LCC compiler, and its version displays not a supported GCC version, but LCC version itself (e.g. LCC 1.25.19 instead of GNU 7.3.0). This commit adds its support for detection, and also converts basically every check like 'is this compiler GNU?' to 'is this compiler GNU or LCC?'. The only places where this check is untouched, is where it regards other platforms where LCC is unavailable (primarily non-Linux), and where it REALLY differs from GNU compiler. Note: this transition may break software that are already ported to Elbrus, but hardly relies that LCC will be detected as GNU; still such software is not known.
4 years ago
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
​
​
Build: Modernize some `foreach` calls to use `IN LISTS`/`IN ITEMS`
3 years ago
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
Build: Use `string(APPEND…)` in the root `CMakeLists.txt`
3 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
Enable some compiler warnings when building CMake. The warnings are enabled for now only when using GCC 4.2 or later. It may be possible later to also enable them when building CMake with clang. Don't duplicate the compiler flags if already set.
13 years ago
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
Enable some compiler warnings when building CMake. The warnings are enabled for now only when using GCC 4.2 or later. It may be possible later to also enable them when building CMake with clang. Don't duplicate the compiler flags if already set.
13 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
Enable some compiler warnings when building CMake. The warnings are enabled for now only when using GCC 4.2 or later. It may be possible later to also enable them when building CMake with clang. Don't duplicate the compiler flags if already set.
13 years ago
ENH: move CMAKE_STRICT option to the top
18 years ago
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
13 years ago
BUG: allow system information to accept the -G option
19 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
​
Set IDE folder for CMake 'documentation' target only if it exists The documentation target will be come optional, so do not reference it when it does not exist.
12 years ago
Add FOLDER target property, for IDEs (#3796) This work was started from a patch by Thomas Schiffer. Thanks, Thomas! See the newly added documentation of the FOLDER target property for details. Also added global properties, USE_FOLDERS and PREDEFINED_TARGETS_FOLDER. See new docs here, too. By default, the FOLDER target property is used to organize targets into folders in IDEs that have support for such organization. This commit adds "solution folder" support to the Visual Studio generators. Currently works with versions 7 through 10. Also, use the new FOLDER property in the ExternalProject test and in the CMake project itself.
15 years ago
Tests: Add missing BUILD_TESTING conditions We should not call `add_test` unless `BUILD_TESTING` is enabled. Fixes: #18500
7 years ago
​
CMakeLists: Remove redundant spaces around CMake command calls
3 years ago
​
Tests: Add missing BUILD_TESTING conditions We should not call `add_test` unless `BUILD_TESTING` is enabled. Fixes: #18500
7 years ago
BUG: possible fix for new SystemInfo test
19 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
XL: Install our Fortran 'cpp' helper script with execute permission This script was added by commit 19f267c75e (XL: Add support for Ninja and XL Fortran, 2019-11-21, v3.17.0-rc1~368^2) but does not have a `.sh` extension so our existing install rules neglect to give it execute permission. Our test suite works on XL Fortran in the build tree but the script is broken without execute permission on installation. Fixes: #20695
5 years ago
AIX: Install ExportImportList script with execute permission This script was added by commit 0f150b69d3 (AIX: Explicitly compute shared object exports for both XL and GNU, 2019-07-11, v3.16.0-rc1~418^2~2) but does not have a `.sh` extension so our existing install rules neglect to give it execute permission. Our test suite works on AIX in the build tree but the script is broken without execute permission on installation. Fixes: #20520
5 years ago
​
​
Help: Restore installation of top-level index We removed installation of `Help/index.rst` in commit d2fde94809 (Help: Add infrastructure for guide-level documentation, 2019-05-30), but the file is required for `--help-full` to work. Restore installation of the file and update it to avoid referencing the `Help/guide` directory in its toctree during processing by `cmRST`.
6 years ago
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
​
​
​
Add undocumented option to sign CMake's own binaries on Windows
6 years ago
​
​
​
​
​
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
12 years ago
  1. # Distributed under the OSI-approved BSD 3-Clause License. See accompanying
  2. # file Copyright.txt or https://cmake.org/licensing for details.
  4. cmake_minimum_required(VERSION 3.13...3.29 FATAL_ERROR)
  5. set(CMAKE_USER_MAKE_RULES_OVERRIDE_C ${CMAKE_CURRENT_SOURCE_DIR}/Source/Modules/OverrideC.cmake)
  6. set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX ${CMAKE_CURRENT_SOURCE_DIR}/Source/Modules/OverrideCXX.cmake)
  8. project(CMake)
  9. unset(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX)
  10. unset(CMAKE_USER_MAKE_RULES_OVERRIDE_C)
  12. # FIXME: This block should go away after a transition period.
  13. if(MSVC AND NOT CMAKE_VERSION VERSION_LESS 3.15)
  14. # Filter out MSVC runtime library flags that may have come from
  15. # the cache of an existing build tree or from scripts.
  16. foreach(l IN ITEMS C CXX)
  17. foreach(c IN ITEMS DEBUG MINSIZEREL RELEASE RELWITHDEBINFO)
  18. string(REGEX REPLACE "[-/]M[DT]d?( |$)" "" "CMAKE_${l}_FLAGS_${c}" "${CMAKE_${l}_FLAGS_${c}}")
  19. endforeach()
  20. endforeach()
  21. endif()
  23. # Make sure we can find internal find_package modules only used for
  24. # building CMake and not for shipping externally
  25. list(INSERT CMAKE_MODULE_PATH 0 ${CMake_SOURCE_DIR}/Source/Modules)
  27. if(CMAKE_BOOTSTRAP)
  28. # Running from bootstrap script. Set local variable and remove from cache.
  29. set(CMAKE_BOOTSTRAP 1)
  30. unset(CMAKE_BOOTSTRAP CACHE)
  31. endif()
  33. if(CMake_TEST_HOST_CMAKE)
  34. get_filename_component(CMake_TEST_EXTERNAL_CMAKE "${CMAKE_COMMAND}" DIRECTORY)
  35. endif()
  37. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  38. if(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
  39. message(FATAL_ERROR
  40. "CMake no longer compiles on HP-UX. See\n"
  41. " https://gitlab.kitware.com/cmake/cmake/-/issues/17137\n"
  42. "Use CMake 3.9 or lower instead."
  43. )
  44. endif()
  46. set(CMake_BIN_DIR ${CMake_BINARY_DIR}/bin)
  47. endif()
  49. if(CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL)
  50. if(CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL MATCHES "^3|2\\.1$")
  51. set(USE_LGPL "${CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL}")
  52. else()
  53. set(USE_LGPL "2.1")
  54. endif()
  55. else()
  56. set(USE_LGPL "")
  57. endif()
  59. # Use most-recent available language dialects with GNU and Clang
  60. if(NOT DEFINED CMAKE_C_STANDARD AND NOT CMake_NO_C_STANDARD)
  61. include(${CMake_SOURCE_DIR}/Source/Checks/cm_c11_thread_local.cmake)
  62. if(NOT CMake_C11_THREAD_LOCAL_BROKEN)
  63. set(CMAKE_C_STANDARD 11)
  64. else()
  65. set(CMAKE_C_STANDARD 99)
  66. endif()
  67. endif()
  68. if(NOT DEFINED CMAKE_CXX_STANDARD AND NOT CMake_NO_CXX_STANDARD)
  69. if(CMAKE_CXX_COMPILER_ID STREQUAL SunPro AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.14)
  70. set(CMAKE_CXX_STANDARD 98)
  71. else()
  72. include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx17_check.cmake)
  73. if(NOT CMake_CXX17_BROKEN)
  74. set(CMAKE_CXX_STANDARD 17)
  75. else()
  76. include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx14_check.cmake)
  77. if(NOT CMake_CXX14_BROKEN)
  78. set(CMAKE_CXX_STANDARD 14)
  79. else()
  80. set(CMAKE_CXX_STANDARD 11)
  81. endif()
  82. endif()
  83. endif()
  84. endif()
  85. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  86. # include special compile flags for some compilers
  87. include(CompileFlags.cmake)
  89. # check for available C++ features
  90. include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx_features.cmake)
  92. if(NOT CMake_HAVE_CXX_UNIQUE_PTR)
  93. message(FATAL_ERROR "The C++ compiler does not support C++11 (e.g. std::unique_ptr).")
  94. endif()
  95. endif()
  97. # Inform STL library header wrappers whether to use system versions.
  98. configure_file(Utilities/std/cmSTL.hxx.in Utilities/cmSTL.hxx @ONLY)
  100. # set the internal encoding of CMake to UTF-8
  101. set(KWSYS_ENCODING_DEFAULT_CODEPAGE CP_UTF8)
  103. # option to use COMPONENT with install command
  104. option(CMake_INSTALL_COMPONENTS "Using components when installing" OFF)
  105. mark_as_advanced(CMake_INSTALL_COMPONENTS)
  106. macro(CMake_OPTIONAL_COMPONENT NAME)
  107. if(CMake_INSTALL_COMPONENTS)
  108. set(COMPONENT COMPONENT ${NAME})
  109. else()
  110. set(COMPONENT)
  111. endif()
  112. endmacro()
  114. # option to disable installing 3rd-party dependencies
  115. option(CMake_INSTALL_DEPENDENCIES
  116. "Whether to install 3rd-party runtime dependencies" OFF)
  117. mark_as_advanced(CMake_INSTALL_DEPENDENCIES)
  119. # option to build reference for CMake developers
  120. option(CMake_BUILD_DEVELOPER_REFERENCE
  121. "Build CMake Developer Reference" OFF)
  122. mark_as_advanced(CMake_BUILD_DEVELOPER_REFERENCE)
  124. # option to build using interprocedural optimizations (IPO/LTO)
  125. option(CMake_BUILD_LTO "Compile CMake with link-time optimization if supported" OFF)
  126. if(CMake_BUILD_LTO)
  127. include(CheckIPOSupported)
  128. check_ipo_supported(RESULT HAVE_IPO)
  129. if(HAVE_IPO)
  130. set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
  131. endif()
  132. endif()
  134. option(CMake_BUILD_PCH "Compile CMake with precompiled headers" OFF)
  136. # Check whether to build support for the debugger mode.
  137. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  138. if(NOT DEFINED CMake_ENABLE_DEBUGGER)
  139. # The debugger uses cppdap, which does not compile everywhere.
  140. if(CMAKE_SYSTEM_NAME MATCHES "Windows|Darwin|Linux|BSD|DragonFly|CYGWIN|MSYS"
  141. AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.16)
  142. AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "XLClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.1)
  143. AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "LCC" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 1.23)
  144. )
  145. set(CMake_ENABLE_DEBUGGER 1)
  146. else()
  147. set(CMake_ENABLE_DEBUGGER 0)
  148. endif()
  149. endif()
  150. else()
  151. set(CMake_ENABLE_DEBUGGER 0)
  152. endif()
  154. #-----------------------------------------------------------------------
  155. # a macro to deal with system libraries, implemented as a macro
  156. # simply to improve readability of the main script
  157. #-----------------------------------------------------------------------
  158. macro(CMAKE_HANDLE_SYSTEM_LIBRARIES)
  159. include(CMakeDependentOption)
  161. # Allow the user to enable/disable all system utility library options by
  162. # defining CMAKE_USE_SYSTEM_LIBRARIES or CMAKE_USE_SYSTEM_LIBRARY_${util}.
  163. set(UTILITIES BZIP2 CPPDAP CURL EXPAT FORM JSONCPP LIBARCHIVE LIBLZMA LIBRHASH LIBUV NGHTTP2 ZLIB ZSTD)
  164. foreach(util IN LISTS UTILITIES)
  165. if(NOT DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util}
  166. AND DEFINED CMAKE_USE_SYSTEM_LIBRARIES)
  167. set(CMAKE_USE_SYSTEM_LIBRARY_${util} "${CMAKE_USE_SYSTEM_LIBRARIES}")
  168. endif()
  169. if(DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util})
  170. if(CMAKE_USE_SYSTEM_LIBRARY_${util})
  171. set(CMAKE_USE_SYSTEM_LIBRARY_${util} ON)
  172. else()
  173. set(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
  174. endif()
  175. if(CMAKE_BOOTSTRAP)
  176. unset(CMAKE_USE_SYSTEM_LIBRARY_${util} CACHE)
  177. endif()
  178. string(TOLOWER "${util}" lutil)
  179. set(CMAKE_USE_SYSTEM_${util} "${CMAKE_USE_SYSTEM_LIBRARY_${util}}"
  180. CACHE BOOL "Use system-installed ${lutil}" FORCE)
  181. elseif(util STREQUAL "CURL" AND APPLE)
  182. # macOS provides a curl with backends configured by Apple.
  183. set(CMAKE_USE_SYSTEM_LIBRARY_${util} ON)
  184. else()
  185. set(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
  186. endif()
  187. endforeach()
  188. if(CMAKE_BOOTSTRAP)
  189. unset(CMAKE_USE_SYSTEM_LIBRARIES CACHE)
  190. endif()
  192. # Optionally use system utility libraries.
  193. option(CMAKE_USE_SYSTEM_LIBARCHIVE "Use system-installed libarchive" "${CMAKE_USE_SYSTEM_LIBRARY_LIBARCHIVE}")
  194. if(CMake_ENABLE_DEBUGGER)
  195. option(CMAKE_USE_SYSTEM_CPPDAP "Use system-installed cppdap" "${CMAKE_USE_SYSTEM_LIBRARY_CPPDAP}")
  196. endif()
  197. option(CMAKE_USE_SYSTEM_CURL "Use system-installed curl" "${CMAKE_USE_SYSTEM_LIBRARY_CURL}")
  198. option(CMAKE_USE_SYSTEM_EXPAT "Use system-installed expat" "${CMAKE_USE_SYSTEM_LIBRARY_EXPAT}")
  199. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_ZLIB "Use system-installed zlib"
  200. "${CMAKE_USE_SYSTEM_LIBRARY_ZLIB}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE;NOT CMAKE_USE_SYSTEM_CURL" ON)
  201. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_BZIP2 "Use system-installed bzip2"
  202. "${CMAKE_USE_SYSTEM_LIBRARY_BZIP2}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE" ON)
  203. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_ZSTD "Use system-installed zstd"
  204. "${CMAKE_USE_SYSTEM_LIBRARY_ZSTD}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE" ON)
  205. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_LIBLZMA "Use system-installed liblzma"
  206. "${CMAKE_USE_SYSTEM_LIBRARY_LIBLZMA}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE" ON)
  207. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_NGHTTP2 "Use system-installed nghttp2"
  208. "${CMAKE_USE_SYSTEM_LIBRARY_NGHTTP2}" "NOT CMAKE_USE_SYSTEM_CURL" ON)
  209. option(CMAKE_USE_SYSTEM_FORM "Use system-installed libform" "${CMAKE_USE_SYSTEM_LIBRARY_FORM}")
  210. CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_JSONCPP "Use system-installed jsoncpp"
  211. "${CMAKE_USE_SYSTEM_LIBRARY_JSONCPP}" "NOT CMAKE_USE_SYSTEM_CPPDAP" ON)
  212. option(CMAKE_USE_SYSTEM_LIBRHASH "Use system-installed librhash" "${CMAKE_USE_SYSTEM_LIBRARY_LIBRHASH}")
  213. option(CMAKE_USE_SYSTEM_LIBUV "Use system-installed libuv" "${CMAKE_USE_SYSTEM_LIBRARY_LIBUV}")
  215. # For now use system KWIML only if explicitly requested rather
  216. # than activating via the general system libs options.
  217. option(CMAKE_USE_SYSTEM_KWIML "Use system-installed KWIML" OFF)
  218. mark_as_advanced(CMAKE_USE_SYSTEM_KWIML)
  220. # Mention to the user what system libraries are being used.
  221. if(CMAKE_USE_SYSTEM_CURL)
  222. # Avoid messaging about curl-only dependencies.
  223. list(REMOVE_ITEM UTILITIES NGHTTP2)
  224. endif()
  225. foreach(util IN LISTS UTILITIES ITEMS KWIML)
  226. if(CMAKE_USE_SYSTEM_${util})
  227. message(STATUS "Using system-installed ${util}")
  228. endif()
  229. endforeach()
  231. # Inform utility library header wrappers whether to use system versions.
  232. configure_file(Utilities/cmThirdParty.h.in Utilities/cmThirdParty.h @ONLY)
  234. endmacro()
  236. #-----------------------------------------------------------------------
  237. # a macro to determine the generator and ctest executable to use
  238. # for testing. Simply to improve readability of the main script.
  239. #-----------------------------------------------------------------------
  240. macro(CMAKE_SETUP_TESTING)
  241. if(BUILD_TESTING)
  242. set(CMAKE_TEST_SYSTEM_LIBRARIES 0)
  243. foreach(util IN ITEMS CURL EXPAT ZLIB)
  244. if(CMAKE_USE_SYSTEM_${util})
  245. set(CMAKE_TEST_SYSTEM_LIBRARIES 1)
  246. endif()
  247. endforeach()
  249. # This variable is set by cmake, however to
  250. # test cmake we want to make sure that
  251. # the ctest from this cmake is used for testing
  252. # and not the ctest from the cmake building and testing
  253. # cmake.
  254. if(CMake_TEST_EXTERNAL_CMAKE)
  255. set(CMAKE_CTEST_COMMAND "${CMake_TEST_EXTERNAL_CMAKE}/ctest")
  256. set(CMAKE_CMAKE_COMMAND "${CMake_TEST_EXTERNAL_CMAKE}/cmake")
  257. set(CMAKE_CPACK_COMMAND "${CMake_TEST_EXTERNAL_CMAKE}/cpack")
  258. foreach(exe IN ITEMS cmake ctest cpack)
  259. add_executable(${exe} IMPORTED)
  260. set_property(TARGET ${exe} PROPERTY IMPORTED_LOCATION ${CMake_TEST_EXTERNAL_CMAKE}/${exe})
  261. endforeach()
  262. else()
  263. set(CMAKE_CTEST_COMMAND "${CMake_BIN_DIR}/ctest")
  264. set(CMAKE_CMAKE_COMMAND "${CMake_BIN_DIR}/cmake")
  265. set(CMAKE_CPACK_COMMAND "${CMake_BIN_DIR}/cpack")
  266. endif()
  267. endif()
  269. # configure some files for testing
  270. configure_file(Tests/.NoDartCoverage Tests/.NoDartCoverage)
  271. configure_file(CTestCustom.cmake.in CTestCustom.cmake @ONLY)
  272. endmacro()
  275. # Provide a way for Visual Studio Express users to turn OFF the new FOLDER
  276. # organization feature. Default to ON for non-Express users. Express users must
  277. # explicitly turn off this option to build CMake in the Express IDE...
  278. #
  279. option(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON)
  280. mark_as_advanced(CMAKE_USE_FOLDERS)
  283. option(CMake_RUN_CLANG_TIDY "Run clang-tidy with the compiler." OFF)
  284. if(CMake_RUN_CLANG_TIDY)
  285. if(CMake_SOURCE_DIR STREQUAL CMake_BINARY_DIR)
  286. message(FATAL_ERROR "CMake_RUN_CLANG_TIDY requires an out-of-source build!")
  287. endif()
  288. find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
  289. if(NOT CLANG_TIDY_COMMAND)
  290. message(FATAL_ERROR "CMake_RUN_CLANG_TIDY is ON but clang-tidy is not found!")
  291. endif()
  292. set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
  294. option(CMake_USE_CLANG_TIDY_MODULE "Use CMake's clang-tidy module." OFF)
  295. if(CMake_USE_CLANG_TIDY_MODULE)
  296. find_library(CMake_CLANG_TIDY_MODULE NAMES cmake-clang-tidy-module DOC "Location of the clang-tidy module")
  297. if(NOT CMake_CLANG_TIDY_MODULE)
  298. message(FATAL_ERROR "CMake_USE_CLANG_TIDY_MODULE is ON but cmake-clang-tidy-module is not found!")
  299. endif()
  300. list(APPEND CMAKE_CXX_CLANG_TIDY "--load=${CMake_CLANG_TIDY_MODULE}")
  301. set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMake_CLANG_TIDY_MODULE}")
  302. endif()
  304. set(CMake_CLANG_TIDY_EXPORT_FIXES_DIR "" CACHE PATH "Directory to put clang-tidy fix files in.")
  305. mark_as_advanced(CMake_CLANG_TIDY_EXPORT_FIXES_DIR)
  306. if(CMake_CLANG_TIDY_EXPORT_FIXES_DIR)
  307. if(NOT IS_ABSOLUTE "${CMake_CLANG_TIDY_EXPORT_FIXES_DIR}")
  308. message(FATAL_ERROR "CMake_CLANG_TIDY_EXPORT_FIXES_DIR must be an absolute path!")
  309. endif()
  310. set(CMAKE_CXX_CLANG_TIDY_EXPORT_FIXES_DIR "${CMake_CLANG_TIDY_EXPORT_FIXES_DIR}")
  311. endif()
  313. # Create a preprocessor definition that depends on .clang-tidy content so
  314. # the compile command will change when .clang-tidy changes. This ensures
  315. # that a subsequent build re-runs clang-tidy on all sources even if they
  316. # do not otherwise need to be recompiled. Nothing actually uses this
  317. # definition. We add it to targets on which we run clang-tidy just to
  318. # get the build dependency on the .clang-tidy file.
  319. file(SHA1 ${CMAKE_CURRENT_SOURCE_DIR}/.clang-tidy clang_tidy_sha1)
  320. set(CLANG_TIDY_DEFINITIONS "CLANG_TIDY_SHA1=${clang_tidy_sha1}")
  321. unset(clang_tidy_sha1)
  322. if(CMake_USE_CLANG_TIDY_MODULE)
  323. file(SHA1 "${CMake_CLANG_TIDY_MODULE}" clang_tidy_module_sha1)
  324. list(APPEND CLANG_TIDY_DEFINITIONS "CLANG_TIDY_MODULE_SHA1=${clang_tidy_module_sha1}")
  325. unset(clang_tidy_module_sha1)
  326. endif()
  328. endif()
  329. configure_file(.clang-tidy .clang-tidy COPYONLY)
  332. option(CMake_RUN_IWYU "Run include-what-you-use with the compiler." OFF)
  333. if(CMake_RUN_IWYU)
  334. if(CMake_BUILD_PCH)
  335. message(FATAL_ERROR "CMake_RUN_IWYU and CMake_BUILD_PCH are ON, but they are incompatible!")
  336. endif()
  337. find_program(IWYU_COMMAND NAMES include-what-you-use iwyu)
  338. if(NOT IWYU_COMMAND)
  339. message(FATAL_ERROR "CMake_RUN_IWYU is ON but include-what-you-use is not found!")
  340. endif()
  341. set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE
  342. "${IWYU_COMMAND};-Xiwyu;--mapping_file=${CMake_SOURCE_DIR}/Utilities/IWYU/mapping.imp;-w")
  343. option(CMake_IWYU_VERBOSE "Run include-what-you-use in verbose mode" OFF)
  344. if (CMake_IWYU_VERBOSE)
  345. list(APPEND CMAKE_CXX_INCLUDE_WHAT_YOU_USE
  346. -Xiwyu -v7)
  347. endif ()
  348. list(APPEND CMAKE_CXX_INCLUDE_WHAT_YOU_USE ${CMake_IWYU_OPTIONS})
  349. endif()
  352. #-----------------------------------------------------------------------
  353. # a macro that only sets the FOLDER target property if it's
  354. # "appropriate"
  355. #-----------------------------------------------------------------------
  356. macro(CMAKE_SET_TARGET_FOLDER tgt folder)
  357. if(CMAKE_USE_FOLDERS)
  358. set_property(GLOBAL PROPERTY USE_FOLDERS ON)
  359. if(MSVC AND TARGET ${tgt})
  360. set_property(TARGET "${tgt}" PROPERTY FOLDER "${folder}")
  361. endif()
  362. else()
  363. set_property(GLOBAL PROPERTY USE_FOLDERS OFF)
  364. endif()
  365. endmacro()
  367. #-----------------------------------------------------------------------
  368. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  369. if(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
  370. execute_process(COMMAND ${CMAKE_CXX_COMPILER}
  371. ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
  372. OUTPUT_VARIABLE _GXX_VERSION
  373. )
  374. string(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
  375. _GXX_VERSION_SHORT ${_GXX_VERSION})
  376. if(_GXX_VERSION_SHORT EQUAL 33)
  377. message(FATAL_ERROR
  378. "GXX 3.3 on OpenBSD is known to cause CPack to Crash.\n"
  379. "Please use GXX 4.2 or greater to build CMake on OpenBSD\n"
  380. "${CMAKE_CXX_COMPILER} version is: ${_GXX_VERSION}")
  381. endif()
  382. endif()
  383. endif()
  385. #-----------------------------------------------------------------------
  386. # The main section of the CMakeLists file
  387. #
  388. #-----------------------------------------------------------------------
  389. include(Source/CMakeVersion.cmake)
  391. include(CTest)
  393. # Set up test-time configuration.
  394. set_directory_properties(PROPERTIES
  395. TEST_INCLUDE_FILE "${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake")
  397. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  398. # where to write the resulting executables and libraries
  399. set(BUILD_SHARED_LIBS OFF)
  400. set(EXECUTABLE_OUTPUT_PATH "" CACHE INTERNAL "No configurable exe dir.")
  401. set(LIBRARY_OUTPUT_PATH "" CACHE INTERNAL
  402. "Where to put the libraries for CMake")
  404. # Load install destinations.
  405. include(Source/CMakeInstallDestinations.cmake)
  407. if(BUILD_TESTING)
  408. include(${CMake_SOURCE_DIR}/Tests/CMakeInstall.cmake)
  409. endif()
  411. # Checks for cmSystemTools.
  412. if(WIN32)
  413. set(HAVE_UNSETENV 0)
  414. set(HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE 1)
  415. else()
  416. include(CheckSymbolExists)
  417. CHECK_SYMBOL_EXISTS(unsetenv "stdlib.h" HAVE_UNSETENV)
  418. CHECK_SYMBOL_EXISTS(environ "stdlib.h" HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)
  419. endif()
  420. endif()
  422. # CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests.
  423. #
  424. # If not defined or "", this variable defaults to the server at
  425. # "http://open.cdash.org".
  426. #
  427. # If set explicitly to "NOTFOUND", curl tests and ctest tests that use
  428. # the network are skipped.
  429. #
  430. # If set to something starting with "http://localhost/", the CDash is
  431. # expected to be an instance of CDash used for CDash testing, pointing
  432. # to a cdash4simpletest database. In these cases, the CDash dashboards
  433. # should be run first.
  434. #
  435. if("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x" AND NOT CMake_TEST_NO_NETWORK)
  436. set(CMAKE_TESTS_CDASH_SERVER "http://open.cdash.org")
  437. endif()
  439. if(CMake_TEST_EXTERNAL_CMAKE)
  440. set(KWIML_TEST_ENABLE 1)
  441. add_subdirectory(Utilities/KWIML)
  442. endif()
  444. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  445. find_package(Threads)
  446. # build the utilities
  447. include(CMakeBuildUtilities)
  449. if(BUILD_QtDialog)
  450. if(APPLE)
  451. set(CMAKE_BUNDLE_VERSION
  452. "${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}")
  453. set(CMAKE_BUNDLE_LOCATION "${CMAKE_INSTALL_PREFIX}")
  454. # make sure CMAKE_INSTALL_PREFIX ends in /
  455. if(NOT CMAKE_INSTALL_PREFIX MATCHES "/$")
  456. string(APPEND CMAKE_INSTALL_PREFIX "/")
  457. endif()
  458. string(APPEND CMAKE_INSTALL_PREFIX "CMake.app/Contents")
  459. endif()
  460. endif()
  462. if(UNIX)
  463. # Install executables with the RPATH set for libraries outside the build tree.
  464. # This is also suitable for binaries in the build tree. Avoid re-link on install.
  465. set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON CACHE BOOL "Install with RPATH set to find custom-built libraries.")
  466. set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE BOOL "Build with RPATH set to match install-tree RPATH.")
  467. mark_as_advanced(CMAKE_INSTALL_RPATH_USE_LINK_PATH CMAKE_BUILD_WITH_INSTALL_RPATH)
  468. endif()
  470. # add the uninstall support
  471. configure_file(cmake_uninstall.cmake.in cmake_uninstall.cmake @ONLY)
  472. add_custom_target(uninstall
  473. "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
  475. include(CMakeCPack.cmake)
  477. endif()
  479. # setup some Testing support (a macro defined in this file)
  480. CMAKE_SETUP_TESTING()
  482. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  483. if(NOT CMake_VERSION_IS_RELEASE)
  484. if((CMAKE_C_COMPILER_ID STREQUAL "GNU" AND
  485. NOT "${CMAKE_C_COMPILER_VERSION}" VERSION_LESS 4.2) OR
  486. (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND
  487. NOT "${CMAKE_C_COMPILER_VERSION}" VERSION_LESS 3.0 AND
  488. NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") OR
  489. CMAKE_C_COMPILER_ID STREQUAL "AppleClang" OR
  490. CMAKE_C_COMPILER_ID STREQUAL "LCC")
  491. set(C_FLAGS_LIST -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts
  492. -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security
  493. -Wmissing-format-attribute -fno-common -Wundef
  494. )
  495. set(CXX_FLAGS_LIST -Wnon-virtual-dtor -Wcast-align -Wchar-subscripts -Wall -W
  496. -Wshadow -Wpointer-arith -Wformat-security -Wundef
  497. )
  499. foreach(FLAG_LANG IN ITEMS C CXX)
  500. foreach(FLAG IN LISTS ${FLAG_LANG}_FLAGS_LIST)
  501. if(NOT " ${CMAKE_${FLAG_LANG}_FLAGS} " MATCHES " ${FLAG} ")
  502. string(APPEND CMAKE_${FLAG_LANG}_FLAGS " ${FLAG}")
  503. endif()
  504. endforeach()
  505. endforeach()
  507. unset(C_FLAGS_LIST)
  508. unset(CXX_FLAGS_LIST)
  509. endif()
  510. endif()
  512. # build the remaining subdirectories
  513. add_subdirectory(Source)
  514. add_subdirectory(Utilities)
  515. endif()
  517. add_subdirectory(Tests)
  519. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  520. if(BUILD_TESTING)
  521. CMAKE_SET_TARGET_FOLDER(CMakeLibTests "Tests")
  522. endif()
  523. if(TARGET documentation)
  524. CMAKE_SET_TARGET_FOLDER(documentation "Documentation")
  525. endif()
  526. endif()
  528. if(BUILD_TESTING)
  529. add_test(SystemInformationNew "${CMAKE_CMAKE_COMMAND}"
  530. --system-information -G "${CMAKE_GENERATOR}"
  531. )
  532. endif()
  534. if(NOT CMake_TEST_EXTERNAL_CMAKE)
  535. # Install license file as it requires.
  536. install(FILES Copyright.txt DESTINATION ${CMAKE_DOC_DIR})
  538. # Install script directories.
  539. install(
  540. DIRECTORY Help Modules Templates
  541. DESTINATION ${CMAKE_DATA_DIR}
  542. FILE_PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
  543. DIRECTORY_PERMISSIONS OWNER_READ OWNER_EXECUTE OWNER_WRITE
  544. GROUP_READ GROUP_EXECUTE
  545. WORLD_READ WORLD_EXECUTE
  546. PATTERN "*.sh*" PERMISSIONS OWNER_READ OWNER_EXECUTE OWNER_WRITE
  547. GROUP_READ GROUP_EXECUTE
  548. WORLD_READ WORLD_EXECUTE
  549. REGEX "/(ExportImportList|cpp)$"
  550. PERMISSIONS OWNER_READ OWNER_EXECUTE OWNER_WRITE
  551. GROUP_READ GROUP_EXECUTE
  552. WORLD_READ WORLD_EXECUTE
  553. REGEX "Help/(dev|guide)($|/)" EXCLUDE
  554. )
  556. # Install auxiliary files integrating with other tools.
  557. add_subdirectory(Auxiliary)
  559. # Optionally sign installed binaries.
  560. if(CMake_INSTALL_SIGNTOOL)
  561. configure_file(Source/CMakeInstallSignTool.cmake.in Source/CMakeInstallSignTool.cmake @ONLY)
  562. install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/Source/CMakeInstallSignTool.cmake)
  563. endif()
  564. endif()