CMake2.8.3命令

CMake变量

cmake --help-variable variable_name命令查看

• CMAKE_AR 静态库的归档工具名字。
• CMAKE_BINARY_DIR 构建树的顶层路径。
• CMAKE_BUILD_TOOL 实际构建过程中使用的工具。
• CMAKE_CACHEFILE_DIR 文件 CMakeCache.txt 所在的路径。
• CMAKE_CACHE_MAJOR_VERSION 用于创建CMakeCache.txt文件的CMake的主版本号。
• VCMAKE_CACHE_MINOR_VERSION 用于创建 CMakeCache.txt 文件的CMake 的子版本号。
• CMAKE_CACHE_PATCH_VERSION 用于创建CMakeCache.txt文件的CMake的补丁号。
• CMAKE_CFG_INTDIR 构建时，与构建配置相对应的输出子路径（只读）。
• CMAKE_COMMAND 指向 CMake 可执行文件的完整路径。
• CMAKE_CROSSCOMPILING 指出 CMake 是否正在交叉编译。
• CMAKE_CTEST_COMMAND 与 cmake 一起安装的 ctest 命令的完整路径。
• CMAKE_CURRENT_BINARY_DIR 当前正在被处理的二进制目录的路径。
• CMAKE_CURRENT_LIST_DIR 当前正在处理的 listfile 的完整目录。
• CMAKE_CURRENT_LIST_FILE 当前正在处理的 listfile 的完整路径。
• CMAKE_CURRENT_LIST_LINE 当前正在处理的 listfile 的行号。
• CMAKE_CURRENT_SOURCE_DIR 指向正在被处理的源码目录的路径。
• CMAKE_DL_LIBS 包含 dlopen 和 dlclose 函数的库的名称。
• CMAKE_EDIT_COMMAND 指向 cmake-gui 或 ccmake 的完整路径。
• CMAKE_EXECUTABLE_SUFFIX(_) 本平台上可执行文件的后缀。
• CMAKE_EXTRA_GENERATOR 构建本工程所需要的额外生成器。
• CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES 附加的共享库后缀（除
  CMAKE_SHARED_LIBRARY_SUFFIX 以外，其他可以识别的共享库的后缀名。）
• CMAKE_GENERATOR 用于构建该工程的生成器。
• CMAKE_HOME_DIRECTORY 指向源码树顶层的路径。
• CMAKE_IMPORT_LIBRARY_PREFIX(_) 需要链接的导入库的前缀。
• CMAKE_IMPORT_LIBRARY_SUFFIX(_) 需要链接的导入库的后缀。
• CMAKE_LINK_LIBRARY_SUFFIX 需要链接的库的后缀。
• CMAKE_MAJOR_VERSION cmake 的主版本号（例如 2.X.X 中的 2）。
• CMAKE_MAKE_PROGRAM 参见 CMAKE_BUILD_TOOL。
• CMAKE_MINOR_VERSION cmake 的次版本号（例如 X.4.X 中的 4）。
• CMAKE_PARENT_LIST_FILE 当前正在被处理 listfile 的父 listfile 的全
  路径。
• CMAKE_PATCH_VERSION cmake 的补丁号(例如 X.X.3 中的 3)。
• CMAKE_PROJECT_NAME 当前工程的工程名。
• CMAKE_RANLIB 静态库的随机化工具的名字（比如 linux 下的 ranlib）。
• CMAKE_ROOT CMake 的安装路径。
• CMAKE_SHARED_LIBRARY_PREFIX(_) 被链接的共享库的前缀。
• CMAKE_SHARED_LIBRARY_SUFFIX(_) 被链接的共享库的后缀。
• CMAKE_SHARED_MODULE_PREFIX(_) 被链接的可加载模块的前缀。
• CMAKE_SHARED_MODULE_SUFFIX(_) 被链接的共享库的后缀。
• CMAKE_SIZEOF_VOID_P void 指针的长度。
• CMAKE_SKIP_RPATH 如果变量为真，不为编译出的可执行文件添加运行时的路径信息。默认添加。
• CMAKE_SOURCE_DIR 源码树的顶层路径。
• CMAKE_STANDARD_LIBRARIES 链接到所有可执行文件和共享库上的
  库。这是一个 list。
• CMAKE_STATIC_LIBRARY_PREFIX(_) 被链接的静态库的前缀。
• CMAKE_STATIC_LIBRARY_SUFFIX(_) 被链接的静态库的后缀。
• CMAKE_TWEAK_VERSION cmake 的 tweak 版本号(例如 X.X.X.1 中 的 1)。
• CMAKE_USING_VC_FREE_TOOLS 如果用到了免费的 visual studio 工具，设置为真。
• CMAKE_VERBOSE_MAKEFILE 设置该变量为真将创建完整版本的makefile。
• CMAKE_VERSION cmake 的完整版本号；格式为major.minor.patch[.tweak[-id]]。
• PROJECT_BINARY_DIR 指向工程构建目录的全路径。
• PROJECT_NAME 向 project 命令传递的工程名参数。
• PROJECT_SOURCE_DIR 当前工程的源码路径。
• [Project name]_BINARY_DIR 给定工程的二进制文件顶层路径。
• [Project name]_SOURCE_DIR 给定工程的源码顶层路径

add_custom_command

• 为生成的构建系统添加一条自定义的构建规则
• 第一种功能是为了生成输出文件，添加一条自定义命令

/*
这种命令格式定义了一条生成指定的文件（文件组）的生成命令。在相同路径下创建的目标
（CMakeLists.txt文件）——任何自定义命令的输出都作为它的源文件——被设置了一条规则：
在构建的时候，使用指定的命令来生成这些文件。如果一个输出文件名是相对路径，它将被解释
成相对于构建树路径的相对路径，并且与当前源码路径是对应的。注意，MAIN_DEPENDENCY
完全是可选的，它用来向 visual studio 建议在何处停止自定义命令。对
*/
add_custom_command(OUTPUT output1 [output2 ...]
	COMMAND command1 [ARGS] [args1...]
	[COMMAND command2 [ARGS] [args2...] ...]
	[MAIN_DEPENDENCY depend]
	[DEPENDS [depends...]]
	[IMPLICIT_DEPENDS <lang1> depend1 ...]
	[WORKING_DIRECTORY dir]
	[COMMENT comment] [VERBATIM] [APPEND])

• 第二种功能，格式为一个目标

/*
格式为一个目标——比如一个库文件或者可执行文件——添加一条自定义命令。这种
格式可以用于目标构建前或构建后的一些操作。这条命令会成为目标的一部分，并且只有目标被
构建时才会执行。如果目标已经构建了，该目标将不会执行。
这条命令定义了一个与指定目标的构建过程相关的新命令。新命令在何时执行，由下述的选项决定：
 PRE_BUILD - 在所有其它的依赖之前执行；
 PRE_LINK - 在所有其它的依赖之后执行；
 POST_BUILD - 在目标被构建之后执行；
 注意，只有 Visual Studio 7 或更高的版本才支持 PRE_BUILD。对于其他的生成器，
PRE_BUILD 会被当做 PRE_LINK 来对待。
*/
add_custom_command(TARGET target
	PRE_BUILD | PRE_LINK | POST_BUILD
	COMMAND command1 [ARGS] [args1...]
	[COMMAND command2 [ARGS] [args2...] ...]
	[WORKING_DIRECTORY dir]
	[COMMENT comment] [VERBATIM])

• 如果指定了 WORKING_DIRECTORY 选项，这条命令会在给定的路径下执行
• 如果设置了 COMMENT 选项，后跟的参数会在构建时、以构建信息的形式、在命令执行之前显示出
• 如果指定了 APPEND 选项，COMMAND 以及 DEPENDS 选项的值会附加到第一个输出文件的自定义命令上
• 如果指定了 VERBATIM 选项，所有该命令的参数将会合适地被转义，以便构建工具能够以原汁原味的参数去调用那些构建命令
• IMPLICIT_DEPENDS 选项请求扫描一个输入文件的隐含依赖关系
• 如果 COMMAND 选项指定了一个可执行目标（由 ADD_EXECUTABLE 命令创建的目标），在构建时，它会自动被可执行文件的位置所替换而且，一个目标级的依赖性将会被添加进去，这样这个可执行目标将会在所有依赖于该自定义命令的结果的目标之前被构建
• DEPENDS 选项指定了该命令依赖的文件。如果依赖的对象是同一目录（CMakeLists.txt文件）下另外一个自定义命令的输出，CMake 会自动将其它自定义命令带到这个命令中来。如果 DEPENDS 指定了任何类型的目标（由 ADD_*命令创建），一个目标级的依赖性将会被创建，以保证该目标在任何其它目标使用这个自定义命令的输出之前，该目标已经被创建了。而且如果该目标是可执行文件或库文件，一个文件级依赖将会被创建，用来引发自定义命令在目标被重编译时的重新运行

add_custom_target

添加一个目标，没有输出，这样它就总是会被构建

/*
用 Name 选项给定的名字添加一个目标，这个目标会引发给定的那些命令。这个目标没有
输出文件，并且总是被认为是过时的，即使那些命令试图去创建一个与该目标同名的文件。使用
ADD_CUSTOM_COMMAND 命令可以生成一个带有依赖性的文件。默认情况下，没有目标会
依赖于自定义目标。使用 ADD_DEPENDENCIES 命令可以添加依赖于该目标或者被该目标依
赖的目标。如果指定了 ALL 选项，这表明这个目标应该被添加到默认的构建目标中，这样它每
次都会被构建（命令的名字不能是 ALL）。命令和选项是可选的；如果它们没有被指定，将会
产生一个空目标。
*/
add_custom_target(Name [ALL] [command1 [args1...]]
	[COMMAND command2 [args2...] ...]
	[DEPENDS depend depend depend ... ]
	[WORKING_DIRECTORY dir]
	[COMMENT comment] [VERBATIM]
	[SOURCES src1 [src2...]])

• 如果设定了 WORKING_DIRECTORY 参数，该命令会在它指定的路径下执行
• 如果指定了 COMMENT 选项，后跟的参数将会在构件的时候，在命令执行之前，被显示出来
• DEPENDS 选项后面列出来的依赖目标可以引用 add_custom_command 命令在相同路径下（CMakeLists.txt）生成的输出和文件
• 如果指定了 VERBATIM 选项，所有传递到该命令的选项将会被合适地转义
• SOURCES 选项指定了会被包含到自定义目标中的附加的源文件

add_definitions

为源文件的编译添加由-D 引入的 define flag

/*
在编译器的命令行上，为当前路径以及下层路径的源文件加入一些 define flag，用来引入预处理器的定义
那些以-D 或/D 开头的像预处理器定义的flag，会被自动加到当前路径的 COMPILE_DEFINITIONS 属性中
特定的域及配置中增加预处理器的定义，参考路径、目标以及源文件的COMPILE_DEFINITIONS属性来获取更多细节
*/
add_definitions(-DFOO -DBAR ...)

add_dependencies

为顶层目标引入一个依赖关系

/*
让一个顶层目标依赖于其他的顶层目标。一个顶层目标是由命令 ADD_EXECUTABLE，
ADD_LIBRARY，或者 ADD_CUSTOM_TARGET 产生的目标。为这些命令的输出引入依赖性
可以保证某个目标在其他的目标之前被构建。查看 ADD_CUSTOM_TARGET 和
ADD_CUSTOM_COMMAND 命令的 DEPENDS 选项，可以了解如何根据自定义规则引入文件
级的依赖性。查看 SET_SOURCE_FILES_PROPERTIES 命令的 OBJECT_DEPENDS 选项，
可以了解如何为目标文件引入文件级的依赖性。
*/
add_dependencies(target-name depend-target1 depend-target2 ...)

add_executable

使用给定的源文件，为工程引入一个可执行文件

/*
引入一个名为<name>的可执行目标，该目标会由调用该命令时在源文件列表中指定的源
文件来构建。<name>对应于逻辑目标名字，并且在工程范围内必须是全局唯一的。被构建的
可执行目标的实际文件名将根据具体的本地平台创建出来。
默认情况下，可执行文件将会在构建树的路径下被创建，对应于该命令被调用的源文件树的
路径。如果要改变这个位置，查看 RUNTIME_OUTPUT_DIRECTORY 目标属性的相关文档。
如果要改变最终文件名的<name>部分，查看 OUTPUT_NAME 目标属性的相关文档
*/
add_executable(<name> [WIN32] [MACOSX_BUNDLE]
	[EXCLUDE_FROM_ALL]
	source1 source2 ... sourceN)

• 如果指定了 EXCLUDE_FROM_ALL 选项，对应的属性将会设置在被创建的目标上。查看EXCLUDE_FROM_ALL 目标属性的文档可以找到更多的细节
• 如果指定了 MACOSX_BUNDLE 选项，对应的属性会附加在创建的目标上。查看MACOSX_BUNDLE 目标属性的文档可以找到更多的细节。

add_library

指定的源文件向工程中添加一个库

/*
添加一个名为<name>的库文件，该库文件将会根据调用的命令里列出的源文件来创建。
<name>对应于逻辑目标名称，而且在一个工程的全局域内必须是唯一的。待构建的库文件的
实际文件名根据对应平台的命名约定来构造（比如 lib<name>.a 或者<name>.lib）
指定STATIC，SHARED，或者 MODULE 参数用来指定要创建的库的类型。STATIC 库是目标文件
的归档文件，在链接其它目标的时候使用。SHARED 库会被动态链接，在运行时被加载。
MODULE 库是不会被链接到其它目标中的插件，但是可能会在运行时使用 dlopen-系列的函数
动态链接。如果没有类型被显式指定，这个选项将会根据变量 BUILD_SHARED_LIBS 的当前
值是否为真决定是 STATIC 还是 SHARED。
默认状态下，库文件将会在于源文件目录树的构建目录树的位置被创建，该命令也会在这里
被调用。查阅 ARCHIVE_OUTPUT_DIRECTORY，LIBRARY_OUTPUT_DIRECTORY，和
RUNTIME_OUTPUT_DIRECTORY 这三个目标属性的文档来改变这一位置。查阅
OUTPUT_NAME 目标属性的文档来改变最终文件名的<name>部分。
*/
add_library(<name> [STATIC | SHARED | MODULE]
	[EXCLUDE_FROM_ALL]
	source1 source2 ... sourceN)

• 如果指定了 EXCLUDE_FROM_ALL 属性，对应的一些属性会在目标被创建时被设置

add_subdirectory

为构建添加一个子路径

/*
这条命令的作用是为构建添加一个子路径。source_dir 选项指定了 CMakeLists.txt 源文
件和代码文件的位置。如果 source_dir 是一个相对路径，那么 source_dir 选项会被解释为相
对于当前的目录，但是它也可以是一个绝对路径。binary_dir 选项指定了输出文件的路径。如
果 binary_dir 是相对路径，它将会被解释为相对于当前输出路径，但是它也可以是一个绝对路
径。如果没有指定 binary_dir，binary_dir 的值将会是没有做任何相对路径展开的 source_dir，
这也是通常的用法。在 source_dir 指定路径下的 CMakeLists.txt 将会在当前输入文件的处理
过程执行到该命令之前，立即被 CMake 处理。
*/
add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

• 如果指定了 EXCLUDE_FROM_ALL 选项，在子路径下的目标默认不会被包含到父路径的ALL 目标里，并且也会被排除在 IDE 工程文件之外

add_test

以指定的参数为工程添加一个测试

add_test(testname Exename arg1 arg2 ... )

aux_source_directory

查找在某个路径下的所有源文件

/*
搜集所有在指定路径下的源文件的文件名，将输出结果列表储存在指定的<variable>变量中
*/
aux_source_directory(<dir> <variable>)

build_command

获取构建该工程的命令行

/*
把给定的变量<variable>设置成一个字符串，其中包含使用由变量CMAKE_GENERATOR 确定的项目构建工具
去构建某一个工程的某一个目标配置的命令行
*/
build_command(<variable>
	[CONFIGURATION <config>]
	[PROJECT_NAME <projname>]
	[TARGET <target>])

• 对于多配置生成器，如果忽略 CONFIGURATION 选项，CMake 将会选择一个合理的默认值；而对于单配置生成器，该选项会被忽略
• 如果 PROJECT_NAME 选项被忽略，得到的命令行用来构建当前构建树上的顶层工程
• 如果 TARGET 选项被忽略，得到的命令行可以用来构建所有目标，比较高效的用法是构建目标 all 或者 ALL_BUILD

cmake_minimum_required

设置一个工程所需要的最低 CMake 版本

/*
如果 CMake 的当前版本低于指定的版本，它会停止处理工程文件，并报告错误
当指定的版本高于 2.4 时，它会隐含调用：cmake_policy(VERSION major[.minor[.patch[.tweak]]])
从而将 cmale 的策略版本级别设置为指定的版本
当指定的版本是 2.4 或更低时，这条命令隐含调用：cmake_policy(VERSION 2.4)，启用对于 CMake 2.4 及更低版本的兼容性
*/
cmake_minimum_required(VERSION major[.minor[.patch[.tweak]]][FATAL_ERROR])

cmake_policy

管理 CMake 的策略设置

cmake_policy(VERSION major.minor[.patch[.tweak]])

configure_file

将一份文件拷贝到另一个位置并修改它的内容

/*
将文件<input>拷贝到<output>然后替换文件内容中引用到的变量值。如果<input>是
相对路径，它被评估的基础路径是当前源码路径。<input>必须是一个文件，而不是个路径。
如果<output>是一个相对路径，它被评估的基础路径是当前二进制文件路径。如果<output>
是一个已有的路径，那么输入文件将会以它原来的名字放到那个路径下

该命令替换掉在输入文件中，以${VAR}格式或@VAR@格式引用的任意变量，如同它们
的值是由 CMake 确定的一样。 如果一个变量还未定义，它会被替换为空

configure_file 的作用是让普通文件也能使用 CMake 中的变量
*/
configure_file(<input> <output>[COPYONLY] [ESCAPE_QUOTES] [@ONLY])

• 如果指定了COPYONLY 选项，那么变量就不会展开
• 如果指定了 ESCAPE_QUOTES 选项，那么所有被替换的变量将会按照 C 语言的规则被转义，该文件将会以 CMake 变量的当前值被配置
• 如果指定了@ONLY 选项，只有@VAR@格式的变量会被替换而${VAR}格式的变量则会被忽略，对于配置使用${VAR}格式的脚本文件比较有用。任何类似于#cmakedefine VAR 的定义语句将会被替换为#define VAR 或者/* #undef VAR */，视 CMake 中对 VAR 变量的设置而定。任何类似于#cmakedefine01 VAR 的定义语句将会被替换为#define VAR 1 或#define VAR 0， 视 VAR 被评估为 TRUE 或 FALSE 而定

create_test_sourcelist

构建测试程序创建一个测试驱动器和源码列表

/*
测试驱动器是一个将很多小的测试代码连接为一个单一的可执行文件的程序。这在为了缩减
总的需用空间而用很多大的库文件去构建静态可执行文件的时候，特别有用。
*/
create_test_sourcelist(sourceListName driverName
	test1 test2 test3
	EXTRA_INCLUDE include.h
	FUNCTION function)

• 构建测试驱动所需要的源文件列表会在变量 sourceListName 中
• DriverName 变量是测试驱动器的名字,可以在命令行中按名字调用这些测试中的每一个
• 其它的参数还包括一个测试源代码文件的清单，中间可以用分号隔开
• 每个测试源码文件中应该有一个与去掉扩展名的文件名同名的函数（比如 foo.cxx 文件里应该有 int foo(int, char*[])
• 如果指定了 EXTRA_INCLUDE，那么它后面的参数（即 include.h）会被包含到生成的文件里
• 如果指定了 FUNCTION 选项，那么它后面的参数（即 function）会被认为是一个函数名，传递给它的参数是一个指向 argc 的指针和 argv。这个选项可以用来为每个测试函数添加额外的命令行参数处理过程
• CMake 变量CMAKE_TESTDRIVER_BEFORE_TESTMAIN 用来设置在调用测试的 main 函数之前调用的代码

define_property

定义并描述（Document）自定义属性

/*
在一个域（scope）中定义一个可以用 set_property 和 get_property 命令访问
的属性。这个命令对于把文档和可以通过 get_property 命令得到的属性名称关联起来非
常有用。第一个参数确定了这个属性可以使用的范围。它必须是下列值中的一个：
GLOBAL = 与全局命名空间相关联
DIRECTORY = 与某一个目录相关联
TARGET = 与一个目标相关联
SOURCE = 与一个源文件相关联
TEST = 与一个以 add_test 命名的测试相关联
VARIABLE = 描述（document）一个 CMake 语言变量
CACHED_VARIABLE = 描述（document）一个 CMake 语言缓存变量
注意，与set_property和get_property不相同，不需要给出实际的作用域；只有作用域的类型才是重要的
*/
define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE |	TEST | VARIABLE | CACHED_VARIABLE>
	PROPERTY <name> [INHERITED]
	BRIEF_DOCS <brief-doc> [docs...]
	FULL_DOCS <full-doc> [docs...])

• PROPERTY 选项必须有，它后面紧跟要定义的属性名
• 如果指定了INHERITED 选项，那么如果 get_property 命令所请求的属性在该作用域中未设置，它会沿着链条向更高的作用域去搜索， DIRECTORY 域向上是 GLOBAL。TARGET，SOURCE 和 TEST向上是 DIRECTORY
• BRIEF_DOCS 和 FULL_DOCS 选项后面的参数是和属性相关联的字符串，分别作为变量的简单描述和完整描述。在使用 get_property 命令时，对应的选项可以获取这些描述信息

enable_language

支持某种语言（CXX/C/Fortran/等）

/*
该命令打开了 CMake 对参数中指定的语言的支持。这与 project 命令相同，但是不会创建
任何 project 命令会产生的额外变量。可以选用的语言的类型有 CXX，C，Fortran 等
*/
enable_language(languageName [OPTIONAL] )

• 如果指定了 OPTIONAL 选项，用 CMAKE__COMPILER_WORKS 变量来判断该语言是否被成功支持

enable_testing

打开当前及以下目录中的测试功能

/*
为当前及其下级目录打开测试功能。也可参见 add_test 命令。注意，ctest 需要在
构建跟目录下找到一个测试文件。因此，这个命令应该在源文件目录的根目录下
*/
enable_testing()

execute_process

执行一个或更多个子进程

/*
运行一条或多条命令，使得前一条命令的标准输出以管道的方式成为下一条命令的标准输入。
所有进程公用一个单独的标准错误管道

execute_process 命令是 exec_program 命令的一个较新的功能更加强大的版本。但是
为了兼容性的原因，旧的 exec_program 命令还会继续保留。
*/
execute_process(COMMAND <cmd1> [args1...]]
	[COMMAND <cmd2> [args2...] [...]]
	[WORKING_DIRECTORY <directory>]
	[TIMEOUT <seconds>]
	[RESULT_VARIABLE <variable>]
	[OUTPUT_VARIABLE <variable>]
	[ERROR_VARIABLE <variable>]
	[INPUT_FILE <file>]
	[OUTPUT_FILE <file>]
	[ERROR_FILE <file>]
	[OUTPUT_QUIET]
	[ERROR_QUIET]
	[OUTPUT_STRIP_TRAILING_WHITESPACE]
	[ERROR_STRIP_TRAILING_WHITESPACE])

• 如果指定了 WORKING_DIRECTORY 选项，后面的路径选项将会设置为子进程的当前工作路径
• 如果指定了 TIMEOUT 选项，如果子进程没有在指定的秒数（允许分数）里完成，子进程会自动终止
• 如果指定了 RESULT_VARIABLE 选项，该变量将保存为正在运行的进程的结果；它可以是最后一个子进程的整数返回代码，也可以是一个描述错误状态的字符串
• 如果指定了 OUTPUT_VARIABLE 或者 ERROR_VARIABLE，后面的变量将会被分别设置为标准输出和标准错误管道的值。如果两个管道都是用了相同的变量，它们的输出将会按产生的顺序被合并
• 如果指定了 INPUT_FILE，OUTPUT_FILE 或ERROR_FILE 选项，其后的文件将会分别被附加到第一个进程的标准输入、最后一个进程的标准输出，或者所有进程的标准错误管道上
• 如果指定了 OUTPUT_QUIET 后者 ERROR_QUIET选项，那么标准输出或标准错误的结果将会被静静的忽略掉。如果为同一个管道指定了多于一个的 OUTPUT_或 ERROR_ 选项，优先级是没有指定的。如果没有指定 OUTPUT_*或者ERROR_*选项，输出将会与 CMake 进程自身对应的管道共享

export

从构建树中导出目标供外部使用

/*
创建一个名为<filename>的文件，它可以被外部工程包含进去，从而外部工程可以从当前
工程的构建树中导入目标。这对于交叉编译那些可以运行在宿主平台的的 utility 可执行文件，
然后将它们导入到另外一个编译成目标平台代码的工程中的情形，特别有用

由该命令创建的文件是与指定的构建树一致的，并且绝对不应该被安装
*/
export(TARGETS [target1 [target2 [...]]] [NAMESPACE <namespace>]
	[APPEND] FILE <filename>)

• 如果指定了NAMESPACE 选项，字符串将会被扩展到输出文件中的所有目标的名字中
• 如果指定了 APPEND 选项，生成的代码将会续接在文件之后，而不是覆盖它。如果一个库目标被包含在 export 中，但是连接成它的目标没有被包含，行为没有指定

export(PACKAGE <name>)

• 在 CMake 的用户包注册表中，为包(package)存储当前的构建目录。这将有助于依赖于它的工程从当前工程的构建树中查找并使用包而不需要用户的介入。注意，该命令在包注册表中创建的条目，仅仅在与跟构建树一起运行的包配置文件(Config.cmake)一起使用时才会起作用。

file

文件操作命令

file(WRITE filename "message to write"... )
file(APPEND filename "message to write"... )
file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])
file(STRINGS filename variable [LIMIT_COUNT num]
	[LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes]
	[LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes]
	[NEWLINE_CONSUME] [REGEX regex]
	[NO_HEX_CONVERSION])
file(GLOB variable [RELATIVE path] [globbing expressions]...)
file(GLOB_RECURSE variable [RELATIVE path] 
	[FOLLOW_SYMLINKS] [globbing expressions]...)
file(RENAME <oldname> <newname>)
file(REMOVE [file1 ...])
file(REMOVE_RECURSE [file1 ...])
file(MAKE_DIRECTORY [directory1 directory2 ...])
file(RELATIVE_PATH variable directory file)
file(TO_CMAKE_PATH path result)
file(TO_NATIVE_PATH path result)
file(DOWNLOAD url file [TIMEOUT timeout] [STATUS status] [LOG log]
	[EXPECTED_MD5 sum] [SHOW_PROGRESS])

• WRITE 选项将会写一条消息到名为 filename 的文件中。如果文件已经存在，该命令会覆盖已有的文件；如果文件不存在，它将创建该文件
• APPEND 选项和 WRITE 选项一样，将会写一条消息到名为 filename 的文件中，只是该消息会附加到文件末尾
• READ 选项将会读一个文件中的内容并将其存储在变量里。读文件的位置从 offset 开始，最多读 numBytes 个字节。如果指定了 HEX 参数，二进制代码将会转换为十六进制表达方式，并存储在变量里
• STRINGS 将会从一个文件中将一个 ASCII 字符串的 list 解析出来，然后存储在 variable变量中。文件中的二进制数据会被忽略。回车换行符会被忽略。它也可以用在 Intel 的 Hex 和Motorola 的 S-记录文件；读取它们时，它们会被自动转换为二进制格式。可以使用NO_HEX_CONVERSION 选项禁止这项功能
• LIMIT_COUNT 选项设定了返回的字符串的最大数量
• LIMIT_INPUT 设置了从输入文件中读取的最大字节数
• LIMIT_OUTPUT 设置了在输出变量中存储的最大字节数
• LENGTH_MINIMUM 设置了要返回的字符串的最小长度；小于该长度的字符串会被忽略
• LENGTH_MAXIMUM 设置了返回字符串的最大长度；更长的字符串会被分割成不长于最大长度的字符串
• NEWLINE_CONSUME 选项允许新行被包含到字符串中，而不是终止它们
• REGEX 选项指定了一个待返回的字符串必须满足的正则表达式
• GLOB 选项将会为所有匹配查询表达式的文件生成一个文件 list，并将该 list 存储进变量variable 里
• GLOB_RECURSE 选项将会生成一个类似于通常的 GLOB 选项的 list，只是它会寻访所有那些匹配目录的子路径并同时匹配查询表达式的文件。作为符号链接的子路径只有在给定FOLLOW_SYMLINKS 选项或者 cmake 策略 CMP0009 被设置为 NEW 时，才会被寻访到
• MAKE_DIRECTORY 选项将会创建指定的目录，如果它们的父目录不存在时，同样也会创建
• RENAME 选项对同一个文件系统下的一个文件或目录重命名
• REMOVE 选项将会删除指定的文件，包括在子路径下的文件
• REMOVE_RECURSE 选项会删除给定的文件以及目录，包括非空目录
• RELATIVE_PATH 选项会确定从 direcroty 参数到指定文件的相对路径
• TO_CMAKE_PATH 选项会把 path 转换为一个以 unix 的 / 开头的 cmake 风格的路径。输入可以是一个单一的路径，也可以是一个系统路径，比如"$ENV{PATH}"
• TO_NATIVE_PATH 选项与 TO_CMAKE_PATH 选项很相似，但是它会把 cmake 风格的路径转换为本地路径风格：windows 下用\，而 unix 下用/
• DOWNLOAD 将给定的 URL 下载到指定的文件中。如果指定了 LOG var 选项，下载日志将会被输出到 var 中。如果指定了 STATUS var 选项，下载操作的状态会被输出到 var 中。该状态返回值是一个长度为 2 的 list。list 的第一个元素是操作的数字返回值，第二个返回值是错误的字符串值。错误信息如果是数字 0，操作中没有发生错误。如果指定了 TIMEOUT time 选项，在 time 秒之后，操作会超时退出；time 应该是整数。如果指定了EXPECTED_MD5 sum选项，下载操作会认证下载的文件的实际 MD5 和是否与期望值匹配。如果不匹配，操作将返回一个错误。如果指定了 SHOW_PROGRESS 选项，进度信息会以状态信息的形式被打印出来，直到操作完成

file(<COPY|INSTALL> files... DESTINATION <dir>
	[FILE_PERMISSIONS permissions...]
 	[DIRECTORY_PERMISSIONS permissions...]
	[NO_SOURCE_PERMISSIONS] [USE_SOURCE_PERMISSIONS]
	[FILES_MATCHING]
	[[PATTERN <pattern> | REGEX <regex>]
	[EXCLUDE] [PERMISSIONS permissions...]] [...])

• COPY 版本把文件、目录以及符号连接拷贝到一个目标文件夹。相对输入路径的评估是基于当前的源代码目录进行的，相对目标路径的评估是基于当前的构建目录进行的。复制过程将保留输入文件的时间戳；并且如果目标路径处存在同名同时间戳的文件，复制命令会把它优化掉。赋值过程将保留输入文件的访问权限，除非显式指定权限或指定NO_SOURCE_PERMISSIONS选项（默认是 USE_SOURCE_PERMISSIONS）
• INSTALL 版本与 COPY 版本只有十分微小的差别：它会打印状态信息，并且默认使用NO_SOURCE_PERMISSIONS 选项

find_file

查找一个文件的完整路径

/*
一个名字是<VAR>的缓存条目变量会被创建，用来存储该命令的结果。如果发现了文件
的一个完整路径，该结果会被存储到该变量里并且搜索过程不会再重复，除非该变量被清除。如
果什么都没发现，搜索的结果将会是<VAR>-NOTFOUND；并且在下一次以相同的变量调用
find_file 时，该搜索会重新尝试。被搜索的文件的文件名由 NAMES 选项后的名字列表指定。
附加的其他搜索位置可以在 PATHS 选项之后指定。如果 ENV var 在 HINTS 或 PATHS 段中出
现，环境变量 var 将会被读取然后被转换为一个系统级环境变量，并存储在一个 cmake 风格的
路径 list 中。比如，使用 ENV PATH 将会将系统的 path 变量列出来。在 DOC 之后的变量将
会用于 cache 中的文档字符串（documentation string）。PATH_SUFFIXES 指定了在每个
搜索路径下的需要搜索的子路径。
*/
find_file(<VAR> name1 [path1 path2 ...])
find_file(<VAR>name | NAMES name1 [name2 ...]
	[HINTS path1 [path2 ... ENV var]]
	[PATHS path1 [path2 ... ENV var]]
	[PATH_SUFFIXES suffix1 [suffix2 ...]]
	[DOC "cache documentation string"]
	[NO_DEFAULT_PATH]
	[NO_CMAKE_ENVIRONMENT_PATH]
	[NO_CMAKE_PATH]
	[NO_SYSTEM_ENVIRONMENT_PATH]
	[NO_CMAKE_SYSTEM_PATH]
	[CMAKE_FIND_ROOT_PATH_BOTH |
	ONLY_CMAKE_FIND_ROOT_PATH |
	NO_CMAKE_FIND_ROOT_PATH]
 )

如果指定了 NO_DEFAULT_PATH 选项，那么在搜索时不会附加其它路径。如果没有指定NO_DEFAULT_PATH 选项，搜索过程如下：

• 在 cmake 特有的 cache 变量中指定的搜索路径搜索，这些路径用于在命令行里用-DVAR=value 被设置。如果使用了 NO_CMAKE_PATH 选项，该路径会被跳过。搜索路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的路径<prefix>，<prefix>/include 变量：CMAKE_INCLUDE_PATH 变量：CMAKE_FRAMEWORK_PATH
• 在 cmake 特定的环境变量中指定的搜索路径搜索。该路径会在用户的 shell 配置中被设置。如果指定了 NO_CMAKE_ENVIRONMENT_PATH 选项，该路径会被跳过。搜索路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的路径<prefix>，<prefix>/include 变量：CMAKE_INCLUDE_PATH 变量：CMAKE_FRAMEWORK_PATH
• 由 HINTS 选项指定的搜索路径
• 搜索标准的系统环境变量。如果指定NO_SYSTEM_ENVIRONMENT_PATH 选项，搜索路径将跳过其后的参数。搜索路径包括环境变量 PATH 个 INCLUDE
• 查找在当前系统的平台文件中定义的 cmake 变量。如果指定NO_CMAKE_SYSTEM_PATH 选项，该路径会被跳过。其他的搜索路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的路径<prefix>，<prefix>/include 变量：CMAKE_INCLUDE_PATH 变量：CMAKE_FRAMEWORK_PATH
• 搜索由 PATHS 选项指定的路径或者在命令的简写版本中指定的路径

find_library

查找一个库文件

/*
一个名为<VAR>的 cache 条目会被创建来存储该命令的结
果。如果找到了该库文件，那么结果会存储在该变量里，并且搜索过程将不再重复，除非该变量
被清空。如果没有找到，结果变量将会是<VAR>-NOTFOUND，并且在下次使用相同变量调用
find_library 命令时，搜索过程会再次尝试。在 NAMES 参数后列出的文件名是要被搜索的库
名。附加的搜索位置在 PATHS 参数后指定。如果再 HINTS 或者 PATHS 字段中设置了 ENV 变 量 var，环境变量 var 将会被读取并从系统环境变量转换为一个 cmake 风格的路径 list。例如，
指定 ENV PATH 是获取系统 path 变量并将其转换为 cmake 的 list 的一种方式。在 DOC 之后
的参数用来作为 cache 中的注释字符串。PATH_SUFFIXES 选项指定了每个搜索路径下待搜索
的子路径。
*/
find_library(<VAR> name1 [path1 path2 ...])
find_library(<VAR> name | NAMES name1 [name2 ...]
	[HINTS path1 [path2 ... ENV var]]
	[PATHS path1 [path2 ... ENV var]]
	[PATH_SUFFIXES suffix1 [suffix2 ...]]
	[DOC "cache documentation string"]
	[NO_DEFAULT_PATH]
	[NO_CMAKE_ENVIRONMENT_PATH]
	[NO_CMAKE_PATH]
	[NO_SYSTEM_ENVIRONMENT_PATH]
	[NO_CMAKE_SYSTEM_PATH]
	[CMAKE_FIND_ROOT_PATH_BOTH |
	ONLY_CMAKE_FIND_ROOT_PATH |
	NO_CMAKE_FIND_ROOT_PATH]
 )

如果指定了 NO_DEFAULT_PATH 选项，那么搜索的过程中不会有其他的附加路径。如果没有指定该选项，搜索过程如下：

• 搜索 cmake 特有的 cache 变量指定的路径。这些变量是在用 cmake 命令行时，通过-DVAR=value 指定的变量。如果指定了 NO_CMAKE_PATH 选项，这些路径会被跳过。搜索的路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的<prefix>，路径<prefix>/lib，CMAKE_LIBRARY_PATH，CMAKE_FRAMEWORK_PATH
• 搜索 cmake 特有的环境变量指定的路径。这些变量是用户的 shell 配置中设置的变量。如果指定了 NO_CMAKE_ENVIRONMENT_PATH 选项，这些路径会被跳过。搜索的路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的<prefix>，路径<prefix>/lib，CMAKE_LIBRARY_PATH，CMAKE_FRAMEWORK_PATH
• 搜索由 HINTS 选项指定的路径
• 查找标准的系统环境变量。如果指定NO_SYSTEM_ENVIRONMENT_PATH 选项，这些路径会被跳过。搜索的路径还包括：PATH 和 LIB
• 查找在为当前系统的平台文件中定义的 cmake 变量。如果指定了NO_CMAKE_SYSTEM_PATH 选项，该路径会被跳过。搜索的路径还包括：对于每个在 CMAKE_PREFIX_PATH 中的<prefix>，路径<prefix>/lib，CMAKE_SYSTEM_LIBRARY_PATH，CMAKE_SYSTEM_FRAMEWORK_PATH
• 搜索 PATHS 选项或者精简版命令指定的路径

find_package

为外部工程加载设置

/*
查找并加载外来工程的设置。该命令会设置<package>_FOUND 变量，用来指示要找的
包是否被找到了。如果这个包被找到了，与它相关的信息可以通过包自身记载的变量中得到
QUIET 选项将会禁掉包没有被发现时的警告信息
REQUIRED 选项表示如果报没有找到的话，cmake 的过程会终止，并输出警告信息在 REQUIRED 选项之后，或者如果没有指定REQUIRED 选项但是指定了 COMPONENTS 选项，在它们的后面可以列出一些与包相关的部件清单（components list）
[version]参数需要一个版本号，它是正在查找的包应该兼容的版本号（格式是 major[.minor[.patch[.tweak]]]）
EXACT 选项要求该版本号必须精确匹配

模块模式
CMake 搜索所有名为Find<package>.cmake 的文件，这些文件的路径由变量由安装 CMake 时指定的CMAKE_MODULE_PATH 变量指定。如果查找到了该文件，它会被 CMake 读取并被处理
*/
find_package(<package> [version] [EXACT] [QUIET]
	[[REQUIRED|COMPONENTS] [components...]]
	[NO_POLICY_SCOPE])

/*
配置模式
find_package(<package> [version] [EXACT] [QUIET]
	[[REQUIRED|COMPONENTS] [components...]] [NO_MODULE]
	[NO_POLICY_SCOPE]
	[NAMES name1 [name2 ...]]
	[CONFIGS config1 [config2 ...]]
	[HINTS path1 [path2 ... ]]
	[PATHS path1 [path2 ... ]]
	[PATH_SUFFIXES suffix1 [suffix2 ...]]
	[NO_DEFAULT_PATH]
	[NO_CMAKE_ENVIRONMENT_PATH]
	[NO_CMAKE_PATH]
	[NO_SYSTEM_ENVIRONMENT_PATH]
	[NO_CMAKE_PACKAGE_REGISTRY]
	[NO_CMAKE_BUILDS_PATH]
	[NO_CMAKE_SYSTEM_PATH]
	[CMAKE_FIND_ROOT_PATH_BOTH |
	ONLY_CMAKE_FIND_ROOT_PATH |
	NO_CMAKE_FIND_ROOT_PATH])
*/

find_path

搜索包含某个文件的路径

find_path(<VAR> name1 [path1 path2 ...])
find_path(<VAR> name | NAMES name1 [name2 ...]
	[HINTS path1 [path2 ... ENV var]]
	[PATHS path1 [path2 ... ENV var]]
	[PATH_SUFFIXES suffix1 [suffix2 ...]]
	[DOC "cache documentation string"]
	[NO_DEFAULT_PATH]
	[NO_CMAKE_ENVIRONMENT_PATH]
	[NO_CMAKE_PATH]
	[NO_SYSTEM_ENVIRONMENT_PATH]
	[NO_CMAKE_SYSTEM_PATH]
	[CMAKE_FIND_ROOT_PATH_BOTH |
	ONLY_CMAKE_FIND_ROOT_PATH |
	NO_CMAKE_FIND_ROOT_PATH]
)

find_program

查找可执行程序

find_program(<VAR> name1 [path1 path2 ...])
find_program(<VAR> name | NAMES name1 [name2 ...]
	[HINTS path1 [path2 ... ENV var]]
	[PATHS path1 [path2 ... ENV var]]
	[PATH_SUFFIXES suffix1 [suffix2 ...]]
	[DOC "cache documentation string"]
	[NO_DEFAULT_PATH]
	[NO_CMAKE_ENVIRONMENT_PATH]
	[NO_CMAKE_PATH]
	[NO_SYSTEM_ENVIRONMENT_PATH]
	[NO_CMAKE_SYSTEM_PATH]
	[CMAKE_FIND_ROOT_PATH_BOTH |
	ONLY_CMAKE_FIND_ROOT_PATH |
	NO_CMAKE_FIND_ROOT_PATH]
)

fltk_wrap_ui

创建 FLTK 用户界面包装器

/*
为所有列出的.fl 和.fld 文件生成.h 和.cxx 文件。这些生成的.h 和.cxx 文件将会加到变量
resultingLibraryName_FLTK_UI_SRCS 中，它也会加到你的库中
*/
fltk_wrap_ui(resultingLibraryName source1 source2 ... sourceN )

get_cmake_property

获取一个 CMake 实例的属性

/*
从指定的 CMake 实例中获取属性。属性的值存储在变量 VAR 中。如果属性不存在，CMake
会报错。一些会被支持的属性包括：VATIABLES，COMMANDS，MACROS以及COMPONENTS
*/
get_cmake_property(VAR property)

get_directory_property

获取 DIRECTORY 域中的某种属性

/*
在指定的变量中存储路径（directory）域中的某种属性。如果该属性没有被定义，将会返回空字符串。
DIRECTORY 参数指定了要取出的属性值的另一个路径。指定的路径必须已经被CMake 遍历过
*/
get_directory_property(<variable> [DIRECTORY <dir>] <prop-name>)

/*
该命令从一个路径中获取一个变量的定义。这种格式在从另一个路径中获取变量的定义时比较有用
get_directory_property(<variable> [DIRECTORY <dir>] DEFINITION <var-name>)
*/

get_filename_component

得到一个完整文件名中的特定部分

/*
将变量<VAR>设置为路径(PATH)，文件名(NAME)，文件扩展名(EXT)，去掉扩展名的文
件名(NAME_WE)，完整路径(ABSOLUTE)，或者所有符号链接被解析出的完整路径
(REALPATH)。注意，路径会被转换为 Unix 的反斜杠(/)，并且没有结尾的反斜杠。该命令已
经考虑了最长的文件扩展名。如果指定了 CACHE 选项，得到的变量会被加到 cache 中
*/
get_filename_component(<VAR> FileName
	PATH|ABSOLUTE|NAME|EXT|NAME_WE|REALPATH [CACHE])

/*
在 FileName 中的程序将会在系统搜索路径中被查找，或者是一个完整路径。如果与
PRPGRAM 一起给定了 PROGRAM_ARGS 选项，那么任何在 Filename 字符串中出现的命令
行中选项将会从程序名中分割出来并存储在变量<ARG_VAR>中。这可以用来从一个命令行字
符串中分离程序名及其选项。
*/
get_filename_component(<VAR> FileName
	PROGRAM [PROGRAM_ARGS <ARG_VAR>] [CACHE])

get_property

获取一个属性值

/*
获取在某个域中一个对象的某种属性值。第一个参数指定了存储属性值的变量。第二个参数
确定了获取该属性的域。域的选项仅限于：
GLOBAL 域是唯一的，它不接受域名字。
 DIRECTORY 域默认为当前目录，但是其他的路径（已经被 CMake 处理过）可以以相
对路径或完整路径的方式跟在该域后面。
 TARGET 域后面必须跟有一个已有的目标名。
 SOURCE 域后面必须跟有一个源文件名。
 TEST 域后面必须跟有一个已有的测试。
 CACHE 域后面必须跟有一个 cache 条目。
 VARIABLE 域是唯一的，它不接受域名字。
*/
get_property(<variable>
	<GLOBAL | DIRECTORY [dir] | TARGET <target> | SOURCE <source> | TEST <test> | CACHE <entry> | VARIABLE> 
	PROPERTY <name>
	[SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

• PROPERTY 选项是必须的，它后面紧跟要获取的属性名。如果该属性没有被设置，该命令将返回空值
• 如果给定了 SET 选项，那么返回值会被设置为一个布尔值，用来指示该属性是否被设置过
• 如果给定了 DEFINED 选项，那么返回值会被设置为一个布尔值，用来指示该属性是否被类似于 define_property 的命令定义过
• 如果指定了 BRIEF_DOCS 或者 FULL_DOCS选项，那么该变量将会被设置为被查询属性的文档的字符串。如果被请求的属性的文档没有被定义，将返回 NOTFOUND

get_source_file_property

为一个源文件获取一种属性值

/*
从一个源文件中获取某种属性值。这个属性值存储在变量 VAR 中。如果该属性没有被找到，
VAR 会被设置为 NOTFOUND。使用 set_source_files_proterties 命令来设置属性值。源文
件属性通常用来控制文件如何被构建。一个必定存在的属性是 LOCATION
*/
get_source_file_property(VAR file property)

get_target_property

从一个目标中获取一个属性值

/*
从一个目标中获取属性值。属性的值会被存储在变量 VAR 中。如果该属性没有被发现，VAR
会被设置为 NOTFOUND。使用 set_target_properties 命令来设置属性值。属性值一般用于
控制如何去构建一个目标，但是有些属性用来查询目标的信息。该命令可以获取当前已经被构建
好的任意目标的属性。该目标不一定存在于当前的 CMakeLists.txt 文件中
*/
get_target_property(VAR target property)

get_test_property

获取一个测试的属性

/*
从指定的测试中获取某种属性。属性值会被存储到变量 VAR 中。如果没有找到该属性，
CMake 将会报错。你可以使用命令 cmake --help-property-list 来获取标准属性的清单
*/
get_test_property(test VAR property)

include

从给定的文件中读取 CMake 的列表文件

/*
从给定的文件中读取 CMake 的清单文件代码。在清单文件中的命令会被立即处理，
就像它们是写在这条 include 命令展开的地方一样
*/
include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
	[NO_POLICY_SCOPE])

• 如果指定了 OPTIONAL 选项，那么如果被包含文件不存在的话，不会报错
• 如果指定了 RESULT_VARIABLE 选项，那么 var 或者会被设置为被包含文件的完整路径，或者是 NOTFOUND，表示没有找到该文件
• 如果指定的是一个模块（module）而不是一个文件，查找的对象会变成路径CMAKE_MODULE_PATH 下的文件.camke
• 参考 cmake_policy()命令文档中关于 NO_POLICY_SCOPE 选项

include_directories

为构建树添加包含路径

/*
将给定的路径添加到编译器搜索包含文件（.h 文件）的路径列表中。缺省情况下，
该路径会被附加在当前路径列表的后面。这种缺省行为可以通过设置
CMAKE_include_directories_BEFORE 变量为 ON 被改变。通过将该变量改变为
BEFORE 或 AFTER，你可以在追加和附加在前端这两种方式中选择，而不用理会缺省设置
*/
include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)

• 如果指定了 SYSTEM 选项，编译器将会认为该路径是某种平台上的系统包含路径

include_external_msproject

在一个 workspace 中包含一个外部的Microsoft 工程

/*
在生成的 workspace 文件中包含一个外部的 Microsoft 工程。它会创建一个名
为[projectname]的目标。这个目标可以用在 add_dependencies 命令中让其他工
程依赖于这个外部工程。当前版本下，该命令在 UNIX 平台上不会做任何事情
*/
include_external_msproject(projectname location dep1 dep2 ...)

include_regular_expression

设置用于依赖性检查的正则表达式

/*
设置依赖性检查的正则表达式。这有匹配正则表达式 regex_match 的文件会成为
依赖性跟踪的对象。只有匹配 regex_complain 的文件，在找不到它们的时候才会给
出警告（标准头文件不会被搜索）。正则表达式的默认值是：
regex_match = "^.*$" (匹配所有文件)
regex_complain = "^$" (仅匹配空字符串)
*/
include_regular_expression(regex_match [regex_complain])

install

指定在安装时要运行的规则

• 该命令为一个工程生成安装规则。在某一源文件路径中，调用这条命令所指定的规则会在安装时按顺序执行
• List itemDESTINATION 选项指定了一个文件会安装到磁盘的哪个路径下。若果给出的是全路径（以反斜杠或者驱动器名开头），它会被直接使用。如果给出的是相对路径，它会被解释为相对于CMAKE_INSTALL_PREFIX 的值的相对路径
• PERMISSIONS 选项制定了安装文件需要的权限。合法的权限有：OWNER_READ，OWNER_WRITE，OWNER_EXECUTE，GROUP_READ，GROUP_WRITE，GROUP_EXECUTE，WORLD_READ，WORLD_WRITE，WORLD_EXECUTE，SETUID 和SETGID。对于在某些特定的平台上没有意义的权限，在这些平台上会忽略这些选项
• CONFIGURATIONS 选项指定了该安装规则将会加诸之上的一系列的构建配置（Debug，Release，等等）
• COMPONENT 选项指定了该安装规则相关的一个安装部件的名字，比如“runtime”或“development”。对于那些指定安装部件的安装过程来说，在安装时只有与给定的部件名相关的安装规则会被执行。对于完整安装，所有部件都会被安装
• RENAME 选项为一个可能不同于原始文件的已经安装的文件指定另一个名字。重命名只有在该命令正在安装一个单一文件时才被允许
• OPTIONAL 选项表示要安装的文件不存在不会导致错误

//TARGETS 版本的 install 命令
install(TARGETS targets... [EXPORT <export-name>]
	[[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|
	PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE]
	[DESTINATION <dir>]
	[PERMISSIONS permissions...]
	[CONFIGURATIONS [Debug|Release|...]]
	[COMPONENT <component>]
	[OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]
	] [...])

• 有 5 中可以被安装的目标文件：ARCHIVE，LIBRARY，RUNTIME，FRAMEWORK，和 BUNDLE。除了被标记为 MACOSX_BUNDLE 属性的可执行文件被当做 OS X 上的 BUNDLE 目标外，其他的可执行文件都被当做 RUNTIME 目标。静态链接的库文件总是被当做 ARCHIVE 目标。模块库总是被当做 LIBRARY 目标。对于动态库不是 DLL 格式的平台来说，动态库会被当做 LIBRARY目标来对待，被标记为 FRAMEWORK 的动态库是例外，它们被当做 OS X 上的 FRAMEWORK目标。对于 DLL 平台而言，动态库的 DLL 部分被当做一个 RUNTIME 目标而对应的导出库被当做是一个ARCHIVE目标。所有基于Windows的系统，包括Cygwin，都是DLL平台。ARCHIVE，LIBRARY，RUNTIME 和 FRAMEWORK 参数改变了后续属性会加诸之上的目标的类型。如果只给出了一种类型，那么只有那种类型的目标会被安装（这样通常只会安装一个 DLL 或者一个导出库。）
• PRIVATE_HEADER，PUBLIC_HEADER，和 RESOURCE 选项的功能是，在非苹果平台上，将后续的属性应用在待安装的一个 FRAMEWORK 共享库目标的相关文件上。这些选项定义的规则在苹果系统上会被忽略掉，因为相关的文件将会被安装到 framework 文件夹内的合适位置。参见 PRIVATE_HEADER，PUBLIC_HEADER 和 RESOURCE 目标属性中更为详细的解释
• 可以指定 NAMELINK_ONLY 或者 NAMELINK_SKIP 选项作为 LIBRARY 选项。在一些平台上，版本化的共享库有一个符号链接，比如 lib.so -> lib.so.1，其中“lib.so.1”是 so 库文件名（soname）而“lib.so”是一个符号链接，当指定“-l”选项时，链接器将会查找这个符号链接。如果一个库目标已经被安装，NAMELINK_ONLY 选项表示仅仅安装符号链接；而 NAME_SKIP 选项则表示仅仅安装库文件而不是符号链接。当两种选项都没有给出时，动态库的两个部分都会被安装。在那些版本化的共享库没有符号链接或者库没有被版本化的平台，选项NAMELINK_SKIP 安装这个库，而NAMELINK_ONLY 选项什么都不会安装
• EXPORT 选项将已经安装的目标文件和一个名为的导出文件关联起来。它必须出现在所有 RUNTIME，LIBRARY 或者 ARCHIVE 选项之前。为了实际安装导出文件本身（export file），调用 install(EXPORT)
• 将 EXCLUDE_FROM_ALL 设置为 true 时，安装一个目标会造成未定义的行为
• 在该命令的 TARGETS 版本的一次调用中，可以一次性指定一个或多个属性组。一个目标也可以被多次安装到不同的位置

//假设有三个目标 myExe，mySharedLib 和 myStaticLib
/*
将会把 myExe 安装到<prefix>/bin 目录下，把 myStaticLib 安装到<prefix>/lib/static 目
录下。在非-DLL 平台上，mySharedLib 将会被安装到<prefix>/lib 和/some/full/path 下。
在 DLL 平台上，mySharedLib DLL 将会被安装到<prefix>/bin 和/some/full/path 路径下，
它的导出库会被安装到<prefix>/lib/static 和/some/full/path 路径下
*/
install(TARGETS myExe mySharedLib myStaticLib
	RUNTIME DESTINATION bin
	LIBRARY DESTINATION lib
	ARCHIVE DESTINATION lib/static)
install(TARGETS mySharedLib DESTINATION /some/full/path)

//FILES 版本的 install 命令
/*
FILES 版本的 install 命令指定了为一个工程安装文件的规则。在命令中，以相对路径方式
给出的文件名是相对于当前源代码路径而言的。以这个版本安装的文件，如果没有指定
PERMISSIONS 选项，默认会具有 OWNER_WRITE，OWNER_READ，GROUP_READ，和
WORLD_READ 的权限
*/
install(FILES files... DESTINATION <dir>
	[PERMISSIONS permissions...]
	[CONFIGURATIONS [Debug|Release|...]]
	[COMPONENT <component>]
	[RENAME <name>] [OPTIONAL])

//PROGRAMS 版本的 install 命令
/*
PROGRAMS 版本与 FILES 版本一样，只在默认权限上有所不同：它还包括了
OWNER_EXECUTE，GROUP_EXECUTE 和 WORLD_EXECUTE 选项。INSTALL 的这个版
本用来安装不是目标的程序，比如shell脚本。使用TARGETS格式安装该工程内部构建的目标
*/
install(PROGRAMS files... DESTINATION <dir>
	[PERMISSIONS permissions...]
	[CONFIGURATIONS [Debug|Release|...]]
	[COMPONENT <component>]
	[RENAME <name>] [OPTIONAL])

//DIRECTORY 版本的 install 命令
/*
将一个或者多个路径下的内容安装到指定的目标地址下。目录结构会原封不动地（verbatim）
拷贝到目标地址。每个路径名的最后一部分会追加到目标路径下，但是结尾反斜杠
（trailing slash）可以用来避免这一点，因为这样最后一部分就是空的。
给定的相对路径名被解释成相对于当前源路径的路径。如果没有指定输入目录名字，目标目录会
被创建，但是不会安装任何东西
*/
install(DIRECTORY dirs... DESTINATION <dir>
	[FILE_PERMISSIONS permissions...]
	[DIRECTORY_PERMISSIONS permissions...]
	[USE_SOURCE_PERMISSIONS] [OPTIONAL]
	[CONFIGURATIONS [Debug|Release|...]]
	[COMPONENT <component>] [FILES_MATCHING]
	[[PATTERN <pattern> | REGEX <regex>]
	[EXCLUDE] [PERMISSIONS permissions...]] [...])

• FILE_PERMISSIONS 和 DIRECTORY_PERMISSIONS 选项指定了赋予目标路径和目标文件的权限
• 如果指定了USE_SOURCE_PERMISSIONS选项，但没有指定 FILE_PERMISSIONS 选项，文件权限将沿袭源目录结构的权限，而且这个路径会被赋予 PAROGRAMS 版本中指定的默认权限
• 通过使用 PATTERN 或 REGEX 选项可以对路径安装做出细粒度的控制。这些用于匹配的选项指定了一个查询模式或正则表达式来匹配输入路径内的路径或文件。它们可以用来将特定的选项（见下文）加诸于遇到的文件和路径的一个子集上。每个输入文件或路径的完整路径（反斜杠/开头的路径）将用来匹配该表达式。PATTERN 仅仅用来匹配完全文件名：匹配该模式的全路径的那部分必须出现在文件名的结尾，并且必须以一个反斜杠开始

//SCRIPT 和 CODE 版本的 install 命令
/*
SCRIPT 格式将会在安装期调用给定的脚本文件。如果脚本文件名是一个相对路径，它会被
解释为相对于当前的源路径。CODE 格式将会在安装期调用给定的 CMake 代码。code 被指定
为一个双引号括起来的单独的参数。例如在安装时打印一条信息
install(CODE "MESSAGE(\"Sample install message.\")")
*/
install([[SCRIPT <file>] [CODE <code>]] [...])

//EXPORT 版本的 install 命令
/*
EXPORT 格式的 install 命令生成并安装一个包含将安装过程的安装树导入到另一个工程中
的 CMake 文件。Target 格式的安装过程与上文提及的使用 EXPORT 选项的
install(TARGET ...)格式的命令中的 EXPORT <export-name>选项是相关的。NAMESPACE
选项会在它们被写入到导入文件时加到目标名字之前。缺省时，生成的文件就是
<export-name>.cmake；但是 FILE 选项可以用来指定不同于次的文件名。FILE 选项后面的
参数必须是一“.cmake”为扩展名的文件。如果指定了 CONFIGURATIONS 选项，那么只有那
些具名的配置中的一个被安装时，这个文件才会被安装。而且，生成的导入文件只能涉及到匹配
的目标配置版本。如果指定了一个 COMPONENT 选项，并且<component>与那个
<export-name>相关的目标指定的部件不匹配，那么行为是未定义的。如果一个库目标被包
含在 export 之中，但是与之关联的库却没有背包含，那么结果是未指定的。
*/
install(EXPORT <export-name> DESTINATION <dir>
	[NAMESPACE <namespace>] [FILE <name>.cmake]
	[PERMISSIONS permissions...]
	[CONFIGURATIONS [Debug|Release|...]]
	[COMPONENT <component>])

install(TARGETS myexe EXPORT myproj DESTINATION bin)
install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)
/*
将会把可执行文件 myexe 安装到<prefix>/bin 下，并且将导入它的代码写到文件
"<prefix>/lib/myproj/myproj.cmake"中。一个外部工程可以用 include 命令加载这个文件，
并且可以在安装树上使用导入的目标名 mp_myexe（前缀_目标名——译注）引用 myexe 可
执行文件，如同这个目标是它自身的构建树的内置目标一样。
 注意：这个命令会取代 INSTALL_TARGETS 命令以及 PRE_INSTALL_SCRIPT 和
POST_INSTALL_SCRIPT 两个目标属性。它也可以取代 FILES 格式的 INSTALL_FILES 命令
和 INSTALL_PROGRAMS 命令。由 INSTALL 命令生成的安装规则相对于那些由
INSTALL_TARGETS，INSTALL_FILES 和 INSTALL_PROGRAMS 命令生成的安装规则处理
顺序是未定义的
*/

link_directories

指定连接器查找库的路径

/*
指定连接器搜索库文件时的路径。该命令仅仅能用在那些在它被调用后才生成的目标上。由
于历史上的原因，为该命令指定的相对路径将会不加改变地传递给连接器（不像许多其他 CMake
命令那样解释为相对于当前源路径的相对路径。）
*/
link_directories(directory1 directory2 ...)

list

列表操作命令

/*
注意：在 CMake 中，一个 list 是一个由封号;分割的一组字符串。使用 set 命令可以创建
一个 list。例如，set(var a b c d e)命令将会创建一个 list：a;b;c;d;e；而 set(var "a b c d 
e")命令创建的只是一个字符串，或者说是只有一个项的 list。

 当使用指定索引的命令格式时，如果<element index>是大于等于 0 的数，<element 
index>是从 list 第一个项开始的序号，list 的第一项的索引是 0。如果<element index>小于
等于-1，这个索引是从结尾开始的逆向索引，其中-1 表示的是 list 的最后一项。当使用负数索
引时，注意它们不是从 0 开始！-0 与 0 等价，它指向 list 的第一个成员
*/
list(LENGTH <list> <output variable>)
list(GET <list> <element index> [<element index> ...] <output variable>)
list(APPEND <list> <element> [<element> ...])
list(FIND <list> <value> <output variable>)
list(INSERT <list> <element_index> <element> [<element> ...])
list(REMOVE_ITEM <list> <value> [<value> ...])
list(REMOVE_AT <list> <index> [<index> ...])
list(REMOVE_DUPLICATES <list>)
list(REVERSE <list>)
list(SORT <list>)

• 使用 LENGTH 选项时，该命令会返回给定 list 的长度
• 使用 GET 选项时，该命令返回 list 中所有被 index 索引的元素构成的 list
• 使用 APPEND 选项时，该命令将会在该 list 之后追加若干元素
• 使用 FIND 选项时，该命令将返回 list 中指定的元素的索引；若果未找到，返回-1
• 使用 INSERT 选项时，该命令将在 list 中指定的位置插入若干元素
• 使用 REMOVE_AT 和 REMOVE_ITEM 选项将会从 list 中删除一些元素。它们之间的区别是：REMOVE_ITEM 删除的是指定的项，而 REMOVE_AT 删除的是在指定索引处的项
• 使用 REMOVE_DUPLICATES 选项时，该命令将删除 list 中的重复项
• 使用 REVERSE 选项时，该命令将把 list 的内容就地前后倒换
• 使用 SORT 选项时，该命令将按字母序对 list 总的内容就地排序

load_cache

从另一个工程的 CMake cache 中加载值

/*
该命令读取指定的 cache 文件，并将以请求的前缀为其前缀的那些 cache 文件中的
entry(ies)保存到变量中。这个格式仅仅读取值，但是不在本地工程的 cache 中创建
entry(ies)
*/
load_cache(pathToCacheFile READ_WITH_PREFIX prefix entry1...)

/*
从另一个 cache 文件中加载值并像内部 entry(ies)那样，将它们存储到本地工程的 cache
中。这条命令对于一个依赖于另一个不同构建树上的另一个工程的工程比较有用。EXCLUDE 选
项给出了那些需要排除在外的 entry(ies)的一个 list。INCLUDE_INTERNALS 选项给出了需
要包含的 entry(ies)的内部 entry(ies)的一个 list。通常情况下，不需要引入内部 entry(ies)。
强烈不推荐使用该命令的这种格式，但是它可以被用来维持向后兼容性
*/
load_cache(pathToCacheFile [EXCLUDE entry1...] [INCLUDE_INTERNALS entry1...])

load_command

将一条命令加载到一个运行中的 CMake

/*
该命令将在给定的路径下查找名字为 cmCOMMAND_NAME 的一个库。如果找到了，它将
会以模块的方式被加载，然后该命令将会被添加到可用的 CMake 命令集中。通常，
TRY_COMPILE 选项被用在这个命令之前来编译这个模块。如果该命令被成功加载，一个名为
CMAKE_LOADED_COMMAND_<COMMAND_NAME>的变量将会被设置为这个加载模块
的完整路径。否则，这个变量就不会被设置。
*/
load_command(COMMAND_NAME <loc1> [loc2 ...])

mark_as_advanced

将 CMake 的缓存变量标记为高级

/*
将缓存的变量标记为高级变量。其中，高级变量指的是那些在 cmake GUI 中，只有当“显
示高级选项”被打开时才会被显示的变量。如果 CLEAR 是第一个选项，参数中的高级变量将变
回非高级变量。如果 FORCE 是第一个选项，参数中的变量会被提升为高级变量。如果两者都未
出现，新的变量会被标记为高级变量；如果这个变量已经是高级/非高级状态的话，它将会维持原状
*/
mark_as_advanced([CLEAR|FORCE] VAR VAR2 VAR...)

math

数学表达式

/*
EXPR 计算数学表达式然后通过 output 变量返回计算结果。数学表达式的一个例子是
"5*(10+13)"。该命令支持的运算符包括：+ - * / % ^ ~ << >> ；它们的含义与 C 语言
中的完全一致
*/
math(EXPR <output variable> <math expression>)

message

为用户显示一条消息

/*
可以用下述可选的关键字指定消息的类型：
 (无) = 重要消息；
 STATUS = 非重要消息；
 WARNING = CMake 警告, 会继续执行；
 AUTHOR_WARNING = CMake 警告 (dev), 会继续执行；
 SEND_ERROR = CMake 错误, 继续执行，但是会跳过生成的步骤；
 FATAL_ERROR = CMake 错误, 终止所有处理过程；
 
	CMake 的命令行工具会在 stdout 上显示 STATUS 消息，在 stderr 上显示其他所有消息。
CMake 的 GUI 会在它的 log 区域显示所有消息。交互式的对话框（ccmake 和 CMakeSetup）
将会在状态行上一次显示一条 STATUS 消息，而其他格式的消息会出现在交互式的弹出式对话
框中。
	CMake 警告和错误消息的文本显示使用的是一种简单的标记语言。文本没有缩进，超过长
度的行会回卷，段落之间以新行做为分隔符
*/
message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR]
	"message to display" ...)

option

为用户提供一个可选项

/*
该命令为用户提供了一个在 ON 和 OFF 中做出选择的选项。如果没有指定初始值，将会使
用 OFF 作为初值。如果有些选项依赖于其他选项的值，参见 CMakeDependentOption 模块
的帮助文件
*/
option(<option_variable> "描述选项的帮助性文字" [initial value])

output_required_files

输出一个 list，其中包含了一个给定源文件所需要的其他源文件

/*
输出一个指定的源文件所需要的所有源文件的 list。这个 list 会写到 outputfile 变量中。该
命令的功能是将 srcfile 的依赖性写出到 outputfile 中，不过该命令将尽可能地跳过.h 文件，搜
索依赖中的.cxx，.c 和.cpp 文件
*/
output_required_files(srcfile outputfile)

project

为整个工程设置一个工程名

/*
为本工程设置一个工程名。而且，该命令还将变量<projectName>_BINARY_DIR 和
<projectName>_SOURCE_DIR 设置为对应值。后面的可选项还可以让你指定你的工程可以
支持的语言。比如 CXX(即 C++)，C，Fortran，等等。在默认条件下，支持 C 和 CXX 语言。
例如，如果你没有 C++编译器，你可以通过列出你想要支持的语言，例如 C，来明确地禁止对
它的检查。使用特殊语言"NONE"，针对任何语言的检查都会被禁止。
*/
project(<projectname> [languageName1 languageName2 ... ] )

qt_wrap_cpp

创建 Qt 包裹器

/*
为所有在 SourceLists 中列出的.h 文件生成 moc 文件。这些 moc 文件将会被添加到那些
使用 DestName 源文件列表的库文件中
*/
qt_wrap_cpp(resultingLibraryName DestName SourceLists ...)

qt_wrap_ui

qt_wrap_ui 创建 Qt 的 UI 包裹器

/*
为所有在 SourceLists 中列出的.ui 文件生成.h 和.cxx 文件。这些.h 文件会被添加到使用
HeadersDestNamesource 列表的库中。这些.cxx 文件会被添加到使用
SourcesDestNamesource 列表的库中
*/
qt_wrap_ui(resultingLibraryName HeadersDestName SourcesDestName 
	SourceLists ...)

remove_definitions

取消由 add_definitions 命令添加的-D 定义标志

/*
在当前及以下的路径，从编译命令行中取消（由 add_definitions 命令添加的）标志
*/
remove_definitions(-DFOO -DBAR ...)

return

从一个文件，路径或函数内返回

/*
从一个文件，路径或函数中返回。若出现在一个 include 文件里（经由 include()或
find_package()命令），该命令会导致当前文件的处理过程停止，并且将控制权转移到试图包
含它的文件中。若出现在一个不被任何文件包含的文件中，例如，一个 CMakeLists.txt 中，那
么该命令将控制权转移到父目录下，如果存在这样的父目录的话。如果在一个函数中调用 return
函数，控制权会返回到该函数的调用函数那里。注意，宏不是函数，它不会像函数那样去处理
return 命令。
*/
return()

separate_arguments

将空格分隔的参数解析为一个分号分隔的 list

/*
解析一个 unix 或者 windows 风格的命令行字符串"<args>"，并将结果以分号分隔的 list
的形式存储到<var>中。整个命令行都必须从这个"<args>"参数中给出
*/
separate_arguments(<var> <UNIX|WINDOWS>_COMMAND "<args>")

set

将一个 CMAKE 变量设置为给定值

/*
	将变量<variable>的值设置为<value>。在<variable>被设置之前，<value>会被展开。
如果有 CACHE 选项，那么<variable>就会添加到 cache 中；这时<type>和<docstring>
是必需的。<type>被 CMake GUI 用来选择一个窗口，让用户设置值。<type>可以是下述值
中的一个：
 FILEPATH = 文件选择对话框。
 PATH = 路径选择对话框。
 STRING = 任意的字符串。
 BOOL = 布尔值选择复选框。
 INTERNAL = 不需要 GUI 输入端。(适用于永久保存的变量)。
 	如果<type>是内部的(INTERNAL)，那么<value>总是会被写入到 cache 中，并替换任
何已经存在于 cache 中的值。如果它不是一个 cache 变量，那么这个变量总是会写入到当前的
makefile 中。FORCE 选项将覆盖 cache 值，从而去掉任何用户带来的改变。
 	如果指定了 PARENT_SCOPE 选项，变量<variable>将会被设置为当前作用域之上的作
用域中。每一个新的路径或者函数都可以创建一个新作用域。该命令将会把一个变量的值设置到
父路径或者调用函数中（或者任何类似的可用的情形中。）
 如果没有指定<value>，那么这个变量就会被撤销而不是被设置。另见：unset()命令。
 set(<variable> <value1> ... <valueN>)
 在这种情形下，<variable>被设置为一个各个值之间由分号分隔的 list。
 <variable>可以是环境变量，比如：
 set( ENV{PATH} /home/martink )
 在这种情形下，环境变量将会被设置
*/
set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | 
	PARENT_SCOPE])

set_directory_properties

设置某个路径的一种属性

/*
为当前的路径及其子路径设置一种属性。如果该属性不存在，CMake 将会报告一个错误。
属性包括：INCLUDE_DIRECTORIES, LINK_DIRECTORIES, 
INCLUDE_REGULAR_EXPRESSION, 以及 ADDITIONAL_MAKE_CLEAN_FILES 共四种。
ADDITIONAL_MAKE_CLEAN_FILES 是一个文件名的 list，其中包含有"make clean"阶段会
被清除掉的文件。
*/
set_directory_properties(PROPERTIES prop1 value1 prop2 value2)

set_property

在给定的作用域内设置一个命名的属性

/*
	为作用域里的 0 个或多个对象设置一种属性。第一个参数决定了属性可以影响到的作用域。
他必须是下述值之一：GLOBAL，全局作用域，唯一，并且不接受名字。DIRECTORY，路径作
用域，默认为当前路径，但是也可以用全路径或相对路径指定其他值。TARGET，目标作用域，
可以命名 0 个或多个已有的目标。SOURCE，源作用域，可以命名 0 个或多个源文件。注意，
源文件属性只对加到相同路径（CMakeLists.txt）中的目标是可见的。TEST 测试作用域可以
命名 0 个或多个已有的测试。CACHE 作用域必须指定 0 个或多个 cache 中已有的条目。
	PROPERTY 选项是必须的，并且要紧跟在待设置的属性的后面。剩余的参数用来组成属性
值，该属性值是一个以分号分隔的 list。如果指定了 APPEND 选项，该 list 将会附加在已有的
属性值之后
*/
set_property(<GLOBAL |
	DIRECTORY [dir] |
	TARGET [target1 [target2 ...]] |
	SOURCE [src1 [src2 ...]] |
	TEST [test1 [test2 ...]] |
	CACHE [entry1 [entry2 ...]]>
 	[APPEND]
	PROPERTY <name> [value1 [value2 ...]])

set_source_files_properties

源文件有一些属性来可以改变它们构建的方式

/*
以键/值对的方式设置与源文件相关的那些属性值。那些 CMake 中的源文件属性，参见关
于属性的相关文档。不能被识别的属性将会被忽略。源文件属性只对同一路径（CMakeLists.txt）
中添加的目标可见
*/
set_source_files_properties([file1 [file2 [...]]]
	PROPERTIES prop1 value1
	[prop2 value2 [...]])

set_target_properties

设置目标的一些属性来改变它们构建的方式

/*
该命令的语法是列出所有你想要变更的文件，然后提供你想要设置的
值。你能够使用任何你想要的属性/值对，并且在随后的代码中调用 GET_TARGET_PROPERTY
命令取出属性的值
*/
set_target_properties(target1 target2 ...
	PROPERTIES prop1 value1
	prop2 value2 ...)

• PREFIX 和 SUFFIX 属性覆盖了默认的目标名前缀（比如 lib）和后缀（比如.so）
• IMPORT_PREFIX 和 IMPORT_SUFFIX 是与之等价的属性，不过针对的是 DLL（共享库目标）的导入库
• 在构建目标时，OUTPUT_NAME 属性设置目标的真实名字，并且可以用来辅助创建两个具有相同名字的目标，即使 CMake 需要唯一的逻辑目标名
• <CONFIG>_OUTPUT_NAME 可以为不同的配置设置输出的目标名字。当目标在指定的配置名<CONFIG>（全部大写，例如 DEBUG_POSTFIX）下被构建时，<CONFIG>POSTFIX 为目标的真实名字设置一个后缀。该属性的值在目标创建时被初始化为CMAKE_POSTFIX 的值（可执行目标除外，因为较早的 CMake 版本不会为可执行文件使用这个属性。）
• LINK_FLAGS 属性可以用来为一个目标的链接阶段添加额外的标志
• LINK_FLAGS_将为配置添加链接标志，例如 DEBUG，RELEASE，MINSIZEREL，RELWITHDEBINFO
• DEFINE_SYMBOL 属性设置了编译一个共享库中的源文件时才会被定义的预处理器符号名。如果这个值没有被设置的话，那么它会被设置为默认值target_EXPORTS
• COMPILE_FLAGS 属性可以设置附加的编译器标志，它们会在构建目标内的源文件时被用到。它也可以用来传递附加的预处理器定义
• LINKER_LANGUAGE 属性用来改变链接可执行文件或共享库的工具。默认的值是设置与库中的文件相匹配的语言。CXX 和 C 是这个属性的公共值
• 对于共享库，VERSION 和 SOVERSION 属性分别可以用来指定构建的版本号以及 API 版本号。当构建或者安装时，如果平台支持符号链接并且链接器支持 so 名字，那么恰当的符号链接会被创建。如果只指定两者中的一个，缺失的另一个假定为具有相同的版本号。对于可执行文件，VERSION 可以被用来指定构建版本号。当构建或者安装时，如果该平台支持符号链接，那么合适的符号链接会被创建。对于在 Windows 系统而言，共享库和可执行文件的 VERSION属性被解析成为一个"major.minor"的版本号。这些版本号被用做该二进制文件的镜像版本
• INSTALL_RPATH 是一个分号分隔的 list，它指定了在安装目标时使用的 rpath（针对支持 rpath 的平台而言）
• INSTALL_RPATH_USE_LINK_PATH 是一个布尔值属性，如果它被设置为真，那么在链接器的搜索路径中以及工程之外的目录会被附加到 INSTALL_RPATH 之后
• SKIP_BUILD_RPATH 是一个布尔值属性，它指定了是否跳过一个 rpath 的自动生成过程，从而可以从构建树开始运行
• BUILD_WITH_INSTALL_RPATH 是一个布尔值属性，它指定了是否将在构建树上的目标与 INSTALL_RPATH 链接。该属性要优先于 SKIP_BUILD_RPATH，因此避免了安装之前的重新链接
• INSTALL_NAME_DIR 是一个字符串属性，它用于在 Mac OSX 系统上，指定了被安装的目标中使用的共享库的"install_name"域的目录部分。如果目标已经被创建，变量CMAKE_INSTALL_RPATH,CMAKE_INSTALL_RPATH_USE_LINK_PATH, CMAKE_SKIP_BUILD_RPATH, CMAKE_BUILD_WITH_INSTALL_RPATH 和 CMAKE_INSTALL_NAME_DIR 的值会被用来初始化这个属性。
• PROJECT_LABEL 属性可以用来在 IDE 环境，比如 visual studio，中改变目标的名字
• VS_KEYWORD 可以用来改变 visual studio 的关键字，例如如果该选项被设置为Qt4VSv1.0 的话，QT 集成将会运行得更好
• VS_SCC_PROJECTNAME, VS_SCC_LOCALPATH, VS_SCC_PROVIDER 可以被设置，从而增加在一个 VS 工程文件中对源码控制绑定的支持
• PRE_INSTALL_SCRIPT和POST_INSTALL_SCRIPT属性是在安装一个目标之前及之后指定运行 CMake 脚本的旧格式。只有当使用旧式的 INSTALL_TARGETS 来安装目标时，才能使用这两个属性。使用 INSTALL 命令代替这种用法
• EXCLUDE_FROM_DEFAULT_BUILD 属性被 visual studio 生成器使用。如果属性值设置为 1，那么当你选择"构建解决方案"时，目标将不会成为默认构建的一部分

set_tests_properties

设置若干个测试的属性值

/*
	为若干个测试设置一组属性。若属性未被发现，CMake 将会报告一个错误。这组属性包括：
WILL_FAIL， 如果设置它为 true，那将会把这个测试的“通过测试/测试失败”标志反转。
PASS_REGULAR_EXPRESSION，如果它被设置，这个测试的输出将会被检测是否违背指定
的正则表达式，并且至少要有一个正则表达式要匹配；否则测试将会失败。
例子: PASS_REGULAR_EXPRESSION "TestPassed;All ok"
	FAIL_REGULAR_EXPRESSION: 如果该属性被设置，那么只要输出匹配给定的正则表达
式中的一个，那么测试失败。
 例子: PASS_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"
	PASS_REGULAR_EXPRESSION和FAIL_REGULAR_EXPRESSION属性都期望一个正
则表达式列表（list）作为其参数。
	TIMEOUT: 设置该属性将会限制测试的运行时长不超过指定的秒数。
*/
set_tests_properties(test1 [test2...] PROPERTIES prop1 value1 prop2 value2)

site_name

将给定的变量设定为计算机名

site_name(variable)

source_group

为 Makefile 中的源文件定义一个分组

/*
	为工程中的源文件中定义一个分组。这主要用来在 Visual Studio 中建立文件组按钮(file 
tabs)。所有列出来的文件或者匹配正则表达式的文件都会被放到这个文件组中。如果一个文件
匹配多个组，那么最后明确地列出这个文件的组将会包含这个文件，如果有这样的组的话。如果
没有任何组明确地列出这个文件，那么最后那个其正则表达式与该文件名匹配的组，将会成为最
终候选者。
	组名中可以包含反斜杠，以指定子文件组：source_group(outer\\inner ...)
	为了保持后向兼容性，这个命令也支持这种格式：source_group(name regex)
*/
source_group(name [REGULAR_EXPRESSION regex] [FILES src1 src2 ...])

string

字符串操作函数

/*
在正则表达式中，下述字符有特殊含义：
 ^ 在行首匹配。
 $ 在行尾匹配。
 . 匹配任意单个字符。
 [ ] 匹配在中括号中的任意字符。
 [^ ] 匹配不在中括号中的任意字符。
 - 匹配任意在短横线两端字符闭区间中间的任意一个字符。
 - 匹配先前模式零次或多次。
 - 匹配先前模式一次或多次。
 ? 匹配先前模式零次或一次。
 | 匹配|两侧的任意一种模式。
 () 保存一个匹配的子表达式，这个子表达式后续可以在 REGEX REPLACE 操作中以\n
的方式引用。 它也会被所有正则表达式相关的命令所保存；包括，比如，
	如果用到 if( MATCHES )命令的话，这些匹配的值被保存在变量
CMAKE_MATCH_(0..9)中。
*/
string(REGEX MATCH <regular_expression> <output variable> <input> [<input>...])
string(REGEX MATCHALL <regular_expression> <output variable> <input> [<input>...])
string(REGEX REPLACE <regular_expression> <replace_expression> <output variable> <input> [<input>...])
string(REPLACE <match_string> <replace_string> <output variable> <input> [<input>...])
string(COMPARE EQUAL <string1> <string2> <output variable>)
string(COMPARE NOTEQUAL <string1> <string2> <output variable>)
string(COMPARE LESS <string1> <string2> <output variable>)
string(COMPARE GREATER <string1> <string2> <output variable>)
string(ASCII <number> [<number> ...] <output variable>)
string(CONFIGURE <string1> <output variable> [@ONLY] [ESCAPE_QUOTES])
string(TOUPPER <string1> <output variable>)
string(TOLOWER <string1> <output variable>)
string(LENGTH <string> <output variable>)
string(SUBSTRING <string> <begin> <length> <output variable>)
string(STRIP <string> <output variable>)
string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>] [RANDOM_SEED <seed>] <output variable>)

• REGEX MATCH : 匹配正则表达式一次，然后将匹配的值存储到输出变量中
• REGEX MATCHALL : 尽可能多次地匹配正则表达式，然后将匹配的值以 list 的形势存储到输出变量中
• REGEX REPLACE : 尽可能多次地匹配正则表达式，并且将匹配的值用 replacement expression 替换掉，然后存储到输出变量中。这个 replace expression 可以引用包含匹配字符串的子表达式，这些匹配的字符串用圆括号隔开的\1，\2，…，\9 等加以引用
• REPLACE : 将输入字符串内所有出现 match_string 的地方都用 replace_string 代替，然后将结果存储到输出变量中
• COMPARE EQUAL/NOTEQUAL/LESS/GREATER : 将会比较两个字符串，然后将比较的结果（true/false）存储到输出变量中
• ASCII : 将会把所有数字转换为对应的 ASCII 字符
• CONFIGURE : 将一个字符串进行变换，这种变换与将一个 FILE 变换为CONFIGURE_FILE 相似
• TOUPPER/TOLOWER : 将字符串转换为大写/小写字符
• LENGTH : 返回给定字符串的长度
• SUBSTRING : 返回给定字符串的子串
• STRIP : 返回一个给定字符串的子串，它会去掉原先字符串开始和结尾的空格
• RANDOM : 将会返回一个给定长度的随机字符串，它由给定的字母表中的字母组成。默认的长度是 5 个字符，默认的字母表是全部的大小写字母以及数字。如果指定了一个整数RANDOM_SEED，它的值将会被用做随机数发生器的种子

target_link_libraries

将给定的库链接到一个目标上

/*
为给定的目标设置连接时使用的库或者标志(flags)。如果一个库名字与工程中的另外一个
目标相匹配，一个依赖关系会自动添加到构建系统中来，这样就可以在链接目标之前，保证正在
被链接的库是最新的。以“-”开始，但不是“-l”或“-framework”的那些项，将会被当作链接器标
志来处理
*/
target_link_libraries(<target> [item1 [item2 [...]]] 
	[[debug|optimized|general] <item>] ...)

• 关键字“debug”，“optimized”或者“general” 表示紧随关键字之后的库仅仅会被用到相应的构建配置上
• “debug”关键字对应于调试配置（或者，如果全局属性DEBUG_CONFIGURATIONS 被设置的话，就是 DEBUG_CONFIGURATIONS 中的名字所指定的配置）
• “optimized”关键字对应于所有其他的配置类型
• “general”关键字对应于所有的配置，并且纯粹是可选的（它是默认配置，可以省略）
• 通过创建并链接到导入库目标，可以对每种配置规则进行更细致的粒度控制。更多内容参见 add_library 命令的 IMPORTED 模式

try_compile

尝试编译一些代码

/*
尝试编译一个程序。在这种格式时，srcdir 路径下应该包含一个完整的 CMake 工程，包括
CMakeLists.txt 文件以及所有的源文件。在该命令运行完之后，路径 bindir 和 srcdir 不会被
删除。如果指定了<target name>，那么 CMake 将只构建那个目标；否则，目标 all 或
ALL_BUILD 将会被构建
*/
try_compile(RESULT_VAR bindir srcdir
	projectName <targetname> [CMAKE_FLAGS <Flags>]
	[OUTPUT_VARIABLE var])

/*
尝试编译一个 srcfile。在这种情况下，用户仅仅需要提供源文件。CMake 会创建合适的
CMakeLists.txt 文件来构建源文件。如果使用了 COPY_FILE 选项，编译出的文件将会被拷贝
到给定的文件那里
*/
try_compile(RESULT_VAR bindir srcfile
	[CMAKE_FLAGS <Flags>]
	[COMPILE_DEFINITIONS <flags> ...]
	[OUTPUT_VARIABLE var]
	[COPY_FILE <filename> )

try_run

尝试编译并运行某些代码

/*
尝试编译一个源文件 srcfile。通过变量 COMPILE_RESULT_VAR 返回 TRUE 或者 FALSE
来反应编译是否失败。如果构建出了可执行文件，但是不能运行，那么 RUN_RESULT_VAR 会
被设置为 FAILED_TO_RUN。COMPILE_OUTPUT_VARIABLE 变量指定了一个变量，这个变
量存储了构建步骤输出的信息。RUN_OUTPUT_VARIABLE 指定了一个变量，这个变量存储了
运行可执行文件时的输出。出于兼容性的考虑，OUTPUT_VARIABLE 还会被支持，它包含了包
含编译和运行阶段的输出信息
*/
try_run(RUN_RESULT_VAR COMPILE_RESULT_VAR
	bindir srcfile [CMAKE_FLAGS <Flags>]
	[COMPILE_DEFINITIONS <flags>]
	[COMPILE_OUTPUT_VARIABLE comp]
	[RUN_OUTPUT_VARIABLE run]
	[OUTPUT_VARIABLE var]
	[ARGS <arg1> <arg2>...])

unset

撤销对一个变量，cache 变量或者环境变量的设置

/*
删除一个指定的变量，让它变成未定义的。如果指定了 CACHE 选项，那么这个变量将会从
cache 中删除而不是当前作用域。<variable>可以是一个环境变量，比如：
 unset(ENV{LD_LIBRARY_PATH})
在这个例子中，这个变量将会从当前的环境中被删除
*/
unset(<variable> [CACHE])

variable_watch

监视 CMake 变量的改变

/*
如果给定的变量发生了变化，关于正在被改写的变脸的消息会被打印出来。如果指定了
command 选项，这条命令会被执行。这条命令会接受这样的参数：COMMAND(<variable> 
<access> <value> <current list file> <stack>)
*/
variable_watch(<variable name> [<command to execute>])

示例

• 总工程概览

Project:
│ 
├── bin                  可执行文件夹 
├── build                cmake缓存目录 
├── include              头文件目录
│   └── utils.h
├── src                  源文件目录
│   ├── main.cpp     
│   └── utils.cpp    
└── CMakeLists.txt       主目录 CMakeLists

• CMakeLists.txt

CMAKE_MINIMUM_REQUIRED(VERSION 2.8) # cmake最低版本要求

PROJECT(CppTemplate)    # 工程名 CppTemplate

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") # 添加c++11标准支持

SET(CMAKE_C_COMPILER "/usr/bin/gcc") # 默认c编译器
SET(CMAKE_CXX_COMPILER "/usr/bin/g++") # 默认c++编译器

SET(CMAKE_BUILD_TYPE "Debug")  # Debug模式 选项: Release Debug MinSizeRel RelWithDebInfo

SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g2 -ggdb")  # debug模式下 gdb相关选项
SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall") # release模式下 gdb相关选项

# set(CMAKE_VERBOSE_MAKEFILE ON) # 开启调试 出现问题时开启

# enable_testing() # 打开测试

add_definitions(-DDEBUG) # 相当于代码中 #define DEBUG

# add_subdirectory(test) # 添加test子目录

SET(EXECUTABLE_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/bin") # 可执行文件输出目录

INCLUDE_DIRECTORIES("${PROJECT_SOURCE_DIR}/include") # 头文件包含目录

# 这段代码可以区分操作系统
MESSAGE("Identifying the OS...")
if(WIN32)
  MESSAGE("This is Windows.")
elseif(APPLE)
  MESSAGE("This is MacOS.")
elseif(UNIX)
  MESSAGE("This is Linux.")
endif()
# 这段代码可以区分操作系统

AUX_SOURCE_DIRECTORY(src DIR_SRCS) # 添加源代码文件夹, 自动扫描所有文件

add_executable(chess  # 输出名为chess的可执行文件
   ${DIR_SRCS}
)
# 也可以这么写
# add_executable(chess  # 输出名为chess的可执行文件
#    ./src/main.cpp
#    ./src/utils.cpp
# )