嵌入式视频行业。
分类: LINUX
2013-03-12 15:29:26
CMake uses and defines many variables, which can be used in CMakeLists.txt files.
NOTE: As of CMake 2.6.0 many of these variables have been officially documented in TXT and HTML files released with CMake. You may still see some useful variables here that haven't yet been documented in the official documentation, although the number of these diminishes with every release. This page, in either case, is more of a distilled list of some of the more important variables. The official documentation is home of the authoritative guide to all CMake variables, commands, and properties.
CMakeLists.txt contains the PROJECT() command CMAKE_CURRENT_SOURCE_DIR this is the directory where the currently processed CMakeLists.txt is located in CMAKE_FILES_DIRECTORY the directory within the current binary directory that contains all the CMake generated files. Typically evaluates to "/CMakeFiles". Note the leading slash for the directory. Typically used with the current binary directory, i.e. ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} CMAKE_MODULE_PATH tell CMake to search first in directories listed in CMAKE_MODULE_PATH when you use FIND_PACKAGE() or INCLUDE()
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/MyCMakeScripts)
FIND_PACKAGE(HelloWorld) CMAKE_ROOT this is the CMake installation directory CMAKE_SOURCE_DIR this is the directory, from which cmake was started, i.e. the top level source directory EXECUTABLE_OUTPUT_PATH set this variable to specify a common place where CMake should put all executable files (instead of CMAKE_CURRENT_BINARY_DIR)
SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) LIBRARY_OUTPUT_PATH set this variable to specify a common place where CMake should put all libraries (instead of CMAKE_CURRENT_BINARY_DIR)
SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) PROJECT_NAME the name of the project set by PROJECT() command. CMAKE_PROJECT_NAME the name of the first project set by the PROJECT() command, i.e. the top level project. PROJECT_BINARY_DIR contains the full path to the top level directory of your build tree PROJECT_SOURCE_DIR contains the full path to the root of your project source directory, i.e. to the nearest directory where CMakeLists.txt contains the PROJECT() command
These are environment variables which effect cmake behaviour. CMAKE_INCLUDE_PATH This is used when searching for include files e.g. using the FIND_PATH() command. If you have headers in non-standard locations, it may be useful to set this variable to this directory (e.g. /sw/include on Mac OS X). If you need several directories, separate them by the platform specific separators (e.g. ":" on UNIX) CMAKE_LIBRARY_PATH This is used when searching for libraries e.g. using the FIND_LIBRARY() command. If you have libraries in non-standard locations, it may be useful to set this variable to this directory (e.g. /sw/lib on Mac OS X). If you need several directories, separate them by the platform specific separators (e.g. ":" on UNIX) CMAKE_PREFIX_PATH (since CMake 2.6.0) This is used when searching for include files, binaries, or libraries using either the FIND_PACKAGE(), FIND_PATH(), FIND_PROGRAM(), or FIND_LIBRARY() commands. For each path in the CMAKE_PREFIX_PATH list, CMake will check "PATH/include" and "PATH" when FIND_PATH() is called, "PATH/bin" and "PATH" when FIND_PROGRAM() is called, and "PATH/lib" and "PATH" when FIND_LIBRARY() is called. See the documentation for FIND_PACKAGE(), FIND_LIBRARY(), FIND_PATH(), and FIND_PROGRAM() for more details. CMAKE_INSTALL_ALWAYS If set during installation CMake will install all files whether they have changed or not. The default when this is not set is to install only files that have changed since the previous installation. In both cases all files are reported to indicate CMake knows they are up to date in the installed location. $ENV{name} This is not an environment variable , but this is how you can access environment variables from cmake files. It returns the content of the environment variable with the given name (e.g. $ENV{PROGRAMFILES}) DESTDIR If this environment variable is set it will be prefixed to CMAKE_INSTALL_PREFIX in places where it is used to access files during installation. This allows the files to be installed in an intermediate directory tree without changing the final installation path name. Since the value of CMAKE_INSTALL_PREFIX may be included in installed files it is important to use DESTDIR rather than changing CMAKE_INSTALL_PREFIX when it is necessary to install to a intermediate staging directory.
IF(FOO) SET(BAR bar.cc) ELSE() SET(BAR bar2.cc) ENDIF()
You can use these default compilation flags (or modify them) by setting the CMAKE_BUILD_TYPE variable at configuration time from within the "ccmake" GUI. Note! The default values for these flags change with different compilers. If CMake does not know your compiler, the contents will be empty.
If you are using the Makefile generator, you can create your own build type like this:
SET(CMAKE_BUILD_TYPE distribution)
SET(CMAKE_CXX_FLAGS_DISTRIBUTION "-O3")
SET(CMAKE_C_FLAGS_DISTRIBUTION "-O3")
Note that CMAKE_BUILD_TYPE is not initialized with a readable value at configuration time. This is because the user is free to select a build type at build time. Use CMAKE_CFG_INTDIR if you need a variable that evaluates to the correct build time directory.
CMAKE_CONFIGURATION_TYPES
When using a multi-configuration generator, such as the one for Visual Studio, this variable contains a list of the available configurations.
CMAKE_C_COMPILER
the compiler used for C files. Normally it is detected and set during the CMake run, but you can override it at configuration time. Note! It can not be changed after the first cmake or ccmake run. Although the gui allows to enter an alternative, it will be ignored in the next 'configure' run. Use for example:
CC=gcc-3.3 CXX=g++-3.3 cmake
to set the compiler. (You can also set CMAKE_C_COMPILER_INIT, before any PROJECT() or ENABLE_LANGUAGE() command.) Any other way (like writing make CC=gcc-3.3 CXX=g++-3.3) will not work. When using distcc or similar tools, you need to write:
CC="distcc gcc-3.3" CXX="distcc g++-3.3" cmake
However, this will empty all your CMAKE_..._FLAGS_... above.
CMAKE_C_FLAGS
the compiler flags for compiling C sources. Note you can also specify switches with ADD_DEFINITIONS().
CMAKE_C_FLAGS_DEBUG
compiler flags for compiling a debug build from C sources.
CMAKE_C_FLAGS_RELEASE
compiler flags for compiling a release build from C sources.
CMAKE_C_FLAGS_RELWITHDEBINFO
compiler flags for compiling a release build with debug flags from C sources.
CMAKE_C_OUTPUT_EXTENSION
what C object files end in. Typically .o or .obj.
CMAKE_CFG_INTDIR
meta-variable! Please note that this is an important variable, since on multi-configuration generators it will be generated into dynamically switched content based on the configuration that the user currently selected within the generated build environment. Indicates the name of the current configuration (~ directory) for the project. May be used for any purpose which needs per-configuration-dynamic switching of strings, not just OutputDir configuration. For multi-configuration generators (e.g. MSVC) the resulting strings are typically some of "Debug", "Release", "RelWithDebInfo", or "MinSizeRel". For other compiler generators (single-configuration ones) it is typically ".", as they don't use MSVC-style configuration directories.
CMAKE_CXX_COMPILER
the compiler used for C++ files. Normally it is detected and set during the CMake run, but you can override it at configuration time. Note! It can not be changed after the first cmake or ccmake run. See CMAKE_C_COMPILER above.
CMAKE_CXX_FLAGS
the compiler flags for compiling C++ sources. Note you can also specify switches with ADD_DEFINITIONS().
CMAKE_CXX_FLAGS_DEBUG
compiler flags for compiling a debug build from C++ sources.
CMAKE_CXX_FLAGS_RELEASE
compiler flags for compiling a release build from C++ sources.
CMAKE_CXX_FLAGS_RELWITHDEBINFO
compiler flags for compiling a release build with debug flags from C++ sources.
CMAKE_RANLIB
tool for creating libraries. See also CMAKE_AR, as "ar" and "ranlib" are typically used together.
CMAKE_SHARED_LINKER_FLAGS
additional compiler flags for building shared libraries, e.g.:
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined")
On Unix systems, this will make linker report any unresolved symbols from object files (which is quite typical when you compile many targets in CMake projects, but do not bother with linking target dependencies in proper order).
Build rules are defined in CMakeCInformation.cmake and CMakeCXXInformation.cmake.
Rules for C++ sources: CMAKE_CXX_CREATE_SHARED_LIBRARY CMAKE_CXX_CREATE_SHARED_MODULE CMAKE_CXX_CREATE_STATIC_LIBRARY CMAKE_CXX_COMPILE_OBJECT CMAKE_CXX_LINK_EXECUTABLE
and the equivalents for C sources: CMAKE_C_CREATE_SHARED_LIBRARY CMAKE_C_CREATE_SHARED_MODULE CMAKE_C_CREATE_STATIC_LIBRARY CMAKE_C_COMPILE_OBJECT CMAKE_C_LINK_EXECUTABLE
You can override the variables manually, e.g. replacing some flags in the linker command, but you can't change the value of the variables in sharp braces. Usually you don't have to change these rules, only in rare cases. You should only do this if you know what you are doing and there is no other way.
From examining the source code the following style names exist: ASSEMBLY_SOURCE FLAGS LANGUAGE_COMPILE_FLAGS LINK_FLAGS LINK_LIBRARIES OBJECT OBJECTS OBJECTS_QUOTED OBJECT_DIR PREPROCESSED_SOURCE SOURCE TARGET TARGET_BASE TARGET_IMPLIB TARGET_INSTALLNAME_DIR TARGET_PDB TARGET_QUOTED TARGET_SONAME TARGET_VERSION_MAJOR TARGET_VERSION_MINOR