reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-23 19:49:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
56148cb98f
CMake/Modules/CMakeFindPackageMode.cmake

204 lines
6.0 KiB
CMake
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.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 15:17:36 +00:00
#.rst:
# CMakeFindPackageMode
# --------------------
#
#
#
# This file is executed by cmake when invoked with --find-package. It
# expects that the following variables are set using -D:
#
Modules: Format documentation to avoid over-long preformatted lines Convert several preformatted code block literals that enumerate lists of options or variables to use reST definition lists instead. Manually wrap other long lines in code blocks.
2014-10-22 19:52:31 +00:00
# ``NAME``
# name of the package
# ``COMPILER_ID``
# the CMake compiler ID for which the result is,
# i.e. GNU/Intel/Clang/MSVC, etc.
# ``LANGUAGE``
# language for which the result will be used,
Various typo fixes Some are user-facing. Others are source comments.
2018-01-03 12:09:54 +00:00
# i.e. C/CXX/Fortran/ASM
Modules: Format documentation to avoid over-long preformatted lines Convert several preformatted code block literals that enumerate lists of options or variables to use reST definition lists instead. Manually wrap other long lines in code blocks.
2014-10-22 19:52:31 +00:00
# ``MODE``
# ``EXIST``
# only check for existence of the given package
# ``COMPILE``
# print the flags needed for compiling an object file which uses
# the given package
# ``LINK``
# print the flags needed for linking when using the given package
# ``QUIET``
# if TRUE, don't print anything
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
if(NOT NAME)
Improve documentation for --find-package mode Alex
2011-08-10 00:05:33 +00:00
message(FATAL_ERROR "Name of the package to be searched not specified. Set the CMake variable NAME, e.g. -DNAME=JPEG .")
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
endif()
if(NOT COMPILER_ID)
message(FATAL_ERROR "COMPILER_ID argument not specified. In doubt, use GNU.")
endif()
if(NOT LANGUAGE)
message(FATAL_ERROR "LANGUAGE argument not specified. Use C, CXX or Fortran.")
endif()
if(NOT MODE)
message(FATAL_ERROR "MODE argument not specified. Use either EXIST, COMPILE or LINK.")
endif()
Require the current cmake version in --find-package mode This fixes the problem that otherwise Platforms/CYGWIN.cmake doesn't know whether it should set WIN32 or not. Now it uses always the current behaviour. Alex
2011-08-22 19:23:55 +00:00
# require the current version. If we don't do this, Platforms/CYGWIN.cmake complains because
# it doesn't know whether it should set WIN32 or not:
cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} )
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
Fix --find-package mode on Cygwin, where enable_language(RC) is called In --find-package mode we can't enable a language, since a lot of stuff has not been set up, e.g. which make tool to use. So disable enable_language() in this mode. Alex
2011-08-22 19:53:22 +00:00
macro(ENABLE_LANGUAGE)
# disable the enable_language() command, otherwise --find-package breaks on Windows.
# On Windows, enable_language(RC) is called in the platform files unconditionally.
# But in --find-package mode, we don't want (and can't) enable any language.
endmacro()
Make platform information files specific to the CMake version At the top of a build tree we configure inside the CMakeFiles directory files such as "CMakeSystem.cmake" and "CMake<lang>Compiler.cmake" to save information detected about the system and compilers in use. The method of detection and the exact results store varies across CMake versions as things improve. This leads to problems when loading files configured by a different version of CMake. Previously we ignored such existing files only if the major.minor part of the CMake version component changed, and depended on the CMakeCache.txt to tell us the last version of CMake that wrote the files. This led to problems if the user deletes the CMakeCache.txt or we add required information to the files in a patch-level release of CMake (still a "feature point" release by modern CMake versioning convention). Ensure that we always have version-consistent platform information files by storing them in a subdirectory named with the CMake version. Every version of CMake will do its own system and compiler identification checks even when a build tree has already been configured by another version of CMake. Stored results will not clobber those from other versions of CMake which may be run again on the same tree in the future. Loaded results will match what the system and language modules expect. Rename the undocumented variable CMAKE_PLATFORM_ROOT_BIN to CMAKE_PLATFORM_INFO_DIR to clarify its purpose. The new variable points at the version-specific directory while the old variable did not.
2012-08-24 12:48:59 +00:00
set(CMAKE_PLATFORM_INFO_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
include(CMakeDetermineSystem)
Dont check for -isysroot and -mmacosx-version on OSX in --find-package mode Alex
2011-08-15 22:30:07 +00:00
# short-cut some tests on Darwin, see Darwin-GNU.cmake:
if("${CMAKE_SYSTEM_NAME}" MATCHES Darwin AND "${COMPILER_ID}" MATCHES GNU)
OS X: Always generate -isysroot if any SDK is in use Drop the last use of CMAKE_OSX_SYSROOT_DEFAULT. Replace internal platform variable CMAKE_${lang}_HAS_ISYSROOT with a more general CMAKE_${lang}_SYSROOT_FLAG variable. If the -isysroot flag exists and CMAKE_OSX_SYSROOT points to an SDK (not "/") then always add it to compiler command lines. This is already done in the Xcode IDE.
2012-09-21 12:53:42 +00:00
set(CMAKE_${LANGUAGE}_SYSROOT_FLAG "")
set(CMAKE_${LANGUAGE}_OSX_DEPLOYMENT_TARGET_FLAG "")
Dont check for -isysroot and -mmacosx-version on OSX in --find-package mode Alex
2011-08-15 22:30:07 +00:00
endif()
CMakeFindPackageMode: Perform platform-specific initialization Since commit v3.1.0-rc1~565^2~3 (Add platform-specific initialization step when enabling languages, 2014-04-29) the main enable-language logic includes the `CMakeSystemSpecificInitialize` module to perform platform-specific initialization based on `CMAKE_SYSTEM_NAME`. This should be done during `cmake --find-package` mode too.
2018-04-18 11:28:47 +00:00
include(CMakeSystemSpecificInitialize)
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
# Also load the system specific file, which sets up e.g. the search paths.
# This makes the FIND_XXX() calls work much better
include(CMakeSystemSpecificInformation)
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
if(UNIX)
# try to guess whether we have a 64bit system, if it has not been set
# from the outside
if(NOT CMAKE_SIZEOF_VOID_P)
Use the file-utility to test for 64bit if there is no /usr/lib64 Alex
2011-07-18 19:40:45 +00:00
set(CMAKE_SIZEOF_VOID_P 4)
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
if(EXISTS /usr/lib64)
set(CMAKE_SIZEOF_VOID_P 8)
else()
Use the file-utility to test for 64bit if there is no /usr/lib64 Alex
2011-07-18 19:40:45 +00:00
# use the file utility to check whether itself is 64 bit:
find_program(FILE_EXECUTABLE file)
if(FILE_EXECUTABLE)
CMakeFindPackageMode: fix 32/64bit detection if 'file' is a symlink
2012-02-23 21:39:39 +00:00
get_filename_component(FILE_ABSPATH "${FILE_EXECUTABLE}" ABSOLUTE)
execute_process(COMMAND "${FILE_ABSPATH}" "${FILE_ABSPATH}" OUTPUT_VARIABLE fileOutput ERROR_QUIET)
Use the file-utility to test for 64bit if there is no /usr/lib64 Alex
2011-07-18 19:40:45 +00:00
if("${fileOutput}" MATCHES "64-bit")
set(CMAKE_SIZEOF_VOID_P 8)
endif()
endif()
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
endif()
endif()
# guess Debian multiarch if it has not been set:
if(EXISTS /etc/debian_version)
CMakeFindPackageMode: Fix Debian multiarch default guess (#15250) In commit v2.8.6~102^2~18 (Better support for lib64 and Debian multiarch, 2011-07-14) variable names "..._LANGUAGE_ARCHITECTURE" were set instead of the correct "..._LIBRARY_ARCHITECTURE". Fix this typo and also set the language-independent variable CMAKE_LIBRARY_ARCHITECTURE.
2015-01-19 15:39:21 +00:00
if(NOT CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE )
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
file(GLOB filesInLib RELATIVE /lib /lib/*-linux-gnu* )
foreach(file ${filesInLib})
if("${file}" MATCHES "${CMAKE_LIBRARY_ARCHITECTURE_REGEX}")
CMakeFindPackageMode: Fix Debian multiarch default guess (#15250) In commit v2.8.6~102^2~18 (Better support for lib64 and Debian multiarch, 2011-07-14) variable names "..._LANGUAGE_ARCHITECTURE" were set instead of the correct "..._LIBRARY_ARCHITECTURE". Fix this typo and also set the language-independent variable CMAKE_LIBRARY_ARCHITECTURE.
2015-01-19 15:39:21 +00:00
set(CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE ${file})
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
break()
endif()
endforeach()
endif()
CMakeFindPackageMode: Fix Debian multiarch default guess (#15250) In commit v2.8.6~102^2~18 (Better support for lib64 and Debian multiarch, 2011-07-14) variable names "..._LANGUAGE_ARCHITECTURE" were set instead of the correct "..._LIBRARY_ARCHITECTURE". Fix this typo and also set the language-independent variable CMAKE_LIBRARY_ARCHITECTURE.
2015-01-19 15:39:21 +00:00
if(NOT CMAKE_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE ${CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE})
endif()
Better support for lib64 and Debian multiarch If CMAKE_SIZEOF_VOID_P is not set from the outside, it checks for the existance of /usr/lib64, and if it exists, SIZEOF_VOID_P is set to 8. For multiarch, if this is debian and CMAKE_${LANGUAGE}_LANGUAGE_ARCHITECTURE has not been set, it globs for the files in /lib, and uses the first one which matches CMAKE_LIBRARY_ARCHITECTURE_REGEX. Alex
2011-07-14 21:53:01 +00:00
endif()
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
endif()
set(CMAKE_${LANGUAGE}_COMPILER "dummy")
set(CMAKE_${LANGUAGE}_COMPILER_ID "${COMPILER_ID}")
include(CMake${LANGUAGE}Information)
Rename helper macros print_compile_flags() to set_compile_flags_var() The same for print_link_flags(), it is now set_link_flags_var(). Both macros don't print anything anymore, this was only in the beginning. Alex
2011-08-15 22:22:17 +00:00
function(set_compile_flags_var _packageName)
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
string(TOUPPER "${_packageName}" PACKAGE_NAME)
# Check the following variables:
# FOO_INCLUDE_DIRS
# Foo_INCLUDE_DIRS
# FOO_INCLUDES
# Foo_INCLUDES
# FOO_INCLUDE_DIR
# Foo_INCLUDE_DIR
set(includes)
if(DEFINED ${_packageName}_INCLUDE_DIRS)
set(includes ${_packageName}_INCLUDE_DIRS)
elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIRS)
set(includes ${PACKAGE_NAME}_INCLUDE_DIRS)
elseif(DEFINED ${_packageName}_INCLUDES)
set(includes ${_packageName}_INCLUDES)
elseif(DEFINED ${PACKAGE_NAME}_INCLUDES)
set(includes ${PACKAGE_NAME}_INCLUDES)
elseif(DEFINED ${_packageName}_INCLUDE_DIR)
set(includes ${_packageName}_INCLUDE_DIR)
elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIR)
set(includes ${PACKAGE_NAME}_INCLUDE_DIR)
endif()
set(PACKAGE_INCLUDE_DIRS "${${includes}}" PARENT_SCOPE)
# Check the following variables:
# FOO_DEFINITIONS
# Foo_DEFINITIONS
set(definitions)
if(DEFINED ${_packageName}_DEFINITIONS)
set(definitions ${_packageName}_DEFINITIONS)
elseif(DEFINED ${PACKAGE_NAME}_DEFINITIONS)
set(definitions ${PACKAGE_NAME}_DEFINITIONS)
endif()
set(PACKAGE_DEFINITIONS "${${definitions}}" )
endfunction()
Rename helper macros print_compile_flags() to set_compile_flags_var() The same for print_link_flags(), it is now set_link_flags_var(). Both macros don't print anything anymore, this was only in the beginning. Alex
2011-08-15 22:22:17 +00:00
function(set_link_flags_var _packageName)
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
string(TOUPPER "${_packageName}" PACKAGE_NAME)
# Check the following variables:
# FOO_LIBRARIES
# Foo_LIBRARIES
# FOO_LIBS
# Foo_LIBS
set(libs)
if(DEFINED ${_packageName}_LIBRARIES)
set(libs ${_packageName}_LIBRARIES)
elseif(DEFINED ${PACKAGE_NAME}_LIBRARIES)
set(libs ${PACKAGE_NAME}_LIBRARIES)
elseif(DEFINED ${_packageName}_LIBS)
set(libs ${_packageName}_LIBS)
elseif(DEFINED ${PACKAGE_NAME}_LIBS)
set(libs ${PACKAGE_NAME}_LIBS)
endif()
set(PACKAGE_LIBRARIES "${${libs}}" PARENT_SCOPE )
endfunction()
find_package("${NAME}" QUIET)
set(PACKAGE_FOUND FALSE)
string(TOUPPER "${NAME}" UPPERCASE_NAME)
if(${NAME}_FOUND OR ${UPPERCASE_NAME}_FOUND)
set(PACKAGE_FOUND TRUE)
if("${MODE}" STREQUAL "EXIST")
# do nothing
elseif("${MODE}" STREQUAL "COMPILE")
Rename helper macros print_compile_flags() to set_compile_flags_var() The same for print_link_flags(), it is now set_link_flags_var(). Both macros don't print anything anymore, this was only in the beginning. Alex
2011-08-15 22:22:17 +00:00
set_compile_flags_var(${NAME})
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
elseif("${MODE}" STREQUAL "LINK")
Rename helper macros print_compile_flags() to set_compile_flags_var() The same for print_link_flags(), it is now set_link_flags_var(). Both macros don't print anything anymore, this was only in the beginning. Alex
2011-08-15 22:22:17 +00:00
set_link_flags_var(${NAME})
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
2012-08-13 17:50:14 +00:00
else()
Implement find-package mode of cmake In find-package mode, cmake executes Modules/CMakeFindPackage.cmake, which calls find_package(), and this is then evaluated in cmake.cxx, which prints an appropriate message to stdout, so it can be used e.g. in a normal Makefile: $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=EXIST JPEG found. $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=COMPILE $ /opt/cmake-HEAD/bin/cmake --find-package -DNAME=JPEG -DCOMPILER_ID=GNU -DLANGUAGE=C -DMODE=LINK -rdynamic -ljpeg Alex
2011-07-02 21:14:28 +00:00
message(FATAL_ERROR "Invalid mode argument ${MODE} given.")
endif()
endif()
set(PACKAGE_QUIET ${SILENT} )
Reference in New Issue Copy Permalink