这不是最新的 CMake 版本。请参见主 CMake 文档 索引以获取更新的版本。
CMake 2.6 文档 由 cmake 程序使用 cmake --help-html 生成。
cmake - cmake

主索引

名称

  cmake - Cross-Platform Makefile Generator.

用法

  cmake [options] <path-to-source>
  cmake [options] <path-to-existing-build>

描述

"cmake" 可执行文件是 CMake 命令行界面。它可用于在脚本中配置项目。项目配置设置可以使用 -D 选项在命令行上指定。-i 选项将导致 cmake 交互式提示输入此类设置。

CMake 是一个跨平台构建系统生成器。项目使用平台无关的 CMake 列表文件来指定其构建过程，这些列表文件包含在源树的每个目录中，名称为 CMakeLists.txt。用户通过使用 CMake 为其平台上的本机工具生成构建系统来构建项目。

选项

  • -C <initial-cache>: 预加载脚本以填充缓存。

    当 cmake 首次在空构建树中运行时，它会创建一个 CMakeCache.txt 文件并使用项目的可定制设置填充它。此选项可用于指定要从中加载缓存条目以在第一次遍历项目的 cmake 列表文件之前的文件。加载的条目优先于项目的默认值。给定的文件应是一个 CMake 脚本，其中包含使用 CACHE 选项的 SET 命令，而不是缓存格式文件。

  • -D <var>:<type>=<value>: 创建 cmake 缓存条目。

    当 cmake 首次在空构建树中运行时，它会创建一个 CMakeCache.txt 文件并使用项目的可定制设置填充它。此选项可用于指定优先于项目的默认值的设置。此选项可以重复使用，以指定任意数量的缓存条目。

  • -U <globbing_expr>: 从 CMake 缓存中删除匹配的条目。

    此选项可用于从 CMakeCache.txt 文件中删除一个或多个变量，支持使用 * 和 ? 的通配符表达式。此选项可以重复使用，以指定任意数量的缓存条目。

    谨慎使用，可能会导致 CMakeCache.txt 无法正常工作。

  • -G <generator-name>: 指定一个 makefile 生成器。

    CMake 可能会在某些平台上支持多种本机构建系统。makefile 生成器负责生成特定的构建系统。生成器名称可以在生成器部分中找到。

  • -Wno-dev: 抑制开发人员警告。

    抑制针对 CMakeLists.txt 文件作者的警告。

  • -Wdev: 启用开发人员警告。

    启用针对 CMakeLists.txt 文件作者的警告。

  • -E: CMake 命令模式。

    为了实现真正的平台独立性，CMake 提供了一系列可在所有系统上使用的命令。使用 -E help 获取用法信息。可用的命令有：chdir、copy、copy_if_different copy_directory、compare_files、echo、echo_append、environment、make_directory、md5sum、remove_directory、remove、tar、time、touch、touch_nocreate、write_regv、delete_regv、comspec、create_symlink。

  • -i: 在向导模式下运行。

    向导模式在没有 GUI 的情况下交互式运行 cmake。用户会被提示回答有关项目配置的问题。答案用于设置 cmake 缓存值。

  • -L[A][H]: 列出非高级缓存变量。

    列出缓存变量将运行 CMake 并列出 CMake 缓存中所有未标记为 INTERNAL 或 ADVANCED 的变量。这将有效地显示当前 CMake 设置，然后可以使用 -D 选项进行更改。更改某些变量可能会导致创建更多变量。如果指定了 A，则还会显示高级变量。如果指定了 H，则还会显示每个变量的帮助信息。

  • -N: 仅查看模式。

    仅加载缓存。不实际运行配置和生成步骤。

  • -P <file>: 处理脚本模式。

    以 CMake 语言编写的脚本形式处理给定的 cmake 文件。不会执行任何配置或生成步骤，也不会修改缓存。如果使用 -D 定义变量，则必须在 -P 参数之前执行此操作。

  • --graphviz=[file]: 生成依赖项的 graphviz。

    生成一个 graphviz 输入文件，其中将包含项目中的所有库和可执行文件依赖项。

  • --system-information [file]: 转储有关此系统的信息。

    转储有关当前系统的大量信息。如果从 CMake 项目的二叉树顶部运行，它将转储其他信息，例如缓存、日志文件等。

  • --debug-trycompile: 不要删除尝试编译目录。

    不要删除为 try_compile 调用创建的文件和目录。这在调试 try_compile 失败时很有用。但是，它可能会改变 try-compile 的结果，因为来自先前 try-compile 的旧垃圾可能会导致不同的测试错误地通过或失败。此选项最适合一次使用一个 try-compile，并且仅在调试时使用。

  • --debug-output: 将 cmake 设置为调试模式。

    在 cmake 运行期间打印额外的内容，例如使用 message(send_error ) 调用时的堆栈跟踪。

  • --trace: 将 cmake 设置为跟踪模式。

    打印所有调用及其来源的跟踪，使用 message(send_error ) 调用。

  • --help-command cmd [file]: 打印单个命令的帮助信息并退出。

    显示与给定命令相关的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-command-list [file]: 列出可用的列表文件命令并退出。

    此列表包含可以使用 --help-command 参数后跟命令名称来获取帮助的所有命令。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-commands [file]: 打印所有命令的帮助信息并退出。

    显示所有当前命令的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-compatcommands [file]: 打印兼容性命令的帮助信息。

    显示所有兼容性命令的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-module module [file]: 打印单个模块的帮助信息并退出。

    显示与给定模块相关的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-module-list [file]: 列出可用的模块并退出。

    此列表包含可以使用 --help-module 参数后跟模块名称来获取帮助的所有模块。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-modules [file]: 打印所有模块的帮助信息并退出。

    显示所有模块的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-custom-modules [file]: 打印所有自定义模块的帮助信息并退出。

    显示所有自定义模块的完整文档。如果指定了文件，则文档将写入该文件，并且输出格式将根据文件名后缀确定。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-policy cmp [file]: 打印单个策略的帮助信息并退出。

    显示与给定策略相关的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-policies [file]: 打印所有策略的帮助信息并退出。

    显示所有策略的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-property prop [file]: 打印单个属性的帮助信息并退出。

    显示与给定属性相关的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-property-list [file]: 列出可用的属性并退出。

    该列表包含所有可以使用 --help-property 选项后跟属性名称来获取帮助信息的属性。如果指定了文件，则将帮助信息写入其中。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-properties [file]: 打印所有属性的帮助信息并退出。

    显示所有属性的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-variable var [file]: 打印单个变量的帮助信息并退出。

    显示与给定变量相关的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-variable-list [file]: 列出已记录的变量并退出。

    该列表包含所有可以使用 --help-variable 选项后跟变量名称来获取帮助信息的变量。如果指定了文件，则将帮助信息写入其中。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --help-variables [file]: 打印所有变量的帮助信息并退出。

    显示所有变量的完整文档。如果指定了文件，则将文档写入其中，并根据文件名后缀确定输出格式。支持的格式包括手册页、HTML、DocBook 和纯文本。

  • --copyright [file]: 打印 CMake 版权信息并退出。

    如果指定了文件，则将版权信息写入其中。

  • --help: 打印使用信息并退出。

    使用方法描述了基本的命令行界面及其选项。

  • --help-full [file]: 打印完整帮助信息并退出。

    完整帮助信息显示了 UNIX 手册页提供的多数文档。它提供给非 UNIX 平台使用，但如果手册页未安装，它也很方便。如果指定了文件，则将帮助信息写入其中。

  • --help-html [file]: 以 HTML 格式打印完整帮助信息。

    CMake 作者使用此选项来帮助生成网页。如果指定了文件，则将帮助信息写入其中。

  • --help-man [file]: 将完整帮助信息作为 UNIX 手册页打印并退出。

    cmake 构建使用此选项来生成 UNIX 手册页。如果指定了文件，则将帮助信息写入其中。

  • --version [file]: 显示程序名称/版本横幅并退出。

    如果指定了文件，则将版本信息写入其中。

生成器

此平台上提供以下生成器

  • Borland Makefiles: 生成 Borland Makefile。
  • MSYS Makefiles: 生成 MSYS Makefile。

    Makefile 使用 /bin/sh 作为 shell。它们要求机器上安装 msys。

  • MinGW Makefiles: 生成一个用于 mingw32-make 的 Makefile。

    生成的 Makefile 使用 cmd.exe 作为 shell。它们不需要 msys 或 unix shell。

  • NMake Makefiles: 生成 NMake Makefile。
  • Unix Makefiles: 生成标准的 UNIX Makefile。

    将在构建树中生成一个 UNIX Makefile 的层次结构。任何标准的 UNIX 风格的 make 程序都可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

  • Visual Studio 6: 生成 Visual Studio 6 项目文件。
  • Visual Studio 7: 生成 Visual Studio .NET 2002 项目文件。
  • Visual Studio 7 .NET 2003: 生成 Visual Studio .NET 2003 项目文件。
  • Visual Studio 8 2005: 生成 Visual Studio .NET 2005 项目文件。
  • Visual Studio 8 2005 Win64: 生成 Visual Studio .NET 2005 Win64 项目文件。
  • Visual Studio 9 2008: 生成 Visual Studio 9 2008 项目文件。
  • Visual Studio 9 2008 Win64: 生成 Visual Studio 9 2008 Win64 项目文件。
  • Watcom WMake: 生成 Watcom WMake Makefile。
  • CodeBlocks - MinGW Makefiles: 生成 CodeBlocks 项目文件。

    将在顶层目录和每个包含 PROJECT() 调用的 CMakeLists.txt 文件的子目录中创建 CodeBlocks 项目文件。此外，将在构建树中生成一个 Makefile 的层次结构。合适的 make 程序可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

  • CodeBlocks - Unix Makefiles: 生成 CodeBlocks 项目文件。

    将在顶层目录和每个包含 PROJECT() 调用的 CMakeLists.txt 文件的子目录中创建 CodeBlocks 项目文件。此外，将在构建树中生成一个 Makefile 的层次结构。合适的 make 程序可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

  • Eclipse CDT4 - MinGW Makefiles: 生成 Eclipse CDT 4.0 项目文件。

    将在顶层目录中创建 Eclipse 项目文件，并将链接到每个包含 PROJECT() 调用的 CMakeLists.txt 文件的子目录。此外，将在构建树中生成一个 Makefile 的层次结构。合适的 make 程序可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

  • Eclipse CDT4 - NMake Makefiles: 生成 Eclipse CDT 4.0 项目文件。

    将在顶层目录中创建 Eclipse 项目文件，并将链接到每个包含 PROJECT() 调用的 CMakeLists.txt 文件的子目录。此外，将在构建树中生成一个 Makefile 的层次结构。合适的 make 程序可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

  • Eclipse CDT4 - Unix Makefiles: 生成 Eclipse CDT 4.0 项目文件。

    将在顶层目录中创建 Eclipse 项目文件，并将链接到每个包含 PROJECT() 调用的 CMakeLists.txt 文件的子目录。此外，将在构建树中生成一个 Makefile 的层次结构。合适的 make 程序可以通过默认的 make 目标构建项目。还提供了 "make install" 目标。

命令

  • add_custom_command: 向生成的构建系统添加自定义构建规则。

    add_custom_command 有两个主要签名。第一个签名用于向生成输出的自定义命令添加自定义命令。

      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])

    这定义了一个新的命令，该命令可以在构建过程中执行。命名的输出应列为要为其生成输出的 target 的源文件。如果输出名称是相对路径，它将相对于当前源目录对应的构建树目录进行解释。请注意，MAIN_DEPENDENCY 完全是可选的，它用作 Visual Studio 关于在何处挂钩自定义命令的建议。用 Makefile 术语来说，这将以以下形式创建一个新的 target

      OUTPUT: MAIN_DEPENDENCY DEPENDS
              COMMAND

    如果指定了多个命令，它们将按顺序执行。可选的 ARGS 参数用于向后兼容，将被忽略。

    第二个签名向 target（如库或可执行文件）添加自定义命令。这对于在构建 target 之前或之后执行操作很有用。该命令将成为 target 的一部分，并且仅在构建 target 本身时才会执行。如果 target 已经构建，则命令不会执行。

      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])

    这定义了一个新的命令，该命令将与构建指定的 target 相关联。命令何时发生取决于以下哪些内容被指定

      PRE_BUILD - run before all other dependencies
      PRE_LINK - run after other dependencies
      POST_BUILD - run after the target has been built

    请注意，PRE_BUILD 选项仅在 Visual Studio 7 或更高版本上受支持。对于所有其他生成器，PRE_BUILD 将被视为 PRE_LINK。

    如果指定了 WORKING_DIRECTORY，则将在给定的目录中执行命令。如果设置了 COMMENT，则该值将在构建时命令执行之前显示为消息。如果指定了 APPEND，则 COMMAND 和 DEPENDS 选项值将追加到第一个指定输出的自定义命令中。必须已经对使用相同输出的此命令进行了先前的调用。当给出 APPEND 时，COMMENT、WORKING_DIRECTORY 和 MAIN_DEPENDENCY 选项当前被忽略，但将来可能会使用。

    如果指定了 VERBATIM，那么无论使用何种构建工具，命令的所有参数都将按指定的方式传递。请注意，CMake 语言处理器在 ADD_CUSTOM_TARGET 甚至看到参数之前，仍然会使用一个级别的转义。建议使用 VERBATIM，因为它可以实现正确的行为。当未指定 VERBATIM 时，行为是平台特定的。将来可能会默认启用 VERBATIM。它成为一个选项的唯一原因是为了保持与旧版 CMake 代码的兼容性。

    如果自定义命令的输出实际上不是作为磁盘上的文件创建的，则应使用 SET_SOURCE_FILES_PROPERTIES 将其标记为 SYMBOLIC。

    IMPLICIT_DEPENDS 选项请求扫描输入文件的隐式依赖项。给定的语言指定了应使用其相应的依赖项扫描程序的编程语言。目前仅支持 C 和 CXX 语言扫描程序。在构建时，从扫描中发现的依赖项将添加到自定义命令的依赖项中。请注意，IMPLICIT_DEPENDS 选项目前仅适用于 Makefile 生成器，其他生成器将忽略它。

    如果 COMMAND 指定一个可执行目标（由 ADD_EXECUTABLE 创建），它将自动被构建时创建的可执行文件的位置替换。此外，将添加一个目标级依赖项，以便可执行目标将在使用此自定义命令的任何目标之前构建。但是，这不会添加一个文件级依赖项，该依赖项会导致每次重新编译可执行文件时重新运行自定义命令。

    如果 DEPENDS 指定任何目标（由 ADD_* 命令创建），则将创建一个目标级依赖项，以确保目标在使用此自定义命令的任何目标之前构建。此外，如果目标是可执行文件或库，则将创建一个文件级依赖项，以在每次重新编译目标时重新运行自定义命令。

  • add_custom_target: 添加一个没有输出的目标，因此它将始终构建。
      add_custom_target(Name [ALL] [command1 [args1...]]
                        [COMMAND command2 [args2...] ...]
                        [DEPENDS depend depend depend ... ]
                        [WORKING_DIRECTORY dir]
                        [COMMENT comment] [VERBATIM]
                        [SOURCES src1 [src2...]])

    添加一个具有给定名称的目标，该目标执行给定的命令。目标没有输出文件，并且即使命令尝试创建与目标同名的文件，也始终被视为过时。使用 ADD_CUSTOM_COMMAND 生成具有依赖项的文件。默认情况下，没有任何内容依赖于自定义目标。使用 ADD_DEPENDENCIES 向其他目标添加依赖项或从其他目标添加依赖项。如果指定了 ALL 选项，则表示应将此目标添加到默认构建目标中，以便每次都运行它（命令不能称为 ALL）。命令和参数是可选的，如果未指定，则将创建一个空目标。如果设置了 WORKING_DIRECTORY，则命令将在该目录中运行。如果设置了 COMMENT，则该值将在构建时执行命令之前显示为消息。使用 ADD_CUSTOM_COMMAND 创建的自定义命令的 DEPENDS 参数中列出的依赖项可能引用文件和输出。

    如果指定了 VERBATIM，那么无论使用何种构建工具，命令的所有参数都将按指定的方式传递。请注意，CMake 语言处理器在 add_custom_target 甚至看到参数之前，仍然会使用一个级别的转义。建议使用 VERBATIM，因为它可以实现正确的行为。当未指定 VERBATIM 时，行为是平台特定的。将来可能会默认启用 VERBATIM。它成为一个选项的唯一原因是为了保持与旧版 CMake 代码的兼容性。

    SOURCES 选项指定要包含在自定义目标中的其他源文件。指定的源文件将添加到 IDE 项目文件中，以便于编辑，即使它们没有构建规则。

  • add_definitions: 向源文件的编译添加 -D 定义标志。
      add_definitions(-DFOO -DBAR ...)

    向当前目录及其以下目录中的源代码的编译器命令行添加标志。此命令可用于添加任何标志，但最初的目的是添加预处理器定义。以 -D 或 /D 开头的看起来像预处理器定义的标志会自动添加到当前目录的 COMPILE_DEFINITIONS 属性中。出于向后兼容性的原因，具有非平凡值的定义可能会保留在标志集中，而不是被转换。有关将预处理器定义添加到特定范围和配置的详细信息，请参阅目录、目标和源文件 COMPILE_DEFINITIONS 属性的文档。

  • add_dependencies: 在顶级目标之间添加依赖项。
      add_dependencies(target-name depend-target1
                       depend-target2 ...)

    使顶级目标依赖于其他顶级目标。顶级目标是由 ADD_EXECUTABLE、ADD_LIBRARY 或 ADD_CUSTOM_TARGET 创建的。使用此命令添加依赖项可以确保一个目标在另一个目标之前构建。有关在自定义规则中添加文件级依赖项，请参阅 ADD_CUSTOM_TARGET 和 ADD_CUSTOM_COMMAND 的 DEPENDS 选项。有关向目标文件添加文件级依赖项，请参阅 SET_SOURCE_FILES_PROPERTIES 中的 OBJECT_DEPENDS 选项。

  • add_executable: 使用指定的源文件向项目添加可执行文件。
      add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
                     source1 source2 ... sourceN)

    添加一个名为 <name> 的可执行目标，该目标将从命令调用中列出的源文件构建。<name> 对应于逻辑目标名称，在项目中必须全局唯一。构建的可执行文件的实际文件名是根据本机平台的约定构造的（例如 <name>.exe 或仅 <name>）。

    默认情况下，可执行文件将创建在与调用命令的源树目录相对应的构建树目录中。有关更改此位置的详细信息，请参阅 RUNTIME_OUTPUT_DIRECTORY 目标属性的文档。有关更改最终文件名中 <name> 部分的详细信息，请参阅 OUTPUT_NAME 目标属性的文档。

    如果指定了 WIN32，则属性 WIN32_EXECUTABLE 将设置为创建的目标。有关详细信息，请参阅该目标属性的文档。

    如果指定了 MACOSX_BUNDLE，则相应的属性将设置为创建的目标。有关详细信息，请参阅 MACOSX_BUNDLE 目标属性的文档。

    如果指定了 EXCLUDE_FROM_ALL，则相应的属性将设置为创建的目标。有关详细信息，请参阅 EXCLUDE_FROM_ALL 目标属性的文档。

    add_executable 命令还可以使用以下签名创建导入的可执行目标

      add_executable(<name> IMPORTED)

    导入的可执行目标引用位于项目外部的可执行文件。不会生成用于构建它的规则。目标名称在创建它的目录及其以下目录中具有作用域。它可以像项目中构建的任何目标一样被引用。导入的可执行文件对于从诸如 add_custom_command 之类的命令进行方便引用很有用。有关导入的可执行文件的详细信息，请通过设置名称以 "IMPORTED_" 开头的属性来指定。其中最重要的属性是 IMPORTED_LOCATION（及其每个配置的版本 IMPORTED_LOCATION_<CONFIG>），它指定磁盘上主可执行文件的位置。有关更多信息，请参阅 IMPORTED_* 属性的文档。

  • add_library: 使用指定的源文件向项目添加库。
      add_library(<name> [STATIC | SHARED | MODULE] [EXCLUDE_FROM_ALL]
                  source1 source2 ... sourceN)

    添加一个名为 <name> 的库目标，该目标将从命令调用中列出的源文件构建。<name> 对应于逻辑目标名称，在项目中必须全局唯一。构建的库的实际文件名是根据本机平台的约定构造的（例如 lib<name>.a 或 <name>.lib）。

    STATIC、SHARED 或 MODULE 可以用来指定要创建的库类型。静态库是目标文件档案，用于链接其他目标。共享库是动态链接的，并在运行时加载。模块库是插件，不会链接到其他目标，但可以在运行时使用 dlopen 类功能动态加载。如果未显式给出类型，则类型为 STATIC 或 SHARED，具体取决于变量 BUILD_SHARED_LIBS 的当前值是否为 true。

    默认情况下，库文件将创建在与调用命令的源树目录相对应的构建树目录中。有关更改此位置的详细信息，请参阅 ARCHIVE_OUTPUT_DIRECTORY、LIBRARY_OUTPUT_DIRECTORY 和 RUNTIME_OUTPUT_DIRECTORY 目标属性的文档。有关更改最终文件名中 <name> 部分的详细信息，请参阅 OUTPUT_NAME 目标属性的文档。

    如果指定了 EXCLUDE_FROM_ALL，则相应的属性将设置为创建的目标。有关详细信息，请参阅 EXCLUDE_FROM_ALL 目标属性的文档。

    add_library 命令还可以使用以下签名创建导入的库目标

      add_library(<name> <SHARED|STATIC|MODULE|UNKNOWN> IMPORTED)

    导入的库目标引用位于项目外部的库文件。不会生成用于构建它的规则。目标名称在创建它的目录及其以下目录中具有作用域。它可以像项目中构建的任何目标一样被引用。导入的库对于从诸如 target_link_libraries 之类的命令进行方便引用很有用。有关导入的库的详细信息，请通过设置名称以 "IMPORTED_" 开头的属性来指定。其中最重要的属性是 IMPORTED_LOCATION（及其每个配置的版本 IMPORTED_LOCATION_<CONFIG>），它指定磁盘上主库文件的位置。有关更多信息，请参阅 IMPORTED_* 属性的文档。

  • add_subdirectory: 向构建添加子目录。
      add_subdirectory(source_dir [binary_dir] 
                       [EXCLUDE_FROM_ALL])

    向构建添加子目录。source_dir 指定包含源 CmakeLists.txt 和代码文件的目录。如果它是一个相对路径，它将相对于当前目录（典型用法）进行评估，但它也可以是一个绝对路径。binary_dir 指定放置输出文件的目录。如果它是一个相对路径，它将相对于当前输出目录进行评估，但它也可以是一个绝对路径。如果未指定 binary_dir，则将使用 source_dir 的值，在扩展任何相对路径之前（典型用法）。指定源目录中的 CMakeLists.txt 文件将立即由 CMake 处理，然后再继续处理当前输入文件中的此命令之后的代码。

    如果提供了 EXCLUDE_FROM_ALL 参数，则子目录中的目标默认情况下不会包含在父目录的 ALL 目标中，并且将从 IDE 项目文件中排除。用户必须显式构建子目录中的目标。这旨在用于子目录包含项目的一个独立部分的情况，该部分有用但并非必需，例如一组示例。通常，子目录应包含它自己的 project() 命令调用，以便在子目录中生成一个完整的构建系统（例如 VS IDE 解决方案文件）。请注意，跨目标依赖关系优先于此排除。如果父项目构建的目标依赖于子目录中的目标，则依赖目标将包含在父项目构建系统中以满足依赖关系。

  • add_test: 使用指定的参数向项目添加测试。
      add_test(testname Exename arg1 arg2 ...)

    如果已运行 ENABLE_TESTING 命令，则此命令会向当前目录添加一个测试目标。如果未运行 ENABLE_TESTING，则此命令不执行任何操作。测试由测试子系统通过使用指定的参数执行 Exename 来运行。Exename 可以是此项目构建的可执行文件，也可以是系统上的任意可执行文件（如 tclsh）。测试将以当前工作目录设置为二进制树中对应于 CMakeList.txt 文件的目录来运行。

  • aux_source_directory: 查找目录中的所有源文件。
      aux_source_directory(<dir> <variable>)

    收集指定目录中所有源文件的名称，并将列表存储在提供的 <variable> 中。此命令旨在用于使用显式模板实例化的项目。模板实例化文件可以存储在 "Templates" 子目录中，并使用此命令自动收集，以避免手动列出所有实例化。

    使用此命令来避免编写库或可执行目标的源文件列表，这似乎很诱人。虽然这似乎有效，但 CMake 无法生成一个能够在添加新源文件时感知到的构建系统。通常，生成的构建系统知道何时需要重新运行 CMake，因为 CMakeLists.txt 文件被修改以添加新的源文件。当源文件只是被添加到目录中而没有修改此文件时，就需要手动重新运行 CMake 来生成一个包含新文件的构建系统。

  • break: 从包含的 foreach 或 while 循环中退出。
      break()

    从包含的 foreach 循环或 while 循环中退出

  • build_command: 获取构建此项目的命令行。
      build_command(<variable> <makecommand>)

    将给定的 <variable> 设置为一个字符串，该字符串包含使用 <makecommand> 给定的构建工具从构建树的根目录构建此项目的命令。<makecommand> 应该是 msdev、nmake、make 或其中一个最终用户构建工具。这对于配置测试系统很有用。

  • cmake_minimum_required: 设置项目所需的 CMake 最低版本。
      cmake_minimum_required(VERSION major[.minor[.patch]]
                             [FATAL_ERROR])

    如果当前的 CMake 版本低于所需版本，它将停止处理项目并报告错误。当指定高于 2.4 的版本时，该命令隐式调用

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

    它将 cmake 策略版本级别设置为指定的版本。当给出 2.4 或更低版本时，该命令隐式调用

      cmake_policy(VERSION 2.4)

    它启用了 CMake 2.4 及更低版本的兼容性功能。

    FATAL_ERROR 选项被 CMake 2.6 及更高版本接受但被忽略。它应该被指定，以便 CMake 版本 2.4 及更低版本以错误而不是警告的方式失败。

  • cmake_policy: 管理 CMake 策略设置。

    随着 CMake 的发展，有时需要更改现有行为才能修复错误或改进现有功能的实现。CMake 策略机制旨在帮助保持现有项目在新的 CMake 版本引入行为更改时能够构建。每个新策略（行为更改）都将获得一个格式为“CMP<NNNN>”的标识符，其中“<NNNN>”是一个整数索引。与每个策略相关的文档描述了 OLD 和 NEW 行为以及引入策略的原因。项目可以设置每个策略以选择所需的行为。当 CMake 需要知道要使用哪个行为时，它会检查项目指定的设置。如果未设置，则假定 OLD 行为，并发出警告请求设置策略。

    cmake_policy 命令用于将策略设置为 OLD 或 NEW 行为。虽然支持单独设置策略，但我们鼓励项目根据 CMake 版本设置策略。

      cmake_policy(VERSION major.minor[.patch])

    指定当前 CMake 列表文件是为给定版本的 CMake 编写的。在指定版本或更早版本中引入的所有策略将被设置为使用 NEW 行为。在指定版本之后引入的所有策略将被重置为使用 OLD 行为，并发出警告。这实际上请求在给定 CMake 版本下首选的行为，并告诉更新的 CMake 版本警告其新策略。指定的策略版本必须至少为 2.4，否则命令将报告错误。为了获得支持 2.4 之前版本的兼容性功能，请参阅策略 CMP0001 的文档。

      cmake_policy(SET CMP<NNNN> NEW)
      cmake_policy(SET CMP<NNNN> OLD)

    告诉 CMake 对给定策略使用 OLD 或 NEW 行为。依赖于给定策略的旧行为的项目可以通过将策略状态设置为 OLD 来静默策略警告。或者，可以修复项目以使用新行为并将策略状态设置为 NEW。

      cmake_policy(GET CMP<NNNN> <variable>)

    检查给定策略是否设置为 OLD 或 NEW 行为。如果设置了策略，输出变量值将为“OLD”或“NEW”，否则为空。

    CMake 在堆栈上保留策略设置，因此 cmake_policy 命令所做的更改仅影响堆栈的顶部。每个子目录都将自动管理策略堆栈上的新条目，以保护其父级和兄弟级。CMake 还为由 include() 和 find_package() 命令加载的脚本管理新条目，除非在使用 NO_POLICY_SCOPE 选项调用时（另请参阅策略 CMP0011）。cmake_policy 命令提供了一个接口来管理策略堆栈上的自定义条目

      cmake_policy(PUSH)
      cmake_policy(POP)

    每个 PUSH 必须有一个匹配的 POP 来擦除任何更改。这对于对策略设置进行临时更改很有用。

    函数和宏在创建时记录策略设置，并在调用时使用预记录的策略。如果函数或宏实现设置策略，则更改将自动向上传播到调用者，直到它们到达最近的嵌套策略堆栈条目。

  • configure_file: 将文件复制到另一个位置并修改其内容。
      configure_file(InputFile OutputFile
                     [COPYONLY] [ESCAPE_QUOTES] [@ONLY])

    输入和输出文件必须具有完整路径。此命令将输入文件中引用为 ${VAR} 或 @VAR@ 的所有变量替换为 CMake 确定的其值。如果未定义变量，它将被替换为空。如果指定了 COPYONLY，则不会执行任何变量扩展。如果指定了 ESCAPE_QUOTES，则任何替换的引号都将被 C 样式转义。文件将使用 CMake 变量的当前值进行配置。如果指定了 @ONLY，则只有 @VAR@ 形式的变量会被替换，而 ${VAR} 将被忽略。这对于配置使用 ${VAR} 的脚本很有用。任何 #cmakedefine VAR 的出现都将被替换为 #define VAR 或 /* #undef VAR */，具体取决于 VAR 在 CMake 中的设置

  • 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*[]);）。DriverName 将能够通过命令行按名称调用每个测试。如果指定了 EXTRA_INCLUDE，则下一个参数将被包含在生成的文件中。如果指定了 FUNCTION，则下一个参数将被视为传递给 ac 和 av 指针的函数名称。这可以用来为每个测试添加额外的命令行处理。cmake 变量 CMAKE_TESTDRIVER_BEFORE_TESTMAIN 可以设置为包含将在调用测试主函数之前直接放置的代码。CMAKE_TESTDRIVER_AFTER_TESTMAIN 可以设置为包含将在调用测试主函数之后直接放置的代码。

  • define_property: 定义和记录自定义属性。
      define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE |
                       TEST | VARIABLE | CACHED_VARIABLE>
                       PROPERTY <name> [INHERITED]
                       BRIEF_DOCS <brief-doc>
                       FULL_DOCS <full-doc>)

    在范围内定义一个属性，供 set_property 和 get_property 命令使用。这主要用于将文档与可能使用 get_property 命令检索的属性名称相关联。第一个参数确定属性应该使用的范围类型。它必须是以下之一

      GLOBAL    = associated with the global namespace
      DIRECTORY = associated with one directory
      TARGET    = associated with one target
      SOURCE    = associated with one source file
      TEST      = associated with a test named with add_test command
      VARIABLE  = documents a CMake language variable
      CACHED_VARIABLE = documents a CMake cache variable

    请注意，与 set_property 和 get_property 不同，不需要给出实际范围；只有范围类型很重要。

    必需的 PROPERTY 选项紧随其后是正在定义的属性的名称。

    如果随后使用 INHERITED 选项，则当请求的属性未在给定给命令的范围内设置时，get_property 命令将向上链接到下一个更高的范围。DIRECTORY 范围链接到 GLOBAL。TARGET、SOURCE 和 TEST 链接到 DIRECTORY。

    BRIEF_DOCS 和 FULL_DOCS 选项紧随其后是与属性关联的字符串，作为其简要和完整文档。get_property 命令的相应选项将检索文档。

  • else: 开始 if 块的 else 部分。
      else(expression)

    请参阅 if 命令。

  • elseif: 开始 if 块的 elseif 部分。
      elseif(expression)

    请参阅 if 命令。

  • enable_language: 启用语言（CXX/C/Fortran 等）
      enable_language(languageName [OPTIONAL] )

    此命令在 CMake 中启用对命名语言的支持。这与 project 命令相同，但不会创建 project 命令创建的任何额外变量。示例语言包括 CXX、C、Fortran。

    如果使用 OPTIONAL，则使用 CMAKE_<languageName>_COMPILER_WORKS 变量来检查语言是否已成功启用。

  • enable_testing: 为当前目录及其以下启用测试。
      enable_testing()

    为当前目录及其以下启用测试。另请参阅 add_test 命令。请注意，ctest 预计在构建目录根目录中找到测试文件。因此，此命令应该位于源目录根目录中。

  • endforeach: 结束 FOREACH 块中的命令列表。
      endforeach(expression)

    请参阅 FOREACH 命令。

  • endfunction: 结束函数块中的命令列表。
      endfunction(expression)

    请参阅 function 命令。

  • endif: 结束 if 块中的命令列表。
      endif(expression)

    请参阅 if 命令。

  • endmacro: 结束宏块中的命令列表。
      endmacro(expression)

    请参阅 macro 命令。

  • endwhile: 结束 while 块中的命令列表。
      endwhile(expression)

    请参阅 while 命令。

  • execute_process: 执行一个或多个子进程。
      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 进程本身的相应管道共享。

    execute_process 命令是 exec_program 的一个更新、更强大的版本，但保留了旧命令以实现兼容性。

  • export: 从构建树中导出目标，以便外部项目使用。
      export(TARGETS [target1 [target2 [...]]] [NAMESPACE <namespace>]
             [APPEND] FILE <filename>)

    创建一个 <filename> 文件，外部项目可以将其包含进来，以从当前项目的构建树中导入目标。这在交叉编译期间很有用，可以构建在主机平台上运行的实用程序可执行文件，然后将其导入正在为目标平台编译的另一个项目中。如果给定了 NAMESPACE 选项，则 <namespace> 字符串将被附加到写入文件的所有目标名称之前。如果给定了 APPEND 选项，则生成的代码将被追加到文件而不是覆盖它。如果在导出中包含了一个库目标，但未包含链接到的目标，则行为未指定。

    此命令创建的文件特定于构建树，永远不应该被安装。请参阅 install(EXPORT) 命令，从安装树中导出目标。

  • 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(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])

    WRITE 会将消息写入名为“filename”的文件。如果文件已存在，它将覆盖该文件，如果文件不存在，它将创建该文件。

    APPEND 会像 WRITE 一样将消息写入文件，只是它会将消息追加到文件的末尾。

    READ 会读取文件的内容并将其存储到变量中。它将从给定的偏移量开始读取，最多读取 numBytes 字节。如果给出了 HEX 参数，则二进制数据将被转换为十六进制表示形式，并将存储在变量中。

    STRINGS 将从文件解析 ASCII 字符串列表并将其存储到变量中。忽略文件中的二进制数据。忽略回车符 (CR)。它也适用于 Intel Hex 和 Motorola S-record 文件，这些文件在读取时会自动转换为二进制格式。使用 NO_HEX_CONVERSION 禁用此功能。

    LIMIT_COUNT 设置要返回的最大字符串数。LIMIT_INPUT 设置从输入文件读取的最大字节数。LIMIT_OUTPUT 设置要存储到输出变量中的最大字节数。LENGTH_MINIMUM 设置要返回的字符串的最小长度。忽略较短的字符串。LENGTH_MAXIMUM 设置要返回的字符串的最大长度。较长的字符串将被拆分为长度不超过最大长度的字符串。NEWLINE_CONSUME 允许将换行符包含在字符串中，而不是用换行符终止它们。

    REGEX 指定字符串必须匹配才能返回的正则表达式。典型用法

      file(STRINGS myfile.txt myfile)

    将列表存储在变量“myfile”中，其中每个项目都是输入文件的一行。

    GLOB 将生成与通配符表达式匹配的所有文件的列表，并将其存储到变量中。通配符表达式类似于正则表达式，但更简单。如果为表达式指定了 RELATIVE 标志，则结果将作为相对于给定路径的相对路径返回。

    通配符表达式的示例包括

       *.cxx      - match all files with extension cxx
       *.vt?      - match all files with extension vta,...,vtz
       f[3-5].txt - match files f3.txt, f4.txt, f5.txt

    GLOB_RECURSE 将生成与常规 GLOB 类似的列表，只是它将遍历匹配目录的所有子目录并匹配文件。只有在给出 FOLLOW_SYMLINKS 或 cmake 策略 CMP0009 未设置为 NEW 时，才会遍历作为符号链接的子目录。有关更多信息，请参见 cmake --help-policy CMP0009。

    递归通配符的示例包括

       /dir/*.py  - match all python files in /dir and subdirectories

    MAKE_DIRECTORY 将创建给定的目录，即使它们的父目录尚不存在。

    REMOVE 将删除给定的文件，也包括子目录中的文件。

    REMOVE_RECURSE 将删除给定的文件和目录，也包括非空目录。

    RELATIVE_PATH 将确定从目录到给定文件的相对路径。

    TO_CMAKE_PATH 将路径转换为具有 unix /. 的 cmake 风格路径。输入可以是单个路径或系统路径，如 "$ENV{PATH}"。请注意，ENV 调用周围的双引号 TO_CMAKE_PATH 仅接受一个参数。

    TO_NATIVE_PATH 的工作原理与 TO_CMAKE_PATH 相同，但会将 cmake 风格路径转换为本机路径风格 \（适用于 Windows）和 /（适用于 UNIX）。

    DOWNLOAD 会将给定的 URL 下载到给定的文件。如果指定了 LOG var，则下载日志将放在 var 中。如果指定了 STATUS var，则操作状态将放在 var 中。状态以长度为 2 的列表返回。第一个元素是操作的数字返回值，第二个元素是错误的字符串值。数字错误 0 表示操作没有错误。如果指定了 TIMEOUT time，则操作将在 time 秒后超时，time 可以指定为浮点数。

  • find_file: 查找文件的完整路径。
       find_path(<VAR> name1 [path1 path2 ...])

    这是命令的简写签名，在许多情况下已经足够了。它与 find_path(<VAR> name1 [PATHS 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]
                )

    此命令用于查找名为文件的完整路径。将创建名为 <VAR> 的缓存条目来存储此命令的结果。如果找到文件的完整路径，结果将存储在变量中，并且除非清除变量，否则不会重复搜索。如果什么也没找到，结果将是 <VAR>-NOTFOUND，并且下次调用 find_path 时，如果使用相同的变量，将再次尝试搜索。要搜索的完整路径的文件名由 NAMES 参数之后列出的名称指定。可以在 PATHS 参数之后指定其他搜索位置。如果在 HINTS 或 PATHS 部分中找到 ENV var，则将读取环境变量 var 并将其从系统环境变量转换为 cmake 风格的路径列表。例如，ENV PATH 将是列出系统路径变量的一种方式。DOC 之后的参数将用于缓存中的文档字符串。PATH_SUFFIXES 指定要检查每个搜索路径下方的其他子目录。

    如果指定了 NO_DEFAULT_PATH，则不会将任何其他路径添加到搜索中。如果没有指定 NO_DEFAULT_PATH，则搜索过程如下

    1. 搜索在 cmake 特定缓存变量中指定的路径。这些旨在通过命令行使用 -DVAR=value 来使用。如果传递了 NO_CMAKE_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜索在 cmake 特定环境变量中指定的路径。这些旨在设置在用户的 shell 配置中。如果传递了 NO_CMAKE_ENVIRONMENT_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜索 HINTS 选项指定的路径。这些应该是由系统自省计算的路径，例如由已找到的另一个项目的路径提供的提示。硬编码猜测应该使用 PATHS 选项指定。

    4. 搜索标准系统环境变量。如果 NO_SYSTEM_ENVIRONMENT_PATH 是参数，则可以跳过此步骤。

       PATH
       INCLUDE

    5. 搜索在当前系统的 Platform 文件中定义的 cmake 变量。如果传递了 NO_CMAKE_SYSTEM_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_INCLUDE_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜索 PATHS 选项或命令的简写版本中指定的路径。这些通常是硬编码猜测。

    在 Darwin 或支持 OS X Frameworks 的系统上，cmake 变量 CMAKE_FIND_FRAMEWORK 可以设置为 empty 或以下之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支持 OS X Application Bundles 的系统上，cmake 变量 CMAKE_FIND_APPBUNDLE 可以设置为 empty 或以下之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 变量 CMAKE_FIND_ROOT_PATH 指定一个或多个目录，这些目录将附加到所有其他搜索目录的前面。这实际上是在给定位置下“重新根目录”整个搜索。默认情况下，它是空的。在交叉编译时，它尤其有用，用于指向目标环境的根目录，并且 CMake 也将在那里进行搜索。默认情况下，首先搜索 CMAKE_FIND_ROOT_PATH 中列出的目录，然后搜索非根目录。可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_INCLUDE 来调整默认行为。此行为可以在每个调用基础上手动覆盖。通过使用 CMAKE_FIND_ROOT_PATH_BOTH，搜索顺序将如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，则不会使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，则只搜索重新根目录的目录。

    默认搜索顺序旨在针对常见用例最具体到最不具体。项目可以通过简单地多次调用命令并使用 NO_* 选项来覆盖顺序

       find_path(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
       find_path(<VAR> NAMES name)

    一旦其中一个调用成功，结果变量将被设置并存储在缓存中，以便不会有任何调用再次搜索。

  • find_library: 查找库。
       find_library(<VAR> name1 [path1 path2 ...])

    这是命令的简写签名，在许多情况下已经足够了。它与 find_library(<VAR> name1 [PATHS 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]
                )

    此命令用于查找库。将创建名为 <VAR> 的缓存条目来存储此命令的结果。如果找到库，结果将存储在变量中，并且除非清除变量，否则不会重复搜索。如果什么也没找到，结果将是 <VAR>-NOTFOUND，并且下次调用 find_library 时，如果使用相同的变量，将再次尝试搜索。要搜索的库的名称由 NAMES 参数之后列出的名称指定。可以在 PATHS 参数之后指定其他搜索位置。如果在 HINTS 或 PATHS 部分中找到 ENV var，则将读取环境变量 var 并将其从系统环境变量转换为 cmake 风格的路径列表。例如，ENV PATH 将是列出系统路径变量的一种方式。DOC 之后的参数将用于缓存中的文档字符串。PATH_SUFFIXES 指定要检查每个搜索路径下方的其他子目录。

    如果指定了 NO_DEFAULT_PATH，则不会将任何其他路径添加到搜索中。如果没有指定 NO_DEFAULT_PATH，则搜索过程如下

    1. 搜索在 cmake 特定缓存变量中指定的路径。这些旨在通过命令行使用 -DVAR=value 来使用。如果传递了 NO_CMAKE_PATH，则可以跳过此步骤。

       <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_LIBRARY_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜索在 cmake 特定环境变量中指定的路径。这些旨在设置在用户的 shell 配置中。如果传递了 NO_CMAKE_ENVIRONMENT_PATH，则可以跳过此步骤。

       <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_LIBRARY_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜索 HINTS 选项指定的路径。这些应该是由系统自省计算的路径，例如由已找到的另一个项目的路径提供的提示。硬编码猜测应该使用 PATHS 选项指定。

    4. 搜索标准系统环境变量。如果 NO_SYSTEM_ENVIRONMENT_PATH 是参数，则可以跳过此步骤。

       PATH
       LIB

    5. 搜索在当前系统的 Platform 文件中定义的 cmake 变量。如果传递了 NO_CMAKE_SYSTEM_PATH，则可以跳过此步骤。

       <prefix>/lib for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_LIBRARY_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜索 PATHS 选项或命令的简写版本中指定的路径。这些通常是硬编码猜测。

    在 Darwin 或支持 OS X Frameworks 的系统上，cmake 变量 CMAKE_FIND_FRAMEWORK 可以设置为 empty 或以下之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支持 OS X Application Bundles 的系统上，cmake 变量 CMAKE_FIND_APPBUNDLE 可以设置为 empty 或以下之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 变量 CMAKE_FIND_ROOT_PATH 指定一个或多个目录，这些目录将附加到所有其他搜索目录的前面。这实际上是在给定位置下“重新根目录”整个搜索。默认情况下，它是空的。在交叉编译时，它尤其有用，用于指向目标环境的根目录，并且 CMake 也将在那里进行搜索。默认情况下，首先搜索 CMAKE_FIND_ROOT_PATH 中列出的目录，然后搜索非根目录。可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_LIBRARY 来调整默认行为。此行为可以在每个调用基础上手动覆盖。通过使用 CMAKE_FIND_ROOT_PATH_BOTH，搜索顺序将如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，则不会使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，则只搜索重新根目录的目录。

    默认搜索顺序旨在针对常见用例最具体到最不具体。项目可以通过简单地多次调用命令并使用 NO_* 选项来覆盖顺序

       find_library(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
       find_library(<VAR> NAMES name)

    一旦其中一个调用成功，结果变量将被设置并存储在缓存中，以便不会有任何调用再次搜索。

    如果找到的库是框架，则 VAR 将设置为框架的完整路径 <fullPath>/A.framework。当使用框架的完整路径作为库时，CMake 将使用 -framework A 和 -F<fullPath> 将框架链接到目标。

  • find_package: 加载外部项目的设置。
      find_package(<package> [version] [EXACT] [QUIET]
                   [[REQUIRED|COMPONENTS] [components...]]
                   [NO_POLICY_SCOPE])

    从外部项目中查找并加载设置。<package>_FOUND 将被设置为指示包是否被找到。当包被找到时，包特定的信息将通过包本身记录的变量提供。QUIET 选项在找不到包时禁用消息。REQUIRED 选项在找不到包时停止处理并显示错误消息。包特定的组件列表可以列在 REQUIRED 选项之后，或者在没有 REQUIRED 选项的情况下列在 COMPONENTS 选项之后。[version] 参数请求一个与找到的包兼容的版本（格式为 major[.minor[.patch[.tweak]]]）。EXACT 选项请求精确匹配版本。如果在 find-module 内部的递归调用中没有给出 [version]，则 [version] 和 EXACT 参数会自动从外部调用转发。版本支持目前仅在每个包的基础上提供（详细信息见下文）。

    用户代码通常应该使用上述简单签名来查找包。本命令文档的其余部分指定了完整的命令签名和搜索过程的详细信息。希望提供一个可以通过此命令找到的包的项目维护者，建议继续阅读。

    该命令有两种搜索包的模式：“模块”模式和“配置”模式。当使用上述简化签名调用命令时，模块模式可用。CMake 在 CMAKE_MODULE_PATH 后面跟着 CMake 安装路径搜索名为“Find<package>.cmake”的文件。如果找到该文件，CMake 会读取并处理它。它负责查找包、检查版本并生成任何必要的消息。许多 find-module 提供有限的或没有版本支持；请检查模块文档。如果找不到模块，命令将继续执行配置模式。

    完整的配置模式命令签名是

      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_BUILDS_PATH]
                   [NO_CMAKE_SYSTEM_PATH]
                   [CMAKE_FIND_ROOT_PATH_BOTH |
                    ONLY_CMAKE_FIND_ROOT_PATH |
                    NO_CMAKE_FIND_ROOT_PATH])

    NO_MODULE 选项可用于显式跳过模块模式。它也隐含在使用简化签名中未指定的选项时。

    配置模式尝试定位由要查找的包提供的配置文件。将创建一个名为 <package>_DIR 的缓存条目，用于保存包含该文件的目录。默认情况下，命令搜索名为 <package> 的包。如果给出 NAMES 选项，则使用其后的名称而不是 <package>。命令搜索每个指定名称的“<name>Config.cmake”或“<lower-case-name>-config.cmake”文件。可以使用 CONFIGS 选项给出可能的配置文件名称的替代集。搜索过程在下面指定。找到后，配置文件将由 CMake 读取和处理。由于该文件由包提供，因此它已经知道包内容的位置。配置文件的完整路径存储在 cmake 变量 <package>_CONFIG 中。

    如果找不到包配置文件，CMake 将生成一条描述问题的错误消息，除非指定了 QUIET 参数。如果指定了 REQUIRED 且找不到包，将生成致命错误，并且配置步骤将停止执行。如果 <package>_DIR 已被设置为一个不包含配置文件的目录，CMake 将忽略它并从头开始搜索。

    当给出 [version] 参数时，配置模式将仅查找声明与请求的版本兼容的包版本（格式为 major[.minor[.patch[.tweak]]]）。如果给出 EXACT 选项，则仅能找到声明与请求的版本完全匹配的包版本。CMake 没有为版本号的含义建立任何约定。包版本号由包本身提供的“版本”文件进行检查。对于候选包配置文件“<config-file>.cmake”，相应的版本文件位于它旁边，并命名为“<config-file>-version.cmake”或“<config-file>Version.cmake”。如果没有这样的版本文件，则认为配置文件与任何请求的版本都不兼容。当找到版本文件时，将加载它以检查请求的版本号。版本文件在嵌套作用域中加载，其中定义了以下变量

      PACKAGE_FIND_NAME          = the <package> name
      PACKAGE_FIND_VERSION       = full requested version string
      PACKAGE_FIND_VERSION_MAJOR = major version if requested, else 0
      PACKAGE_FIND_VERSION_MINOR = minor version if requested, else 0
      PACKAGE_FIND_VERSION_PATCH = patch version if requested, else 0
      PACKAGE_FIND_VERSION_TWEAK = tweak version if requested, else 0
      PACKAGE_FIND_VERSION_COUNT = number of version components, 0 to 4

    版本文件检查它是否满足请求的版本，并设置这些变量

      PACKAGE_VERSION            = full provided version string
      PACKAGE_VERSION_EXACT      = true if version is exact match
      PACKAGE_VERSION_COMPATIBLE = true if version is compatible
      PACKAGE_VERSION_UNSUITABLE = true if unsuitable as any version

    find_package 命令检查这些变量以确定配置文件是否提供可接受的版本。在 find_package 调用返回后，它们不可用。如果版本可接受，则将设置以下变量

      <package>_VERSION       = full provided version string
      <package>_VERSION_MAJOR = major version if provided, else 0
      <package>_VERSION_MINOR = minor version if provided, else 0
      <package>_VERSION_PATCH = patch version if provided, else 0
      <package>_VERSION_TWEAK = tweak version if provided, else 0
      <package>_VERSION_COUNT = number of version components, 0 to 4

    并加载相应的包配置文件。当多个包配置文件的版本文件声明与请求的版本兼容时，选择哪一个是不确定的。不会尝试选择最高或最接近的版本号。

    配置模式提供了详细的界面和搜索过程。大部分界面是为了完整性和由模块模式加载的 find-module 在内部使用而提供的。大多数用户代码应该简单地调用

      find_package(<package> [major[.minor]] [EXACT] [REQUIRED|QUIET])

    以找到一个包。提供 CMake 包配置文件的包维护者建议对它们进行命名和安装，以便下面的过程可以找到它们，而无需使用其他选项。

    CMake 为包构建了一组可能的安装前缀。在每个前缀下，都会搜索几个目录以查找配置文件。下表显示了搜索的目录。每个条目都是为遵循 Windows (W)、UNIX (U) 或 Apple (A) 约定的安装树而设计的。

      <prefix>/                                               (W)
      <prefix>/(cmake|CMake)/                                 (W)
      <prefix>/<name>*/                                       (W)
      <prefix>/<name>*/(cmake|CMake)/                         (W)
      <prefix>/(share|lib)/cmake/<name>*/                     (U)
      <prefix>/(share|lib)/<name>*/                           (U)
      <prefix>/(share|lib)/<name>*/(cmake|CMake)/             (U)

    在支持 OS X 框架和应用程序包的系统上，将搜索以下目录以查找包含配置文件的框架或包

      <prefix>/<name>.framework/Resources/                    (A)
      <prefix>/<name>.framework/Resources/CMake/              (A)
      <prefix>/<name>.framework/Versions/*/Resources/         (A)
      <prefix>/<name>.framework/Versions/*/Resources/CMake/   (A)
      <prefix>/<name>.app/Contents/Resources/                 (A)
      <prefix>/<name>.app/Contents/Resources/CMake/           (A)

    在所有情况下，<name> 都被视为不区分大小写，并且对应于任何指定的名称（<package> 或 NAMES 给出的名称）。如果指定了 PATH_SUFFIXES，则将一个接一个地将后缀附加到每个 (W) 或 (U) 目录条目。

    这组目录旨在与在安装树中提供配置文件的项目协同工作。上面标记为 (W) 的目录用于在 Windows 上安装，其中前缀可以指向应用程序安装目录的顶部。那些标记为 (U) 的目录用于在 UNIX 平台上安装，其中前缀由多个包共享。这只是一个约定，因此所有 (W) 和 (U) 目录仍在所有平台上搜索。标记为 (A) 的目录用于在 Apple 平台上安装。cmake 变量 CMAKE_FIND_FRAMEWORK 和 CMAKE_FIND_APPBUNDLE 确定如下所述的优先级顺序。

    使用以下步骤构建安装前缀集。如果指定了 NO_DEFAULT_PATH，则所有 NO_* 选项都将被启用。

    1. 搜索在 cmake 特定缓存变量中指定的路径。这些旨在通过命令行使用 -DVAR=value 来使用。如果传递了 NO_CMAKE_PATH，则可以跳过此步骤。

       CMAKE_PREFIX_PATH
       CMAKE_FRAMEWORK_PATH
       CMAKE_APPBUNDLE_PATH

    2. 搜索在 cmake 特定环境变量中指定的路径。这些旨在设置在用户的 shell 配置中。如果传递了 NO_CMAKE_ENVIRONMENT_PATH，则可以跳过此步骤。

       CMAKE_PREFIX_PATH
       CMAKE_FRAMEWORK_PATH
       CMAKE_APPBUNDLE_PATH

    3. 搜索由 HINTS 选项指定的路径。这些应该是通过系统自省计算出的路径，例如由已找到的其他项目的位置提供的提示。硬编码的猜测应该用 PATHS 选项指定。

    4. 搜索标准系统环境变量。如果传递了 NO_SYSTEM_ENVIRONMENT_PATH，则可以跳过此步骤。以“/bin”或“/sbin”结尾的路径条目会自动转换为其父目录。

       PATH

    5. 搜索最近在 CMake GUI 中配置的项目构建树。如果传递了 NO_CMAKE_BUILDS_PATH，则可以跳过此步骤。它适用于用户连续构建多个依赖项目的情况。

    6. 搜索在当前系统的平台文件中定义的 cmake 变量。如果传递了 NO_CMAKE_SYSTEM_PATH，则可以跳过此步骤。

       CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH
       CMAKE_SYSTEM_APPBUNDLE_PATH

    7. 搜索由 PATHS 选项指定的路径。这些通常是硬编码的猜测。

    在 Darwin 或支持 OS X Frameworks 的系统上，cmake 变量 CMAKE_FIND_FRAMEWORK 可以设置为 empty 或以下之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支持 OS X Application Bundles 的系统上，cmake 变量 CMAKE_FIND_APPBUNDLE 可以设置为 empty 或以下之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 变量 CMAKE_FIND_ROOT_PATH 指定一个或多个目录，这些目录将被预先添加到所有其他搜索目录。这实际上将整个搜索“重新根植”在给定的位置。默认情况下，它为空。在交叉编译时，它特别有用，指向目标环境的根目录，CMake 也会在那里搜索。默认情况下，首先搜索 CMAKE_FIND_ROOT_PATH 中列出的目录，然后搜索非根目录。默认行为可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_PACKAGE 来调整。这种行为可以在每个调用基础上手动覆盖。通过使用 CMAKE_FIND_ROOT_PATH_BOTH，搜索顺序将如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，则不会使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，则只搜索重新根植的目录。

    默认搜索顺序旨在针对常见用例最具体到最不具体。项目可以通过简单地多次调用命令并使用 NO_* 选项来覆盖顺序

       find_package(<package> PATHS paths... NO_DEFAULT_PATH)
       find_package(<package>)

    一旦其中一个调用成功，结果变量将被设置并存储在缓存中，以便不会有任何调用再次搜索。

    有关 NO_POLICY_SCOPE 选项的讨论，请参阅 cmake_policy() 命令文档。

  • find_path: 查找包含文件的目录。
       find_path(<VAR> name1 [path1 path2 ...])

    这是命令的简写签名，在许多情况下已经足够了。它与 find_path(<VAR> name1 [PATHS 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]
                )

    此命令用于查找包含命名文件的目录。将创建一个名为 <VAR> 的缓存条目来存储此命令的结果。如果在目录中找到了文件，则结果将存储在变量中，并且除非清除变量，否则不会重复搜索。如果什么也没找到，则结果将是 <VAR>-NOTFOUND，并且下次使用相同变量调用 find_path 时，将再次尝试搜索。在目录中搜索的文件的名称由 NAMES 参数之后列出的名称指定。可以在 PATHS 参数之后指定其他搜索位置。如果在 HINTS 或 PATHS 部分找到了 ENV var，则会读取环境变量 var 并将其从系统环境变量转换为 cmake 风格的路径列表。例如，ENV PATH 将是列出系统路径变量的一种方式。DOC 后的参数将用于缓存中的文档字符串。PATH_SUFFIXES 指定要检查的每个搜索路径下的其他子目录。

    如果指定了 NO_DEFAULT_PATH，则不会将任何其他路径添加到搜索中。如果没有指定 NO_DEFAULT_PATH，则搜索过程如下

    1. 搜索在 cmake 特定缓存变量中指定的路径。这些旨在通过命令行使用 -DVAR=value 来使用。如果传递了 NO_CMAKE_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜索在 cmake 特定环境变量中指定的路径。这些旨在设置在用户的 shell 配置中。如果传递了 NO_CMAKE_ENVIRONMENT_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜索 HINTS 选项指定的路径。这些应该是由系统自省计算的路径，例如由已找到的另一个项目的路径提供的提示。硬编码猜测应该使用 PATHS 选项指定。

    4. 搜索标准系统环境变量。如果 NO_SYSTEM_ENVIRONMENT_PATH 是参数，则可以跳过此步骤。

       PATH
       INCLUDE

    5. 搜索在当前系统的 Platform 文件中定义的 cmake 变量。如果传递了 NO_CMAKE_SYSTEM_PATH，则可以跳过此步骤。

       <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_INCLUDE_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜索 PATHS 选项或命令的简写版本中指定的路径。这些通常是硬编码猜测。

    在 Darwin 或支持 OS X Frameworks 的系统上，cmake 变量 CMAKE_FIND_FRAMEWORK 可以设置为 empty 或以下之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支持 OS X Application Bundles 的系统上，cmake 变量 CMAKE_FIND_APPBUNDLE 可以设置为 empty 或以下之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 变量 CMAKE_FIND_ROOT_PATH 指定一个或多个目录，这些目录将附加到所有其他搜索目录的前面。这实际上是在给定位置下“重新根目录”整个搜索。默认情况下，它是空的。在交叉编译时，它尤其有用，用于指向目标环境的根目录，并且 CMake 也将在那里进行搜索。默认情况下，首先搜索 CMAKE_FIND_ROOT_PATH 中列出的目录，然后搜索非根目录。可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_INCLUDE 来调整默认行为。此行为可以在每个调用基础上手动覆盖。通过使用 CMAKE_FIND_ROOT_PATH_BOTH，搜索顺序将如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，则不会使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，则只搜索重新根目录的目录。

    默认搜索顺序旨在针对常见用例最具体到最不具体。项目可以通过简单地多次调用命令并使用 NO_* 选项来覆盖顺序

       find_path(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
       find_path(<VAR> NAMES name)

    一旦其中一个调用成功，结果变量将被设置并存储在缓存中，以便不会有任何调用再次搜索。

    在搜索框架时，如果将文件指定为 A/b.h，则框架搜索将查找 A.framework/Headers/b.h。如果找到，则路径将设置为框架的路径。CMake 将将其转换为正确的 -F 选项以包含该文件。

  • find_program: 查找可执行程序。
       find_program(<VAR> name1 [path1 path2 ...])

    这是命令的简写签名，在许多情况下已经足够了。它与 find_program(<VAR> name1 [PATHS 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]
                )

    此命令用于查找程序。会创建一个名为<VAR>的缓存条目来存储此命令的结果。如果找到程序，结果将存储在变量中，并且除非清除该变量，否则不会重复搜索。如果什么也没找到，结果将为<VAR>-NOTFOUND，并且下次使用相同的变量调用find_program时将再次尝试搜索。要搜索的程序名称由 NAMES 参数后列出的名称指定。可以在 PATHS 参数后指定其他搜索位置。如果在 HINTS 或 PATHS 部分中找到 ENV 变量，则会读取环境变量 var，并将其从系统环境变量转换为 cmake 样式的路径列表。例如，ENV PATH 将是列出系统路径变量的一种方式。DOC 后面的参数将用于缓存中的文档字符串。PATH_SUFFIXES 指定要在每个搜索路径下检查的其他子目录。

    如果指定了 NO_DEFAULT_PATH，则不会将任何其他路径添加到搜索中。如果没有指定 NO_DEFAULT_PATH，则搜索过程如下

    1. 搜索在 cmake 特定缓存变量中指定的路径。这些旨在通过命令行使用 -DVAR=value 来使用。如果传递了 NO_CMAKE_PATH，则可以跳过此步骤。

       <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_PROGRAM_PATH
       CMAKE_APPBUNDLE_PATH

    2. 搜索在 cmake 特定环境变量中指定的路径。这些旨在设置在用户的 shell 配置中。如果传递了 NO_CMAKE_ENVIRONMENT_PATH，则可以跳过此步骤。

       <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_PROGRAM_PATH
       CMAKE_APPBUNDLE_PATH

    3. 搜索 HINTS 选项指定的路径。这些应该是由系统自省计算的路径，例如由已找到的另一个项目的路径提供的提示。硬编码猜测应该使用 PATHS 选项指定。

    4. 搜索标准系统环境变量。如果 NO_SYSTEM_ENVIRONMENT_PATH 是参数，则可以跳过此步骤。

       PATH

    5. 搜索在当前系统的 Platform 文件中定义的 cmake 变量。如果传递了 NO_CMAKE_SYSTEM_PATH，则可以跳过此步骤。

       <prefix>/[s]bin for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_PROGRAM_PATH
       CMAKE_SYSTEM_APPBUNDLE_PATH

    6. 搜索 PATHS 选项或命令的简写版本中指定的路径。这些通常是硬编码猜测。

    在 Darwin 或支持 OS X Frameworks 的系统上，cmake 变量 CMAKE_FIND_FRAMEWORK 可以设置为 empty 或以下之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支持 OS X Application Bundles 的系统上，cmake 变量 CMAKE_FIND_APPBUNDLE 可以设置为 empty 或以下之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 变量 CMAKE_FIND_ROOT_PATH 指定一个或多个目录，这些目录将被附加到所有其他搜索目录之前。这实际上是在给定位置“重新定位”整个搜索。默认情况下它为空。它在交叉编译时尤其有用，用于指向目标环境的根目录，CMake 也将在那里进行搜索。默认情况下，首先搜索 CMAKE_FIND_ROOT_PATH 中列出的目录，然后搜索非根目录。默认行为可以通过设置 CMAKE_FIND_ROOT_PATH_MODE_PROGRAM 来调整。此行为可以在每次调用的基础上手动覆盖。通过使用 CMAKE_FIND_ROOT_PATH_BOTH，搜索顺序将如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，则不会使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，则只搜索重新定位的目录。

    默认搜索顺序旨在针对常见用例最具体到最不具体。项目可以通过简单地多次调用命令并使用 NO_* 选项来覆盖顺序

       find_program(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
       find_program(<VAR> NAMES name)

    一旦其中一个调用成功，结果变量将被设置并存储在缓存中，以便不会有任何调用再次搜索。

  • fltk_wrap_ui: 创建 FLTK 用户界面包装器。
      fltk_wrap_ui(resultingLibraryName source1
                   source2 ... sourceN )

    为列出的所有 .fl 和 .fld 文件生成 .h 和 .cxx 文件。生成的 .h 和 .cxx 文件将被添加到名为 resultingLibraryName_FLTK_UI_SRCS 的变量中，该变量应该添加到您的库中。

  • foreach: 为列表中的每个值评估一组命令。
      foreach(loop_var arg1 arg2 ...)
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endforeach(loop_var)
      foreach(loop_var RANGE total)
      foreach(loop_var RANGE start stop [step])

    foreach 和匹配的 endforeach 之间的所以命令都会被记录，但不会被调用。一旦 endforeach 被评估，记录的命令列表就会针对原始 foreach 命令中列出的每个参数调用一次。在循环的每次迭代之前，"${loop_var}" 将被设置为一个变量，该变量包含列表中的当前值。

    Foreach 还可以遍历生成的数字范围。这种迭代有三种类型：

    * 当指定单个数字时，范围将包含 0 到“total”的元素。

    * 当指定两个数字时，范围将包含从第一个数字到第二个数字的元素。

    * 第三个可选数字是用于从第一个数字迭代到第二个数字的增量。

  • function: 开始记录一个函数，以便稍后作为命令调用。
      function(<name> [arg1 [arg2 [arg3 ...]]])
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endfunction(<name>)

    定义一个名为<name>的函数，该函数接受名为 arg1 arg2 arg3 (...) 的参数。列在 function 之后，但 endfunction 之前的命令在函数被调用之前不会被调用。当它被调用时，记录在函数中的命令首先被修改，将形式参数 (${arg1}) 替换为传递的参数，然后像普通命令一样调用。除了引用形式参数之外，您还可以引用变量 ARGC，该变量将被设置为传递给函数的参数数量，以及 ARGV0 ARGV1 ARGV2 ...，这些变量将包含传递的参数的实际值。这有助于创建带有可选参数的函数。此外，ARGV 保存传递给函数的所有参数的列表，ARGN 保存传递给最后一个预期参数后的参数列表。

    有关函数内策略的行为，请参阅 cmake_policy() 命令文档。

  • get_cmake_property: 获取 CMake 实例的属性。
      get_cmake_property(VAR property)

    从 CMake 实例获取属性。属性的值存储在变量 VAR 中。如果找不到属性，CMake 将报告错误。一些支持的属性包括：VARIABLES、CACHE_VARIABLES、COMMANDS、MACROS 和 COMPONENTS。

  • get_directory_property: 获取目录的属性。
      get_directory_property(VAR [DIRECTORY dir] property)

    从目录获取属性。属性的值存储在变量 VAR 中。如果找不到属性，CMake 将报告错误。属性包括：VARIABLES、CACHE_VARIABLES、COMMANDS、MACROS、INCLUDE_DIRECTORIES、LINK_DIRECTORIES、DEFINITIONS、INCLUDE_REGULAR_EXPRESSION、LISTFILE_STACK、PARENT_DIRECTORY 和 DEFINITION varname。如果提供了 DIRECTORY 参数，则将检索提供的目录的属性，而不是当前目录的属性。您只能在遍历 cmake 时获取目录的属性，或者在遍历 cmake 之后获取目录的属性。

  • get_filename_component: 获取完整文件名中的特定组件。
      get_filename_component(VarName FileName
                             PATH|ABSOLUTE|NAME|EXT|NAME_WE
                             [CACHE])

    将 VarName 设置为 FileName 的路径 (PATH)、文件名 (NAME)、文件扩展名 (EXT)、不带扩展名的文件名 (NAME_WE) 或不带符号链接的完整绝对 (ABSOLUTE) 文件名。请注意，路径已转换为 Unix 斜杠格式，并且没有尾部斜杠。始终考虑最长的文件扩展名。如果指定了可选的 CACHE 参数，则结果变量将被添加到缓存中。

      get_filename_component(VarName FileName
                             PROGRAM [PROGRAM_ARGS ArgVar]
                             [CACHE])

    FileName 中的程序将在系统搜索路径中找到，或者保留为完整路径。如果 PROGRAM_ARGS 与 PROGRAM 一起出现，则 FileName 字符串中存在的任何命令行参数将从程序名称中分离出来，并存储在 ArgVar 中。这用于从命令行字符串中分离程序名称及其参数。

  • get_property: 获取属性。
      get_property(<variable>
                   <GLOBAL             |
                    DIRECTORY [dir]    |
                    TARGET    <target> |
                    SOURCE    <source> |
                    TEST      <test>   |
                    VARIABLE>
                   PROPERTY <name>
                   [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

    从一个范围内的某个对象中获取一个属性。第一个参数指定用于存储结果的变量。第二个参数确定要从中获取属性的范围。它必须是以下之一：

    GLOBAL 范围是唯一的，不接受名称。

    DIRECTORY 范围默认情况下为当前目录，但可以通过完整路径或相对路径命名另一个目录（已由 CMake 处理）。

    TARGET 范围必须命名一个现有的目标。

    SOURCE 范围必须命名一个源文件。

    TEST 范围必须命名一个现有的测试。

    VARIABLE 范围是唯一的，不接受名称。

    必需的 PROPERTY 选项紧随其后是待获取的属性的名称。如果未设置该属性，则返回一个空值。如果给出了 SET 选项，则变量将被设置为一个布尔值，指示该属性是否已设置。如果给出了 DEFINED 选项，则变量将被设置为一个布尔值，指示该属性是否已定义，例如使用 define_property。如果给出了 BRIEF_DOCS 或 FULL_DOCS，则变量将被设置为一个字符串，该字符串包含所请求属性的文档。如果请求未定义的属性的文档，则将返回 NOTFOUND。

  • get_source_file_property: 获取源文件的属性。
      get_source_file_property(VAR file property)

    从源文件获取属性。属性的值存储在变量 VAR 中。如果找不到属性，VAR 将被设置为“NOTFOUND”。使用 set_source_files_properties 设置属性值。源文件属性通常控制如何构建文件。始终存在的属性之一是 LOCATION。

  • get_target_property: 从目标获取属性。
      get_target_property(VAR target property)

    从目标获取属性。属性的值存储在变量 VAR 中。如果找不到属性，VAR 将被设置为“NOTFOUND”。使用 set_target_properties 设置属性值。属性通常用于控制如何构建目标，但有些属性会查询目标。此命令可以获取到目前为止创建的任何目标的属性。目标不需要位于当前 CMakeLists.txt 文件中。

  • get_test_property: 获取测试的属性。
      get_test_property(test VAR property)

    从测试获取属性。属性的值存储在变量 VAR 中。如果找不到属性，CMake 将报告错误。要获取标准属性列表，您可以键入 cmake --help-property-list

  • if: 有条件地执行一组命令。
      if(expression)
        # then section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      elseif(expression2)
        # elseif section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      else(expression)
        # else section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endif(expression)

    评估给定的表达式。如果结果为真，则调用 THEN 部分中的命令。否则，将调用 else 部分中的命令。elseif 和 else 部分是可选的。您可以拥有多个 elseif 子句。请注意，if 和 endif 必须使用相同的表达式。可以使用长表达式，优先级顺序是 EXISTS、COMMAND 和 DEFINED 运算符将首先被评估。然后评估任何 EQUAL、LESS、GREATER、STRLESS、STRGREATER、STREQUAL、MATCHES。然后是 NOT 运算符，最后是 AND、OR 运算符。可能的表达式是：

      if(variable)

    如果变量的值不为空、0、N、NO、OFF、FALSE、NOTFOUND 或 <variable>-NOTFOUND，则为真。

      if(NOT variable)

    如果变量的值为空、0、N、NO、OFF、FALSE、NOTFOUND 或 <variable>-NOTFOUND，则为真。

      if(variable1 AND variable2)

    如果两个变量在单独考虑时都将被视为真，则为真。

      if(variable1 OR variable2)

    如果两个变量在单独考虑时都将被视为真，则为真。

      if(COMMAND command-name)

    如果给定名称是可调用的命令、宏或函数，则为真。

      if(POLICY policy-id)

    如果给定名称是现有策略（形式为 CMP<NNNN>），则为真。

      if(TARGET target-name)

    如果给定名称是现有目标（已构建或导入），则为真。

      if(EXISTS file-name)
      if(EXISTS directory-name)

    如果给定文件或目录存在，则为真。行为仅对完整路径有明确的定义。

      if(file1 IS_NEWER_THAN file2)

    如果 file1 比 file2 更新，或者两个文件之一不存在，则为真。行为仅对完整路径有明确的定义。

      if(IS_DIRECTORY directory-name)

    如果给定名称是目录，则为真。行为仅对完整路径有明确的定义。

      if(IS_ABSOLUTE path)

    如果给定路径是绝对路径，则为真。

       if(variable MATCHES regex)
      if(string MATCHES regex)

    如果给定字符串或变量的值匹配给定的正则表达式，则为真。

      if(variable LESS number)
      if(string LESS number)
      if(variable GREATER number)
      if(string GREATER number)
      if(variable EQUAL number)
      if(string EQUAL number)

    如果给定字符串或变量的值是有效数字，并且不等式或等式为真，则为真。

      if(variable STRLESS string)
      if(string STRLESS string)
      if(variable STRGREATER string)
      if(string STRGREATER string)
      if(variable STREQUAL string)
      if(string STREQUAL string)

    如果给定字符串或变量的值在字典排序上小于（或大于、或等于）右侧的字符串，则为真。

      if(version1 VERSION_LESS version2)
      if(version1 VERSION_EQUAL version2)
      if(version1 VERSION_GREATER version2)

    逐组件的整数版本号比较（版本格式为 major[.minor[.patch[.tweak]]]）。

      if(DEFINED variable)

    如果给定变量已定义，则为真。无论变量是真还是假都没有关系，只要它已被设置即可。

  • include: 从给定文件读取 CMake 列表文件代码。
      include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
                            [NO_POLICY_SCOPE])

    从给定文件中读取 CMake 列表文件代码。文件中的命令会立即处理，就像它们是在 include 命令所在位置编写的一样。如果存在 OPTIONAL，则如果文件不存在，则不会引发错误。如果给出 RESULT_VARIABLE，则变量将设置为已包含的完整文件名，或者如果失败则设置为 NOTFOUND。

    如果指定了模块而不是文件，则在 CMAKE_MODULE_PATH 中搜索名为 <modulename>.cmake 的文件。

    有关 NO_POLICY_SCOPE 选项的讨论，请参阅 cmake_policy() 命令文档。

  • include_directories: 将包含目录添加到构建中。
      include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)

    将给定的目录添加到编译器用来搜索包含文件的目录中。默认情况下，目录将附加到当前目录列表的末尾。此默认行为可以通过将 CMAKE_include_directories_BEFORE 设置为 ON 来更改。通过使用 BEFORE 或 AFTER，您可以选择附加或添加，与默认设置无关。如果给出了 SYSTEM 选项，则编译器将被告知这些目录在某些平台上旨在作为系统包含目录。

  • include_external_msproject: 在工作区中包含外部 Microsoft 项目文件。
      include_external_msproject(projectname location
                                 dep1 dep2 ...)

    在生成的工作区文件中包含外部 Microsoft 项目。目前在 UNIX 上什么也不做。这将创建一个名为 INCLUDE_EXTERNAL_MSPROJECT_[projectname] 的目标。这可以在 add_dependencies 命令中使用，以使事物依赖于外部项目。

  • include_regular_expression: 设置用于依赖项检查的正则表达式。
      include_regular_expression(regex_match [regex_complain])

    设置依赖项检查中使用的正则表达式。只有与 regex_match 匹配的文件才会被跟踪为依赖项。只有与 regex_complain 匹配的文件才会在找不到时生成警告（不会搜索标准头文件路径）。默认值为

      regex_match    = "^.*$" (match everything)
      regex_complain = "^$" (match empty string only)
  • install: 指定在安装时运行的规则。

    此命令生成项目的安装规则。在源目录中调用此命令所指定的规则在安装期间按顺序执行。不同目录之间的顺序未定义。

    此命令有多个签名。其中一些为文件和目标定义安装属性。适用于多个签名的属性在此处介绍，但仅适用于指定它们的签名。

    DESTINATION 参数指定文件将被安装到的磁盘上的目录。如果给出完整路径（带有前导斜杠或驱动器号），则直接使用它。如果给出相对路径，则将其解释为相对于 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 参数指定安装规则适用的构建配置列表（调试、发布等）。

    COMPONENT 参数指定安装规则关联的安装组件名称，例如“runtime”或“development”。在特定于组件的安装期间，只会执行与给定组件名称关联的安装规则。在完整安装期间，将安装所有组件。

    RENAME 参数指定已安装文件的名称，该名称可能与原始文件不同。重命名仅在命令安装单个文件时才允许。

    OPTIONAL 参数指定如果要安装的文件不存在，则不是错误。

    TARGETS 签名

      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]
              ] [...])

    TARGETS 形式指定安装项目中目标的规则。可能有五种类型的目标文件可以被安装：ARCHIVE、LIBRARY、RUNTIME、FRAMEWORK 和 BUNDLE。可执行文件被视为 RUNTIME 目标，但那些标记有 MACOSX_BUNDLE 属性的将在 OS X 上被视为 BUNDLE 目标。静态库始终被视为 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 参数会导致随后属性应用于在非 Apple 平台上安装 FRAMEWORK 共享库目标的关联文件。这些参数定义的规则在 Apple 平台上被忽略，因为关联的文件安装在框架文件夹内的适当位置。有关详细信息，请参阅 PRIVATE_HEADER、PUBLIC_HEADER 和 RESOURCE 目标属性的文档。

    NAMELINK_ONLY 或 NAMELINK_SKIP 可以作为 LIBRARY 选项指定。在某些平台上，版本化的共享库具有一个符号链接，例如

      lib<name>.so -> lib<name>.so.1

    其中“lib<name>.so.1”是库的 soname，而“lib<name>.so”是一个“namelink”，允许链接器在给出“-l<name>”时找到库。NAMELINK_ONLY 选项会导致仅安装 namelink 当安装库目标时。NAMELINK_SKIP 选项会导致安装库文件，而不是安装 namelink 当安装库目标时。当没有给出任何选项时，这两部分都将被安装。在版本化的共享库没有 namelink 或库没有版本化的平台上，NAMELINK_SKIP 选项会安装库，而 NAMELINK_ONLY 选项不会安装任何东西。有关创建版本化的共享库的详细信息，请参阅 VERSION 和 SOVERSION 目标属性。

    可以在对此命令的 TARGETS 形式的单个调用中指定一个或多个属性组。目标可以多次安装到不同的位置。考虑假设目标“myExe”、“mySharedLib”和“myStaticLib”。代码

        install(TARGETS myExe mySharedLib myStaticLib
                RUNTIME DESTINATION bin
                LIBRARY DESTINATION lib
                ARCHIVE DESTINATION lib/static)
        install(TARGETS mySharedLib DESTINATION /some/full/path)

    将 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。在非 DLL 平台上，mySharedLib 将被安装到 <prefix>/lib 和 /some/full/path。

    EXPORT 选项将安装的目标文件与名为 <export-name> 的导出关联。它必须出现在任何 RUNTIME、LIBRARY 或 ARCHIVE 选项之前。有关详细信息，请参阅下面 install(EXPORT ...) 签名的文档。

    安装 EXCLUDE_FROM_ALL 设置为 true 的目标具有未定义的行为。

    FILES 签名

      install(FILES files... DESTINATION <dir>
              [PERMISSIONS permissions...]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>]
              [RENAME <name>] [OPTIONAL])

    FILES 形式指定安装项目文件的规则。作为相对路径给出的文件名将相对于当前源目录进行解释。通过此形式安装的文件默认情况下将获得权限 OWNER_WRITE、OWNER_READ、GROUP_READ 和 WORLD_READ，如果未给出 PERMISSIONS 参数。

    PROGRAMS 签名

      install(PROGRAMS files... DESTINATION <dir>
              [PERMISSIONS permissions...]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>]
              [RENAME <name>] [OPTIONAL])

    PROGRAMS 形式与 FILES 形式相同，只是已安装文件的默认权限还包括 OWNER_EXECUTE、GROUP_EXECUTE 和 WORLD_EXECUTE。此形式旨在安装不是目标的程序，例如 shell 脚本。使用 TARGETS 形式安装在项目中构建的目标。

    DIRECTORY 签名

      install(DIRECTORY dirs... DESTINATION <dir>
              [FILE_PERMISSIONS permissions...]
              [DIRECTORY_PERMISSIONS permissions...]
              [USE_SOURCE_PERMISSIONS]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>] [FILES_MATCHING]
              [[PATTERN <pattern> | REGEX <regex>]
               [EXCLUDE] [PERMISSIONS permissions...]] [...])

    DIRECTORY 形式将一个或多个目录的内容安装到给定的目标位置。目录结构将逐字复制到目标位置。每个目录名称的最后一个组件将附加到目标目录，但可以使用尾部斜杠来避免这种情况，因为它会使最后一个组件为空。作为相对路径给出的目录名称将相对于当前源目录进行解释。如果没有给出输入目录名称，则目标目录将被创建，但不会安装任何内容到其中。FILE_PERMISSIONS 和 DIRECTORY_PERMISSIONS 选项指定给定于目标位置中的文件和目录的权限。如果指定了 USE_SOURCE_PERMISSIONS 并且未指定 FILE_PERMISSIONS，则文件权限将从源目录结构中复制。如果没有指定权限，则文件将获得在命令的 FILES 形式中指定的默认权限，而目录将获得在命令的 PROGRAMS 形式中指定的默认权限。

    可以使用 PATTERN 或 REGEX 选项以细粒度控制目录的安装。这些“匹配”选项指定一个 glob 模式或正则表达式来匹配在输入目录中遇到的目录或文件。它们可以用来将某些选项（见下文）应用于遇到的文件和目录的子集。每个输入文件或目录的完整路径（带有正斜杠）将与表达式进行匹配。PATTERN 将仅匹配完整的文件名：与模式匹配的完整路径部分必须出现在文件名的末尾，并且前面必须有斜杠。REGEX 将匹配路径的任何部分，但它可以使用“/”和“$”来模拟 PATTERN 行为。默认情况下，所有文件和目录都会被安装，无论它们是否匹配。FILES_MATCHING 选项可以在第一个匹配选项之前给出，以禁用未与任何表达式匹配的文件（但不是目录）的安装。例如，代码

      install(DIRECTORY src/ DESTINATION include/myproj
              FILES_MATCHING PATTERN "*.h")

    将从源树中提取和安装头文件。

    某些选项可以跟随 PATTERN 或 REGEX 表达式，并且仅应用于与它们匹配的文件或目录。EXCLUDE 选项将跳过匹配的文件或目录。PERMISSIONS 选项将覆盖匹配的文件或目录的权限设置。例如，代码

      install(DIRECTORY icons scripts/ DESTINATION share/myproj
              PATTERN "CVS" EXCLUDE
              PATTERN "scripts/*"
              PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
                          GROUP_EXECUTE GROUP_READ)

    将 icons 目录安装到 share/myproj/icons，将 scripts 目录安装到 share/myproj。icons 将获得默认文件权限，scripts 将获得特定权限，并且任何 CVS 目录将被排除。

    SCRIPT 和 CODE 签名

      install([[SCRIPT <file>] [CODE <code>]] [...])

    SCRIPT 形式将在安装期间调用给定的 CMake 脚本文件。如果脚本文件名是相对路径，它将相对于当前源目录进行解释。CODE 形式将在安装期间调用给定的 CMake 代码。代码被指定为一个双引号字符串中的单个参数。例如，代码

      install(CODE "MESSAGE(\"Sample install message.\")")

    将在安装期间打印一条消息。

    EXPORT 签名

      install(EXPORT <export-name> DESTINATION <dir>
              [NAMESPACE <namespace>] [FILE <name>.cmake]
              [PERMISSIONS permissions...]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>])

    EXPORT 形式生成并安装一个 CMake 文件，其中包含代码，用于将安装树中的目标导入另一个项目。目标安装使用上面记录的 install(TARGETS ...) 签名的 EXPORT 选项与导出 <export-name> 关联。NAMESPACE 选项将在将目标名称写入导入文件时在目标名称前面添加 <namespace>。默认情况下，生成的文件将被称为 <export-name>.cmake，但 FILE 选项可用于指定不同的名称。给定于 FILE 选项的值必须是一个带有“.cmake”扩展名的文件名。如果给出了 CONFIGURATIONS 选项，则只有在安装了命名的配置之一时才会安装该文件。此外，生成的导入文件将仅引用匹配的目标配置。如果指定了一个与与 <export-name> 关联的目标所给定的不匹配的 COMPONENT 选项，则行为将是未定义的。如果库目标包含在导出中，但它链接到的目标未包含在导出中，则行为是不确定的。

    EXPORT 形式有助于外部项目使用当前项目构建和安装的目标。例如，代码

      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。它还取代了 INSTALL_FILES 和 INSTALL_PROGRAMS 命令的 FILES 形式。这些安装规则相对于由 INSTALL_TARGETS、INSTALL_FILES 和 INSTALL_PROGRAMS 命令生成的规则的处理顺序未定义。

  • link_directories: 指定链接器将在其中查找库的目录。
      link_directories(directory1 directory2 ...)

    指定链接器应搜索库的路径。该命令仅适用于调用后创建的目标。出于历史原因，传递给此命令的相对路径会原样传递给链接器（与许多将它们解释为相对于当前源目录的 CMake 命令不同）。

  • 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 将返回给定列表的长度。

    GET 将返回列表中由索引指定的元素列表。

    APPEND 将元素追加到列表中。

    FIND 将返回列表中指定元素的索引，如果未找到则返回 -1。

    INSERT 将元素插入到列表中指定的位点。

    REMOVE_AT 和 REMOVE_ITEM 将从列表中删除项目。区别在于 REMOVE_ITEM 将删除给定的项目，而 REMOVE_AT 将删除给定索引处的项目。

    REMOVE_DUPLICATES 将删除列表中的重复项。

    REVERSE 反转列表内容，就地进行。

    SORT 按字母顺序对列表进行就地排序。

    说明：CMake 中的列表是由分号分隔的字符串组。可以使用 set 命令创建列表。例如，set(var a b c d e) 创建一个带有 a;b;c;d;e 的列表，而 set(var "a b c d e") 创建一个字符串或一个包含一个项目的列表。

    在指定索引值时，如果 <元素索引> 为 0 或更大，则从列表开头进行索引，其中 0 代表第一个列表元素。如果 <元素索引> 为 -1 或更小，则从列表末尾进行索引，其中 -1 代表最后一个列表元素。在使用负索引计数时要小心：它们不是从 0 开始的。-0 等同于 0，即第一个列表元素。

  • load_cache: 从另一个项目的 CMake 缓存中加载值。
      load_cache(pathToCacheFile READ_WITH_PREFIX
                 prefix entry1...)

    读取缓存并将请求的条目存储在变量中，其名称以给定的前缀为前缀。这仅读取值，不会在本地项目的缓存中创建条目。

      load_cache(pathToCacheFile [EXCLUDE entry1...]
                 [INCLUDE_INTERNALS entry1...])

    从另一个缓存中加载值并将其存储在本地项目的缓存中作为内部条目。这对于依赖于不同树中构建的另一个项目的项目很有用。EXCLUDE 选项可用于提供要排除的条目列表。INCLUDE_INTERNALS 可用于提供要包含的内部条目列表。通常，不会引入任何内部条目。强烈建议不要使用此形式的命令，但它为了向后兼容而提供。

  • load_command: 将命令加载到正在运行的 CMake 中。
      load_command(COMMAND_NAME <loc1> [loc2 ...])

    在给定的位置中搜索名称为 cmCOMMAND_NAME 的库。如果找到，它将被加载为模块，并且该命令将被添加到可用 CMake 命令集中。通常，在执行此命令之前会使用 TRY_COMPILE 来编译模块。如果命令成功加载，则名为

      CMAKE_LOADED_COMMAND_<COMMAND_NAME>

    的变量将设置为加载的模块的完整路径。否则，变量将不会被设置。

  • macro: 开始录制宏，以便稍后作为命令调用。
      macro(<name> [arg1 [arg2 [arg3 ...]]])
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endmacro(<name>)

    定义一个名为 <name> 的宏，它接受名为 arg1 arg2 arg3 (...) 的参数。在宏之后列出的命令，但在匹配的 endmacro 之前，不会在宏被调用之前被调用。当它被调用时，在宏中记录的命令首先通过将形式参数 (${arg1}) 替换为传递的参数来修改，然后作为普通命令调用。除了引用形式参数外，还可以引用 ${ARGC} 值，该值将设置为传递给函数的参数数量，以及 ${ARGV0} ${ARGV1} ${ARGV2} ...，它们将具有传递的实际参数值。这有利于创建具有可选参数的宏。此外，${ARGV} 包含传递给宏的所有参数列表，而 ${ARGN} 包含传递给最后一个预期参数的所有参数列表。请注意，宏的参数和 ARGN 之类的值不是通常意义上的 CMake 变量。它们是字符串替换，就像 C 预处理器对宏所做的那样。如果需要真正的 CMake 变量，则应查看 function 命令。

    有关宏内策略的行为，请参阅 cmake_policy() 命令文档。

  • mark_as_advanced: 将 CMake 缓存变量标记为高级。
      mark_as_advanced([CLEAR|FORCE] VAR VAR2 VAR...)

    将命名的缓存变量标记为高级。除非显示高级选项，否则高级变量不会显示在任何 CMake GUI 中。如果 CLEAR 是第一个参数，则高级变量将更改回非高级。如果 FORCE 是第一个参数，则变量将变为高级。如果既没有指定 FORCE 也没有指定 CLEAR，则新值将被标记为高级，但如果变量已经具有高级/非高级状态，则它将不会被更改。

    它在脚本模式下不执行任何操作。

  • math: 数学表达式。
      math(EXPR <output variable> <math expression>)

    EXPR 计算数学表达式并将结果返回到输出变量中。示例数学表达式为 '5 * ( 10 + 13 )'。支持的操作符为 + - * / % | & ^ ~ << >> * / %。它们在 c 代码中的含义相同。

  • message: 向用户显示一条消息。
      message([SEND_ERROR | STATUS | FATAL_ERROR]
              "message to display" ...)

    默认情况下，消息将显示在弹出窗口（CMakeSetup）中，或在 cmake 的 stdout 中，或在 ccmake 的错误部分中。如果第一个参数是 SEND_ERROR，则会引发错误，并且生成阶段将被跳过。如果第一个参数是 FATAL_ERROR，则所有处理都将停止。如果第一个参数是 STATUS，则消息将显示在 GUI 的进度行中，或在命令行 cmake 中以 -- 显示。

  • option: 提供用户可以选择的用户选项。
      option(<option_variable> "help string describing option"
             [initial value])

    为用户提供一个选项，可以选择 ON 或 OFF。如果未提供初始值，则使用 OFF。

  • output_required_files: 输出指定源文件所需源文件的列表。
      output_required_files(srcfile outputfile)

    输出指定 srcfile 所需的所有源文件的列表。此列表将写入 outputfile。这类似于写出 srcfile 的依赖项，不同之处在于它会从 .h 文件跳转到 .cxx、.c 和 .cpp 文件（如果可能）。

  • project: 为整个项目设置名称。
      project(projectname [CXX] [C] [Java])

    设置项目的名称。这将创建变量 projectname_BINARY_DIR 和 projectname_SOURCE_DIR。可以选择指定项目支持的语言。默认情况下支持所有语言。如果没有 C++ 编译器，但希望使用 cmake 构建 c 程序，则使用此选项。

  • qt_wrap_cpp: 创建 Qt 包装器。
      qt_wrap_cpp(resultingLibraryName DestName
                  SourceLists ...)

    为 SourceLists 中列出的所有 .h 文件生成 moc 文件。moc 文件将使用 DestName 源列表添加到库中。

  • qt_wrap_ui: 创建 Qt 用户界面包装器。
      qt_wrap_ui(resultingLibraryName HeadersDestName
                 SourcesDestName SourceLists ...)

    为 SourceLists 中列出的所有 .ui 文件生成 .h 和 .cxx 文件。.h 文件将使用 HeadersDestNamesource 列表添加到库中。.cxx 文件将使用 SourcesDestNamesource 列表添加到库中。

  • remove_definitions: 删除由 add_definitions 添加的 -D 定义标志。
      remove_definitions(-DFOO -DBAR ...)

    从当前目录及其以下目录的源代码的编译器命令行中删除标志（由 add_definitions 添加）。

  • return: 从文件、目录或函数返回。
      return()

    从文件、目录或函数返回。当在包含的文件（通过 include() 或 find_package()）中遇到此命令时，它会导致当前文件的处理停止，并将控制权返回给包含文件。如果在没有被另一个文件包含的文件（例如 CMakeLists.txt）中遇到它，则如果存在父目录，则控制权将返回给父目录。如果在函数中调用 return，则控制权将返回给函数的调用者。请注意，宏不是函数，也不像函数那样处理 return。

  • separate_arguments: 将空格分隔的参数拆分为分号分隔的列表。
      separate_arguments(VARIABLE)

    将 VARIABLE 的值转换为分号分隔的列表。所有空格都将替换为 ';'。这有助于生成命令行。

  • set: 将 CMAKE 变量设置为给定值。
      set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])

    在 CMake 中将 <variable> 设置为值 <value>。<value> 在 <variable> 被设置为它之前被展开。如果存在 CACHE，则将 <variable> 放入缓存中。然后需要 <type> 和 <docstring>。<type> 用于 CMake GUI 选择一个供用户设置值的窗口小部件。<type> 的值可以是以下之一

      FILEPATH = File chooser dialog.
      PATH     = Directory chooser dialog.
      STRING   = Arbitrary string.
      BOOL     = Boolean ON/OFF checkbox.
      INTERNAL = No GUI entry (used for persistent variables).

    如果 <type> 为 INTERNAL，则 <value> 始终写入缓存中，替换缓存中存在的任何值。如果它不是缓存变量，则这始终写入当前 makefile 中。FORCE 选项将覆盖缓存值，删除用户进行的任何更改。

    如果存在 PARENT_SCOPE，则变量将在当前作用域之上的作用域中设置。每个新目录或函数都会创建一个新的作用域。此命令将设置变量的值到父目录或调用函数中（无论哪种情况适用于当前情况）。如果未指定 VALUE，则变量将从父作用域中删除。

      set(<variable> <value1> ... <valueN>)

    在这种情况下，<variable> 设置为用分号分隔的值列表。

    <variable> 可以是环境变量，例如

      set( ENV{PATH} /home/martink )

    在这种情况下，将设置环境变量。

  • set_directory_properties: 设置目录的属性。
      set_directory_properties(PROPERTIES prop1 value1 prop2 value2)

    为当前目录及其子目录设置属性。如果找不到属性，CMake 将报告错误。属性包括：INCLUDE_DIRECTORIES、LINK_DIRECTORIES、INCLUDE_REGULAR_EXPRESSION 和 ADDITIONAL_MAKE_CLEAN_FILES。

    ADDITIONAL_MAKE_CLEAN_FILES 是将在“make clean”阶段清理的文件列表。

  • set_property: 在给定范围内设置一个命名的属性。
      set_property(<GLOBAL                            |
                    DIRECTORY [dir]                   |
                    TARGET    [target1 [target2 ...]] |
                    SOURCE    [src1 [src2 ...]]       |
                    TEST      [test1 [test2 ...]]>
                   [APPEND]
                   PROPERTY <name> [value1 [value2 ...]])

    在范围内的零个或多个对象上设置一个属性。第一个参数决定了设置属性的范围。它必须是以下之一

    GLOBAL 范围是唯一的，不接受名称。

    DIRECTORY 范围默认情况下为当前目录，但可以通过完整路径或相对路径命名另一个目录（已由 CMake 处理）。

    TARGET 范围可以命名零个或多个现有的目标。

    SOURCE 范围可以命名零个或多个源文件。

    TEST 范围可以命名零个或多个现有的测试。

    必需的 PROPERTY 选项紧随其后的是要设置的属性的名称。剩余的参数用于以分号分隔的列表形式组合属性值。如果给出 APPEND 选项，则列表将附加到任何现有的属性值。

  • set_source_files_properties: 源文件可以具有影响其构建方式的属性。
      set_source_files_properties(file1 file2 ...
                                  PROPERTIES prop1 value1
                                  prop2 value2 ...)

    在文件上设置属性。该命令的语法是列出要更改的所有文件，然后提供要设置的值。您也可以创建自己的属性。以下属性由 CMake 使用。ABSTRACT 标志（布尔值）由某些类包装命令使用。如果 WRAP_EXCLUDE（布尔值）为真，则许多包装命令将忽略此文件。如果 GENERATED（布尔值）为真，则如果此源文件在添加到目标时不存在，则不会出错。显然，它必须在目标构建之前创建（可能由自定义命令创建）。如果 HEADER_FILE_ONLY（布尔值）属性为真，则不会编译该文件。如果您想将额外的非构建文件添加到 IDE 中，这将非常有用。OBJECT_DEPENDS（字符串）将依赖项添加到目标文件。COMPILE_FLAGS（字符串）在编译源文件时作为附加命令行参数传递给编译器。LANGUAGE（字符串）CXX|C 将更改用于编译源文件的默认编译器。使用的语言需要在 PROJECT 命令中启用。如果 SYMBOLIC（布尔值）设置为 true，则构建系统将被告知源文件实际上不是在磁盘上创建的，而是用作构建规则的符号名称。

  • set_target_properties: 目标可以具有影响其构建方式的属性。
      set_target_properties(target1 target2 ...
                            PROPERTIES prop1 value1
                            prop2 value2 ...)

    在目标上设置属性。该命令的语法是列出要更改的所有文件，然后提供要设置的值。您可以使用您想要的任何 prop 值对，并使用 GET_TARGET_PROPERTY 命令在以后提取它。

    影响目标输出文件名称的属性如下。PREFIX 和 SUFFIX 属性覆盖默认的目标名称前缀（例如“lib”）和后缀（例如“.so”）。IMPORT_PREFIX 和 IMPORT_SUFFIX 是与 DLL 对应的导入库的等效属性（对于 SHARED 库目标）。OUTPUT_NAME 设置目标构建时的真实名称，可用于帮助创建两个相同名称的目标，即使 CMake 要求逻辑目标名称唯一。还存在一个 <CONFIG>_OUTPUT_NAME，它可以根据配置设置输出名称。<CONFIG>_POSTFIX 为目标在名为 <CONFIG>（大写，例如“DEBUG_POSTFIX”）的配置下构建时的真实名称设置后缀。此属性的值在创建目标时初始化为变量 CMAKE_<CONFIG>_POSTFIX 的值（可执行目标除外，因为早期版本的 CMake 未将此变量用于可执行目标）。

    LINK_FLAGS 属性可用于向目标的链接步骤添加额外的标志。LINK_FLAGS_<CONFIG> 将添加到配置 <CONFIG>，例如，DEBUG、RELEASE、MINSIZEREL、RELWITHDEBINFO。DEFINE_SYMBOL 设置在编译共享库中的源代码时定义的预处理器符号的名称。如果此处未设置，则默认情况下设置为 target_EXPORTS（如果目标不是有效的 C 标识符，则会进行一些替换）。这对于头文件了解它们是包含在其库内部还是外部以正确设置 dllexport/dllimport 装饰很有用。COMPILE_FLAGS 属性设置用于构建目标内源代码的额外编译器标志。它还可用于传递额外的预处理器定义。

    LINKER_LANGUAGE 属性用于更改用于链接可执行文件或共享库的工具。默认情况下，该语言设置为与库中的文件匹配。CXX 和 C 是此属性的常见值。

    对于共享库，VERSION 和 SOVERSION 可用于分别指定构建版本和 API 版本。构建或安装时，如果平台支持符号链接且链接器支持 so-name，则会创建适当的符号链接。如果仅指定两者之一，则假定缺少的版本号相同。对于可执行文件，VERSION 可用于指定构建版本。构建或安装时，如果平台支持符号链接，则会创建适当的符号链接。对于 Windows 上的共享库和可执行文件，VERSION 属性将被解析以提取“major.minor”版本号。这些数字用作二进制文件的映像版本。

    有一些属性用于指定 RPATH 规则。INSTALL_RPATH 是一个分号分隔的列表，指定在安装的目标中使用的 rpath（对于支持它的平台）。INSTALL_RPATH_USE_LINK_PATH 是一个布尔值，如果设置为 true，则会将链接器搜索路径和项目外部的目录附加到 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 可用于在 Visual Studio 项目文件中添加对源代码控制绑定的支持。

    当构建库时，CMake 默认情况下会生成代码以删除使用所有可能名称的任何现有库。这是为了支持通过用户选项在 STATIC 和 SHARED 之间切换的库。但是，当使用 OUTPUT_NAME 构建使用不同逻辑目标名称的相同名称的静态库和共享库时，这两个目标将删除彼此的文件。可以通过将 CLEAN_DIRECT_OUTPUT 属性设置为 1 来防止这种情况。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 属性是指定在安装目标之前和之后运行的 CMake 脚本的旧方法。它们仅在使用旧的 INSTALL_TARGETS 命令安装目标时使用。使用 INSTALL 命令代替。

    EXCLUDE_FROM_DEFAULT_BUILD 属性由 Visual Studio 生成器使用。如果将其设置为 1，则在选择“构建解决方案”时，目标将不会是默认构建的一部分。

  • set_tests_properties: 设置测试的属性。
      set_tests_properties(test1 [test2...] PROPERTIES prop1 value1 prop2 value2)

    为测试设置一个属性。如果找不到属性，CMake 将报告错误。属性包括

    WILL_FAIL: 如果设置为 true，这将反转测试的通过/失败标志。

    PASS_REGULAR_EXPRESSION: 如果设置，测试输出将与指定的正则表达式进行检查，并且至少有一个正则表达式必须匹配，否则测试将失败。

      Example: PASS_REGULAR_EXPRESSION "TestPassed;All ok"

    FAIL_REGULAR_EXPRESSION: 如果设置，如果输出与一个指定的正则表达式匹配，则测试将失败。

      Example: PASS_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"

    PASS_REGULAR_EXPRESSION 和 FAIL_REGULAR_EXPRESSION 都期望一个正则表达式列表。

  • site_name: 将给定变量设置为计算机的名称。
      site_name(variable)
  • source_group: 定义 makefile 中源代码的分组。
      source_group(name [REGULAR_EXPRESSION regex] [FILES src1 src2 ...])

    定义一个组，源文件将被放置在项目文件中。这主要用于在 Visual Studio 中设置文件选项卡。任何名称列出或与正则表达式匹配的文件都将被放置在此组中。如果一个文件匹配多个组，则最后一个明确列出该文件的组将优先，如果有的话。如果没有任何组明确列出该文件，则最后一个与该文件匹配的正则表达式的组将优先。

    组的名称可以包含反斜杠以指定子组

      source_group(outer\\inner ...)

    为了向后兼容，此命令还支持以下格式

      source_group(name regex)
  • string: 字符串操作。
      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>]
             <output variable>)

    REGEX MATCH 将匹配正则表达式一次并将匹配结果存储在输出变量中。

    REGEX MATCHALL 将尽可能多次匹配正则表达式并将匹配结果作为列表存储在输出变量中。

    REGEX REPLACE 将尽可能多次匹配正则表达式并将替换表达式替换为输出中的匹配项。替换表达式可以使用 \1、\2、…、\9 引用匹配项的括号分隔的子表达式。请注意，在 CMake 代码中需要两个反斜杠（\\1）才能通过参数解析获得一个反斜杠。

    REPLACE 将替换输入中所有出现的 match_string，并用 replace_string 替换，并将结果存储在输出中。

    COMPARE EQUAL/NOTEQUAL/LESS/GREATER 将比较字符串并在输出变量中存储 true 或 false。

    ASCII 将所有数字转换为相应的 ASCII 字符。

    CONFIGURE 将转换字符串，就像 CONFIGURE_FILE 转换文件一样。

    TOUPPER/TOLOWER 将字符串转换为大写/小写字符。

    LENGTH 将返回给定字符串的长度。

    SUBSTRING 将返回给定字符串的子字符串。

    STRIP 将返回给定字符串的子字符串，并删除前导和尾随空格。

    RANDOM 将返回一个给定长度的随机字符串，该字符串由给定字母表中的字符组成。默认长度为 5 个字符，默认字母表为所有数字和大小写字母。

    以下字符在正则表达式中具有特殊含义

       ^         Matches at beginning of a line
       $         Matches at end of a line
       .         Matches any single character
       [ ]       Matches any character(s) inside the brackets
       [^ ]      Matches any character(s) not inside the brackets
        -        Matches any character in range on either side of a dash
       *         Matches preceding pattern zero or more times
       +         Matches preceding pattern one or more times
       ?         Matches preceding pattern zero or once only
       |         Matches a pattern on either side of the |
       ()        Saves a matched subexpression, which can be referenced in the REGEX REPLACE operation. Additionally it is saved in the special CMake variables CMAKE_MATCH_(0..9).
  • target_link_libraries: 将目标链接到给定的库。
      target_link_libraries(<target> [lib1 [lib2 [...]]]
                            [[debug|optimized|general] <lib>] ...)

    指定要链接到指定目标的库列表。如果任何库名称与当前项目中的目标名称匹配，则将在构建系统中自动添加依赖项，以确保在目标链接之前链接的库是最新的。

    关键字“debug”、“optimized”或“general”指示紧随其后的库仅在相应的构建配置中使用。“debug”关键字对应于 Debug 配置（如果设置了 DEBUG_CONFIGURATIONS 全局属性，则对应于该属性中命名的配置）。“optimized”关键字对应于所有其他配置。“general”关键字对应于所有配置，并且是完全可选的（如果省略，则假定）。通过创建和链接到 IMPORTED 库目标，可以实现针对每个配置规则的更高粒度。有关更多信息，请参见 add_library 命令的 IMPORTED 模式。

    库依赖关系默认情况下是可传递的。当此目标链接到另一个目标时，链接到此目标的库也会出现在另一个目标的链接行中。请参阅 LINK_INTERFACE_LIBRARIES 目标属性以覆盖目标的传递链接依赖项集。

      target_link_libraries(<target> LINK_INTERFACE_LIBRARIES
                            [[debug|optimized|general] <lib>] ...)

    LINK_INTERFACE_LIBRARIES 模式将库追加到 LINK_INTERFACE_LIBRARIES 及其每个配置等效目标属性，而不是用于链接。指定为“debug”的库将追加到 LINK_INTERFACE_LIBRARIES_DEBUG 属性（如果设置了 DEBUG_CONFIGURATIONS 全局属性，则追加到与该属性中列出的配置相对应的属性）。指定为“optimized”的库将追加到 LINK_INTERFACE_LIBRARIES 属性。指定为“general”（或不带任何关键字）的库将被视为同时指定为“debug”和“optimized”。

  • try_compile: 尝试编译一些代码。
      try_compile(RESULT_VAR bindir srcdir
                  projectName <targetname> [CMAKE_FLAGS <Flags>]
                  [OUTPUT_VARIABLE var])

    尝试编译程序。在这种形式中，srcdir 应该包含一个完整的 CMake 项目，其中包含 CMakeLists.txt 文件和所有源代码。运行此命令后，不会删除 bindir 和 srcdir。如果指定了 <目标名称>，则仅构建该目标，否则将构建 all 或 ALL_BUILD 目标。

      try_compile(RESULT_VAR bindir srcfile
                  [CMAKE_FLAGS <Flags>]
                  [COMPILE_DEFINITIONS <flags> ...]
                  [OUTPUT_VARIABLE var]
                  [COPY_FILE <filename> )

    尝试编译 srcfile。在这种情况下，用户只需要提供一个源文件。CMake 将创建适当的 CMakeLists.txt 文件来构建源代码。如果使用 COPY_FILE，则编译后的文件将被复制到给定的文件。

    在此版本中，bindir/CMakeFiles/CMakeTmp 中的所有文件将被自动清理，为了调试，可以将 --debug-trycompile 传递给 cmake 以避免清理。可以包含的一些额外标志是 INCLUDE_DIRECTORIES、LINK_DIRECTORIES 和 LINK_LIBRARIES。COMPILE_DEFINITIONS 是 -Ddefinition，它将被传递到编译行。try_compile 动态创建一个 CMakeList.txt 文件，如下所示

      add_definitions( <expanded COMPILE_DEFINITIONS from calling cmake>)
      include_directories(${INCLUDE_DIRECTORIES})
      link_directories(${LINK_DIRECTORIES})
      add_executable(cmTryCompileExec sources)
      target_link_libraries(cmTryCompileExec ${LINK_LIBRARIES})

    在这两个命令版本中，如果指定了 OUTPUT_VARIABLE，则构建过程的输出将存储在给定的变量中。在 RESULT_VAR 中返回成功或失败。CMAKE_FLAGS 可用于将 -DVAR:TYPE=VALUE 标志传递给构建过程中运行的 cmake。

  • try_run: 尝试编译并运行一些代码。
      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>...])

    尝试编译 srcfile。在 COMPILE_RESULT_VAR 中返回 TRUE 或 FALSE 以表示成功或失败。然后，如果编译成功，则运行可执行文件并在 RUN_RESULT_VAR 中返回其退出代码。如果可执行文件已构建，但无法运行，则 RUN_RESULT_VAR 将被设置为 FAILED_TO_RUN。COMPILE_OUTPUT_VARIABLE 指定编译步骤的输出所在的变量。RUN_OUTPUT_VARIABLE 指定运行的可执行文件的输出所在的变量。

    出于兼容性原因，仍然支持 OUTPUT_VARIABLE，它提供来自编译和运行步骤的组合输出。


    交叉编译问题

    交叉编译时，第一步编译的可执行文件通常无法在构建主机上运行。try_run() 检查 CMAKE_CROSSCOMPILING 变量以检测 CMake 是否处于交叉编译模式。如果是这种情况，它将仍然尝试编译可执行文件，但不会尝试运行可执行文件。相反，它将创建缓存变量，这些变量必须由用户填充，或者在某些 CMake 脚本文件中预设为可执行文件在实际目标平台上运行时会产生的值。这些变量是 RUN_RESULT_VAR（解释见上文），如果使用了 RUN_OUTPUT_VARIABLE（或 OUTPUT_VARIABLE），则还有一个额外的缓存变量 RUN_RESULT_VAR__COMPILE_RESULT_VAR__TRYRUN_OUTPUT。这旨在保存可执行文件的标准输出和标准错误。

    为了使交叉编译项目更容易，仅在真正需要时才使用 try_run。如果使用 try_run，仅在真正需要时才使用 RUN_OUTPUT_VARIABLE（或 OUTPUT_VARIABLE）。使用它们将要求在交叉编译时手动将缓存变量设置为可执行文件的输出。您还可以使用 if(CMAKE_CROSSCOMPILING) 来“保护”对 try_run 的调用，并为此情况提供一个易于预设的替代方案。

  • unset: 取消设置变量、缓存变量或环境变量。
      unset(<variable> [CACHE])

    删除指定的变量，使其变为未定义。如果存在 CACHE，则从缓存中删除变量，而不是从当前作用域中删除。

    <variable> 可以是环境变量，例如

      unset(ENV{LD_LIBRARY_PATH})

    在这种情况下，将从当前环境中删除该变量。

  • variable_watch: 监视 CMake 变量的变化。
      variable_watch(<variable name> [<command to execute>])

    如果指定的变量发生变化，则将打印关于变量发生变化的消息。如果指定了命令，则将执行该命令。该命令将接收以下参数：COMMAND(<variable> <access> <value> <current list file> <stack>)

  • while: 在条件为真时评估一组命令
      while(condition)
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endwhile(condition)

    while 和匹配的 endwhile 之间的命令将被记录而不被调用。一旦评估了 endwhile，则记录的命令列表将在条件为真的情况下被调用。条件使用与 if 命令相同的逻辑进行评估。

属性

  CMake Properties - Properties supported by CMake, the Cross-Platform Makefile Generator.

这是对 CMake 支持的属性的文档。属性可以具有不同的范围。它们可以分配给源文件、目录、目标或全局分配给 CMake。通过修改属性的值，可以自定义构建系统的行为。

全局范围的属性

  • ALLOW_DUPLICATE_CUSTOM_TARGETS: 允许创建重复的自定义目标。

    通常情况下，CMake 要求在项目中构建的所有目标都具有全局唯一的逻辑名称（请参阅策略 CMP0002）。这是在 Xcode 和 VS IDE 生成器中生成有意义的项目文件名所必需的。它还允许以不模糊的方式引用目标名称。

    Makefile 生成器能够支持重复的自定义目标名称。对于只关心 Makefile 生成器并且不希望支持 Xcode 或 VS IDE 生成器的项目，可以将此属性设置为 true 以允许重复的自定义目标。该属性允许在不同目录中的多个 add_custom_target 命令调用指定相同的目标名称。但是，设置此属性会导致非 Makefile 生成器产生错误并拒绝生成项目。

  • DEBUG_CONFIGURATIONS: 指定哪些配置用于调试。

    该值必须是一个用分号分隔的配置名称列表。目前，此属性仅由 target_link_libraries 命令使用（请参阅其文档以了解详细信息）。将来可能会定义其他用途。

    此属性必须在项目的顶层设置，并且必须在第一个 target_link_libraries 命令调用之前设置。如果列表中的任何条目与项目有效的配置不匹配，则行为未定义。

  • DISABLED_FEATURES: CMake 运行期间禁用的功能列表。

    CMake 运行期间禁用的功能列表。默认情况下，它包含所有未找到的包的名称。这是使用 <NAME>_FOUND 变量确定的。以 QUIET 模式搜索的包不会被列出。项目可以将自己的功能添加到此列表中。此属性由 FeatureSummary.cmake 中的宏使用。

  • ENABLED_FEATURES: CMake 运行期间启用的功能列表。

    CMake 运行期间启用的功能列表。默认情况下，它包含所有找到的包的名称。这是使用 <NAME>_FOUND 变量确定的。以 QUIET 模式搜索的包不会被列出。项目可以将自己的功能添加到此列表中。此属性由 FeatureSummary.cmake 中的宏使用。

  • ENABLED_LANGUAGES: 包含当前启用的语言列表的只读属性

    设置为当前启用的语言列表。

  • FIND_LIBRARY_USE_LIB64_PATHS: FIND_LIBRARY 是否应该自动搜索 lib64 目录。

    FIND_LIBRARY_USE_LIB64_PATHS 是一个布尔值，指定 FIND_LIBRARY 命令在构建 64 位二进制文件时是否应该自动搜索搜索路径中名为 lib 的目录的 lib64 变体。

  • GLOBAL_DEPENDS_DEBUG_MODE: 启用全局目标依赖关系图调试模式。

    CMake 在本机构建系统生成开始时会自动分析全局目标间依赖关系图。此属性导致它将分析的详细信息显示到 stderr。

  • IN_TRY_COMPILE: 在尝试编译配置期间为真的只读属性。

    在 TRY_COMPILE 或 TRY_RUN 命令内构建项目时为真。

  • PACKAGES_FOUND: CMake 运行期间找到的包列表。

    CMake 运行期间找到的包列表。是否找到包是使用 <NAME>_FOUND 变量确定的。

  • PACKAGES_NOT_FOUND: CMake 运行期间未找到的包列表。

    CMake 运行期间未找到的包列表。是否找到包是使用 <NAME>_FOUND 变量确定的。

  • REPORT_UNDEFINED_PROPERTIES: 如果设置，将所有未定义的属性报告到此文件。

    如果此属性设置为文件名，则 CMake 运行时将报告访问但未定义的任何属性或变量到此属性中指定的文件名。

  • TARGET_ARCHIVES_MAY_BE_SHARED_LIBS: 设置是否允许将共享库命名为存档。

    在 AIX 上，共享库可以命名为“lib<name>.a”。在这些平台上，此属性设置为 true。

  • TARGET_SUPPORTS_SHARED_LIBS: 目标平台是否支持共享库。

    TARGET_SUPPORTS_SHARED_LIBS 是一个布尔值，指定目标平台是否支持共享库。基本上所有当前的通用目的操作系统都这样做，例外通常是没有任何操作系统或具有特殊操作系统的嵌入式系统。

  • __CMAKE_DELETE_CACHE_CHANGE_VARS_: 内部属性

    用于检测编译器更改，请勿设置。

目录属性

  • ADDITIONAL_MAKE_CLEAN_FILES: 在 make clean 阶段清理的其他文件。

    将在“make clean”阶段清理的文件列表。

  • CACHE_VARIABLES: 当前目录中可用的缓存变量列表。

    此只读属性指定当前定义的 CMake 缓存变量列表。它旨在用于调试目的。

  • CLEAN_NO_CUSTOM: 是否应保留自定义命令的输出。

    如果为 true，则此目录的自定义命令的输出在“make clean”阶段不会被删除。

  • COMPILE_DEFINITIONS: 用于编译目录源代码的预处理器定义。

    COMPILE_DEFINITIONS 属性可以设置为使用语法 VAR 或 VAR=value 的预处理器定义列表。不支持函数式定义。CMake 会自动为本机构建系统正确地转义该值（请注意，CMake 语言语法可能需要转义才能指定某些值）。可以使用名称 COMPILE_DEFINITIONS_<CONFIG> 在每个配置的基础上设置此属性，其中 <CONFIG> 是一个大写名称（例如，“COMPILE_DEFINITIONS_DEBUG”）。此属性将在每个目录中由其在目录父级中的值初始化。

    CMake 会自动删除本机构建工具不支持的某些定义。VS6 IDE 不支持带值的定义（但 NMake 支持）。

    免责声明：大多数本机构建工具对转义某些值的支持很差。CMake 对许多情况都有解决方法，但某些值可能无法正确传递。如果某个值似乎没有被正确转义，请不要尝试通过向该值添加转义序列来解决问题。你的解决方法可能会在未来版本中因 CMake 改善了转义支持而失效。相反，请考虑在（已配置的）头文件中定义宏。然后报告限制。

  • COMPILE_DEFINITIONS_<CONFIG>: 目录中的每个配置预处理器定义。

    这是 COMPILE_DEFINITIONS 的特定于配置的版本。此属性将在每个目录中由其在目录父级中的值初始化。

  • DEFINITIONS: 仅为了与 CMake 2.4 保持兼容性。请使用 COMPILE_DEFINITIONS 代替。

    此只读属性指定迄今为止传递给 add_definitions 命令的标志列表。它用于调试目的。请使用 COMPILE_DEFINITIONS 代替。

  • EXCLUDE_FROM_ALL: 将目录从其父级的 all 目标中排除。

    目录上的一个属性，指示其目标是否从默认构建目标中排除。如果不是，那么使用 Makefile 时，例如输入 make 会导致构建这些目标。相同概念适用于其他生成器的默认构建。

  • IMPLICIT_DEPENDS_INCLUDE_TRANSFORM: 指定目录中依赖项的 #include 行转换。

    此属性指定在对 C 和 C++ 源文件的隐式依赖项扫描期间转换类似宏的 #include 行的规则。规则列表必须用分号分隔，每个条目都采用 "A_MACRO(%)=value-with-%" 格式（% 必须是文字）。在依赖项扫描期间，#include 行上的 A_MACRO(...) 出现将被用给定宏参数替换 '%' 的值替换。例如，条目

      MYDIR(%)=<mydir/%>

    将转换以下形式的行

      #include MYDIR(myheader.h)

    为

      #include <mydir/myheader.h>

    允许跟踪依赖项。

    此属性适用于目录中所有目标的源代码。此属性值将在每个目录中由其在目录父级中的值初始化。

  • INCLUDE_DIRECTORIES: 预处理器包含文件搜索目录列表。

    此只读属性指定迄今为止传递给 include_directories 命令的目录列表。它用于调试目的。

  • INCLUDE_REGULAR_EXPRESSION: 包含文件扫描正则表达式。

    此只读属性指定在依赖项扫描期间用于匹配应跟踪的包含文件的正则表达式。请参阅 include_regular_expression 命令。

  • LINK_DIRECTORIES: 链接器搜索目录列表。

    此只读属性指定迄今为止传递给 link_directories 命令的目录列表。它用于调试目的。

  • LISTFILE_STACK: 当前正在处理的列表文件堆栈。

    此属性主要在尝试调试 CMake 脚本中的错误时有用。它返回一个正在处理的列表文件列表，按顺序排列。因此，如果一个列表文件执行 INCLUDE 命令，那么这实际上是在将包含的列表文件压入堆栈。

  • MACROS: 当前目录中可用的宏命令列表。

    此只读属性指定当前定义的 CMake 宏列表。它用于调试目的。请参阅 macro 命令。

  • PARENT_DIRECTORY: 添加当前子目录的源目录。

    此只读属性指定将当前源目录添加为构建的子目录的源目录。在顶层目录中，该值为空字符串。

  • TEST_INCLUDE_FILE: 在运行 ctest 时将包含的 cmake 文件。

    如果你指定了 TEST_INCLUDE_FILE，那么当在目录上运行 ctest 时，将包含并处理该文件。

  • VARIABLES: 当前目录中定义的变量列表。

    此只读属性指定当前定义的 CMake 变量列表。它用于调试目的。

目标属性

  • <CONFIG>_POSTFIX: 要附加到配置 <CONFIG> 的目标文件名后面的后缀。

    使用配置 <CONFIG> 构建时，此属性的值将附加到磁盘上构建的目标文件名。对于非可执行目标，如果在创建目标时设置了变量 CMAKE_<CONFIG>_POSTFIX，则此属性将由其值初始化。此属性在 Mac 上的框架和应用程序捆绑包中被忽略。

  • ARCHIVE_OUTPUT_DIRECTORY: 构建 ARCHIVE 目标文件的输出目录。

    此属性指定应构建存档目标文件的目录。可以构建三种目标文件：存档、库和运行时。可执行文件始终被视为运行时目标。静态库始终被视为存档目标。模块库始终被视为库目标。对于非 DLL 平台，共享库被视为库目标。对于 DLL 平台，共享库的 DLL 部分被视为运行时目标，相应的导入库被视为存档目标。所有基于 Windows 的系统（包括 Cygwin）都是 DLL 平台。如果在创建目标时设置了变量 CMAKE_ARCHIVE_OUTPUT_DIRECTORY，则此属性将由其值初始化。

  • BUILD_WITH_INSTALL_RPATH: 构建树目标是否应该具有安装树 rpath。

    BUILD_WITH_INSTALL_RPATH 是一个布尔值，指定是否使用 INSTALL_RPATH 链接构建树中的目标。这优先于 SKIP_BUILD_RPATH，并避免了在安装之前重新链接的需要。

  • CLEAN_DIRECT_OUTPUT: 不要删除此目标的其他变体。

    当构建库时，CMake 默认情况下会生成代码以删除使用所有可能名称的任何现有库。这是为了支持通过用户选项在 STATIC 和 SHARED 之间切换的库。但是，当使用 OUTPUT_NAME 构建使用不同逻辑目标名称的相同名称的静态库和共享库时，这两个目标将删除彼此的文件。可以通过将 CLEAN_DIRECT_OUTPUT 属性设置为 1 来防止这种情况。

  • COMPILE_DEFINITIONS: 用于编译目标源代码的预处理器定义。

    COMPILE_DEFINITIONS 属性可以设置为使用语法 VAR 或 VAR=value 的预处理器定义列表。不支持函数式定义。CMake 会自动为本机构建系统正确地转义该值（请注意，CMake 语言语法可能需要转义才能指定某些值）。可以使用名称 COMPILE_DEFINITIONS_<CONFIG> 在每个配置的基础上设置此属性，其中 <CONFIG> 是一个大写名称（例如，“COMPILE_DEFINITIONS_DEBUG”）。

    CMake 会自动删除本机构建工具不支持的某些定义。VS6 IDE 不支持带值的定义（但 NMake 支持）。

    免责声明：大多数本机构建工具对转义某些值的支持很差。CMake 对许多情况都有解决方法，但某些值可能无法正确传递。如果某个值似乎没有被正确转义，请不要尝试通过向该值添加转义序列来解决问题。你的解决方法可能会在未来版本中因 CMake 改善了转义支持而失效。相反，请考虑在（已配置的）头文件中定义宏。然后报告限制。

  • COMPILE_DEFINITIONS_<CONFIG>: 目标上的每个配置预处理器定义。

    这是 COMPILE_DEFINITIONS 的特定于配置的版本。

  • COMPILE_FLAGS: 用于编译此目标源代码的附加标志。

    COMPILE_FLAGS 属性设置用于构建目标内源代码的附加编译器标志。请使用 COMPILE_DEFINITIONS 传递额外的预处理器定义。

  • DEBUG_POSTFIX: 请参阅目标属性 <CONFIG>_POSTFIX。

    此属性是更通用的 <CONFIG>_POSTFIX 属性针对 DEBUG 配置的特殊情况。

  • DEFINE_SYMBOL: 在编译此目标源代码时定义一个符号。

    DEFINE_SYMBOL 设置编译共享库中的源代码时定义的预处理器符号的名称。如果此处未设置，则默认设置为 target_EXPORTS（如果目标不是有效的 C 标识符，则会进行一些替换）。这对于头文件知道它们是从其库内部还是外部包含进来非常有用，以便正确设置 dllexport/dllimport 装饰。

  • ENABLE_EXPORTS: 指定可执行文件是否为可加载模块导出符号。

    通常，可执行文件不会导出任何符号，因为它是一个最终程序。可执行文件可以导出符号，供可加载模块使用。当此属性设置为 true 时，CMake 会允许其他目标使用 TARGET_LINK_LIBRARIES 命令“链接”到可执行文件。在所有平台上，都会为链接到可执行文件的目标创建目标级依赖关系。对于非 DLL 平台，链接规则会被简单地忽略，因为动态加载器在加载模块时会自动绑定符号。对于 DLL 平台，将为导出的符号创建导入库，然后用于链接。所有基于 Windows 的系统（包括 Cygwin）都是 DLL 平台。

  • EXCLUDE_FROM_ALL: 将目标从 all 目标中排除。

    目标上的一个属性，指示目标是否从默认构建目标中排除。如果不是，那么使用 Makefile 时，例如输入 make 会导致构建此目标。相同概念适用于其他生成器的默认构建。安装具有 EXCLUDE_FROM_ALL 设置为 true 的目标会导致未定义的行为。

  • EchoString: 在构建目标时显示的消息。

    在某些生成器（例如 makefile）上，在构建目标时显示的消息。

  • FRAMEWORK: 此目标是 Mac 上的一个框架。

    如果共享库目标将此属性设置为 true，那么它将在 Mac 上构建时被构建为一个框架。它将具有框架所需的目录结构，并且适合与 -framework 选项一起使用。

  • Fortran_MODULE_DIRECTORY: 指定目标提供的 Fortran 模块的输出目录。

    如果目标包含提供模块的 Fortran 源文件，并且编译器支持模块输出目录，则此属性指定放置模块的目录。未设置此属性时，模块将放置在与目标源目录相对应的构建目录中。如果在创建目标时设置了变量 CMAKE_Fortran_MODULE_DIRECTORY，则其值将用于初始化此属性。

  • GENERATOR_FILE_NAME: 此目标的生成器的文件。

    一些生成器用来记录与该目标关联的项目或 dsp 文件名称的内部属性。

  • HAS_CXX: 强制目标使用 CXX 链接器。

    在目标上设置 HAS_CXX 将强制目标即使没有 C++ 代码也要使用 C++ 链接器（和 C++ 运行时库）进行链接。

  • IMPLICIT_DEPENDS_INCLUDE_TRANSFORM: 指定目标依赖项中的 #include 行转换。

    此属性指定在对 C 和 C++ 源文件的隐式依赖项扫描期间转换类似宏的 #include 行的规则。规则列表必须用分号分隔，每个条目都采用 "A_MACRO(%)=value-with-%" 格式（% 必须是文字）。在依赖项扫描期间，#include 行上的 A_MACRO(...) 出现将被用给定宏参数替换 '%' 的值替换。例如，条目

      MYDIR(%)=<mydir/%>

    将转换以下形式的行

      #include MYDIR(myheader.h)

    为

      #include <mydir/myheader.h>

    允许跟踪依赖项。

    此属性适用于其设置的目标中的源文件。

  • IMPORTED: 目标是否为 IMPORTED 的只读指示。

    此属性的布尔值为使用 IMPORTED 选项添加到 add_executable 或 add_library 创建的目标为真。对于在项目中构建的目标为假。

  • IMPORTED_CONFIGURATIONS: 为 IMPORTED 目标提供的配置。

    列出 IMPORTED 目标可用的配置名称。这些名称对应于从目标导入的项目中定义的配置。如果导入项目使用不同的配置集，则可以使用 MAP_IMPORTED_CONFIG_<CONFIG> 属性映射这些名称。对于非导入目标，此属性将被忽略。

  • IMPORTED_IMPLIB: IMPORTED 目标的导入库的完整路径。

    指定 Windows DLL 的 ".lib" 部分的位置。对于非导入目标，此属性将被忽略。

  • IMPORTED_IMPLIB_<CONFIG>: IMPORTED_IMPLIB 属性的每个配置版本。

    此属性在加载导入目标的 <CONFIG> 配置的设置时使用。配置名称对应于从目标导入的项目提供的配置名称。

  • IMPORTED_LINK_DEPENDENT_LIBRARIES: 导入的共享库的依赖共享库。

    共享库可以链接到其他共享库作为其实现的一部分。在某些平台上，链接器会搜索他们正在链接的共享库的依赖库。此属性列出了导入库的依赖共享库。此列表应与 IMPORTED_LINK_INTERFACE_LIBRARIES 属性中的接口库列表不重叠。在需要在链接时找到依赖共享库的平台上，CMake 使用此列表向链接命令行添加适当的文件或路径。对于非导入目标，此属性将被忽略。

  • IMPORTED_LINK_DEPENDENT_LIBRARIES_<CONFIG>: IMPORTED_LINK_DEPENDENT_LIBRARIES 的每个配置版本。

    此属性在加载导入目标的 <CONFIG> 配置的设置时使用。配置名称对应于从目标导入的项目提供的配置名称。如果已设置，此属性将完全覆盖命名配置的通用属性。

  • IMPORTED_LINK_INTERFACE_LIBRARIES: IMPORTED 目标的传递链接接口。

    列出当 IMPORTED 库目标链接到另一个目标时其接口将被包含的库。这些库将包含在目标的链接行中。与 LINK_INTERFACE_LIBRARIES 属性不同，此属性适用于所有导入的目标类型，包括 STATIC 库。此属性对于非导入目标将被忽略。

  • IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG>: IMPORTED_LINK_INTERFACE_LIBRARIES 的每个配置版本。

    此属性在加载导入目标的 <CONFIG> 配置的设置时使用。配置名称对应于从目标导入的项目提供的配置名称。如果已设置，此属性将完全覆盖命名配置的通用属性。

  • IMPORTED_LOCATION: IMPORTED 目标在磁盘上的主文件的完整路径。

    指定 IMPORTED 目标文件在磁盘上的位置。对于可执行文件，这是可执行文件的位置。对于 OS X 上的捆绑包，这是应用程序捆绑包文件夹下 Contents/MacOS 中的可执行文件的位置。对于静态库和模块，这是库或模块的位置。对于非 DLL 平台上的共享库，这是共享库的位置。对于 OS X 上的框架，这是框架文件夹内库文件符号链接的位置。对于 DLL，这是 ".dll" 部分库的位置。对于 UNKNOWN 库，这是要链接的文件的位置。对于非导入目标，此属性将被忽略。

  • IMPORTED_LOCATION_<CONFIG>: IMPORTED_LOCATION 属性的每个配置版本。

    此属性在加载导入目标的 <CONFIG> 配置的设置时使用。配置名称对应于从目标导入的项目提供的配置名称。

  • IMPORTED_SONAME: 共享库类型的 IMPORTED 目标的 "soname"。

    指定嵌入导入共享库的 "soname"。这仅在支持该功能的平台上有意义。对于非导入目标，此属性将被忽略。

  • IMPORTED_SONAME_<CONFIG>: IMPORTED_SONAME 属性的每个配置版本。

    此属性在加载导入目标的 <CONFIG> 配置的设置时使用。配置名称对应于从目标导入的项目提供的配置名称。

  • IMPORT_PREFIX: 导入库名称之前的部分。

    类似于目标属性 PREFIX，但用于导入库（通常对应于 DLL）而不是常规库。可以设置为覆盖导入库名称的“lib”等前缀的目标属性。

  • IMPORT_SUFFIX: 导入库名称之后的部分。

    类似于目标属性 SUFFIX，但用于导入库（通常对应于 DLL）而不是常规库。可以设置为覆盖导入库名称的 ".lib" 等后缀的目标属性。

  • INSTALL_NAME_DIR: Mac OSX 安装目标的目录名称。

    INSTALL_NAME_DIR 是一个字符串，指定 Mac OSX 上共享库的 "install_name" 字段中要使用的目录部分，用于安装的目标。

  • INSTALL_RPATH: 用于安装目标的 rpath。

    一个用分号分隔的列表，指定用于安装目标的 rpath（对于支持此功能的平台）。

  • INSTALL_RPATH_USE_LINK_PATH: 将路径添加到链接器搜索路径和已安装的 rpath。

    INSTALL_RPATH_USE_LINK_PATH 是一个布尔值，如果设置为 true，它会将链接器搜索路径中的目录和项目外部的目录附加到 INSTALL_RPATH。

  • LIBRARY_OUTPUT_DIRECTORY: 构建 LIBRARY 目标文件的输出目录。

    此属性指定应该构建库目标文件的目录。可能会构建三种类型的目标文件：存档、库和运行时。可执行文件始终被视为运行时目标。静态库始终被视为存档目标。模块库始终被视为库目标。对于非 DLL 平台，共享库被视为库目标。对于 DLL 平台，共享库的 DLL 部分被视为运行时目标，相应的导入库被视为存档目标。所有基于 Windows 的系统，包括 Cygwin，都是 DLL 平台。如果在创建目标时设置了变量 CMAKE_LIBRARY_OUTPUT_DIRECTORY，则此属性将由其值初始化。

  • LINKER_LANGUAGE: 用于链接的工具，基于语言。

    LINKER_LANGUAGE 属性用于更改用于链接可执行文件或共享库的工具。默认情况下，该语言设置为与库中的文件匹配。CXX 和 C 是此属性的常见值。

  • LINK_FLAGS: 链接此目标时使用的附加标志。

    LINK_FLAGS 属性可用于向目标的链接步骤添加额外的标志。LINK_FLAGS_<CONFIG> 将添加到配置 <CONFIG>，例如，DEBUG、RELEASE、MINSIZEREL、RELWITHDEBINFO。

  • LINK_FLAGS_<CONFIG>: 目标的每个配置链接器标志。

    这是 LINK_FLAGS 的特定于配置的版本。

  • LINK_INTERFACE_LIBRARIES: 列出共享库或可执行文件的公共接口库。

    默认情况下，链接到共享库目标会传递链接到库本身链接的目标。对于具有导出项的可执行文件（参见 ENABLE_EXPORTS 属性），不使用默认的传递链接依赖项。此属性用明确的列表替换默认的传递链接依赖项。当目标链接到另一个目标时，列出的库（以及递归地它们的链接接口库）也将提供给另一个目标。如果列表为空，则即使默认集非空，当此目标链接到另一个目标时，也不会合并任何传递链接依赖项。此属性对于 STATIC 库将被忽略。

  • LINK_INTERFACE_LIBRARIES_<CONFIG>: 目标的公共接口库的每个配置列表。

    这是 LINK_INTERFACE_LIBRARIES 的特定于配置的版本。如果已设置，此属性将完全覆盖命名配置的通用属性。

  • LINK_SEARCH_END_STATIC: 结束链接行，以便使用静态系统库。

    一些链接器支持诸如 -Bstatic 和 -Bdynamic 之类的开关，以确定是否使用静态或共享库来处理 -lXXX 选项。CMake 使用这些选项来设置库的链接类型，这些库的完整路径未知或（在某些情况下）位于平台的隐式链接目录中。默认情况下，链接器搜索类型在库列表末尾保留为 -Bdynamic。此属性将最终的链接器搜索类型切换为 -Bstatic。

  • LOCATION: 目标在磁盘上的只读位置。

    对于导入的目标，此只读属性返回未指定配置 <CONFIG> 的 LOCATION_<CONFIG> 属性的值，该属性由目标提供。

    对于非导入的目标，此属性是为了与 CMake 2.4 及更低版本兼容而提供的。它旨在获取可执行目标的输出文件的位置，以便在 add_custom_command 中使用。路径可能包含构建系统特定的部分，该部分在构建时会替换为正在构建的配置（例如，VS 中的 "$(ConfigurationName)"）。在 CMake 2.6 及更高版本中，add_custom_command 会自动识别其 COMMAND 和 DEPENDS 选项中的目标名称并计算目标位置。因此，此属性不需要用于创建自定义命令。

  • LOCATION_<CONFIG>: 提供目标在磁盘上的位置的只读属性。

    一个只读属性，指示目标的主文件在配置 <CONFIG> 的磁盘上的位置。该属性仅针对库和可执行目标定义。导入的目标可能提供一组与导入项目不同的配置。默认情况下，CMake 会查找完全匹配项，否则会使用任意的可用配置。使用 MAP_IMPORTED_CONFIG_<CONFIG> 属性来显式映射导入的配置。

  • MACOSX_BUNDLE: 将可执行文件作为 Mac OS X 上的应用程序捆绑包构建。

    当此属性设置为 true 时，在 Mac OS X 上构建的可执行文件将被创建为应用程序捆绑包。这使其成为可以从 Finder 启动的 GUI 可执行文件。有关应用程序捆绑包的 Info.plist 文件创建的信息，请参见 MACOSX_BUNDLE_INFO_PLIST 目标属性。

  • MACOSX_BUNDLE_INFO_PLIST: 为 Mac OS X 应用程序捆绑包指定自定义 Info.plist 模板。

    启用 MACOSX_BUNDLE 的可执行目标将在 Mac OS X 上构建为应用程序包。默认情况下，其 Info.plist 文件是通过配置位于 CMAKE_MODULE_PATH 中的名为 MacOSXBundleInfo.plist.in 的模板创建的。此属性指定一个可选的模板文件名，它可以是完整路径。

    可以设置以下目标属性来指定要配置到文件中的内容

      MACOSX_BUNDLE_INFO_STRING
      MACOSX_BUNDLE_ICON_FILE
      MACOSX_BUNDLE_GUI_IDENTIFIER
      MACOSX_BUNDLE_LONG_VERSION_STRING
      MACOSX_BUNDLE_BUNDLE_NAME
      MACOSX_BUNDLE_SHORT_VERSION_STRING
      MACOSX_BUNDLE_BUNDLE_VERSION
      MACOSX_BUNDLE_COPYRIGHT

    具有相同名称的 CMake 变量可以设置为影响目录中所有未设置特定属性的目标。如果此属性指定了一个自定义 Info.plist，当然可以对所有设置进行硬编码，而不是使用目标属性。

  • MACOSX_FRAMEWORK_INFO_PLIST: 指定 Mac OS X 框架的自定义 Info.plist 模板。

    启用 FRAMEWORK 的库目标将在 Mac OS X 上构建为框架。默认情况下，其 Info.plist 文件是通过配置位于 CMAKE_MODULE_PATH 中的名为 MacOSXFrameworkInfo.plist.in 的模板创建的。此属性指定一个可选的模板文件名，它可以是完整路径。

    可以设置以下目标属性来指定要配置到文件中的内容

      MACOSX_FRAMEWORK_ICON_FILE
      MACOSX_FRAMEWORK_IDENTIFIER
      MACOSX_FRAMEWORK_SHORT_VERSION_STRING
      MACOSX_FRAMEWORK_BUNDLE_VERSION

    具有相同名称的 CMake 变量可以设置为影响目录中所有未设置特定属性的目标。如果此属性指定了一个自定义 Info.plist，当然可以对所有设置进行硬编码，而不是使用目标属性。

  • MAP_IMPORTED_CONFIG_<CONFIG>: 将项目配置映射到导入目标的配置。

    列出导入目标的配置，这些配置可用于当前项目的 <CONFIG> 配置。从另一个项目导入的目标可能无法提供与当前项目中相同的配置名称集。设置此属性告诉 CMake 哪些导入配置适合在构建 <CONFIG> 配置时使用。将选择列表中第一个发现由导入目标提供的配置。如果找不到匹配的配置，则认为未找到导入的目标。此属性对于非导入目标被忽略。

  • OUTPUT_NAME: 设置目标构建时的实际名称。

    设置目标构建时的实际名称，可用于帮助创建两个名称相同的目标，即使 CMake 要求逻辑目标名称唯一。还有一个 <CONFIG>_OUTPUT_NAME 可以根据配置设置输出名称。

  • POST_INSTALL_SCRIPT: 已弃用的安装支持。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 属性是指定在安装目标之前和之后运行的 CMake 脚本的旧方法。它们仅在使用旧的 INSTALL_TARGETS 命令安装目标时使用。使用 INSTALL 命令代替。

  • PREFIX: 库名称之前的部分。

    一个目标属性，可以设置为覆盖库名称的前缀（例如 "lib"）。

  • PRE_INSTALL_SCRIPT: 已弃用的安装支持。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 属性是指定在安装目标之前和之后运行的 CMake 脚本的旧方法。它们仅在使用旧的 INSTALL_TARGETS 命令安装目标时使用。使用 INSTALL 命令代替。

  • PRIVATE_HEADER: 在 FRAMEWORK 共享库目标中指定私有头文件。

    标记有 FRAMEWORK 属性的共享库目标在 OS X 上生成框架，在其他平台上生成普通的共享库。此属性可以设置为一个头文件列表，这些文件将被放置在框架文件夹内的 PrivateHeaders 目录中。在非 Apple 平台上，这些头文件可以使用 PRIVATE_HEADER 选项安装到 install(TARGETS) 命令中。

  • PROJECT_LABEL: 更改 IDE 中目标的名称。

    可用于更改 IDE（如 Visual Studio）中目标的名称。

  • PUBLIC_HEADER: 在 FRAMEWORK 共享库目标中指定公共头文件。

    标记有 FRAMEWORK 属性的共享库目标在 OS X 上生成框架，在其他平台上生成普通的共享库。此属性可以设置为一个头文件列表，这些文件将被放置在框架文件夹内的 Headers 目录中。在非 Apple 平台上，这些头文件可以使用 PUBLIC_HEADER 选项安装到 install(TARGETS) 命令中。

  • RESOURCE: 在 FRAMEWORK 共享库目标中指定资源文件。

    标记有 FRAMEWORK 属性的共享库目标在 OS X 上生成框架，在其他平台上生成普通的共享库。此属性可以设置为一个文件列表，这些文件将被放置在框架文件夹内的 Resources 目录中。在非 Apple 平台上，这些文件可以使用 RESOURCE 选项安装到 install(TARGETS) 命令中。

  • RUNTIME_OUTPUT_DIRECTORY: 构建 RUNTIME 目标文件的输出目录。

    此属性指定应该构建运行时目标文件的目录。有三种类型的目标文件可以构建：存档、库和运行时。可执行文件始终被视为运行时目标。静态库始终被视为存档目标。模块库始终被视为库目标。对于非 DLL 平台，共享库被视为库目标。对于 DLL 平台，共享库的 DLL 部分被视为运行时目标，相应的导入库被视为存档目标。所有基于 Windows 的系统（包括 Cygwin）都是 DLL 平台。如果在创建目标时设置了变量 CMAKE_RUNTIME_OUTPUT_DIRECTORY，则此属性将由其值初始化。

  • SKIP_BUILD_RPATH: 是否应该为构建树使用 rpath。

    SKIP_BUILD_RPATH 是一个布尔值，指定是否跳过自动生成允许目标从构建树中运行的 rpath。

  • SOURCES: 为目标指定的源名称。

    为目标指定的源的只读列表。返回的名称适合传递给 set_source_files_properties 命令。

  • SOVERSION: 此目标的版本号是什么。

    对于共享库，VERSION 和 SOVERSION 可以分别用于指定构建版本和 API 版本。在构建或安装时，如果平台支持符号链接，并且链接器支持 so-names，则会创建适当的符号链接。如果只指定了其中一个，则假设另一个具有相同的版本号。对于 Windows 上的共享库和可执行文件，VERSION 属性被解析以提取一个 "major.minor" 版本号。这些数字用作二进制文件的映像版本。

  • STATIC_LIBRARY_FLAGS: 链接静态库时使用的额外标志。

    链接静态库时使用的额外标志。

  • SUFFIX: 库名称之后的部分。

    一个目标属性，可以设置为覆盖库名称的后缀（例如 ".so"）。

  • TYPE: 目标的类型。

    此只读属性可用于测试给定目标的类型。它将是 STATIC_LIBRARY、MODULE_LIBRARY、SHARED_LIBRARY、EXECUTABLE 或内部目标类型之一。

  • VERSION: 此目标的版本号是什么。

    对于共享库，VERSION 和 SOVERSION 可用于分别指定构建版本和 API 版本。构建或安装时，如果平台支持符号链接且链接器支持 so-name，则会创建适当的符号链接。如果仅指定两者之一，则假定缺少的版本号相同。对于可执行文件，VERSION 可用于指定构建版本。构建或安装时，如果平台支持符号链接，则会创建适当的符号链接。对于 Windows 上的共享库和可执行文件，VERSION 属性将被解析以提取“major.minor”版本号。这些数字用作二进制文件的映像版本。

  • VS_KEYWORD: Visual Studio 项目关键字。

    可以设置为更改 Visual Studio 关键字，例如，如果将其设置为 Qt4VSv1.0，则 Qt 集成效果更好。

  • VS_SCC_LOCALPATH: Visual Studio 源代码控制提供者。

    可以设置为更改 Visual Studio 源代码控制本地路径属性。

  • VS_SCC_PROJECTNAME: Visual Studio 源代码控制项目。

    可以设置为更改 Visual Studio 源代码控制项目名称属性。

  • VS_SCC_PROVIDER: Visual Studio 源代码控制提供者。

    可以设置为更改 Visual Studio 源代码控制提供者属性。

  • WIN32_EXECUTABLE: 在 Windows 上构建具有 WinMain 入口点的可执行文件。

    当此属性设置为 true 时，在 Windows 上链接时创建的可执行文件将使用 WinMain() 入口点，而不是仅使用 main()。这使其成为 GUI 可执行文件而不是控制台应用程序。请参阅 CMAKE_MFC_FLAG 变量文档以配置 MFC 在 WinMain 可执行文件中的使用。

  • XCODE_ATTRIBUTE_<an-attribute>: 直接设置 Xcode 目标属性。

    告诉 Xcode 生成器在生成的 Xcode 项目中将 '<an-attribute>' 设置为给定值。在其他生成器上忽略。

测试属性

  • FAIL_REGULAR_EXPRESSION: 如果输出与该正则表达式匹配，则测试将失败。

    如果设置，如果输出与指定的正则表达式之一匹配，则测试将失败。例如：PASS_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"

  • MEASUREMENT: 指定要为测试报告的 DART 度量和值。

    如果设置为名称，则该名称将作为带 1 值的名义度量报告给 DART。您还可以通过将 MEASUREMENT 设置为 "measurement=value" 来指定一个值。

  • PASS_REGULAR_EXPRESSION: 输出必须与该正则表达式匹配才能使测试通过。

    如果设置，测试输出将与指定的正则表达式进行检查，并且至少有一个正则表达式必须匹配，否则测试将失败。

  • TIMEOUT: 允许此测试运行多少秒。

    如果设置了此属性，它将限制测试运行时间不超过指定的秒数。如果超过该时间，测试进程将被杀死，ctest 将进入下一个测试。此设置优先于 DART_TESTING_TIMEOUT 和 CTEST_TESTING_TIMEOUT。

  • WILL_FAIL: 如果设置为 true，这将反转测试的通过/失败标志。

    此属性可用于预计会失败并返回非零返回值的测试。

源文件属性

  • ABSTRACT: 此源文件是抽象类吗？

    源文件上的一个属性，指示源文件是否表示一个抽象类。这对于具有抽象类概念的语言才有意义，并且仅由将类包装到其他语言中的一些工具使用。

  • COMPILE_DEFINITIONS: 用于编译源文件的预处理器定义。

    COMPILE_DEFINITIONS 属性可以设置为使用语法 VAR 或 VAR=value 的预处理器定义列表。不支持函数式定义。CMake 会自动为本机构建系统正确地转义该值（请注意，CMake 语言语法可能需要转义才能指定某些值）。可以使用名称 COMPILE_DEFINITIONS_<CONFIG> 在每个配置的基础上设置此属性，其中 <CONFIG> 是一个大写名称（例如，“COMPILE_DEFINITIONS_DEBUG”）。

    CMake 会自动删除本机构建工具不支持的某些定义。VS6 IDE 不支持带值的定义（但 NMake 支持）。Xcode 不支持源文件上的每个配置定义。

    免责声明：大多数本机构建工具对转义某些值的支持很差。CMake 对许多情况都有解决方法，但某些值可能无法正确传递。如果某个值似乎没有被正确转义，请不要尝试通过向该值添加转义序列来解决问题。你的解决方法可能会在未来版本中因 CMake 改善了转义支持而失效。相反，请考虑在（已配置的）头文件中定义宏。然后报告限制。

  • COMPILE_DEFINITIONS_<CONFIG>: 源文件上的每个配置预处理器定义。

    这是 COMPILE_DEFINITIONS 的配置特定版本。请注意，Xcode 不支持每个配置源文件标志，因此此属性将被 Xcode 生成器忽略。

  • COMPILE_FLAGS: 编译此源文件时要添加的额外标志。

    这些标志将在构建此源文件时添加到编译标志列表中。使用 COMPILE_DEFINITIONS 传递额外的预处理器定义。

  • EXTERNAL_OBJECT: 如果设置为 true，则这是一个目标文件。

    如果此属性设置为 true，则源文件实际上是一个目标文件，不应编译。但它仍然会被链接到目标中。

  • GENERATED: 此源文件是否作为构建过程的一部分生成。

    如果源文件是由构建过程生成的，则 CMake 在依赖项检查等方面会以不同的方式处理它。否则，如果源文件不存在，可能会出现问题。

  • HEADER_FILE_ONLY: 此源文件是否仅为头文件。

    源文件上的一个属性，指示源文件是否是一个没有相关实现的头文件。这会根据文件扩展名自动设置，并由 CMake 用于确定是否应计算某些依赖项信息。

  • KEEP_EXTENSION: 使输出文件具有与源文件相同的扩展名。

    如果设置了此属性，则输出文件的扩展名将与源文件的扩展名相同。通常，输出文件扩展名是根据源文件的语言计算的，例如 .cxx 将使用 .o 扩展名。

  • LANGUAGE: 文件使用哪种编程语言。

    可以设置的属性，用于指示源文件使用哪种编程语言。如果没有设置，则语言是根据文件扩展名确定的。常见的值是 CXX C 等。

  • LOCATION: 源文件的完整路径。

    SOURCE FILE 上的只读属性，包含源文件的完整路径。

  • MACOSX_PACKAGE_LOCATION: 将源文件放置在 Mac OS X 包或框架中。

    设置了 MACOSX_BUNDLE 属性的可执行目标在 Apple 平台上被构建为 Mac OS X 应用程序包。设置了 FRAMEWORK 属性的共享库目标在 Apple 平台上被构建为 Mac OS X 框架。在目标中列出的设置了此属性的源文件将被复制到由属性值指定的包或框架内容文件夹内的目录中。对于包，内容文件夹为 “<name>.app/Contents”。对于框架，内容文件夹为 “<name>.framework/Versions/<version>”。有关指定用于 Headers、PrivateHeadres 或 Resources 目录的文件，请参见 PUBLIC_HEADER、PRIVATE_HEADER 和 RESOURCE 目标属性。

  • OBJECT_DEPENDS: 编译后的目标文件所依赖的额外文件。

    指定从该源文件编译的任何目标文件所依赖的文件的完整路径的分号分隔列表。如果任何指定的文件比目标文件更新，则目标文件将被重新编译。

    此属性不需要用于指定源文件对它包含的生成头文件的依赖关系。尽管该属性最初是为了此目的引入的，但现在不再需要。如果生成的头文件是由与源文件相同的目标中的自定义命令创建的，则自动依赖项扫描过程将识别依赖关系。如果生成的头文件是由另一个目标创建的，则应使用 add_dependencies 命令创建跨目标依赖项（如果由于链接关系而尚不存在）。

  • OBJECT_OUTPUTS: Makefile 规则的额外输出。

    编译此源文件创建的额外输出。如果这些输出中的任何一个丢失，则目标文件将被重新编译。这仅在 Makefile 生成器上支持，并在其他生成器上被忽略。

  • SYMBOLIC: 这仅仅是规则的名称吗？

    如果 SYMBOLIC（布尔值）设置为 true，则构建系统将被告知源文件实际上不是在磁盘上创建的，而是用作构建规则的符号名称。

  • WRAP_EXCLUDE: 将此源文件从任何代码包装技术中排除。

    某些包可以将源文件包装到其他语言中，以提供额外的功能。例如，可以使用 SWIG 等将 C++ 代码包装到 Java 或 Python 等中。如果 WRAP_EXCLUDE 设置为 true（1 等），则表示不应包装此源文件。

兼容性命令

  CMake Compatibility Listfile Commands - Obsolete commands supported by CMake for compatibility.

这是以前 CMake 版本中已过时的 listfile 命令的文档，出于兼容性原因仍然支持这些命令。您应该改用更新、更快、更闪亮的全新命令。 ;-)

  • build_name: 已弃用。请改用 ${CMAKE_SYSTEM} 和 ${CMAKE_CXX_COMPILER}。
      build_name(variable)

    将指定变量设置为表示平台和编译器设置的字符串。这些值现在可以通过 CMAKE_SYSTEM 和 CMAKE_CXX_COMPILER 变量获得。

  • exec_program: 已弃用。请改用 execute_process() 命令。

    在处理 CMakeList.txt 文件期间运行可执行程序。

      exec_program(Executable [directory in which to run]
                   [ARGS <arguments to executable>]
                   [OUTPUT_VARIABLE <var>]
                   [RETURN_VALUE <var>])

    可执行程序在可选指定的目录中运行。可执行程序可以包含参数（如果用双引号括起来），但最好使用可选的 ARGS 参数来指定程序的参数。这是因为 cmake 将能够对可执行程序路径中的空格进行转义。可选参数 OUTPUT_VARIABLE 指定一个变量，用于存储输出。要捕获执行的返回值，请提供 RETURN_VALUE。如果指定了 OUTPUT_VARIABLE，则没有任何输出会进入运行 cmake 的控制台的 stdout/stderr。

  • export_library_dependencies: 已弃用。请改用 INSTALL(EXPORT) 或 EXPORT 命令。

    此命令生成旧样式的库依赖项文件。需要 CMake 2.6 或更高版本的项目不应使用该命令。请改用 install(EXPORT) 命令来帮助从安装树中导出目标，以及 export() 命令来从构建树中导出目标。

    旧样式的库依赖项文件没有考虑库的每个配置名称或 LINK_INTERFACE_LIBRARIES 目标属性。

      export_library_dependencies(<file> [APPEND])

    创建一个名为 <file> 的文件，该文件可以使用 INCLUDE 命令包含在 CMake 列表文件中。该文件将包含多个 SET 命令，这些命令将设置库依赖项信息所需的所有变量。这应该是项目顶级 CMakeLists.txt 文件中的最后一个命令。如果指定了 APPEND 选项，则 SET 命令将被附加到给定文件，而不是替换它。

  • install_files: 已弃用。请改用 install(FILES ) 命令。

    此命令已被 install 命令取代。它是为了与旧的 CMake 代码兼容而提供的。FILES 形式直接被 install 命令的 FILES 形式取代。regexp 形式可以使用 file 命令的 GLOB 形式更清晰地表达。

      install_files(<dir> extension file file ...)

    创建规则，将列出的具有给定扩展名的文件安装到给定的目录中。只允许列出当前源树中或其在二进制树中的对应位置中存在的文件。如果指定的文件已经具有扩展名，则该扩展名将首先被删除。这对于提供源文件列表（例如 foo.cxx）很有用，当您希望安装相应的 foo.h 时。一个典型的扩展名是 '.h'。

      install_files(<dir> regexp)

    当前源目录中与正则表达式匹配的任何文件都将被安装。

      install_files(<dir> FILES file file ...)

    在 FILES 关键字之后列出的任何文件都将根据给定的名称显式安装。此形式允许使用完整路径。

    目录 <dir> 相对于安装前缀，该前缀存储在变量 CMAKE_INSTALL_PREFIX 中。

  • install_programs: 已弃用。请改用 install(PROGRAMS ) 命令。

    此命令已被 install 命令取代。它是为了与旧的 CMake 代码兼容而提供的。FILES 形式直接被 INSTALL 命令的 PROGRAMS 形式取代。regexp 形式可以使用 FILE 命令的 GLOB 形式更清晰地表达。

      install_programs(<dir> file1 file2 [file3 ...])
      install_programs(<dir> FILES file1 [file2 ...])

    创建规则，将列出的程序安装到给定的目录中。使用 FILES 参数可确保即使只有一个参数，也使用该命令的文件列表版本。

      install_programs(<dir> regexp)

    在第二种形式中，当前源目录中与正则表达式匹配的任何程序都将被安装。

    此命令旨在安装由 cmake 构建的程序（例如 shell 脚本）。请参见 INSTALL 命令的 TARGETS 形式，以创建由 cmake 构建的目标的安装规则。

    目录 <dir> 相对于安装前缀，该前缀存储在变量 CMAKE_INSTALL_PREFIX 中。

  • install_targets: 已弃用。请改用 install(TARGETS ) 命令。

    此命令已被 install 命令取代。它是为了与旧的 CMake 代码兼容而提供的。

      install_targets(<dir> [RUNTIME_DIRECTORY dir] target target)

    创建规则，将列出的目标安装到给定的目录中。目录 <dir> 相对于安装前缀，该前缀存储在变量 CMAKE_INSTALL_PREFIX 中。如果指定了 RUNTIME_DIRECTORY，则在具有特殊运行时文件（Windows DLL）的系统上，这些文件将被复制到该目录中。

  • link_libraries: 已弃用。请改用 target_link_libraries() 命令。

    将库链接到之后添加的所有目标。

      link_libraries(library1 <debug | optimized> library2 ...)

    指定一个库列表，这些库将被链接到任何后续目标（通常使用 add_executable 或 add_library 调用添加）。此命令将传递到所有子目录。调试和优化字符串可用于指示接下来列出的库仅用于特定类型的构建。

  • make_directory: 已弃用。请使用 file(MAKE_DIRECTORY ) 命令代替。
      make_directory(directory)

    创建指定目录。应给出完整路径。任何不存在的父目录也将被创建。谨慎使用。

  • remove: 已弃用。请使用 list(REMOVE_ITEM ) 命令代替。
      remove(VAR VALUE VALUE ...)

    从变量 VAR 中删除 VALUE。这通常用于从向量中删除条目（例如，用分号分隔的列表）。VALUE 会被展开。

  • subdir_depends: 已弃用。不执行任何操作。
      subdir_depends(subdir dep1 dep2 ...)

    不执行任何操作。此命令过去用于帮助项目正确排序并行构建。此功能现在已自动化。

  • subdirs: 已弃用。请使用 add_subdirectory() 命令代替。

    将子目录列表添加到构建中。

      subdirs(dir1 dir2 ...[EXCLUDE_FROM_ALL exclude_dir1 exclude_dir2 ...] [PREORDER] )

    将子目录列表添加到构建中。尽管 subdirs 仍然有效，但应使用 add_subdirectory 命令代替 subdirs。这将导致 CMake 处理子目录中的任何 CMakeLists.txt 文件。PREORDER 标志之后的任何目录都将首先由 makefile 构建进行遍历，PREORDER 标志对 IDE 项目没有影响。EXCLUDE_FROM_ALL 标记之后的任何目录都不会包含在顶级 makefile 或项目文件中。这对于让 CMake 为项目中的示例集创建 makefile 或项目文件很有用。你可能希望 CMake 同时为所有示例生成 makefile 或项目文件，但你可能不希望它们出现在顶级项目中或每次从顶部运行 make 时都进行构建。

  • use_mangled_mesa: 复制 mesa 头文件以结合使用系统 GL。
      use_mangled_mesa(PATH_TO_MESA OUTPUT_DIRECTORY)

    mesa 包含文件的路径应该包含 gl_mangle.h。mesa 头文件被复制到指定的输出目录。这允许混淆的 mesa 头文件通过在包含目录路径中更早添加来覆盖其他 GL 头文件。

  • utility_source: 指定第三方实用程序的源代码树。
      utility_source(cache_entry executable_name
                     path_to_source [file1 file2 ...])

    当第三方实用程序的源代码包含在发行版中时，此命令指定其位置和名称。除非 path_to_source 和所有列出的文件都存在，否则不会设置缓存条目。假设实用程序的源代码树在需要之前就已经构建好了。

    在交叉编译时，如果执行了 utility_source() 命令，CMake 将打印警告，因为在许多情况下它用于构建稍后执行的可执行文件。这在交叉编译时不起作用，因为可执行文件只能在目标平台上运行。因此，在这种情况下，必须手动调整缓存条目，使其指向在构建主机上可运行的可执行文件。

  • variable_requires: 已弃用。请使用 if() 命令代替。

    断言选项的必需变量的满足情况。

      variable_requires(TEST_VARIABLE RESULT_VARIABLE
                        REQUIRED_VARIABLE1
                        REQUIRED_VARIABLE2 ...)

    第一个参数 (TEST_VARIABLE) 是要测试的变量的名称，如果该变量为 false，则不会执行任何其他操作。如果 TEST_VARIABLE 为 true，则下一个参数 (RESULT_VARIABLE) 是一个变量，如果所有必需的变量都已设置，则该变量将设置为 true。其余参数是必须为 true 或未设置为 NOTFOUND 以避免错误的变量。如果任何一个不为 true，则会报告错误。

  • write_file: 已弃用。请使用 file(WRITE ) 命令代替。
      write_file(filename "message to write"... [APPEND])

    第一个参数是文件名，其余参数是要写入的消息。如果指定了参数 APPEND，则消息将被追加。

    注意 1: file(WRITE ... 和 file(APPEND ... 与此命令执行完全相同，但增加了一些其他功能。

    注意 2: 使用 write_file 时，生成的 file 不能用作 CMake 的输入 (CONFIGURE_FILE、源文件...)，因为它会导致无限循环。如果要生成 CMake 的输入文件，请使用 configure_file。

标准 CMake 模块

以下模块随 CMake 提供。可以使用 INCLUDE(ModuleName) 使用它们。

  CMake Modules - Modules coming with CMake, the Cross-Platform Makefile Generator.

这是随 CMake 附带的模块和脚本的文档。使用这些模块，你可以检查计算机系统上安装的软件包、编译器的功能和头文件的是否存在等等。

  • AddFileDependencies: ADD_FILE_DEPENDENCIES(source_file depend_files...)

    将给定的文件添加为 source_file 的依赖项

  • BundleUtilities:

    BundleUtilities.cmake

    一个 CMake 实用函数集合，对于处理 Mac 上的 .app 包和任何操作系统上的类似包的目录很有用。

    此脚本提供以下函数

       get_bundle_main_executable
       get_dotapp_dir
       get_bundle_and_executable
       get_bundle_all_executables
       get_item_key
       clear_bundle_keys
       set_bundle_key_values
       get_bundle_keys
       copy_resolved_item_into_bundle
       fixup_bundle_item
       fixup_bundle
       copy_and_fixup_bundle
       verify_bundle_prerequisites
       verify_bundle_symlinks
       verify_app


    需要 CMake 2.6 或更高版本，因为它使用 function、break 和 PARENT_SCOPE。还依赖于 GetPrerequisites.cmake。

  • CMakeASM-ATTInformation:

    支持 AT&T 语法汇编器，例如 GNU as

  • CMakeASM_MASMInformation:

    支持 MS 汇编器 masm 和 masm64

  • CMakeBackwardCompatibilityCXX: 定义一堆向后兼容性变量
      CMAKE_ANSI_CXXFLAGS - flag for ansi c++ 
      CMAKE_HAS_ANSI_STRING_STREAM - has <strstream>
      INCLUDE(TestForANSIStreamHeaders)
      INCLUDE(CheckIncludeFileCXX)
      INCLUDE(TestForSTDNamespace)
      INCLUDE(TestForANSIForScope)
  • CMakeDependentOption: 宏，用于提供依赖于其他选项的选项。

    此宏仅在其他条件集为 true 时向用户呈现选项。当未呈现选项时，将使用默认值，但用户设置的任何值都会保留，以便在再次呈现选项时保留其旧值。示例调用

      CMAKE_DEPENDENT_OPTION(USE_FOO "Use Foo" ON
                             "USE_BAR;NOT USE_ZOT" OFF)

    如果 USE_BAR 为 true 且 USE_ZOT 为 false，则这提供了一个名为 USE_FOO 的选项，其默认值为 ON。否则，它将 USE_FOO 设置为 OFF。如果 USE_BAR 或 USE_ZOT 的状态发生变化，则会保存 USE_FOO 选项的任何值，以便在重新启用选项时保留其旧值。

  • CMakeDetermineASM-ATTCompiler:

    确定使用 AT&T 语法的 ASM 的编译器，例如 GNU as

  • CMakeDetermineASMCompiler:

    确定用于 ASM 程序的编译器

  • CMakeDetermineASM_MASMCompiler:

    查找 MS 汇编器 (masm 或 masm64)

  • CMakeExportBuildSettings: 从项目导出构建设置。
      CMAKE_EXPORT_BUILD_SETTINGS(SETTINGS_FILE)

    定义的宏，用于导出构建设置供另一个项目使用。

      SETTINGS_FILE - the file into which the settings are to be stored.
  • CMakeFindFrameworks: 帮助模块，用于查找 OSX 框架
  • CMakeForceCompiler:

    此模块定义的宏旨在供交叉编译工具链文件使用，当 CMake 无法自动检测编译器标识时。

    宏 CMAKE_FORCE_C_COMPILER 具有以下签名

       CMAKE_FORCE_C_COMPILER(<compiler> <compiler-id>)

    它将 CMAKE_C_COMPILER 设置为给定的编译器，并将 cmake 内部变量 CMAKE_C_COMPILER_ID 设置为给定的编译器 ID。它还绕过了对工作编译器和基本编译器信息测试的检查。

    宏 CMAKE_FORCE_CXX_COMPILER 具有以下签名

       CMAKE_FORCE_CXX_COMPILER(<compiler> <compiler-id>)

    它将 CMAKE_CXX_COMPILER 设置为给定的编译器，并将 cmake 内部变量 CMAKE_CXX_COMPILER_ID 设置为给定的编译器 ID。它还绕过了对工作编译器和基本编译器信息测试的检查。

    因此，一个简单的工具链文件可能如下所示

       INCLUDE (CMakeForceCompiler)
       SET(CMAKE_SYSTEM_NAME Generic)
       CMAKE_FORCE_C_COMPILER   (chc12 MetrowerksHicross)
       CMAKE_FORCE_CXX_COMPILER (chc12 MetrowerksHicross)
  • CMakeImportBuildSettings: 从另一个项目导入构建设置
      CMAKE_IMPORT_BUILD_SETTINGS(SETTINGS_FILE)

    定义的宏，用于从另一个项目导入构建设置。SETTINGS_FILE 是另一个项目调用 CMAKE_EXPORT_BUILD_SETTINGS 宏创建的文件，请参见 CMakeExportBuildSettings。

  • CMakeJavaInformation:

    这应该在使用 _INIT 变量初始化缓存之前包含。由于规则变量在其上具有 if 块，因此用户仍然可以在此处定义它们。但是，它仍然应该在平台文件之后，以便可以对这些值进行更改。

  • CMakePrintSystemInformation: 打印系统信息

    此文件可用于诊断目的，只需将其包含在项目中即可查看各种 CMake 内部变量。

  • CPack: 构建二进制和源代码包安装程序


    CPack 模块使用 cpack 程序生成各种格式的二进制和源代码安装程序。包含 CPack 模块将在生成的 makefile 中添加两个新的目标，package 和 package_source，分别用于构建二进制和源代码安装程序。生成的二进制安装程序包含通过 CMake 的 INSTALL 命令安装的所有内容（以及已弃用的 INSTALL_FILES、INSTALL_PROGRAMS 和 INSTALL_TARGETS 命令）。

    对于某些类型的二进制安装程序（包括 Mac OS X 和 Windows 上的图形安装程序），CPack 生成允许用户选择要安装的单个应用程序组件的安装程序。每个组件的内容由 CMake 的 INSTALL 命令的 COMPONENT 参数标识。这些组件可以使用用户友好的名称和描述、组件间依赖关系等进行注释，并以各种方式进行分组以自定义生成的安装程序。有关组件特定安装的更多信息，请参见下面描述的 cpack_add_* 命令。

    在包含 CPack 模块之前，可以设置许多变量以自定义生成的安装程序。最常用的变量是

       CPACK_PACKAGE_NAME - The name of the package (or application). If
       not specified, defaults to the project name.


       CPACK_PACKAGE_VENDOR - The name of the package vendor (e.g.,
       "Kitware").


       CPACK_PACKAGE_VERSION_MAJOR - Package major Version


       CPACK_PACKAGE_VERSION_MINOR - Package minor Version


       CPACK_PACKAGE_VERSION_PATCH - Package patch Version


       CPACK_PACKAGE_DESCRIPTION_FILE - A text file used to describe the
       project. Used, for example, the introduction screen of a
       CPack-generated Windows installer to describe the project.


       CPACK_PACKAGE_DESCRIPTION_SUMMARY - Short description of the
       project (only a few words).


       CPACK_PACKAGE_FILE_NAME - The name of the package file to generate,
       not including the extension. For example, cmake-2.6.1-Linux-i686.


       CPACK_PACKAGE_INSTALL_DIRECTORY - Installation directory on the
       target system, e.g., "CMake 2.5".


       CPACK_RESOURCE_FILE_LICENSE - License file for the project, which
       will typically be displayed to the user (often with an explicit
       "Accept" button, for graphical installers) prior to installation.


       CPACK_RESOURCE_FILE_README - ReadMe file for the project, which
       typically describes in some detail


       CPACK_RESOURCE_FILE_WELCOME - Welcome file for the project, which
       welcomes users to this installer. Typically used in the graphical
       installers on Windows and Mac OS X.


       CPACK_MONOLITHIC_INSTALL - Disables the component-based 
       installation mechanism, so that all components are always installed.


       CPACK_GENERATOR - List of CPack generators to use. If not
       specified, CPack will create a set of options (e.g.,
       CPACK_BINARY_NSIS) allowing the user to enable/disable individual
       generators.


       CPACK_OUTPUT_CONFIG_FILE - The name of the CPack configuration file
       for binary installers that will be generated by the CPack
       module. Defaults to CPackConfig.cmake.


       CPACK_PACKAGE_EXECUTABLES - Lists each of the executables along
       with a text label, to be used to create Start Menu shortcuts on
       Windows. For example, setting this to the list ccmake;CMake will
       create a shortcut named "CMake" that will execute the installed
       executable ccmake.


       CPACK_STRIP_FILES - List of files to be stripped. Starting with
       CMake 2.6.0 CPACK_STRIP_FILES will be a boolean variable which
       enables stripping of all files (a list of files evaluates to TRUE
       in CMake, so this change is compatible).


    以下 CPack 变量特定于源包，不会影响二进制包

       CPACK_SOURCE_PACKAGE_FILE_NAME - The name of the source package,
       e.g., cmake-2.6.1


       CPACK_SOURCE_STRIP_FILES - List of files in the source tree that
       will be stripped. Starting with CMake 2.6.0
       CPACK_SOURCE_STRIP_FILES will be a boolean variable which enables
       stripping of all files (a list of files evaluates to TRUE in CMake,
       so this change is compatible).


       CPACK_SOURCE_GENERATOR - List of generators used for the source
       packages. As with CPACK_GENERATOR, if this is not specified then
       CPack will create a set of options (e.g., CPACK_SOURCE_ZIP)
       allowing users to select which packages will be generated.


       CPACK_SOURCE_OUTPUT_CONFIG_FILE - The name of the CPack
       configuration file for source installers that will be generated by
       the CPack module. Defaults to CPackSourceConfig.cmake.


       CPACK_SOURCE_IGNORE_FILES - Pattern of files in the source tree
       that won't be packaged when building a source package. This is a
       list of patterns, e.g., /CVS/;/\\.svn/;\\.swp$;\\.#;/#;.*~;cscope.*


    以下变量特定于使用 Nullsoft 安装系统在 Windows 上构建的图形安装程序。

       CPACK_PACKAGE_INSTALL_REGISTRY_KEY - Registry key used when
       installing this project.


       CPACK_NSIS_MUI_ICON - The icon file (.ico) for the generated
       install program.


       CPACK_NSIS_MUI_UNIICON - The icon file (.ico) for the generated
       uninstall program.


       CPACK_PACKAGE_ICON - A branding image that will be displayed inside
       the installer.


       CPACK_NSIS_EXTRA_INSTALL_COMMANDS - Extra NSIS commands that will
       be added to the install Section.


       CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS - Extra NSIS commands that will
       be added to the uninstall Section.


       CPACK_NSIS_COMPRESSOR - The arguments that will be passed to the
       NSIS SetCompressor command.


       CPACK_NSIS_MODIFY_PATH - If this is set to "ON", then an extra page
       will appear in the installer that will allow the user to choose
       whether the program directory should be added to the system PATH
       variable.


       CPACK_NSIS_DISPLAY_NAME - The title displayed at the top of the
       installer.


       CPACK_NSIS_INSTALLED_ICON_NAME - A path to the executable that
       contains the installer icon.


       CPACK_NSIS_HELP_LINK - URL to a web site providing assistance in
       installing your application.


       CPACK_NSIS_URL_INFO_ABOUT - URL to a web site providing more
       information about your application.


       CPACK_NSIS_CONTACT - Contact information for questions and comments
       about the installation process.


       CPACK_NSIS_CREATE_ICONS_EXTRA - Additional NSIS commands for
       creating start menu shortcuts.


       CPACK_NSIS_DELETE_ICONS_EXTRA -Additional NSIS commands to
       uninstall start menu shortcuts.


    以下变量特定于在 Mac OS X 上使用 PackageMaker 构建的安装程序

       CPACK_OSX_PACKAGE_VERSION - The version of Mac OS X that the
       resulting PackageMaker archive should be compatible
       with. Different versions of Mac OS X support different
       features. For example, CPack can only build component-based
       installers for Mac OS X 10.4 or newer, and can only build
       installers that download component son-the-fly for Mac OS X 10.5
       or newer. If left blank, this value will be set to the minimum
       version of Mac OS X that supports the requested features. Set this
       variable to some value (e.g., 10.4) only if you want to guarantee
       that your installer will work on that version of Mac OS X, and
       don't mind missing extra features available in the installer
       shipping with later versions of Mac OS X.


    以下变量用于 CPack 的高级用途

       CPACK_CMAKE_GENERATOR - What CMake generator should be used if the
       project is CMake project. Defaults to the value of CMAKE_GENERATOR;
       few users will want to change this setting.


       CPACK_INSTALL_CMAKE_PROJECTS - List of four values that specify
       what project to install. The four values are: Build directory,
       Project Name, Project Component, Directory. If omitted, CPack will
       build an installer that installers everything.


       CPACK_SYSTEM_NAME - System name, defaults to the value of
       ${CMAKE_SYSTEM_NAME}.


       CPACK_PACKAGE_VERSION - Package full version, used internally. By
       default, this is built from CPACK_PACKAGE_VERSION_MAJOR,
       CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH.


       CPACK_TOPLEVEL_TAG - Directory for the installed files.


       CPACK_INSTALL_COMMANDS - Extra commands to install components.


       CPACK_INSTALL_DIRECTORIES - Extra directories to install.


    组件特定安装允许用户在安装过程中选择要安装的特定组件集。安装组件由 CMake 的 INSTALL 命令的 COMPONENT 参数标识，并应通过以下 CPack 命令进一步描述

       cpack_add_component - Describes a CPack installation component
       named by the COMPONENT argument to a CMake INSTALL command.


         cpack_add_component(compname
                             [DISPLAY_NAME name]
                             [DESCRIPTION description]
                             [HIDDEN | REQUIRED | DISABLED ]
                             [GROUP group]
                             [DEPENDS comp1 comp2 ... ]
                             [INSTALL_TYPES type1 type2 ... ]
                             [DOWNLOADED]
                             [ARCHIVE_FILE filename])


       The cmake_add_component command describes an installation
       component, which the user can opt to install or remove as part of
       the graphical installation process. compname is the name of the
       component, as provided to the COMPONENT argument of one or more
       CMake INSTALL commands.


       DISPLAY_NAME is the displayed name of the component, used in
       graphical installers to display the component name. This value can
       be any string.


       DESCRIPTION is an extended description of the component, used in
       graphical installers to give the user additional information about
       the component. Descriptions can span multiple lines using "\n" as
       the line separator. Typically, these descriptions should be no
       more than a few lines long.


       HIDDEN indicates that this component will be hidden in the
       graphical installer, so that the user cannot directly change
       whether it is installed or not.


       REQUIRED indicates that this component is required, and therefore
       will always be installed. It will be visible in the graphical
       installer, but it cannot be unselected. (Typically, required
       components are shown greyed out).


       DISABLED indicates that this component should be disabled
       (unselected) by default. The user is free to select this component
       for installation, unless it is also HIDDEN.


       DEPENDS lists the components on which this component depends. If
       this component is selected, then each of the components listed
       must also be selected. The dependency information is encoded
       within the installer itself, so that users cannot install
       inconsitent sets of components.


       GROUP names the component group of which this component is a
       part. If not provided, the component will be a standalone
       component, not part of any component group. Component groups are
       described with the cpack_add_component_group command, detailed
       below.


       INSTALL_TYPES lists the installation types of which this component
       is a part. When one of these installations types is selected, this
       component will automatically be selected. Installation types are
       described with the cpack_add_install_type command, detailed below.


       DOWNLOADED indicates that this component should be downloaded
       on-the-fly by the installer, rather than packaged in with the
       installer itself. For more information, see the cpack_configure_downloads
       command.


       ARCHIVE_FILE provides a name for the archive file created by CPack
       to be used for downloaded components. If not supplied, CPack will
       create a file with some name based on CPACK_PACKAGE_FILE_NAME and
       the name of the component. See cpack_configure_downloads for more
       information.


       cpack_add_component_group - Describes a group of related CPack
       installation components.


         cpack_add_component_group(groupname
                                  [DISPLAY_NAME name]
                                  [DESCRIPTION description]
                                  [PARENT_GROUP parent]
                                  [EXPANDED]
                                  [BOLD_TITLE])


       The cpack_add_component_group describes a group of installation
       components, which will be placed together within the listing of
       options. Typically, component groups allow the user to
       select/deselect all of the components within a single group via a
       single group-level option. Use component groups to reduce the
       complexity of installers with many options. groupname is an
       arbitrary name used to identify the group in the GROUP argument of
       the cpack_add_component command, which is used to place a
       component in a group. The name of the group must not conflict with
       the name of any component.


       DISPLAY_NAME is the displayed name of the component group, used in
       graphical installers to display the component group name. This
       value can be any string.


       DESCRIPTION is an extended description of the component group,
       used in graphical installers to give the user additional
       information about the components within that group. Descriptions
       can span multiple lines using "\n" as the line
       separator. Typically, these descriptions should be no more than a
       few lines long.


       PARENT_GROUP, if supplied, names the parent group of this group. 
       Parent groups are used to establish a hierarchy of groups, 
       providing an arbitrary hierarchy of groups.


       EXPANDED indicates that, by default, the group should show up as
       "expanded", so that the user immediately sees all of the
       components within the group. Otherwise, the group will initially
       show up as a single entry.


       BOLD_TITLE indicates that the group title should appear in bold,
       to call the user's attention to the group.


       cpack_add_install_type - Add a new installation type containing a
       set of predefined component selections to the graphical installer.
                          
         cpack_add_install_type(typename
                                [DISPLAY_NAME name])   


       The cpack_add_install_type command identifies a set of preselected
       components that represents a common use case for an
       application. For example, a "Developer" install type might include
       an application along with its header and library files, while an
       "End user" install type might just include the application's
       executable. Each component identifies itself with one or more
       install types via the INSTALL_TYPES argument to
       cpack_add_component.


       DISPLAY_NAME is the displayed name of the install type, which will
       typically show up in a drop-down box within a graphical
       installer. This value can be any string.


       cpack_configure_downloads - Configure CPack to download selected
       components on-the-fly as part of the installation process.


         cpack_configure_downloads(site
                                   [UPLOAD_DIRECTORY dirname]
                                   [ALL]
                                   [ADD_REMOVE|NO_ADD_REMOVE])


       The cpack_configure_downloads command configures installation-time
       downloads of selected components. For each downloadable component,
       CPack will create an archive containing the contents of that
       component, which should be uploaded to the given site. When the
       user selects that component for installation, the installer will
       download and extract the component in place. This feature is
       useful for creating small installers that only download the
       requested components, saving bandwidth. Additionally, the
       installers are small enough that they will be installed as part of
       the normal installation process, and the "Change" button in
       Windows Add/Remove Programs control panel will allow one to add or
       remove parts of the application after the original
       installation. On Windows, the downloaded-components functionality
       requires the ZipDLL plug-in for NSIS, available at:


         http://nsis.sourceforge.net/ZipDLL_plug-in


       On Mac OS X, installers that download components on-the-fly can
       only be built and installed on system using Mac OS X 10.5 or
       later.


       The site argument is a URL where the archives for downloadable 
       components will reside, e.g., http://www.cmake.org/files/2.6.1/installer/
       All of the archives produced by CPack should be uploaded to that location.


       UPLOAD_DIRECTORY is the local directory where CPack will create the 
       various archives for each of the components. The contents of this
       directory should be uploaded to a location accessible by the URL given
       in the site argument. If omitted, CPack will use the directory CPackUploads
       inside the CMake binary directory to store the generated archives.


       The ALL flag indicates that all components be downloaded. Otherwise, only 
       those components explicitly marked as DOWNLOADED or that have a specified 
       ARCHIVE_FILE will be downloaded. Additionally, the ALL option implies
       ADD_REMOVE (unless NO_ADD_REMOVE is specified).


       ADD_REMOVE indicates that CPack should install a copy of the installer
       that can be called from Windows' Add/Remove Programs dialog (via the 
       "Modify" button) to change the set of installed components. NO_ADD_REMOVE
       turns off this behavior. This option is ignored on Mac OS X.
  • CPackRPM:

    用于创建 RPM 包的 CPack 脚本 作者：Eric Noulard 在 Alexander Neundorf 的帮助下。CPackRPM 使用的所有变量都以 CPACK_RPM_ 前缀开头

    以下是使用的变量列表

  • CTest: 使用 CTest/CDash 配置项目以进行测试

    此文件配置项目以使用 CTest/CDash/Dart 测试/仪表板流程。此模块应包含在项目顶部的 CMakeLists.txt 文件中。典型用法

      INCLUDE(CTest)
      IF(BUILD_TESTING)
        # ... testing related CMake code ...
      ENDIF(BUILD_TESTING)

    CTest 模块创建 BUILD_TESTING 选项以确定是否应启用测试支持。默认值为 ON。

  • CheckCCompilerFlag: 检查 C 编译器是否支持给定的标志。

    CHECK_C_COMPILER_FLAG(FLAG VARIABLE)

      FLAG - the compiler flag
      VARIABLE - variable to store the result


      This actually calls the check_c_source_compiles macro.
      See help for CheckCSourceCompiles for a listing of variables
      that can modify the build.
  • CheckCSourceCompiles: 检查源代码是否编译的宏

    CHECK_C_SOURCE_COMPILES(SOURCE VAR)

      SOURCE   - source code to try to compile
      VAR      - variable to store whether the source code compiled


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCSourceRuns: 检查源代码是否运行的宏

    CHECK_C_SOURCE_RUNS(SOURCE VAR)

      SOURCE   - source code to try to compile
      VAR      - variable to store the result, 1 for success, empty for failure


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCXXCompilerFlag: 检查 CXX 编译器是否支持给定的标志。

    CHECK_CXX_COMPILER_FLAG(FLAG VARIABLE)

      FLAG - the compiler flag
      VARIABLE - variable to store the result
  • CheckCXXSourceCompiles: 检查源代码是否编译的宏

    CHECK_CXX_SOURCE_COMPILES(SOURCE VAR)

      SOURCE - source code to try to compile
      VAR    - variable to store whether the source code compiled


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCXXSourceRuns: 检查源代码是否编译的宏

    CHECK_CXX_SOURCE_RUNS(SOURCE VAR)

      SOURCE - source code to try to compile
      VAR    - variable to store the result, 1 for success, empty for failure


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckFortranFunctionExists: 检查 Fortran 函数是否存在

    CHECK_FORTRAN_FUNCTION_EXISTS(FUNCTION VARIABLE)

      FUNCTION - the name of the Fortran function
      VARIABLE - variable to store the result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckFunctionExists: 检查函数是否存在

    CHECK_FUNCTION_EXISTS(FUNCTION VARIABLE)

      FUNCTION - the name of the function
      VARIABLE - variable to store the result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckIncludeFile: 检查包含文件是否存在。

    CHECK_INCLUDE_FILE(INCLUDE VARIABLE)

      INCLUDE  - name of include file
      VARIABLE - variable to return result

    可选的第三个参数是添加到编译行的 CFlags，或者可以使用 CMAKE_REQUIRED_FLAGS

    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


  • CheckIncludeFileCXX: 检查包含文件是否存在。
      CHECK_INCLUDE_FILE_CXX(INCLUDE VARIABLE)


      INCLUDE  - name of include file
      VARIABLE - variable to return result

    可选的第三个参数是添加到编译行的 CFlags，或者可以使用 CMAKE_REQUIRED_FLAGS。

    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


  • CheckIncludeFiles: 检查文件是否可以包含


    CHECK_INCLUDE_FILES(INCLUDE VARIABLE)

      INCLUDE  - list of files to include
      VARIABLE - variable to return result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
  • CheckLibraryExists: 检查函数是否存在。

    CHECK_LIBRARY_EXISTS (LIBRARY FUNCTION LOCATION VARIABLE)

      LIBRARY  - the name of the library you are looking for
      FUNCTION - the name of the function
      LOCATION - location where the library should be found
      VARIABLE - variable to store the result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckStructHasMember: 检查给定的结构体或类是否具有指定的成员变量

    CHECK_STRUCT_HAS_MEMBER (STRUCT MEMBER HEADER VARIABLE)

      STRUCT - the name of the struct or class you are interested in
      MEMBER - the member which existence you want to check
      HEADER - the header(s) where the prototype should be declared
      VARIABLE - variable to store the result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


    示例：CHECK_STRUCT_HAS_MEMBER("struct timeval" tv_sec sys/select.h HAVE_TIMEVAL_TV_SEC)

  • CheckSymbolExists: 检查符号是否在包含文件中存在

    CHECK_SYMBOL_EXISTS(SYMBOL FILES VARIABLE)

      SYMBOL   - symbol
      FILES    - include files to check
      VARIABLE - variable to return result


    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckTypeSize: 检查类型的 sizeof
      CHECK_TYPE_SIZE(TYPE VARIABLE [BUILTIN_TYPES_ONLY])

    检查类型是否存在并确定类型的 size。如果类型存在，则 size 将存储到变量中。这也将为 sys/types.h stdint.h 和 stddef.h 调用 check_include_file，设置 HAVE_SYS_TYPES_H、HAVE_STDINT_H 和 HAVE_STDDEF_H。这是因为许多类型存储在这些包含文件中。

      VARIABLE - variable to store size if the type exists.
      HAVE_${VARIABLE} - does the variable exists or not
      BUILTIN_TYPES_ONLY - The third argument is optional and if 
                           it is set to the string BUILTIN_TYPES_ONLY
                           this macro will not check for any header files.

    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckVariableExists: 检查变量是否存在。
      CHECK_VARIABLE_EXISTS(VAR VARIABLE)
      
      VAR      - the name of the variable
      VARIABLE - variable to store the result


    此宏仅适用于 C 变量。

    可以在调用此宏之前设置以下变量以修改运行检查的方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • Dart: 使用 CTest 或旧版 Dart Tcl 客户端配置项目以进行测试

    此文件是 CTest 模块的向后兼容版本。它支持使用旧版 Dart 1 Tcl 客户端来驱动仪表板提交以及使用 CTest 进行测试。此模块应包含在项目顶部的 CMakeLists.txt 文件中。典型用法

      INCLUDE(Dart)
      IF(BUILD_TESTING)
        # ... testing related CMake code ...
      ENDIF(BUILD_TESTING)

    Dart 模块创建 BUILD_TESTING 选项以确定是否应启用测试支持。默认值为 ON。

  • Documentation: DocumentationVTK.cmake

    此文件为 VTK 文档框架提供支持。它依赖于几个工具（Doxygen、Perl 等）。

  • FeatureSummary: 用于生成已启用/已禁用功能摘要的宏


    PRINT_ENABLED_FEATURES()

       Print a summary of all enabled features. By default all successfull
       FIND_PACKAGE() calls will appear here, except the ones which used the QUIET keyword.
       Additional features can be added by appending an entry to the global ENABLED_FEATURES
       property. If SET_FEATURE_INFO() is used for that feature, the output will be much 
       more informative.


    PRINT_DISABLED_FEATURES()

       Same as PRINT_ENABLED_FEATURES(), but for disabled features. It can be extended
       the same way by adding to the global property DISABLED_FEATURES.


    SET_FEATURE_INFO(NAME DESCRIPTION [URL [COMMENT] ] )

        Use this macro to set up information about the named feature, which will
        then be displayed by PRINT_ENABLED/DISABLED_FEATURES().
        Example: SET_FEATURE_INFO(LibXml2 "XML processing library." "http://xmlsoft.org/")


  • FindASPELL: 尝试查找 ASPELL

    完成后，将定义

      ASPELL_FOUND - system has ASPELL
      ASPELL_INCLUDE_DIR - the ASPELL include directory
      ASPELL_LIBRARIES - The libraries needed to use ASPELL
      ASPELL_DEFINITIONS - Compiler switches required for using ASPELL
  • FindAVIFile: 查找 AVIFILE 库和包含路径

    AVIFILE (http://avifile.sourceforge.net/) 是为 i386 机器使用各种 AVI 编解码器的一组库。除了 Linux 之外，支持有限。Windows 提供原生 AVI 支持，因此不需要此库。此模块定义

      AVIFILE_INCLUDE_DIR, where to find avifile.h , etc.
      AVIFILE_LIBRARIES, the libraries to link against
      AVIFILE_DEFINITIONS, definitions to use when compiling
      AVIFILE_FOUND, If false, don't try to use AVIFILE
  • FindBLAS: 查找 BLAS 库

    此模块查找已安装的 fortran 库，该库实现了 BLAS 线性代数接口（请参阅 http://www.netlib.org/blas/）。要搜索的库列表取自 autoconf 宏文件 acx_blas.m4（在 http://ac-archive.sourceforge.net/ac-archive/acx_blas.html 中分发）。

    此模块设置以下变量

      BLAS_FOUND - set to true if a library implementing the BLAS interface
        is found
      BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l
        and -L).
      BLAS_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use BLAS
      BLAS95_LIBRARIES - uncached list of libraries (using full path name)
        to link against to use BLAS95 interface
      BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface
        is found
      BLA_STATIC  if set on this determines what kind of linkage we do (static)
      BLA_VENDOR  if set checks only the specified vendor, if not set checks
         all the posibilities
      BLA_F95     if set on tries to find the f95 interfaces for BLAS/LAPACK

    ######### ## 此模块中有效的供应商列表 (BLA_VENDOR) # ATLAS、PhiPACK、CXML、DXML、SunPerf、SCSL、SGIMATH、IBMESSL、Intel10_32（intel mkl v10 32 位）、Intel10_64lp（intel mkl v10 64 位，lp 线程模型，lp64 模型）、 # Intel（旧版 mkl 32 和 64 位）、ACML、Apple、NAS、Generic C/CXX 应启用以使用 Intel mkl

  • FindBZip2: 尝试查找 BZip2

    完成后，将定义

      BZIP2_FOUND - system has BZip2
      BZIP2_INCLUDE_DIR - the BZip2 include directory
      BZIP2_LIBRARIES - Link these to use BZip2
      BZIP2_DEFINITIONS - Compiler switches required for using BZip2
      BZIP2_NEED_PREFIX - this is set if the functions are prefixed with BZ2_
  • FindBoost: 尝试查找 Boost 包含目录和库

    此模块的使用方式如下

    == 从 Boost 内部使用仅包含库：==

       find_package( Boost 1.36.0 )
       if(Boost_FOUND)
          include_directories(${Boost_INCLUDE_DIRS})
          add_executable(foo foo.cc)
       endif()



    == 从 Boost 内部使用实际库：==

       set(Boost_USE_STATIC_LIBS   ON)
       set(Boost_USE_MULTITHREADED ON)
       find_package( Boost 1.36.0 COMPONENTS date_time filesystem system ... )


       if(Boost_FOUND)
          include_directories(${Boost_INCLUDE_DIRS})
          add_executable(foo foo.cc)
          target_link_libraries(foo ${Boost_LIBRARIES})
       endif()



    组件列表需要包含实际的 Boost 库名称，例如 "date_time" 代表 "libboost_date_time"。如果您使用的是仅包含头文件的 Boost 部分（例如 foreach），则无需指定 COMPONENTS。

    您应该提供要使用的最小版本号。如果您提供了此版本号并指定了 REQUIRED 属性，则如果此模块找不到指定的版本号或更高版本，它将失败。如果您指定了版本号，则此版本号会自动放入要考虑的版本号列表中，因此无需在 Boost_ADDITIONAL_VERSIONS 变量中指定（见下文）。

    Visual Studio 用户的注意

         Automatic linking is used on MSVC & Borland compilers by default when
         #including things in Boost.  It's important to note that setting
         Boost_USE_STATIC_LIBS to OFF is NOT enough to get you dynamic linking,
         should you need this feature.  Automatic linking typically uses static
         libraries with a few exceptions (Boost.Python is one).


         Please see the section below near Boost_LIB_DIAGNOSTIC_DEFINITIONS for
         more details.  Adding a TARGET_LINK_LIBRARIES() as shown in the example
         above appears to cause VS to link dynamically if Boost_USE_STATIC_LIBS
         gets set to OFF.  It is suggested you avoid automatic linking since it
         will make your application less portable.


    =========== Boost_ADDITIONAL_VERSIONS 的混乱之处（抱歉？）============

    好的，Boost_ADDITIONAL_VERSIONS 变量可用于指定在搜索 Boost 时应考虑的 Boost 版本号列表。不幸的是，Boost 会将版本号放入库的实际文件名中，因此当发布新的 Boost 版本时，将来肯定需要使用此变量。

    目前，此模块搜索以下版本号：1.33、1.33.0、1.33.1、1.34、1.34.0、1.34.1、1.35、1.35.0、1.35.1、1.36、1.36.0、1.36.1、1.37、1.37.0、1.38、1.38.0

    注意：如果您在 Boost_ADDITIONAL_VERSIONS 中添加了新的主要 1.x 版本，则应添加 1.x 和 1.x.0，如上所示。官方 Boost 包含目录从包含路径中省略了第三个版本号，如果它为 0，尽管并非所有二进制 Boost 版本都这样做。

    SET(Boost_ADDITIONAL_VERSIONS "0.99" "0.99.0" "1.78" "1.78.0")

    ============================================================================

    此模块使用的变量，它们可以更改默认行为，并且需要在调用 find_package 之前设置

      Boost_USE_MULTITHREADED       Can be set to OFF to use the non-multithreaded
                                    boost libraries.  If not specified, defaults
                                    to ON.


      Boost_USE_STATIC_LIBS         Can be set to ON to force the use of the static
                                    boost libraries. Defaults to OFF.


    此模块使用的其他变量，您可能希望设置。

      Boost_ADDITIONAL_VERSIONS     A list of version numbers to use for searching
                                    the boost include directory.  Please see
                                    the documentation above regarding this
                                    annoying, but necessary variable :(


      Boost_DEBUG                   Set this to TRUE to enable debugging output
                                    of FindBoost.cmake if you are having problems.
                                    Please enable this before filing any bug
                                    reports.


      Boost_COMPILER                Set this to the compiler suffix used by Boost
                                    (e.g. "-gcc43") if FindBoods has problems finding
                                    the proper Boost installation


      These last three variables are available also as environment variables:


      BOOST_ROOT or BOOSTROOT       The preferred installation prefix for searching for
                                    Boost.  Set this if the module has problems finding
                                    the proper Boost installation.


      BOOST_INCLUDEDIR              Set this to the include directory of Boost, if the
                                    module has problems finding the proper Boost installation


      BOOST_LIBRARYDIR              Set this to the lib directory of Boost, if the
                                    module has problems finding the proper Boost installation


    此模块定义的变量

      Boost_FOUND                          System has Boost, this means the include dir was
                                           found, as well as all the libraries specified in
                                           the COMPONENTS list.


      Boost_INCLUDE_DIRS                   Boost include directories: not cached


      Boost_INCLUDE_DIR                    This is almost the same as above, but this one is
                                           cached and may be modified by advanced users


      Boost_LIBRARIES                      Link these to use the Boost libraries that you
                                           specified: not cached


      Boost_LIBRARY_DIRS                   The path to where the Boost library files are.


      Boost_VERSION                        The version number of the boost libraries that
                                           have been found, same as in version.hpp from Boost


      Boost_LIB_VERSION                    The version number in filename form as
                                           it's appended to the library filenames


      Boost_MAJOR_VERSION                  major version number of boost
      Boost_MINOR_VERSION                  minor version number of boost
      Boost_SUBMINOR_VERSION               subminor version number of boost


      Boost_LIB_DIAGNOSTIC_DEFINITIONS     [WIN32 Only] You can call
                                           add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINTIIONS})
                                           to have diagnostic information about Boost's
                                           automatic linking outputted during compilation time.


    对于您列出的每个组件，将设置以下变量。注意：组件名称需要小写，就像 Boost 库名称一样，但是 CMake 变量在组件部分使用大写。所以您会得到 Boost_SERIALIZATION_FOUND 等等。

      Boost_${COMPONENT}_FOUND             True IF the Boost library "component" was found.
      Boost_${COMPONENT}_LIBRARY           The absolute path of the Boost library "component".
      Boost_${COMPONENT}_LIBRARY_DEBUG     The absolute path of the debug version of the
                                           Boost library "component".
      Boost_${COMPONENT}_LIBRARY_RELEASE   The absolute path of the release version of the
                                           Boost library "component"


      Copyright (c) 2006-2008 Andreas Schneider <[email protected]>
      Copyright (c) 2007      Wengo
      Copyright (c) 2007      Mike Jackson
      Copyright (c) 2008      Andreas Pakulat <[email protected]>


      Redistribution AND use is allowed according to the terms of the New
      BSD license.
      For details see the accompanying COPYING-CMAKE-SCRIPTS file.


  • FindCABLE: 查找 CABLE

    此模块查找 CABLE 是否已安装，并确定包含文件和库的位置。此代码设置以下变量

      CABLE             the path to the cable executable
      CABLE_TCL_LIBRARY the path to the Tcl wrapper library
      CABLE_INCLUDE_DIR the path to the include directory


    要构建 Tcl 包装器，您应该添加共享库并将其链接到 ${CABLE_TCL_LIBRARY}。您还应该添加 ${CABLE_INCLUDE_DIR} 作为包含目录。

  • FindCURL: 查找 curl

    查找本机 CURL 标头和库。

      CURL_INCLUDE_DIRS - where to find curl/curl.h, etc.
      CURL_LIBRARIES    - List of libraries when using curl.
      CURL_FOUND        - True if curl found.
  • FindCVS:

    此模块定义以下变量

       CVS_EXECUTABLE - path to cvs command line client
       CVS_FOUND - true if the command line client was found

    示例用法

       find_package(CVS)
       if(CVS_FOUND)
         message("CVS found: ${CVS_EXECUTABLE}")
       endif(CVS_FOUND)
  • FindCoin3D: 查找 Coin3D（Open Inventor）

    Coin3D 是 Open Inventor API 的实现。它提供用于 3D 可视化的数据结构和算法 http://www.coin3d.org/

    此模块定义以下变量

      COIN3D_FOUND         - system has Coin3D - Open Inventor
      COIN3D_INCLUDE_DIRS  - where the Inventor include directory can be found
      COIN3D_LIBRARIES     - Link to this to use Coin3D


  • FindCups: 尝试查找 Cups 打印系统

    完成后，将定义

      CUPS_FOUND - system has Cups
      CUPS_INCLUDE_DIR - the Cups include directory
      CUPS_LIBRARIES - Libraries needed to use Cups
      Set CUPS_REQUIRE_IPP_DELETE_ATTRIBUTE to TRUE if you need a version which 
      features this function (i.e. at least 1.1.19)
  • FindCurses: 查找 curses 包含文件和库


      CURSES_FOUND - system has Curses
      CURSES_INCLUDE_DIR - the Curses include directory
      CURSES_LIBRARIES - The libraries needed to use Curses
      CURSES_HAVE_CURSES_H - true if curses.h is available
      CURSES_HAVE_NCURSES_H - true if ncurses.h is available
      CURSES_HAVE_NCURSES_NCURSES_H - true if ncurses/ncurses.h is available
      CURSES_HAVE_NCURSES_CURSES_H - true if ncurses/curses.h is available
      CURSES_LIBRARY - set for backwards compatibility with 2.4 CMake


    如果需要 NCurses 功能，请在 FIND_PACKAGE() 命令之前将 CURSES_NEED_NCURSES 设置为 TRUE。

  • FindCxxTest: 查找 CxxTest

    查找 CxxTest 套件并声明一个辅助宏，用于创建单元测试并将它们与 CTest 集成。有关 CxxTest 的更多详细信息，请参阅 http://cxxtest.tigris.org

    输入变量

       CXXTEST_USE_PYTHON
           If true, the CXXTEST_ADD_TEST macro will use
           the Python test generator instead of Perl.


    输出变量

       CXXTEST_FOUND
           True if the CxxTest framework was found
       CXXTEST_INCLUDE_DIR
           Where to find the CxxTest include directory
       CXXTEST_PERL_TESTGEN_EXECUTABLE
           The perl-based test generator.
       CXXTEST_PYTHON_TESTGEN_EXECUTABLE
           The python-based test generator.


    CMake 用户使用的宏

        CXXTEST_ADD_TEST(<test_name> <gen_source_file> <input_files_to_testgen...>)
           Creates a CxxTest runner and adds it to the CTest testing suite
           Parameters:
               test_name               The name of the test
               gen_source_file         The generated source filename to be generated by CxxTest
               input_files_to_testgen  The list of header files containing the
                                       CxxTest::TestSuite's to be included in this runner
               
           #==============
           Example Usage:


               FIND_PACKAGE(CxxTest)
               INCLUDE_DIRECTORIES(${CXXTEST_INCLUDE_DIR})


               ENABLE_TESTING()
               CXXTEST_ADD_TEST(unittest_foo foo_test.cc ${CMAKE_CURRENT_SOURCE_DIR}/foo_test.h)


                  This will:
                  1. Invoke the testgen executable to autogenerate foo_test.cc in the
                     binary tree from "foo_test.h" in the current source directory.
                  2. Create an executable and test called unittest_foo.
                   
          #=============
          Example foo_test.h:


              #include <cxxtest/TestSuite.h>
              
              class MyTestSuite : public CxxTest::TestSuite 
              {
              public:
                 void testAddition( void )
                 {
                    TS_ASSERT( 1 + 1 > 1 );
                    TS_ASSERT_EQUALS( 1 + 1, 2 );
                 }
              };



    FindCxxTest.cmake 版权所有 (c) 2008

         Philip Lowman <[email protected]>


    版本 1.0 (1/8/08)

         Fixed CXXTEST_INCLUDE_DIRS so it will work properly
         Eliminated superfluous CXXTEST_FOUND assignment
         Cleaned up and added more documentation
  • FindCygwin: 此模块查找 Cygwin


  • FindDCMTK: 查找 DCMTK 库


  • FindDart: 查找 DART

    此模块查找 dart 测试软件并将 DART_ROOT 设置为指向找到它的位置。

  • FindDevIL:

    此模块查找开发人员的图像库。 http://openil.sourceforge.net/

    此模块设置：IL_LIBRARY IL 库的名称。ILU_LIBRARY ILU 库的名称。ILUT_LIBRARY ILUT 库的名称。IL_INCLUDE_DIR 查找 il.h、ilu.h 和 ilut.h 文件的位置。IL_FOUND 如果所有上述变量都已设置，则将其设置为 TRUE。

  • FindDoxygen: 此模块查找 Doxygen 和 Graphviz 的 dot 的路径

    Doxygen 是一个文档生成工具。请参阅 http://www.doxygen.org

    此模块接受以下可选变量

       DOXYGEN_SKIP_DOT       = If true this module will skip trying to find Dot
                                (an optional component often used by Doxygen)


    此模块定义以下变量

       DOXYGEN_EXECUTABLE     = The path to the doxygen command.
       DOXYGEN_FOUND          = Was Doxygen found or not?


       DOXYGEN_DOT_EXECUTABLE = The path to the dot program used by doxygen.
       DOXYGEN_DOT_FOUND      = Was Dot found or not?
       DOXYGEN_DOT_PATH       = The path to dot not including the executable



  • FindEXPAT: 查找 expat

    查找本机 EXPAT 头文件和库。

      EXPAT_INCLUDE_DIRS - where to find expat.h, etc.
      EXPAT_LIBRARIES    - List of libraries when using expat.
      EXPAT_FOUND        - True if expat found.
  • FindFLTK: 查找本机 FLTK 包含文件和库


    默认情况下，FindFLTK.cmake 将搜索所有 FLTK 组件并将它们添加到 FLTK_LIBRARIES 变量中。

       You can limit the components which get placed in FLTK_LIBRARIES by
       defining one or more of the following three options:


         FLTK_SKIP_OPENGL, set to true to disable searching for opengl and
                           the FLTK GL library
         FLTK_SKIP_FORMS, set to true to disable searching for fltk_forms
         FLTK_SKIP_IMAGES, set to true to disable searching for fltk_images


         FLTK_SKIP_FLUID, set to true if the fluid binary need not be present
                          at build time


    将定义以下变量

         FLTK_FOUND, True if all components not skipped were found
         FLTK_INCLUDE_DIR, where to find include files
         FLTK_LIBRARIES, list of fltk libraries you should link against
         FLTK_FLUID_EXECUTABLE, where to find the Fluid tool
         FLTK_WRAP_UI, This enables the FLTK_WRAP_UI command


    以下缓存变量已分配，但不应使用。请改用 FLTK_LIBRARIES 变量。

         FLTK_BASE_LIBRARY   = the full path to fltk.lib
         FLTK_GL_LIBRARY     = the full path to fltk_gl.lib
         FLTK_FORMS_LIBRARY  = the full path to fltk_forms.lib
         FLTK_IMAGES_LIBRARY = the full path to fltk_images.lib
  • FindFLTK2: 查找本机 FLTK2 包含文件和库

    定义以下设置

      FLTK2_FLUID_EXECUTABLE, where to find the Fluid tool
      FLTK2_WRAP_UI, This enables the FLTK2_WRAP_UI command
      FLTK2_INCLUDE_DIR, where to find include files
      FLTK2_LIBRARIES, list of fltk2 libraries
      FLTK2_FOUND, Don't use FLTK2 if false.

    以下设置通常不应使用。

      FLTK2_BASE_LIBRARY   = the full path to fltk2.lib
      FLTK2_GL_LIBRARY     = the full path to fltk2_gl.lib
      FLTK2_IMAGES_LIBRARY = the full path to fltk2_images.lib
  • FindFreetype: 定位 FreeType 库

    此模块定义

      FREETYPE_LIBRARIES, the library to link against
      FREETYPE_FOUND, if false, do not try to link to FREETYPE
      FREETYPE_INCLUDE_DIRS, where to find headers.
      This is the concatenation of the paths:
      FREETYPE_INCLUDE_DIR_ft2build
      FREETYPE_INCLUDE_DIR_freetype2


    $FREETYPE_DIR 是一个环境变量，它对应于在构建 FREETYPE 时使用的 ./configure --prefix=$FREETYPE_DIR。

  • FindGCCXML: 查找 GCC-XML 前端可执行文件。
  • FindGDAL:

    定位 gdal

    此模块接受以下环境变量

        GDAL_DIR or GDAL_ROOT - Specify the location of GDAL


    此模块定义以下 CMake 变量

        GDAL_FOUND - True if libgdal is found
        GDAL_LIBRARY - A variable pointing to the GDAL library
        GDAL_INCLUDE_DIR - Where to find the headers


    $GDALDIR 是一个环境变量，它对应于在构建 gdal 时使用的 ./configure --prefix=$GDAL_DIR。

    由 Eric Wing 创建。我不是 gdal 用户，但 OpenSceneGraph 使用它来处理 osgTerrain，因此我为了完整性而编写了这个模块。实际上我不知道约定或文件通常在发行版中的放置位置。任何真正的 gdal 用户都鼓励更正此问题（但请在这样做时不要破坏 OS X 框架内容，这通常似乎会发生）。

  • FindGIF:

    此模块定义 GIF_LIBRARIES - 用于链接以使用 GIF GIF_FOUND 的库，如果为 false，则不要尝试链接 GIF_INCLUDE_DIR，用于查找头文件的位置

    $GIF_DIR 是一个环境变量，它对应于 ./configure --prefix=$GIF_DIR

  • FindGLUT: 尝试查找 glut 库和包含文件
      GLUT_INCLUDE_DIR, where to find GL/glut.h, etc.
      GLUT_LIBRARIES, the libraries to link against
      GLUT_FOUND, If false, do not try to use GLUT.

    此外，还定义了以下内容，但不用于一般用途

      GLUT_glut_LIBRARY = the full path to the glut library.
      GLUT_Xmu_LIBRARY  = the full path to the Xmu library.
      GLUT_Xi_LIBRARY   = the full path to the Xi Library.
  • FindGTK: 尝试查找 GTK（和 glib）以及 GTKGLArea
      GTK_INCLUDE_DIR   - Directories to include to use GTK
      GTK_LIBRARIES     - Files to link against to use GTK
      GTK_FOUND         - GTK was found
      GTK_GL_FOUND      - GTK's GL features were found
  • FindGettext: 查找 GNU gettext 工具

    此模块查找 GNU gettext 工具。此模块定义以下值

      GETTEXT_MSGMERGE_EXECUTABLE: the full path to the msgmerge tool.
      GETTEXT_MSGFMT_EXECUTABLE: the full path to the msgfmt tool.
      GETTEXT_FOUND: True if gettext has been found.


    此外，它还提供以下宏：GETTEXT_CREATE_TRANSLATIONS ( outputFile [ALL] file1 ... fileN )

        This will create a target "translations" which will convert the 
        given input po files into the binary output mo file. If the 
        ALL option is used, the translations will also be created when
        building the default target.
  • FindGnuplot: 此模块查找 gnuplot


    完成后，将定义

      GNUPLOT_FOUND - system has Gnuplot
      GNUPLOT_EXECUTABLE - the Gnuplot executable
  • FindHSPELL: 尝试查找 HSPELL

    完成后，将定义

      HSPELL_FOUND - system has HSPELL
      HSPELL_INCLUDE_DIR - the HSPELL include directory
      HSPELL_LIBRARIES - The libraries needed to use HSPELL
      HSPELL_DEFINITIONS - Compiler switches required for using HSPELL
  • FindHTMLHelp: 此模块查找 Microsoft HTML 帮助编译器

    它定义

       HTML_HELP_COMPILER     : full path to the Compiler (hhc.exe)
       HTML_HELP_INCLUDE_PATH : include path to the API (htmlhelp.h)
       HTML_HELP_LIBRARY      : full path to the library (htmlhelp.lib)


  • FindITK: 查找 ITK 安装或构建树。
  • FindImageMagick: 查找 ImageMagick 二进制套件。

    此模块将搜索在 FIND_PACKAGE 调用中指定为组件的一组 ImageMagick 工具。典型的组件包括但不限于（未来版本的 ImageMagick 可能包含此处未列出的其他组件）

      animate
      compare
      composite
      conjure
      convert
      display
      identify
      import
      mogrify
      montage
      stream


    如果在 FIND_PACKAGE 调用中未指定任何组件，则它只搜索 ImageMagick 可执行文件目录。此代码定义以下变量

      ImageMagick_FOUND                  - TRUE if all components are found.
      ImageMagick_EXECUTABLE_DIR         - Full path to executables directory.
      ImageMagick_<component>_FOUND      - TRUE if <component> is found.
      ImageMagick_<component>_EXECUTABLE - Full path to <component> executable.


    还有以下 ImageMagick API 的组件

      Magick++
      MagickWand
      MagickCore


    对于这些组件，将设置以下变量

      ImageMagick_FOUND                    - TRUE if all components are found.
      ImageMagick_INCLUDE_DIRS             - Full paths to all include dirs.
      ImageMagick_LIBRARIES                - Full paths to all libraries.
      ImageMagick_<component>_FOUND        - TRUE if <component> is found.
      ImageMagick_<component>_INCLUDE_DIRS - Full path to <component> include dirs.
      ImageMagick_<component>_LIBRARIES    - Full path to <component> libraries.


    示例用法

      FIND_PACKAGE(ImageMagick)
      FIND_PACKAGE(ImageMagick COMPONENTS convert)
      FIND_PACKAGE(ImageMagick COMPONENTS convert mogrify display)
      FIND_PACKAGE(ImageMagick COMPONENTS Magick++)
      FIND_PACKAGE(ImageMagick COMPONENTS Magick++ convert)


    请注意，支持标准 FIND_PACKAGE 功能（即 QUIET、REQUIRED 等）。

  • FindJNI: 查找 JNI java 库。

    此模块查找是否已安装 Java 并确定包含文件和库的位置。它还确定库的名称。此代码设置以下变量

       
      JNI_INCLUDE_DIRS      = the include dirs to use
      JNI_LIBRARIES         = the libraries to use
      JAVA_AWT_LIBRARY      = the path to the jawt library
      JAVA_JVM_LIBRARY      = the path to the jvm library
      JAVA_INCLUDE_PATH     = the include path to jni.h
      JAVA_INCLUDE_PATH2    = the include path to jni_md.h
      JAVA_AWT_INCLUDE_PATH = the include path to jawt.h


  • FindJPEG: 查找 JPEG

    查找本机 JPEG 包含文件和库 此模块定义

      JPEG_INCLUDE_DIR, where to find jpeglib.h, etc.
      JPEG_LIBRARIES, the libraries needed to use JPEG.
      JPEG_FOUND, If false, do not try to use JPEG.

    此外，还定义了以下内容，但不用于一般用途

      JPEG_LIBRARY, where to find the JPEG library.
  • FindJasper: 尝试查找 Jasper JPEG2000 库

    完成后，将定义

      JASPER_FOUND - system has Jasper
      JASPER_INCLUDE_DIR - the Jasper include directory
      JASPER_LIBRARIES - The libraries needed to use Jasper
  • FindJava: 查找 Java

    此模块查找是否已安装 Java 并确定包含文件和库的位置。此代码设置以下变量

      JAVA_RUNTIME    = the full path to the Java runtime
      JAVA_COMPILE    = the full path to the Java compiler
      JAVA_ARCHIVE    = the full path to the Java archiver


  • FindKDE3: 查找 KDE3 包含和库目录，KDE 预处理器并定义一些宏


    此模块定义以下变量

      KDE3_DEFINITIONS         - compiler definitions required for compiling KDE software
      KDE3_INCLUDE_DIR         - the KDE include directory
      KDE3_INCLUDE_DIRS        - the KDE and the Qt include directory, for use with INCLUDE_DIRECTORIES()
      KDE3_LIB_DIR             - the directory where the KDE libraries are installed, for use with LINK_DIRECTORIES()
      QT_AND_KDECORE_LIBS      - this contains both the Qt and the kdecore library
      KDE3_DCOPIDL_EXECUTABLE  - the dcopidl executable
      KDE3_DCOPIDL2CPP_EXECUTABLE - the dcopidl2cpp executable
      KDE3_KCFGC_EXECUTABLE    - the kconfig_compiler executable
      KDE3_FOUND               - set to TRUE if all of the above has been found


    提供以下用户可调整选项

      KDE3_BUILD_TESTS - enable this to build KDE testcases



    它还添加了以下宏（来自 KDE3Macros.cmake）SRCS_VAR 始终是包含应用程序或库源文件列表的变量。

    KDE3_AUTOMOC(file1 ... fileN)

        Call this if you want to have automatic moc file handling.
        This means if you include "foo.moc" in the source file foo.cpp
        a moc file for the header foo.h will be created automatically.
        You can set the property SKIP_AUTOMAKE using SET_SOURCE_FILES_PROPERTIES()
        to exclude some files in the list from being processed.


    KDE3_ADD_MOC_FILES(SRCS_VAR file1 ... fileN )

        If you don't use the KDE3_AUTOMOC() macro, for the files
        listed here moc files will be created (named "foo.moc.cpp")


    KDE3_ADD_DCOP_SKELS(SRCS_VAR header1.h ... headerN.h )

        Use this to generate DCOP skeletions from the listed headers.


    KDE3_ADD_DCOP_STUBS(SRCS_VAR header1.h ... headerN.h )

         Use this to generate DCOP stubs from the listed headers.


    KDE3_ADD_UI_FILES(SRCS_VAR file1.ui ... fileN.ui )

        Use this to add the Qt designer ui files to your application/library.


    KDE3_ADD_KCFG_FILES(SRCS_VAR file1.kcfgc ... fileN.kcfgc )

        Use this to add KDE kconfig compiler files to your application/library.


    KDE3_INSTALL_LIBTOOL_FILE(target)

        This will create and install a simple libtool file for the given target.


    KDE3_ADD_EXECUTABLE(name file1 ... fileN )

        Currently identical to ADD_EXECUTABLE(), may provide some advanced features in the future.


    KDE3_ADD_KPART(name [WITH_PREFIX] file1 ... fileN )

        Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
        If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't.
        It creates and installs an appropriate libtool la-file.


    KDE3_ADD_KDEINIT_EXECUTABLE(name file1 ... fileN )

        Create a KDE application in the form of a module loadable via kdeinit.
        A library named kdeinit_<name> will be created and a small executable which links to it.


    不再支持启用全合一编译的选项 KDE3_ENABLE_FINAL。


    作者：Alexander Neundorf <[email protected]>

  • FindKDE4:

    查找 KDE4 并提供所有必要的变量和宏以对其进行软件编译。它按以下顺序在以下目录中查找 KDE 4

      CMAKE_INSTALL_PREFIX
      KDEDIRS
      /opt/kde4


    请在 FindKDE4Internal.cmake 和 KDE4Macros.cmake 中查找更多信息。它们与 KDE 4 库一起安装在 $KDEDIRS/share/apps/cmake/modules/ 中。

    作者：Alexander Neundorf <[email protected]>

  • FindLAPACK: 查找 LAPACK 库

    此模块查找已安装的 fortran 库，该库实现 LAPACK 线性代数接口（请参阅 http://www.netlib.org/lapack/）。

    该方法遵循针对 autoconf 宏文件 acx_lapack.m4（在 http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html 中分发）所采取的方法。

    此模块设置以下变量

      LAPACK_FOUND - set to true if a library implementing the LAPACK interface
        is found
      LAPACK_LINKER_FLAGS - uncached list of required linker flags (excluding -l
        and -L).
      LAPACK_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use LAPACK
      LAPACK95_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use LAPACK95
      LAPACK95_FOUND - set to true if a library implementing the LAPACK f95
        interface is found
      BLA_STATIC  if set on this determines what kind of linkage we do (static)
      BLA_VENDOR  if set checks only the specified vendor, if not set checks
         all the posibilities
      BLA_F95     if set on tries to find the f95 interfaces for BLAS/LAPACK

    ## 此模块中有效的供应商列表（BLA_VENDOR）# Intel(mkl)、ACML、Apple、NAS、Generic

  • FindLATEX: 查找 Latex

    此模块查找是否已安装 Latex 并确定可执行文件的位置。此代码设置以下变量

      
      LATEX_COMPILER:       path to the LaTeX compiler
      PDFLATEX_COMPILER:    path to the PdfLaTeX compiler
      BIBTEX_COMPILER:      path to the BibTeX compiler
      MAKEINDEX_COMPILER:   path to the MakeIndex compiler
      DVIPS_CONVERTER:      path to the DVIPS converter
      PS2PDF_CONVERTER:     path to the PS2PDF converter
      LATEX2HTML_CONVERTER: path to the LaTeX2Html converter


  • FindLibXml2: 尝试查找 LibXml2

    完成后，将定义

      LIBXML2_FOUND - System has LibXml2
      LIBXML2_INCLUDE_DIR - The LibXml2 include directory
      LIBXML2_LIBRARIES - The libraries needed to use LibXml2
      LIBXML2_DEFINITIONS - Compiler switches required for using LibXml2
      LIBXML2_XMLLINT_EXECUTABLE - The XML checking tool xmllint coming with LibXml2
  • FindLibXslt: 尝试查找 LibXslt

    完成后，将定义

      LIBXSLT_FOUND - system has LibXslt
      LIBXSLT_INCLUDE_DIR - the LibXslt include directory
      LIBXSLT_LIBRARIES - Link these to LibXslt
      LIBXSLT_DEFINITIONS - Compiler switches required for using LibXslt
  • FindLua50:

    定位 Lua 库 此模块定义

      LUA50_FOUND, if false, do not try to link to Lua 
      LUA_LIBRARIES, both lua and lualib
      LUA_INCLUDE_DIR, where to find lua.h and lualib.h (and probably lauxlib.h)


    请注意，预期的包含约定为

      #include "lua.h"

    而不是

      #include <lua/lua.h>

    这是因为，lua 位置没有标准化，可能存在于 lua/ 以外的位置。

  • FindLua51:

    定位 Lua 库 此模块定义

      LUA51_FOUND, if false, do not try to link to Lua 
      LUA_LIBRARIES
      LUA_INCLUDE_DIR, where to find lua.h


    请注意，预期的包含约定为

      #include "lua.h"

    而不是

      #include <lua/lua.h>

    这是因为，lua 位置没有标准化，可能存在于 lua/ 以外的位置。

  • FindMFC: 在 Windows 上查找 MFC

    查找本机 MFC - 即确定应用程序是否可以链接到 MFC 库。

      MFC_FOUND - Was MFC support found

    您无需包含任何内容或链接任何内容即可使用它。

  • FindMPEG: 查找本机 MPEG 包含文件和库

    此模块定义

      MPEG_INCLUDE_DIR, where to find MPEG.h, etc.
      MPEG_LIBRARIES, the libraries required to use MPEG.
      MPEG_FOUND, If false, do not try to use MPEG.

    此外，还定义了以下内容，但不用于一般用途

      MPEG_mpeg2_LIBRARY, where to find the MPEG library.
      MPEG_vo_LIBRARY, where to find the vo library.
  • FindMPEG2: 查找本机 MPEG2 包含文件和库

    此模块定义

      MPEG2_INCLUDE_DIR, path to mpeg2dec/mpeg2.h, etc.
      MPEG2_LIBRARIES, the libraries required to use MPEG2.
      MPEG2_FOUND, If false, do not try to use MPEG2.

    此外，还定义了以下内容，但不用于一般用途

      MPEG2_mpeg2_LIBRARY, where to find the MPEG2 library.
      MPEG2_vo_LIBRARY, where to find the vo library.
  • FindMPI: 消息传递接口 (MPI) 模块。


    消息传递接口 (MPI) 是一个库，用于编写使用消息传递的高性能并行应用程序，通常部署在集群上。MPI 是一个标准接口（由 MPI 论坛定义），它有许多可用实现。所有这些实现都具有略微不同的编译方法（不同的包含路径、要链接的库等），而此模块试图消除这些差异。

    此模块将设置以下变量

       MPI_FOUND                  TRUE if we have found MPI
       MPI_COMPILE_FLAGS          Compilation flags for MPI programs
       MPI_INCLUDE_PATH           Include path(s) for MPI header
       MPI_LINK_FLAGS             Linking flags for MPI programs
       MPI_LIBRARY                First MPI library to link against (cached)
       MPI_EXTRA_LIBRARY          Extra MPI libraries to link against (cached)
       MPI_LIBRARIES              All libraries to link MPI programs against
       MPIEXEC                    Executable for running MPI programs
       MPIEXEC_NUMPROC_FLAG       Flag to pass to MPIEXEC before giving it the
                                  number of processors to run on
       MPIEXEC_PREFLAGS           Flags to pass to MPIEXEC directly before the
                                  executable to run.
       MPIEXEC_POSTFLAGS          Flags to pass to MPIEXEC after all other flags.


    此模块将尝试自动检测这些设置，首先通过查找 MPI 编译器，许多 MPI 实现将其提供为对本机编译器的直通，以简化 MPI 程序的编译。MPI 编译器存储在缓存变量 MPI_COMPILER 中，并将尝试查找常用名称的驱动程序 mpic++、mpicxx、mpiCC 或 mpicc。如果找到并识别了编译器驱动程序，它将用于设置所有模块变量。若要跳过此自动检测，请在 CMake 缓存中设置 MPI_LIBRARY 和 MPI_INCLUDE_PATH。

    如果找不到编译器驱动程序或未识别编译器驱动程序，此模块将接着搜索常见的包含路径和库名称以尝试检测 MPI。

    如果 CMake 最初找到与预期不同的 MPI，并且您想要使用 MPI 编译器自动检测来使用不同的 MPI 实现，请将 MPI_COMPILER 设置为要使用的 MPI 编译器驱动程序（例如，mpicxx），然后将 MPI_LIBRARY 设置为字符串 MPI_LIBRARY-NOTFOUND。重新配置时，MPI 的自动检测将使用新指定的 MPI_COMPILER 再次运行。

    在使用 MPIEXEC 执行 MPI 应用程序时，您通常应使用所有 MPIEXEC 标志，如下所示

       ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} PROCS ${MPIEXEC_PREFLAGS} EXECUTABLE
         ${MPIEXEC_POSTFLAGS} ARGS

    其中 PROCS 是要执行程序的处理器数量，EXECUTABLE 是 MPI 程序，而 ARGS 是要传递给 MPI 程序的参数。

  • FindMatlab: 此模块查找 Matlab

    定义

      MATLAB_INCLUDE_DIR: include path for mex.h, engine.h
      MATLAB_LIBRARIES:   required libraries: libmex, etc
      MATLAB_MEX_LIBRARY: path to libmex.lib
      MATLAB_MX_LIBRARY:  path to libmx.lib
      MATLAB_ENG_LIBRARY: path to libeng.lib
  • FindMotif: 尝试查找 Motif（或 lesstif）

    完成后，将定义

      MOTIF_FOUND        - system has MOTIF
      MOTIF_INCLUDE_DIR  - incude paths to use Motif
      MOTIF_LIBRARIES    - Link these to use Motif
  • FindOpenAL:

    定位 OpenAL 此模块定义 OPENAL_LIBRARY OPENAL_FOUND，如果为 false，则不要尝试链接到 OpenAL OPENAL_INCLUDE_DIR，用于查找头文件的位置

    $OPENALDIR 是一个环境变量，它对应于在构建 OpenAL 时使用的 ./configure --prefix=$OPENALDIR。

    由 Eric Wing 创建。这受 FindSDL.cmake 模块的影响。

  • FindOpenGL: 尝试查找 OpenGL

    完成后，将定义

      
      OPENGL_FOUND        - system has OpenGL
      OPENGL_XMESA_FOUND  - system has XMESA
      OPENGL_GLU_FOUND    - system has GLU
      OPENGL_INCLUDE_DIR  - the GL include directory
      OPENGL_LIBRARIES    - Link these to use OpenGL and GLU

    如果您只想使用 GL，可以使用这些值

      OPENGL_gl_LIBRARY   - Path to OpenGL Library
      OPENGL_glu_LIBRARY  - Path to GLU Library

    在 OSX 上默认使用框架版本的 opengl 人们必须更改 OPENGL_glu_LIBRARY 和 OPENGL_gl_LIBRARY 的缓存值才能在 OSX 上使用 X11 的 OpenGL

  • FindOpenMP: 查找 OpenMP 支持

    此模块可用于检测编译器中的 OpenMP 支持。如果编译器支持 OpenMP，则将设置使用 openmp 支持进行编译所需的标志。

    将设置以下变量

       OpenMP_C_FLAGS - flags to add to the C compiler for OpenMP support
       OpenMP_CXX_FLAGS - flags to add to the CXX compiler for OpenMP support
       OPENMP_FOUND - true if openmp is detected


    支持的编译器可以在 http://openmp.org/wp/openmp-compilers/ 找到

  • FindOpenSSL: 尝试查找 OpenSSL 加密库

    完成后，将定义

      OPENSSL_FOUND - system has the OpenSSL library
      OPENSSL_INCLUDE_DIR - the OpenSSL include directory
      OPENSSL_LIBRARIES - The libraries needed to use OpenSSL
  • FindOpenSceneGraph: 查找 OpenSceneGraph

    此模块搜索 OpenSceneGraph 核心“osg”库以及 OpenThreads，以及您指定的任何其他组件。

        See http://www.openscenegraph.org


    注意：如果您想在您的 CMAKE_MODULE_PATH 中使用此模块，而不是要求 CMake >= 2.6.3，您还需要下载 FindOpenThreads.cmake、Findosg_functions.cmake、Findosg.cmake 以及您需要调用的任何组件的文件（FindosgDB.cmake、FindosgUtil.cmake 等）

    ==================================

    此模块接受以下变量（请注意大小写混合使用）

        OpenSceneGraph_DEBUG - Enable debugging output


        OpenSceneGraph_MARK_AS_ADVANCED - Mark cache variables as advanced 
                                          automatically


    以下环境变量也适用于查找 OSG 及其各种组件。CMAKE_PREFIX_PATH 也可用于此（请参阅 find_library() CMake 文档）。

        <MODULE>_DIR (where MODULE is of the form "OSGVOLUME" and there is a FindosgVolume.cmake file)
        OSG_DIR
        OSGDIR
        OSG_ROOT


    此模块定义以下输出变量

        OPENSCENEGRAPH_FOUND - Was the OSG and all of the specified components found?


        OPENSCENEGRAPH_VERSION - The version of the OSG which was found


        OPENSCENEGRAPH_INCLUDE_DIRS - Where to find the headers


        OPENSCENEGRAPH_LIBRARIES - The OSG libraries


    ================================== 示例用法

      find_package(OpenSceneGraph 2.0.0 COMPONENTS osgDB osgUtil)
      include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS})


      add_executable(foo foo.cc)
      target_link_libraries(foo ${OPENSCENEGRAPH_LIBRARIES})


    ==================================

    命名约定

      Local variables of the form _osg_foo
      Input variables of the form OpenSceneGraph_FOO
      Output variables of the form OPENSCENEGRAPH_FOO


    版权所有 (c) 2009，Philip Lowman <[email protected]>

    根据新 BSD 许可证的条款允许重新分发和使用。有关详细信息，请参阅随附的 COPYING-CMAKE-SCRIPTS 文件。

    ==================================

  • FindOpenThreads:

    OpenThreads 是一个基于 C++ 的线程库。它最大的用户群似乎是 OpenSceneGraph，因此您可能会注意到我接受 OSGDIR 作为环境路径。我认为这是 Findosg* 套件的一部分，用于查找 OpenSceneGraph 组件。每个组件都是独立的，您必须选择加入每个模块。

    定位 OpenThreads 此模块定义 OPENTHREADS_LIBRARY OPENTHREADS_FOUND，如果为 false，则不要尝试链接到 OpenThreads OPENTHREADS_INCLUDE_DIR，用于查找头文件的位置

    $OPENTHREADS_DIR 是一个环境变量，它对应于在构建 osg 时使用的 ./configure --prefix=$OPENTHREADS_DIR。

    由 Eric Wing 创建。

  • FindPHP4: 查找 PHP4

    此模块查找是否安装了 PHP4，并确定包含文件和库的位置。 它还确定库的名称。 此代码设置以下变量

      PHP4_INCLUDE_PATH       = path to where php.h can be found
      PHP4_EXECUTABLE         = full path to the php4 binary


  • FindPNG: 查找本机 PNG 包含文件和库


    此模块定义

      PNG_INCLUDE_DIR, where to find png.h, etc.
      PNG_LIBRARIES, the libraries to link against to use PNG.
      PNG_DEFINITIONS - You should ADD_DEFINITONS(${PNG_DEFINITIONS}) before compiling code that includes png library files.
      PNG_FOUND, If false, do not try to use PNG.

    此外，还定义了以下内容，但不用于一般用途

      PNG_LIBRARY, where to find the PNG library.

    如果找不到 zlib，则上述内容均不会定义。 PNG 依赖于 Zlib

  • FindPackageHandleStandardArgs:

    FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME (DEFAULT_MSG|"自定义失败消息") VAR1 ... )

        This macro is intended to be used in FindXXX.cmake modules files.
        It handles the REQUIRED and QUIET argument to FIND_PACKAGE() and
        it also sets the <UPPERCASED_NAME>_FOUND variable.
        The package is found if all variables listed are TRUE.
        Example:


        FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARIES LIBXML2_INCLUDE_DIR)


        LibXml2 is considered to be found, if both LIBXML2_LIBRARIES and 
        LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE.
        If it is not found and REQUIRED was used, it fails with FATAL_ERROR, 
        independent whether QUIET was used or not.
        If it is found, the location is reported using the VAR1 argument, so 
        here a message "Found LibXml2: /usr/lib/libxml2.so" will be printed out.
        If the second argument is DEFAULT_MSG, the message in the failure case will 
        be "Could NOT find LibXml2", if you don't like this message you can specify
        your own custom failure message there.
  • FindPackageMessage:

    FIND_PACKAGE_MESSAGE(<name> "用户消息" "查找结果详细信息")

    此宏旨在用于 FindXXX.cmake 模块文件。 它将为每个唯一的查找结果打印一次消息。 这对于告诉用户在何处找到包很有用。 第一个参数指定包的名称 (XXX)。 第二个参数指定要显示的消息。 第三个参数列出有关查找结果的详细信息，以便如果它们更改，则将再次显示消息。 该宏还服从 find_package 命令的 QUIET 参数。

    示例

      IF(X11_FOUND)
        FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
          "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
      ELSE(X11_FOUND)
       ...
      ENDIF(X11_FOUND)
  • FindPerl: 查找 Perl

    此模块查找 Perl

      PERL_EXECUTABLE - the full path to perl
      PERL_FOUND      - If false, don't attempt to use perl.
  • FindPerlLibs: 查找 Perl 库

    此模块查找是否安装了 PERL，并确定包含文件和库的位置。 它还确定库的名称。 此代码设置以下变量

      PERL_INCLUDE_PATH = path to where perl.h is found
      PERL_EXECUTABLE   = full path to the perl binary


  • FindPhysFS:

    找到 PhysFS 库 此模块定义 PHYSFS_LIBRARY，要链接到的库的名称 PHYSFS_FOUND，如果为假，则不要尝试链接到 PHYSFS PHYSFS_INCLUDE_DIR，在何处找到 physfs.h

    $PHYSFSDIR 是一个环境变量，它对应于构建 PHYSFS 时使用的 ./configure --prefix=$PHYSFSDIR。

    由 Eric Wing 创建。

  • FindPike: 查找 Pike

    此模块查找是否安装了 PIKE，并确定包含文件和库的位置。 它还确定库的名称。 此代码设置以下变量

      PIKE_INCLUDE_PATH       = path to where program.h is found
      PIKE_EXECUTABLE         = full path to the pike binary


  • FindPkgConfig: CMake 的 pkg-config 模块


    用法

       pkg_check_modules(<PREFIX> [REQUIRED] <MODULE> [<MODULE>]*)
         checks for all the given modules


       pkg_search_module(<PREFIX> [REQUIRED] <MODULE> [<MODULE>]*)
         checks for given modules and uses the first working one


    当设置了 'REQUIRED' 参数时，宏在找不到模块时将失败并显示错误

    它设置以下变量

       PKG_CONFIG_FOUND         ... true if pkg-config works on the system
       PKG_CONFIG_EXECUTABLE    ... pathname of the pkg-config program
       <PREFIX>_FOUND           ... set to 1 if module(s) exist


    对于以下变量，存在两组值； 第一组是通用组，具有给定的 PREFIX。 第二组包含使用 '--static' 选项调用 pkgconfig 时给出的标志。

       <XPREFIX>_LIBRARIES      ... only the libraries (w/o the '-l')
       <XPREFIX>_LIBRARY_DIRS   ... the paths of the libraries (w/o the '-L')
       <XPREFIX>_LDFLAGS        ... all required linker flags
       <XPREFIX>_LDFLAGS_OTHER  ... all other linker flags
       <XPREFIX>_INCLUDE_DIRS   ... the '-I' preprocessor flags (w/o the '-I')
       <XPREFIX>_CFLAGS         ... all required cflags
       <XPREFIX>_CFLAGS_OTHER   ... the other compiler flags


       <XPREFIX> = <PREFIX>        for common case
       <XPREFIX> = <PREFIX>_STATIC for static linking


    有一些特殊变量，其前缀取决于给定模块的数量。 当只有一个模块时，<PREFIX> 保持不变。 当有多个模块时，前缀将更改为 <PREFIX>_<MODNAME>

       <XPREFIX>_VERSION    ... version of the module
       <XPREFIX>_PREFIX     ... prefix-directory of the module
       <XPREFIX>_INCLUDEDIR ... include-dir of the module
       <XPREFIX>_LIBDIR     ... lib-dir of the module


       <XPREFIX> = <PREFIX>  when |MODULES| == 1, else
       <XPREFIX> = <PREFIX>_<MODNAME>


    <MODULE> 参数可以具有以下格式

       {MODNAME}            ... matches any version
       {MODNAME}>={VERSION} ... at least version <VERSION> is required
       {MODNAME}={VERSION}  ... exactly version <VERSION> is required
       {MODNAME}<={VERSION} ... modules must not be newer than <VERSION>


    示例

       pkg_check_modules (GLIB2   glib-2.0)


       pkg_check_modules (GLIB2   glib-2.0>=2.10)
         requires at least version 2.10 of glib2 and defines e.g.
           GLIB2_VERSION=2.10.3


       pkg_check_modules (FOO     glib-2.0>=2.10 gtk+-2.0)
         requires both glib2 and gtk2, and defines e.g.
           FOO_glib-2.0_VERSION=2.10.3
           FOO_gtk+-2.0_VERSION=2.8.20


       pkg_check_modules (XRENDER REQUIRED xrender)
         defines e.g.:
           XRENDER_LIBRARIES=Xrender;X11
           XRENDER_STATIC_LIBRARIES=Xrender;X11;pthread;Xau;Xdmcp


       pkg_search_module (BAR     libxml-2.0 libxml2 libxml>=2)
  • FindProducer:

    虽然 Producer 不是 OpenSceneGraph 的直接组成部分，但其主要用户是 OSG，因此我认为这是 Findosg* 套件的一部分，用于查找 OpenSceneGraph 组件。 您会注意到，我接受 OSGDIR 作为环境路径。

    每个组件都是独立的，您必须选择加入每个模块。 您还必须选择加入 OpenGL（和 OpenThreads？），因为这些模块不会为您执行此操作。 这样做是为了让您可以逐个控制自己的系统，以防您需要退出某些组件或更改特定模块的 Find 行为（例如，因为默认的 FindOpenGL.cmake 模块不适用于您的系统）。 如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    找到 Producer 此模块定义 PRODUCER_LIBRARY PRODUCER_FOUND，如果为假，则不要尝试链接到 Producer PRODUCER_INCLUDE_DIR，在何处找到标题

    $PRODUCER_DIR 是一个环境变量，它对应于构建 osg 时使用的 ./configure --prefix=$PRODUCER_DIR。

    由 Eric Wing 创建。

  • FindPythonInterp: 查找 Python 解释器

    此模块查找是否安装了 Python 解释器，并确定可执行文件的位置。 此代码设置以下变量

      PYTHONINTERP_FOUND - Was the Python executable found
      PYTHON_EXECUTABLE  - path to the Python interpreter


  • FindPythonLibs: 查找 Python 库

    此模块查找是否安装了 Python，并确定包含文件和库的位置。 它还确定库的名称。 此代码设置以下变量

      PYTHONLIBS_FOUND     = have the Python libs been found
      PYTHON_LIBRARIES     = path to the python library
      PYTHON_INCLUDE_PATH  = path to where Python.h is found
      PYTHON_DEBUG_LIBRARIES = path to the debug library


  • FindQt: 搜索所有已安装版本的 QT。

    这仅应在您的项目可以与多个版本的 QT 一起使用时使用。 否则，您应该直接使用 FindQt4 或 FindQt3。 如果在机器上找到多个版本的 QT，则用户必须将选项 DESIRED_QT_VERSION 设置为他们要使用的版本。 如果机器上只找到一个版本的 qt，则 DESIRED_QT_VERSION 设置为该版本，并包含匹配的 FindQt3 或 FindQt4 模块。 用户设置 DESIRED_QT_VERSION 后，将包含 FindQt3 或 FindQt4 模块。

      QT_REQUIRED if this is set to TRUE then if CMake can 
                  not find QT4 or QT3 an error is raised 
                  and a message is sent to the user.


      DESIRED_QT_VERSION OPTION is created
      QT4_INSTALLED is set to TRUE if qt4 is found.
      QT3_INSTALLED is set to TRUE if qt3 is found.
  • FindQt3: 找到 Qt 包含路径和库

    此模块定义

      QT_INCLUDE_DIR - where to find qt.h, etc.
      QT_LIBRARIES   - the libraries to link against to use Qt.
      QT_DEFINITIONS - definitions to use when
                       compiling code that uses Qt.
      QT_FOUND       - If false, don't try to use Qt.


    如果您需要 Qt 的多线程版本，请将 QT_MT_REQUIRED 设置为 TRUE

    此外，还定义了以下内容，但不用于一般用途

      QT_MOC_EXECUTABLE, where to find the moc tool.
      QT_UIC_EXECUTABLE, where to find the uic tool.
      QT_QT_LIBRARY, where to find the Qt library.
      QT_QTMAIN_LIBRARY, where to find the qtmain
       library. This is only required by Qt3 on Windows.
  • FindQt4: 查找 QT 4

    此模块可用于查找 Qt4。 最重要的问题是 Qt4 qmake 可通过系统路径获得。 然后使用此 qmake 来检测基本上所有其他内容。 此模块定义了一些关键变量和宏。 首先是 QT_USE_FILE，它是可以包含以编译 Qt 4 应用程序和库的 CMake 文件的路径。 默认情况下，将加载 QtCore 和 QtGui 库。 可以通过在执行 INCLUDE(${QT_USE_FILE}) 之前将以下一个或多个变量设置为 true 来更改此行为

                        QT_DONT_USE_QTCORE
                        QT_DONT_USE_QTGUI
                        QT_USE_QT3SUPPORT
                        QT_USE_QTASSISTANT
                        QT_USE_QAXCONTAINER
                        QT_USE_QAXSERVER
                        QT_USE_QTDESIGNER
                        QT_USE_QTMOTIF
                        QT_USE_QTMAIN
                        QT_USE_QTNETWORK
                        QT_USE_QTNSPLUGIN
                        QT_USE_QTOPENGL
                        QT_USE_QTSQL
                        QT_USE_QTXML
                        QT_USE_QTSVG
                        QT_USE_QTTEST
                        QT_USE_QTUITOOLS
                        QT_USE_QTDBUS
                        QT_USE_QTSCRIPT
                        QT_USE_QTASSISTANTCLIENT
                        QT_USE_QTHELP
                        QT_USE_QTWEBKIT
                        QT_USE_QTXMLPATTERNS
                        QT_USE_PHONON


    由 QT_USE_FILE 指向的文件将通过添加包含目录、预处理器定义和填充包含所有 Qt 库及其依赖项的 QT_LIBRARIES 变量来设置您的编译环境。 将 QT_LIBRARIES 变量添加到您的 TARGET_LINK_LIBRARIES 中。

    典型的用法可能类似于

       FIND_PACKAGE(Qt4)
       SET(QT_USE_QTXML 1)
       INCLUDE(${QT_USE_FILE})
       ADD_EXECUTABLE(myexe main.cpp)
       TARGET_LINK_LIBRARIES(myexe ${QT_LIBRARIES})



    还有一些文件需要由一些 Qt 工具（如 moc 和 uic）进行处理。 下面列出了可用于处理这些文件的宏。

      
      macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
            create moc code from a list of files containing Qt class with
            the Q_OBJECT declaration.  Per-direcotry preprocessor definitions 
            are also added.  Options may be given to moc, such as those found
            when executing "moc -help".  


      macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
            create code from a list of Qt designer ui files.
            Options may be given to uic, such as those found
            when executing "uic -help"


      macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
            create code from a list of Qt resource files.
            Options may be given to rcc, such as those found
            when executing "rcc -help"


      macro QT4_GENERATE_MOC(inputfile outputfile )
            creates a rule to run moc on infile and create outfile.
            Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
            because you need a custom filename for the moc file or something similar.


      macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
            This macro is still experimental.
            It can be used to have moc automatically handled.
            So if you have the files foo.h and foo.cpp, and in foo.h a 
            a class uses the Q_OBJECT macro, moc has to run on it. If you don't
            want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
            #include "foo.moc"
            in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
            scan all listed files at cmake-time for such included moc files and if it finds
            them cause a rule to be generated to run moc at build time on the 
            accompanying header file foo.h.
            If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.


      macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
            create a the interface header and implementation files with the 
            given basename from the given interface xml file and add it to 
            the list of sources


      macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
            create the interface header and implementation files 
            for all listed interface xml files
            the name will be automatically determined from the name of the xml file


      macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] )
            create a dbus adaptor (header and implementation file) from the xml file
            describing the interface, and add it to the list of sources. The adaptor
            forwards the calls to a parent class, defined in parentheader and named
            parentclassname. The name of the generated files will be
            <basename>adaptor.{cpp,h} where basename is the basename of the xml file.


      macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] )
            generate the xml interface file from the given header.
            If the optional argument interfacename is omitted, the name of the 
            interface file is constructed from the basename of the header with
            the suffix .xml appended.


      macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ... 
                                    ts_files ... OPTIONS ...)
            out: qm_files
            in:  directories sources ts_files
            options: flags to pass to lupdate, such as -extensions to specify
            extensions for a directory scan.
            generates commands to create .ts (vie lupdate) and .qm
            (via lrelease) - files from directories and/or sources. The ts files are 
            created and/or updated in the source tree (unless given with full paths).
            The qm files are generated in the build tree.
            Updating the translations can be done by adding the qm_files
            to the source list of your library/executable, so they are
            always updated, or by adding a custom target to control when
            they get updated/generated.


      macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
            out: qm_files
            in:  ts_files
            generates commands to create .qm from .ts - files. The generated
            filenames can be found in qm_files. The ts_files
            must exists and are not updated in any way.



      QT_FOUND         If false, don't try to use Qt.
      QT4_FOUND        If false, don't try to use Qt 4.


      QT_VERSION_MAJOR The major version of Qt found.
      QT_VERSION_MINOR The minor version of Qt found.
      QT_VERSION_PATCH The patch version of Qt found.


      QT_EDITION               Set to the edition of Qt (i.e. DesktopLight)
      QT_EDITION_DESKTOPLIGHT  True if QT_EDITION == DesktopLight
      QT_QTCORE_FOUND          True if QtCore was found.
      QT_QTGUI_FOUND           True if QtGui was found.
      QT_QT3SUPPORT_FOUND      True if Qt3Support was found.
      QT_QTASSISTANT_FOUND     True if QtAssistant was found.
      QT_QAXCONTAINER_FOUND     True if QAxContainer was found (Windows only).
      QT_QAXSERVER_FOUND          True if QAxServer was found (Windows only).
      QT_QTDBUS_FOUND          True if QtDBus was found.
      QT_QTDESIGNER_FOUND      True if QtDesigner was found.
      QT_QTDESIGNERCOMPONENTS  True if QtDesignerComponents was found.
      QT_QTMOTIF_FOUND         True if QtMotif was found.
      QT_QTNETWORK_FOUND       True if QtNetwork was found.
      QT_QTNSPLUGIN_FOUND      True if QtNsPlugin was found.
      QT_QTOPENGL_FOUND        True if QtOpenGL was found.
      QT_QTSQL_FOUND           True if QtSql was found.
      QT_QTXML_FOUND           True if QtXml was found.
      QT_QTSVG_FOUND           True if QtSvg was found.
      QT_QTSCRIPT_FOUND        True if QtScript was found.
      QT_QTTEST_FOUND          True if QtTest was found.
      QT_QTUITOOLS_FOUND       True if QtUiTools was found.
      QT_QTASSISTANTCLIENT_FOUND  True if QtAssistantClient was found.
      QT_QTHELP_FOUND          True if QtHelp was found.
      QT_QTWEBKIT_FOUND        True if QtWebKit was found.
      QT_QTXMLPATTERNS_FOUND   True if QtXmlPatterns was found.
      QT_PHONON_FOUND          True if phonon was found.



      QT_DEFINITIONS   Definitions to use when compiling code that uses Qt.
                       You do not need to use this if you include QT_USE_FILE.
                       The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
                       to fit your current build type.  Those are not contained
                       in QT_DEFINITIONS.
                      
      QT_INCLUDES      List of paths to all include directories of 
                       Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
                       always in this variable even if NOTFOUND,
                       all other INCLUDE_DIRS are
                       only added if they are found.
                       You do not need to use this if you include QT_USE_FILE.
       


      Include directories for the Qt modules are listed here.
      You do not need to use these variables if you include QT_USE_FILE.


      QT_INCLUDE_DIR              Path to "include" of Qt4
      QT_QT3SUPPORT_INCLUDE_DIR   Path to "include/Qt3Support" 
      QT_QTASSISTANT_INCLUDE_DIR  Path to "include/QtAssistant" 
      QT_QAXCONTAINER_INCLUDE_DIR  Path to "include/ActiveQt" (Windows only)
      QT_QAXSERVER_INCLUDE_DIR  Path to "include/ActiveQt" (Windows only)
      QT_QTCORE_INCLUDE_DIR       Path to "include/QtCore"         
      QT_QTDESIGNER_INCLUDE_DIR   Path to "include/QtDesigner" 
      QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR   Path to "include/QtDesigner"
      QT_QTDBUS_INCLUDE_DIR       Path to "include/QtDBus" 
      QT_QTGUI_INCLUDE_DIR        Path to "include/QtGui" 
      QT_QTMOTIF_INCLUDE_DIR      Path to "include/QtMotif" 
      QT_QTNETWORK_INCLUDE_DIR    Path to "include/QtNetwork" 
      QT_QTNSPLUGIN_INCLUDE_DIR   Path to "include/QtNsPlugin" 
      QT_QTOPENGL_INCLUDE_DIR     Path to "include/QtOpenGL" 
      QT_QTSQL_INCLUDE_DIR        Path to "include/QtSql" 
      QT_QTXML_INCLUDE_DIR        Path to "include/QtXml" 
      QT_QTSVG_INCLUDE_DIR        Path to "include/QtSvg"
      QT_QTSCRIPT_INCLUDE_DIR     Path to "include/QtScript"
      QT_QTTEST_INCLUDE_DIR       Path to "include/QtTest"
      QT_QTASSISTANTCLIENT_INCLUDE_DIR       Path to "include/QtAssistant"
      QT_QTHELP_INCLUDE_DIR       Path to "include/QtHelp"
      QT_QTWEBKIT_INCLUDE_DIR     Path to "include/QtWebKit"
      QT_QTXMLPATTERNS_INCLUDE_DIR  Path to "include/QtXmlPatterns"
      QT_PHONON_INCLUDE_DIR       Path to "include/phonon"
                                
      QT_BINARY_DIR               Path to "bin" of Qt4
      QT_LIBRARY_DIR              Path to "lib" of Qt4
      QT_PLUGINS_DIR              Path to "plugins" for Qt4
      QT_TRANSLATIONS_DIR         Path to "translations" of Qt4
      QT_DOC_DIR                  Path to "doc" of Qt4
      QT_MKSPECS_DIR              Path to "mkspecs" of Qt4


    Qt 工具包可能包含调试库和发布库。 在这种情况下，以下库变量将包含两者。 如果包含了 QT_USE_FILE 并使用了 QT_LIBRARIES，则您不需要使用这些变量。

      QT_QT3SUPPORT_LIBRARY            The Qt3Support library
      QT_QTASSISTANT_LIBRARY           The QtAssistant library
      QT_QAXCONTAINER_LIBRARY           The QAxContainer library (Windows only)
      QT_QAXSERVER_LIBRARY                The QAxServer library (Windows only)
      QT_QTCORE_LIBRARY                The QtCore library
      QT_QTDBUS_LIBRARY                The QtDBus library
      QT_QTDESIGNER_LIBRARY            The QtDesigner library
      QT_QTDESIGNERCOMPONENTS_LIBRARY  The QtDesignerComponents library
      QT_QTGUI_LIBRARY                 The QtGui library
      QT_QTMOTIF_LIBRARY               The QtMotif library
      QT_QTNETWORK_LIBRARY             The QtNetwork library
      QT_QTNSPLUGIN_LIBRARY            The QtNsPLugin library
      QT_QTOPENGL_LIBRARY              The QtOpenGL library
      QT_QTSQL_LIBRARY                 The QtSql library
      QT_QTXML_LIBRARY                 The QtXml library
      QT_QTSVG_LIBRARY                 The QtSvg library
      QT_QTSCRIPT_LIBRARY              The QtScript library
      QT_QTTEST_LIBRARY                The QtTest library
      QT_QTMAIN_LIBRARY                The qtmain library for Windows
      QT_QTUITOOLS_LIBRARY             The QtUiTools library
      QT_QTASSISTANTCLIENT_LIBRARY     The QtAssistantClient library
      QT_QTHELP_LIBRARY                The QtHelp library
      QT_QTWEBKIT_LIBRARY              The QtWebKit library
      QT_QTXMLPATTERNS_LIBRARY         The QtXmlPatterns library
      QT_PHONON_LIBRARY                The phonon library

    也已定义，但 _NOT_ 用于一般用途是

      QT_MOC_EXECUTABLE          Where to find the moc tool.
      QT_UIC_EXECUTABLE          Where to find the uic tool.
      QT_UIC3_EXECUTABLE         Where to find the uic3 tool.
      QT_RCC_EXECUTABLE          Where to find the rcc tool
      QT_DBUSCPP2XML_EXECUTABLE  Where to find the qdbuscpp2xml tool.
      QT_DBUSXML2CPP_EXECUTABLE  Where to find the qdbusxml2cpp tool.
      QT_LUPDATE_EXECUTABLE      Where to find the lupdate tool.
      QT_LRELEASE_EXECUTABLE     Where to find the lrelease tool.


    这些是为了向后兼容性而存在的，它们将被设置

      QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
      QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found

    这些变量 _NOT_ 具有任何影响（与 FindQt.cmake 相比）

      QT_MT_REQUIRED         Qt4 is now always multithreaded

    这些变量设置为 "" 因为 Qt 结构已更改（它们在 Qt4 中没有意义）

      QT_QT_LIBRARY        Qt-Library is now split
  • FindQuickTime:

    找到 QuickTime 此模块定义 QUICKTIME_LIBRARY QUICKTIME_FOUND，如果为假，则不要尝试链接到 gdal QUICKTIME_INCLUDE_DIR，在何处找到标题

    $QUICKTIME_DIR 是一个环境变量，它对应于 ./configure --prefix=$QUICKTIME_DIR

    由 Eric Wing 创建。

  • FindRTI: 尝试查找 M&S HLA RTI 库

    此模块查找是否安装了任何 HLA RTI，并找到标准 RTI 包含文件和库。

    RTI 是 IEEE 和 SISO 标准化的仿真基础设施。 它有一个定义明确的 C++ API，确保仿真应用程序独立于特定的 RTI 实现。 http://en.wikipedia.org/wiki/Run-Time_Infrastructure_(模拟)

    此代码设置以下变量

      RTI_INCLUDE_DIR = the directory where RTI includes file are found
      RTI_LIBRARIES = The libraries to link against to use RTI
      RTI_DEFINITIONS = -DRTI_USES_STD_FSTREAM
      RTI_FOUND = Set to FALSE if any HLA RTI was not found


    向 <[email protected]> 报告问题

  • FindRuby: 查找 Ruby

    此模块查找是否安装了 Ruby，并确定包含文件和库的位置。 它还确定库的名称。 此代码设置以下变量

      RUBY_INCLUDE_PATH = path to where ruby.h can be found
      RUBY_EXECUTABLE   = full path to the ruby binary
      RUBY_LIBRARY      = full path to the ruby library
  • FindSDL:

    找到 SDL 库 此模块定义 SDL_LIBRARY，要链接到的库的名称 SDL_FOUND，如果为假，则不要尝试链接到 SDL SDL_INCLUDE_DIR，在何处找到 SDL.h

    此模块响应标志：SDL_BUILDING_LIBRARY 如果定义了此标志，则不会链接任何 SDL_main，因为只有应用程序需要 main()。 否则，假设您正在构建一个应用程序，并且此模块将尝试找到并设置适当的链接标志作为返回的 SDL_LIBRARY 变量的一部分。

    不要忘记在您的项目中包含 SDLmain.h 和 SDLmain.m 以用于基于 OS X 框架的版本。 （其他版本链接到 -lSDLmain，此模块将尝试代表您找到它。）同样对于 OS X，此模块将自动代表您添加 -framework Cocoa。


    附加说明：如果您在配置中看到空的 SDL_LIBRARY_TEMP 并且没有 SDL_LIBRARY，则表示 CMake 未找到您的 SDL 库（SDL.dll、libsdl.so、SDL.framework 等）。 将 SDL_LIBRARY_TEMP 设置为指向您的 SDL 库，然后重新配置。 同样，如果您看到空的 SDLMAIN_LIBRARY，则应根据需要设置此值。 这些值用于生成最终的 SDL_LIBRARY 变量，但当这些值未设置时，SDL_LIBRARY 不会被创建。


    $SDLDIR 是一个环境变量，它对应于构建 SDL 时使用的 ./configure --prefix=$SDLDIR。 l.e.galup 9-20-02

    由 Eric Wing 修改。 添加了代码以通过使用环境变量并提供更受控/一致的搜索行为来帮助自动构建。 添加了新的修改以识别 OS X 框架和额外的 Unix 路径（FreeBSD 等）。 还将标题搜索路径更正为遵循“正确”的 SDL 指南。 添加了对 SDLmain 的搜索，某些平台需要它。 添加了对线程的搜索，某些平台需要它。 添加了 MinGW 所需的编译开关。

    在 OSX 上，这将优先于其他版本使用 Framework 版本（如果找到）。 用户必须手动更改 SDL_LIBRARY 的缓存值以覆盖此选择，或设置 CMake 环境 CMAKE_INCLUDE_PATH 以修改搜索路径。

    请注意，标题路径已从 SDL/SDL.h 更改为 SDL.h。 这需要更改，因为“正确”的 SDL 约定是 #include "SDL.h"，而不是 <SDL/SDL.h>。 这样做是为了便携性，因为并非所有系统都将事物放在 SDL/ 中（参见 FreeBSD）。

  • FindSDL_image:

    找到 SDL_image 库 此模块定义 SDLIMAGE_LIBRARY，要链接到的库的名称 SDLIMAGE_FOUND，如果为假，则不要尝试链接到 SDL SDLIMAGE_INCLUDE_DIR，在何处找到 SDL/SDL.h

    $SDLDIR 是一个环境变量，它对应于构建 SDL 时使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 创建。 这是受 FindSDL.cmake 模块的影响，但经过修改以识别 OS X 框架和额外的 Unix 路径（FreeBSD 等）。

  • FindSDL_mixer:

    找到 SDL_mixer 库 此模块定义 SDLMIXER_LIBRARY，要链接到的库的名称 SDLMIXER_FOUND，如果为假，则不要尝试链接到 SDL SDLMIXER_INCLUDE_DIR，在何处找到 SDL/SDL.h

    $SDLDIR 是一个环境变量，它对应于构建 SDL 时使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 创建。 这是受 FindSDL.cmake 模块的影响，但经过修改以识别 OS X 框架和额外的 Unix 路径（FreeBSD 等）。

  • FindSDL_net:

    找到 SDL_net 库 此模块定义 SDLNET_LIBRARY，要链接到的库的名称 SDLNET_FOUND，如果为假，则不要尝试链接到 SDLNET_INCLUDE_DIR，在何处找到标题

    $SDLDIR 是一个环境变量，它对应于构建 SDL 时使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 创建。 这是受 FindSDL.cmake 模块的影响，但经过修改以识别 OS X 框架和额外的 Unix 路径（FreeBSD 等）。

  • FindSDL_sound:

    找到 SDL_sound 库

  • FindSDL_ttf:

    找到 SDL_ttf 库 此模块定义 SDLTTF_LIBRARY，要链接到的库的名称 SDLTTF_FOUND，如果为假，则不要尝试链接到 SDL SDLTTF_INCLUDE_DIR，在何处找到 SDL/SDL.h

    $SDLDIR 是一个环境变量，它对应于构建 SDL 时使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 创建。 这是受 FindSDL.cmake 模块的影响，但经过修改以识别 OS X 框架和额外的 Unix 路径（FreeBSD 等）。

  • FindSWIG: 查找 SWIG

    此模块查找已安装的 SWIG。 它设置以下变量

      SWIG_FOUND - set to true if SWIG is found
      SWIG_DIR - the directory where swig is installed
      SWIG_EXECUTABLE - the path to the swig executable
      SWIG_VERSION   - the version number of the swig executable


    所有信息都从 SWIG_EXECUTABLE 收集，因此要找到的版本可以通过设置 SWIG_EXECUTABLE 从命令行更改

  • FindSelfPackers: 查找 upx

    此模块查找一些可执行文件打包器（即，将可执行文件或共享库压缩为即时自解压可执行文件或共享库的软件。 例如

      UPX: http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
  • FindSquish: -- 典型用法


    此模块可用于查找 Squish（目前支持针对版本 3）。

    SQUISH_FOUND 如果为假，则不要尝试使用 Squish SQUISH_VERSION_MAJOR 找到的 Squish 的主要版本 SQUISH_VERSION_MINOR 找到的 Squish 的次要版本 SQUISH_VERSION_PATCH 找到的 Squish 的修补程序版本

    SQUISH_INSTALL_DIR Squish 安装目录（包含 bin、lib 等） SQUISH_SERVER_EXECUTABLE squishserver 可执行文件 SQUISH_CLIENT_EXECUTABLE squishrunner 可执行文件

    SQUISH_INSTALL_DIR_FOUND 是否找到安装目录？ SQUISH_SERVER_EXECUTABLE_FOUND 是否找到服务器可执行文件？ SQUISH_CLIENT_EXECUTABLE_FOUND 是否找到客户端可执行文件？

    宏 SQUISH_ADD_TEST(testName applicationUnderTest testSuite testCase)

    ENABLE_TESTING() FIND_PACKAGE(Squish) IF (SQUISH_FOUND)

       SQUISH_ADD_TEST(myTestName myApplication testSuiteName testCaseName)

    ENDIF (SQUISH_FOUND)

  • FindSubversion: 从 Subversion 工作副本中提取信息

    此模块定义以下变量

      Subversion_SVN_EXECUTABLE - path to svn command line client
      Subversion_VERSION_SVN - version of svn command line client
      Subversion_FOUND - true if the command line client was found

    如果找到命令行客户端可执行文件，则宏

      Subversion_WC_INFO(<dir> <var-prefix>)

    定义为提取给定位置的 Subversion 工作副本的信息。该宏定义以下变量

      <var-prefix>_WC_URL - url of the repository (at <dir>)
      <var-prefix>_WC_ROOT - root url of the repository
      <var-prefix>_WC_REVISION - current revision
      <var-prefix>_WC_LAST_CHANGED_AUTHOR - author of last commit
      <var-prefix>_WC_LAST_CHANGED_DATE - date of last commit
      <var-prefix>_WC_LAST_CHANGED_REV - revision of last commit
      <var-prefix>_WC_LAST_CHANGED_LOG - last log of base revision
      <var-prefix>_WC_INFO - output of command `svn info <dir>'

    示例用法

      FIND_PACKAGE(Subversion)
      IF(Subversion_FOUND)
        Subversion_WC_INFO(${PROJECT_SOURCE_DIR} Project)
        MESSAGE("Current revision is ${Project_WC_REVISION}")
        Subversion_WC_LOG(${PROJECT_SOURCE_DIR} Project)
        MESSAGE("Last changed log is ${Project_LAST_CHANGED_LOG}")
      ENDIF(Subversion_FOUND)
  • FindTCL: TK_INTERNAL_PATH 已删除。

    此模块查找是否安装了 Tcl 并确定包含文件和库的位置。它还确定库的名称。此代码设置以下变量

      TCL_FOUND              = Tcl was found
      TK_FOUND               = Tk was found
      TCLTK_FOUND            = Tcl and Tk were found
      TCL_LIBRARY            = path to Tcl library (tcl tcl80)
      TCL_INCLUDE_PATH       = path to where tcl.h can be found
      TCL_TCLSH              = path to tclsh binary (tcl tcl80)
      TK_LIBRARY             = path to Tk library (tk tk80 etc)
      TK_INCLUDE_PATH        = path to where tk.h can be found
      TK_WISH                = full path to the wish executable


    为了消除一些混乱并为并非 Tcl/Tk 专家/开发人员的人员解决一些问题，一些变量被移动或删除。与 CMake 2.4 的更改比较

       => they were only useful for people writing Tcl/Tk extensions.
       => these libs are not packaged by default with Tcl/Tk distributions. 
          Even when Tcl/Tk is built from source, several flavors of debug libs
          are created and there is no real reason to pick a single one
          specifically (say, amongst tcl84g, tcl84gs, or tcl84sgx). 
          Let's leave that choice to the user by allowing him to assign 
          TCL_LIBRARY to any Tcl library, debug or not.
       => this ended up being only a Win32 variable, and there is a lot of
          confusion regarding the location of this file in an installed Tcl/Tk
          tree anyway (see 8.5 for example). If you need the internal path at
          this point it is safer you ask directly where the *source* tree is
          and dig from there.
  • FindTIFF: 查找 TIFF 库

    查找本机 TIFF 包含文件和库 此模块定义

      TIFF_INCLUDE_DIR, where to find tiff.h, etc.
      TIFF_LIBRARIES, libraries to link against to use TIFF.
      TIFF_FOUND, If false, do not try to use TIFF.

    此外，还定义了以下内容，但不用于一般用途

      TIFF_LIBRARY, where to find the TIFF library.
  • FindTclStub: TCL_STUB_LIBRARY_DEBUG 和 TK_STUB_LIBRARY_DEBUG 已删除。

    此模块查找 Tcl 存根库。它首先通过调用 FindTCL.cmake 查找 Tcl 包含文件和库。如何使用 Tcl 存根库

       http://tcl.activestate.com/doc/howto/stubs.html

    使用存根库

       http://safari.oreilly.com/0130385603/ch48lev1sec3

    此代码设置以下变量

      TCL_STUB_LIBRARY       = path to Tcl stub library
      TK_STUB_LIBRARY        = path to Tk stub library
      TTK_STUB_LIBRARY       = path to ttk stub library


    为了消除一些混乱并为并非 Tcl/Tk 专家/开发人员的人员解决一些问题，一些变量被移动或删除。与 CMake 2.4 的更改比较

       => these libs are not packaged by default with Tcl/Tk distributions. 
          Even when Tcl/Tk is built from source, several flavors of debug libs
          are created and there is no real reason to pick a single one
          specifically (say, amongst tclstub84g, tclstub84gs, or tclstub84sgx). 
          Let's leave that choice to the user by allowing him to assign 
          TCL_STUB_LIBRARY to any Tcl library, debug or not.
  • FindTclsh: 查找 tclsh

    此模块查找是否安装了 TCL 并确定包含文件和库的位置。它还确定库的名称。此代码设置以下变量

      TCLSH_FOUND = TRUE if tclsh has been found
      TCL_TCLSH = the path to the tclsh executable

    在 cygwin 中，首先查找 cygwin 版本。不要在稍后查找它以避免在 Win32 构建中找到 cygwin 版本。

  • FindThreads: 此模块确定系统的线程库。

    将设置以下变量

      CMAKE_THREAD_LIBS_INIT     - the thread library
      CMAKE_USE_SPROC_INIT       - are we using sproc?
      CMAKE_USE_WIN32_THREADS_INIT - using WIN32 threads?
      CMAKE_USE_PTHREADS_INIT    - are we using pthreads
      CMAKE_HP_PTHREADS_INIT     - are we using hp pthreads
  • FindUnixCommands: 从 cygwin 查找 Unix 命令

    此模块查找一些常见的 Unix 命令。

  • FindVTK: 查找 VTK 安装或构建树。

    如果找到 VTK，则会设置以下变量。如果未找到 VTK，则 VTK_FOUND 将设置为 false。

      VTK_FOUND         - Set to true when VTK is found.
      VTK_USE_FILE      - CMake file to use VTK.
      VTK_MAJOR_VERSION - The VTK major version number.
      VTK_MINOR_VERSION - The VTK minor version number 
                           (odd non-release).
      VTK_BUILD_VERSION - The VTK patch level 
                           (meaningless for odd minor).
      VTK_INCLUDE_DIRS  - Include directories for VTK
      VTK_LIBRARY_DIRS  - Link directories for VTK libraries
      VTK_KITS          - List of VTK kits, in CAPS 
                          (COMMON,IO,) etc.
      VTK_LANGUAGES     - List of wrapped languages, in CAPS
                          (TCL, PYHTON,) etc.

    用户必须设置以下缓存条目才能找到 VTK

      VTK_DIR  - The directory containing VTKConfig.cmake.  
                 This is either the root of the build tree,
                 or the lib/vtk directory.  This is the 
                 only cache entry.

    为向后兼容性设置以下变量，不要在新代码中使用它们

      USE_VTK_FILE - The full path to the UseVTK.cmake file.
                     This is provided for backward 
                     compatibility.  Use VTK_USE_FILE 
                     instead.


  • FindWget: 查找 wget

    此模块查找 wget。此模块定义以下值

      WGET_EXECUTABLE: the full path to the wget tool.
      WGET_FOUND: True if wget has been found.
  • FindWish: 查找 wish 安装

    此模块查找是否安装了 TCL 并确定包含文件和库的位置。它还确定库的名称。此代码设置以下变量

      TK_WISH = the path to the wish executable


    如果定义了 UNIX，则它将首先查找 cygwin 版本

  • FindX11: 查找 X11 安装

    尝试在 UNIX 系统上查找 X11。定义以下值

      X11_FOUND        - True if X11 is available
      X11_INCLUDE_DIR  - include directories to use X11
      X11_LIBRARIES    - link against these to use X11


    以及以下更细粒度的变量：包含路径：X11_ICE_INCLUDE_PATH、X11_ICE_LIB、X11_ICE_FOUND

                    X11_Xaccessrules_INCLUDE_PATH,                     X11_Xaccess_FOUND
                    X11_Xaccessstr_INCLUDE_PATH,                       X11_Xaccess_FOUND
                    X11_Xau_INCLUDE_PATH,          X11_Xau_LIB,        X11_Xau_FOUND
                    X11_Xcomposite_INCLUDE_PATH,   X11_Xcomposite_LIB, X11_Xcomposite_FOUND
                    X11_Xcursor_INCLUDE_PATH,      X11_Xcursor_LIB,    X11_Xcursor_FOUND
                    X11_Xdamage_INCLUDE_PATH,      X11_Xdamage_LIB,    X11_Xdamage_FOUND
                    X11_Xdmcp_INCLUDE_PATH,        X11_Xdmcp_LIB,      X11_Xdmcp_FOUND
                                                   X11_Xext_LIB,       X11_Xext_FOUND
                    X11_dpms_INCLUDE_PATH,         (in X11_Xext_LIB),  X11_dpms_FOUND
                    X11_XShm_INCLUDE_PATH,         (in X11_Xext_LIB),  X11_XShm_FOUND
                    X11_Xshape_INCLUDE_PATH,       (in X11_Xext_LIB),  X11_Xshape_FOUND
                    X11_xf86misc_INCLUDE_PATH,     X11_Xxf86misc_LIB,  X11_xf86misc_FOUND
                    X11_xf86vmode_INCLUDE_PATH,                        X11_xf86vmode_FOUND
                    X11_Xfixes_INCLUDE_PATH,       X11_Xfixes_LIB,     X11_Xfixes_FOUND
                    X11_Xft_INCLUDE_PATH,          X11_Xft_LIB,        X11_Xft_FOUND
                    X11_Xinerama_INCLUDE_PATH,     X11_Xinerama_LIB,   X11_Xinerama_FOUND
                    X11_Xinput_INCLUDE_PATH,       X11_Xinput_LIB,     X11_Xinput_FOUND
                    X11_Xkb_INCLUDE_PATH,                              X11_Xkb_FOUND
                    X11_Xkblib_INCLUDE_PATH,                           X11_Xkb_FOUND
                    X11_Xpm_INCLUDE_PATH,          X11_Xpm_LIB,        X11_Xpm_FOUND
                    X11_XTest_INCLUDE_PATH,        X11_XTest_LIB,      X11_XTest_FOUND
                    X11_Xrandr_INCLUDE_PATH,       X11_Xrandr_LIB,     X11_Xrandr_FOUND
                    X11_Xrender_INCLUDE_PATH,      X11_Xrender_LIB,    X11_Xrender_FOUND
                    X11_Xscreensaver_INCLUDE_PATH, X11_Xscreensaver_LIB, X11_Xscreensaver_FOUND
                    X11_Xt_INCLUDE_PATH,           X11_Xt_LIB,         X11_Xt_FOUND
                    X11_Xutil_INCLUDE_PATH,                            X11_Xutil_FOUND
                    X11_Xv_INCLUDE_PATH,           X11_Xv_LIB,         X11_Xv_FOUND
  • FindXMLRPC: 查找 xmlrpc

    查找本机 XMLRPC 标头和库。

      XMLRPC_INCLUDE_DIRS      - where to find xmlrpc.h, etc.
      XMLRPC_LIBRARIES         - List of libraries when using xmlrpc.
      XMLRPC_FOUND             - True if xmlrpc found.

    XMLRPC 模块可以指定为此查找模块的组件。模块可以通过运行“xmlrpc-c-config”列出。模块包括

      c++            C++ wrapper code
      libwww-client  libwww-based client
      cgi-server     CGI-based server
      abyss-server   ABYSS-based server

    典型用法

      FIND_PACKAGE(XMLRPC REQUIRED libwww-client)
  • FindZLIB: 查找 zlib

    查找本机 ZLIB 包含文件和库

      ZLIB_INCLUDE_DIR - where to find zlib.h, etc.
      ZLIB_LIBRARIES   - List of libraries when using zlib.
      ZLIB_FOUND       - True if zlib found.
  • Findosg:


    注意：强烈建议您使用 CMake 2.6.3 中引入的新 FindOpenSceneGraph.cmake，而不是直接使用此 Find 模块。

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osg 此模块定义

    OSG_FOUND - 是否找到 Osg？ OSG_INCLUDE_DIR - 查找标头的位置 OSG_LIBRARIES - 与 OSG 链接的库（使用此）

    OSG_LIBRARY - OSG 库 OSG_LIBRARY_DEBUG - OSG 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgAnimation:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgAnimation 此模块定义

    OSGANIMATION_FOUND - 是否找到 osgAnimation？ OSGANIMATION_INCLUDE_DIR - 查找标头的位置 OSGANIMATION_LIBRARIES - 与 OSG 链接的库（使用此）

    OSGANIMATION_LIBRARY - OSG 库 OSGANIMATION_LIBRARY_DEBUG - OSG 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgDB:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgDB 此模块定义

    OSGDB_FOUND - 是否找到 osgDB？ OSGDB_INCLUDE_DIR - 查找标头的位置 OSGDB_LIBRARIES - 与 osgDB 链接的库（使用此）

    OSGDB_LIBRARY - osgDB 库 OSGDB_LIBRARY_DEBUG - osgDB 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgFX:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgFX 此模块定义

    OSGFX_FOUND - 是否找到 osgFX？ OSGFX_INCLUDE_DIR - 查找标头的位置 OSGFX_LIBRARIES - 与 osgFX 链接的库（使用此）

    OSGFX_LIBRARY - osgFX 库 OSGFX_LIBRARY_DEBUG - osgFX 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgGA:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgGA 此模块定义

    OSGGA_FOUND - 是否找到 osgGA？ OSGGA_INCLUDE_DIR - 查找标头的位置 OSGGA_LIBRARIES - 与 osgGA 链接的库（使用此）

    OSGGA_LIBRARY - osgGA 库 OSGGA_LIBRARY_DEBUG - osgGA 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgIntrospection:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgINTROSPECTION 此模块定义

    OSGINTROSPECTION_FOUND - 是否找到 osgIntrospection？ OSGINTROSPECTION_INCLUDE_DIR - 查找标头的位置 OSGINTROSPECTION_LIBRARIES - 与 osgIntrospection 链接的库（使用此）

    OSGINTROSPECTION_LIBRARY - osgIntrospection 库 OSGINTROSPECTION_LIBRARY_DEBUG - osgIntrospection 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgManipulator:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgManipulator 此模块定义

    OSGMANIPULATOR_FOUND - 是否找到 osgManipulator？ OSGMANIPULATOR_INCLUDE_DIR - 查找标头的位置 OSGMANIPULATOR_LIBRARIES - 与 osgManipulator 链接的库（使用此）

    OSGMANIPULATOR_LIBRARY - osgManipulator 库 OSGMANIPULATOR_LIBRARY_DEBUG - osgManipulator 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgParticle:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgParticle 此模块定义

    OSGPARTICLE_FOUND - 是否找到 osgParticle？ OSGPARTICLE_INCLUDE_DIR - 查找标头的位置 OSGPARTICLE_LIBRARIES - 与 osgParticle 链接的库（使用此）

    OSGPARTICLE_LIBRARY - osgParticle 库 OSGPARTICLE_LIBRARY_DEBUG - osgParticle 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgProducer:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgProducer 此模块定义

    OSGPRODUCER_FOUND - 是否找到 osgProducer？ OSGPRODUCER_INCLUDE_DIR - 查找标头的位置 OSGPRODUCER_LIBRARIES - 与 osgProducer 链接的库（使用此）

    OSGPRODUCER_LIBRARY - osgProducer 库 OSGPRODUCER_LIBRARY_DEBUG - osgProducer 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgShadow:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgShadow 此模块定义

    OSGSHADOW_FOUND - 是否找到 osgShadow？ OSGSHADOW_INCLUDE_DIR - 查找标头的位置 OSGSHADOW_LIBRARIES - 与 osgShadow 链接的库（使用此）

    OSGSHADOW_LIBRARY - osgShadow 库 OSGSHADOW_LIBRARY_DEBUG - osgShadow 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgSim:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgSim 此模块定义

    OSGSIM_FOUND - 是否找到 osgSim？ OSGSIM_INCLUDE_DIR - 查找标头的位置 OSGSIM_LIBRARIES - 与 osgSim 链接的库（使用此）

    OSGSIM_LIBRARY - osgSim 库 OSGSIM_LIBRARY_DEBUG - osgSim 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgTerrain:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgTerrain 此模块定义

    OSGTERRAIN_FOUND - 是否找到 osgTerrain？ OSGTERRAIN_INCLUDE_DIR - 查找标头的位置 OSGTERRAIN_LIBRARIES - 与 osgTerrain 链接的库（使用此）

    OSGTERRAIN_LIBRARY - osgTerrain 库 OSGTERRAIN_LIBRARY_DEBUG - osgTerrain 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgText:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgText 此模块定义

    OSGTEXT_FOUND - 是否找到 osgText？ OSGTEXT_INCLUDE_DIR - 查找标头的位置 OSGTEXT_LIBRARIES - 与 osgText 链接的库（使用此）

    OSGTEXT_LIBRARY - osgText 库 OSGTEXT_LIBRARY_DEBUG - osgText 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgUtil:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgUtil 此模块定义

    OSGUTIL_FOUND - 是否找到 osgUtil？ OSGUTIL_INCLUDE_DIR - 查找标头的位置 OSGUTIL_LIBRARIES - 与 osgUtil 链接的库（使用此）

    OSGUTIL_LIBRARY - osgUtil 库 OSGUTIL_LIBRARY_DEBUG - osgUtil 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgViewer:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgViewer 此模块定义

    OSGVIEWER_FOUND - 是否找到 osgViewer？ OSGVIEWER_INCLUDE_DIR - 查找标头的位置 OSGVIEWER_LIBRARIES - 与 osgViewer 链接的库（使用此）

    OSGVIEWER_LIBRARY - osgViewer 库 OSGVIEWER_LIBRARY_DEBUG - osgViewer 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgVolume:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgVolume 此模块定义

    OSGVOLUME_FOUND - 是否找到 osgVolume？ OSGVOLUME_INCLUDE_DIR - 查找标头的位置 OSGVOLUME_LIBRARIES - 与 osgVolume 链接的库（使用此）

    OSGVOLUME_LIBRARY - osgVolume 库 OSGVOLUME_LIBRARY_DEBUG - osgVolume 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 创建。

  • FindosgWidget:

    这是用于查找 OpenSceneGraph 组件的 Findosg* 套件的一部分。每个组件都是独立的，您必须选择加入每个模块。您还必须选择加入 OpenGL 和 OpenThreads（如果需要，还需要选择加入 Producer），因为这些模块不会为您这样做。这是为了让您可以按部就班地控制自己的系统，以防您需要选择退出某些组件或更改特定模块的查找行为（例如，因为默认的 FindOpenGL.cmake 模块无法与您的系统一起使用）。如果您想使用包含所有内容的更方便的模块，请使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模块。

    定位 osgWidget 此模块定义

    OSGWIDGET_FOUND - 是否找到 osgWidget？ OSGWIDGET_INCLUDE_DIR - 查找标头的位置 OSGWIDGET_LIBRARIES - 与 osgWidget 链接的库（使用此）

    OSGWIDGET_LIBRARY - osgWidget 库 OSGWIDGET_LIBRARY_DEBUG - osgWidget 调试库

    $OSGDIR 是一个环境变量，对应于构建 osg 时使用的 ./configure --prefix=$OSGDIR。

    FindosgWidget.cmake 从 Eric Wing 创建的 Findosg* 套件中调整而来。

  • Findosg_functions:


    此 CMake 文件包含两个宏，可帮助搜索 OSG 库和节点集。

  • FindwxWidgets: 查找 wxWidgets（也称为 wxWindows）安装。

    此模块查找是否安装了 wxWidgets 并选择要使用的默认配置。wxWidgets 是一个模块化库。要指定要使用的模块，您需要将它们命名为包的组件

    FIND_PACKAGE(wxWidgets COMPONENTS base core ...)

    有两个搜索分支：windows 样式和 unix 样式。对于 windows，将搜索以下变量并在存在多个选择的情况下设置为默认值。如果不需要默认值，请更改它们（即，这些是您应该更改以选择配置的唯一变量）

      wxWidgets_ROOT_DIR      - Base wxWidgets directory
                                (e.g., C:/wxWidgets-2.6.3).
      wxWidgets_LIB_DIR       - Path to wxWidgets libraries
                                (e.g., C:/wxWidgets-2.6.3/lib/vc_lib).
      wxWidgets_CONFIGURATION - Configuration to use
                                (e.g., msw, mswd, mswu, mswunivud, etc.)


    对于 unix 样式，它使用 wx-config 实用程序。您可以在 QtDialog 或 ccmake 界面中通过打开/关闭以下变量来选择调试/发布、unicode/ansi、通用/非通用和静态/共享

      wxWidgets_USE_DEBUG
      wxWidgets_USE_UNICODE
      wxWidgets_USE_UNIVERSAL
      wxWidgets_USE_STATIC

    以下是在为 windows 和 unix 样式完成配置后设置的

      wxWidgets_FOUND            - Set to TRUE if wxWidgets was found.
      wxWidgets_INCLUDE_DIRS     - Include directories for WIN32
                                   i.e., where to find "wx/wx.h" and
                                   "wx/setup.h"; possibly empty for unices.
      wxWidgets_LIBRARIES        - Path to the wxWidgets libraries.
      wxWidgets_LIBRARY_DIRS     - compile time link dirs, useful for
                                   rpath on UNIX. Typically an empty string
                                   in WIN32 environment.
      wxWidgets_DEFINITIONS      - Contains defines required to compile/link
                                   against WX, e.g. -DWXUSINGDLL
      wxWidgets_CXX_FLAGS        - Include dirs and ompiler flags for
                                   unices, empty on WIN32. Esentially
                                   "`wx-config --cxxflags`".
      wxWidgets_USE_FILE         - Convenience include file.


    示例用法

       FIND_PACKAGE(wxWidgets COMPONENTS base core gl net)
       IF(wxWidgets_FOUND)
         INCLUDE(${wxWidgets_USE_FILE})
         # and for each of your dependant executable/library targets:
         TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES})
       ENDIF(wxWidgets_FOUND)


    如果需要 wxWidgets（即，不是可选部分）

       FIND_PACKAGE(wxWidgets REQUIRED base core gl net)
       INCLUDE(${wxWidgets_USE_FILE})
       # and for each of your dependant executable/library targets:
       TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES})
  • FindwxWindows: 查找 wxWindows（wxWidgets）安装

    此模块查找是否安装了 wxWindows/wxWidgets 并确定包含文件和库的位置。它还确定库的名称。请注意，此文件已弃用，并由 FindwxWidgets.cmake 替换。此代码设置以下变量

      WXWINDOWS_FOUND     = system has WxWindows
      WXWINDOWS_LIBRARIES = path to the wxWindows libraries
                            on Unix/Linux with additional
                            linker flags from
                            "wx-config --libs"
      CMAKE_WXWINDOWS_CXX_FLAGS  = Compiler flags for wxWindows,
                                   essentially "`wx-config --cxxflags`"
                                   on Linux
      WXWINDOWS_INCLUDE_DIR      = where to find "wx/wx.h" and "wx/setup.h"
      WXWINDOWS_LINK_DIRECTORIES = link directories, useful for rpath on
                                    Unix
      WXWINDOWS_DEFINITIONS      = extra defines


    选项 如果您需要 OpenGL 支持，请

      SET(WXWINDOWS_USE_GL 1)

    在您的 CMakeLists.txt 中 *在* 您包含此文件之前。

      HAVE_ISYSTEM      - true required to replace -I by -isystem on g++


    为了方便起见，请在您项目的 CMakeLists.txt 中使用 INCLUDE(Use_wxWindows) 包含 Use_wxWindows.cmake。

    用法

      SET(WXWINDOWS_USE_GL 1)
      FIND_PACKAGE(wxWindows)


    注释 wxWidgets 2.6.x 支持单片构建，例如在 wx/build/msw 目录中编译为

      nmake -f makefile.vc BUILD=debug SHARED=0 USE_OPENGL=1 MONOLITHIC=1


    已弃用

      CMAKE_WX_CAN_COMPILE
      WXWINDOWS_LIBRARY
      CMAKE_WX_CXX_FLAGS
      WXWINDOWS_INCLUDE_PATH


    作者 Jan Woetzel <http://www.mip.informatik.uni-kiel.de/~jw> (2003 年 7 月 - 2006 年 1 月)

  • FortranCInterface:

    FortranCInterface.cmake

    此文件定义了函数 create_fortran_c_interface。此函数用于创建一个已配置的标头文件，该文件包含从 C 到 Fortran 函数的映射，使用当前 Fortran 编译器定义的正确名称改编方案。

    该函数获取函数列表和要配置的标头文件的名称。

    此文件还定义了一些辅助函数，这些函数用于检测当前 Fortran 编译器使用的 Fortran 名称改编方案。

      test_fortran_mangling - test a single fortran mangling 
      discover_fortran_mangling - loop over all combos of fortran
       name mangling and call test_fortran_mangling until one of them
       works.
      discover_fortran_module_mangling - try different types of 
      fortran modle name mangling to find one that works




    此函数测试单个 Fortran 改编。代码 - 要尝试的测试代码应定义一个名为“sub”的子例程 前缀 - 要放在 sub 前面的字符串 后缀 - 要放在 sub 后的字符串 ISUPPER - 如果为 TRUE，则 sub 将被调用为 SUB DOC - 用于状态检查的字符串 Fortran ${DOC} 链接 SUB - 要调用的 SUB 的名称 结果 用于存储结果的存储位置 如果此链接有效，则为 TRUE，否则为 FALSE

            if not.


  • GetPrerequisites:

    GetPrerequisites.cmake

    此脚本提供函数来列出可执行文件或共享库文件所依赖的 .dll、.dylib 或 .so 文件。（它的先决条件。）

    它使用各种工具来获取所需的共享库文件列表

       dumpbin (Windows)
       ldd (Linux/Unix)
       otool (Mac OSX)


    此脚本提供以下函数

       gp_append_unique
       gp_file_type
       is_file_executable
       gp_item_default_embedded_path
         (projects can override with gp_item_default_embedded_path_override)
       gp_resolve_item
         (projects can override with gp_resolve_item_override)
       get_prerequisites
       list_prerequisites
       list_prerequisites_by_glob


    需要 CMake 2.6 或更高版本，因为它使用函数、break、return 和 PARENT_SCOPE。

  • ITKCompatibility:

    解决 ITK 早于 3.0 版本的旧错误

  • InstallRequiredSystemLibraries:

    通过包含此文件，CMAKE_INSTALL_DEBUG_LIBRARIES 中的所有文件都将使用 INSTALL_PROGRAMS 安装到 WIN32 的 /bin 和非 win32 的 /lib 中。如果在包含此文件之前将 CMAKE_SKIP_INSTALL_RULES 设置为 TRUE，则不会调用 INSTALL 命令。用户可以使用变量 CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS 使用自定义安装命令并将它们安装到他们想要的任何目录中。如果它是 MSVC 编译器，则会自动找到 Microsoft 运行时库并自动将其添加到 CMAKE_INSTALL_DEBUG_LIBRARIES 中，并安装。如果设置了 CMAKE_INSTALL_DEBUG_LIBRARIES 并且它是 MSVC 编译器，则在可用时会安装调试库。如果设置了 CMAKE_INSTALL_MFC_LIBRARIES，则会安装 MFC 运行时库以及 CRT 运行时库。

  • MacroAddFileDependencies: MACRO_ADD_FILE_DEPENDENCIES(<_file> depend_files...)

    MACRO_OPTIONAL_FIND_PACKAGE( <name> [QUIT] )

  • SquishTestScript:


    此脚本使用 Squish 启动 GUI 测试。您不应该直接调用脚本；相反，您应该通过 FindSquish.cmake 中定义的 SQUISH_ADD_TEST 宏来访问它。

    此脚本启动 Squish 服务器，在客户端启动测试，最后停止 Squish 服务器。如果这些步骤中的任何一个失败（包括测试未通过），则会引发致命错误。

  • TestBigEndian: 定义宏以确定字节序类型

    检查系统是大端还是小端

      TEST_BIG_ENDIAN(VARIABLE)
      VARIABLE - variable to store the result to


  • TestCXXAcceptsFlag: 测试 CXX 编译器的标志

    检查 CXX 编译器是否接受标志

      Macro CHECK_CXX_ACCEPTS_FLAG(FLAGS VARIABLE) -
         checks if the function exists
      FLAGS - the flags to try
      VARIABLE - variable to store the result


  • TestForANSIForScope: 检查 ANSI 范围支持

    检查编译器是否支持 stl 类上的 std::。

      CMAKE_NO_ANSI_FOR_SCOPE - holds result


  • TestForANSIStreamHeaders: 测试编译器对 ANSI 流标头 iostream 等的支持

    检查它们是否具有标准 ansi 流文件（没有 .h）

      CMAKE_NO_ANSI_STREAM_HEADERS - defined by the results


  • TestForSSTREAM:

    # - 测试 std:: 命名空间支持 检查编译器是否支持 stl 类上的 std::

      CMAKE_NO_ANSI_STRING_STREAM - defined by the results


  • TestForSTDNamespace: 测试 std:: 命名空间支持

    检查编译器是否支持 stl 类上的 std::

      CMAKE_NO_STD_NAMESPACE - defined by the results


  • UseEcos: 此模块定义构建 eCos 应用程序所需的变量和宏。

    此文件包含以下宏：ECOS_ADD_INCLUDE_DIRECTORIES() - 添加 eCos 包含目录 ECOS_ADD_EXECUTABLE(name source1 ... sourceN ) - 创建 eCos 可执行文件 ECOS_ADJUST_DIRECTORY(VAR source1 ... sourceN ) - 调整源文件的路径并将结果放入 VAR 中

    用于选择工具链的宏：ECOS_USE_ARM_ELF_TOOLS() - 为调用它的目录启用 ARM ELF 工具链 ECOS_USE_I386_ELF_TOOLS() - 为调用它的目录启用 i386 ELF 工具链 ECOS_USE_PPC_EABI_TOOLS() - 为调用它的目录启用 PowerPC 工具链

    它包含以下变量：ECOS_DEFINITIONS ECOSCONFIG_EXECUTABLE ECOS_CONFIG_FILE - 默认为 ecos.ecc，如果您的 eCos 配置文件具有不同的名称，请调整此变量仅供内部使用

      ECOS_ADD_TARGET_LIB
  • UsePkgConfig: CMake 的已弃用 pkg-config 模块


    定义以下宏

    PKGCONFIG(package includedir libdir linkflags cflags)

    调用 PKGCONFIG 将将所需的信息填充到给定的 4 个参数中，例如 PKGCONFIG(libart-2.0 LIBART_INCLUDE_DIR LIBART_LINK_DIR LIBART_LINK_FLAGS LIBART_CFLAGS) 如果未找到 pkg-config 或指定的软件包不存在，则该变量在函数返回时将为空，否则它们将包含相应的信息

  • UseQt4: Qt4 的使用模块

    设置 C 和 C++ 以使用 Qt 4。假设 FindQt.cmake 已经加载。有关如何将 Qt 4 加载到您的 CMake 项目中的信息，请参见 FindQt.cmake。

  • UseSWIG: CMake 的 SWIG 模块

    定义以下宏

       SWIG_ADD_MODULE(name language [ files ])
         - Define swig module with given name and specified language
       SWIG_LINK_LIBRARIES(name [ libraries ])
         - Link libraries to swig module

    所有其他宏仅供内部使用。要获取 swig 模块的实际名称，请使用：${SWIG_MODULE_name_REAL_NAME}。设置源文件属性（如 CPLUSPLUS 和 SWIG_FLAGS）以指定 SWIG 的特殊行为。此外，全局 CMAKE_SWIG_FLAGS 可用于向所有 swig 调用添加特殊标志。另一个特殊变量是 CMAKE_SWIG_OUTDIR，它允许您指定要写入所有 swig 生成的模块的位置（swig -outdir 选项）名称特定的变量 SWIG_MODULE_<name>_EXTRA_DEPS 可用于指定生成的模块的额外依赖项。

  • Use_wxWindows: ---------------------------------------------------


    此便利包含会查找 wxWindows 是否已安装并设置相应的库、包含目录、标志等。作者 Jan Woetzel <jw -at- mip.informatik.uni-kiel.de> (2003 年 7 月)

    用法

       just include Use_wxWindows.cmake
       in your projects CMakeLists.txt

    INCLUDE( ${CMAKE_MODULE_PATH}/Use_wxWindows.cmake)

       if you are sure you need GL then

    SET(WXWINDOWS_USE_GL 1)

       *before* you include this file.


    2004 年 2 月 16 日：将 INCLUDE 更改为 FIND_PACKAGE 以从用户的自定义非系统 CMAKE_MODULE_PATH 读取（Jan Woetzel JW）2006 年 7 月：重写为 FindwxWidgets.cmake，为向后兼容性保留 JW

  • UsewxWidgets: 使用 wxWidgets 库的便利包含

    查找 wxWidgets 是否已安装并设置相应的库、包含目录、标志等。会调用 INCLUDE_DIRECTORIES、LINK_DIRECTORIES 和 ADD_DEFINITIONS。

    用法

      SET( wxWidgets_USE_LIBS  gl xml xrc ) # optionally: more than wx std libs
      FIND_PACKAGE(wxWidgets REQUIRED)
      INCLUDE( ${xWidgets_USE_FILE} )
      ... add your targets here, e.g. ADD_EXECUTABLE/ ADD_LIBRARY ...
      TARGET_LINK_LIBRARIERS( <yourWxDependantTarget>  ${wxWidgets_LIBRARIES})


    已弃用

      LINK_LIBRARIES is not called in favor of adding dependencies per target.


    作者

      Jan Woetzel <jw -at- mip.informatik.uni-kiel.de>

策略

  • CMP0000: 必须指定最小所需的 CMake 版本。

    CMake 要求项目指定他们编写到的 CMake 版本。制定此策略是为了让尝试构建项目的用户在需要更新 CMake 时得到通知。指定版本还有助于项目使用比指定版本更新的 CMake 版本进行构建。在主 CMakeLists.txt 文件的顶部使用 cmake_minimum_required 命令

      cmake_minimum_required(VERSION <major>.<minor>)

    其中“<major>.<minor>”是要支持的 CMake 版本（例如“2.6”）。该命令将确保至少运行了给定的 CMake 版本，并帮助更新的版本与项目兼容。有关详细信息，请参见 cmake_minimum_required 的文档。

    请注意，该命令调用必须出现在 CMakeLists.txt 文件本身中；包含文件中调用的方法不充分。但是，可以调用 cmake_policy 命令将策略 CMP0000 显式设置为 OLD 或 NEW 行为。OLD 行为是静默忽略缺少的调用。NEW 行为是发出错误而不是警告。包含文件可以显式设置 CMP0000 以影响如何为主 CMakeLists.txt 文件强制执行此策略。

    此策略是在 CMake 2.6.0 版本中引入的。

  • CMP0001: 不应再使用 CMAKE_BACKWARDS_COMPATIBILITY。

    OLD 行为是检查 CMAKE_BACKWARDS_COMPATIBILITY 并将其呈现给用户。NEW 行为是完全忽略 CMAKE_BACKWARDS_COMPATIBILITY。

    在 CMake 2.4 及更低版本中，变量 CMAKE_BACKWARDS_COMPATIBILITY 用于请求与早期版本的 CMake 的兼容性。在 CMake 2.6 及更高版本中，所有兼容性问题都由策略和 cmake_policy 命令处理。但是，CMake 仍然必须检查 CMAKE_BACKWARDS_COMPATIBILITY，以了解为 CMake 2.4 及更低版本编写的项目。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0002: 逻辑目标名称必须在全局范围内唯一。

    使用 add_executable、add_library 或 add_custom_target 创建的目标名称是逻辑构建目标名称。逻辑目标名称必须在全局范围内唯一，因为

      - Unique names may be referenced unambiguously both in CMake
        code and on make tool command lines.
      - Logical names are used by Xcode and VS IDE generators
        to produce meaningful project names for the targets.

    可执行文件和库目标的逻辑名称不必对应于构建的物理文件名。请考虑使用 OUTPUT_NAME 目标属性创建具有相同物理名称但逻辑名称不同的两个目标。自定义目标只需要具有全局唯一的名称（除非使用 Makefiles 生成器使用全局属性 ALLOW_DUPLICATE_CUSTOM_TARGETS）。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0003: 通过完整路径链接的库不再生成链接器搜索路径。

    此策略影响在链接时如何找到其完整路径未知的库，但由于 CMake 处理完整路径已知的库的方式发生变化而创建。考虑以下代码

      target_link_libraries(myexe /path/to/libA.so)

    CMake 2.4 及更低版本通过将它们在链接行上拆分为单独的组件（包括链接器搜索路径和库名称）来实现链接到完整路径已知的库。示例代码可能会生成类似以下内容

      ... -L/path/to -lA ...

    以链接到库 A。执行了分析以对多个链接目录进行排序，以便链接器能够在所需位置找到库 A，但有些情况下这不起作用。CMake 2.6 及更高版本在大多数情况下使用更可靠的方法，直接将库的完整路径传递给链接器。示例代码现在会生成类似以下内容

      ... /path/to/libA.so ....

    不幸的是，这种更改可能会破坏像这样的代码

      target_link_libraries(myexe /path/to/libA.so B)

    其中“B”意图找到“/path/to/libB.so”。此代码是错误的，因为用户要求链接器找到库 B，但没有提供链接器搜索路径（可以使用 link_directories 命令添加）。但是，使用旧的链接实现，该代码会意外地起作用，因为为库 A 添加的链接器搜索路径允许找到库 B。

    为了支持依赖于通过链接到完整路径已知的库而添加的链接器搜索路径的项目，此策略的 OLD 行为将添加链接器搜索路径，即使它们不需要它们自己的库。当此策略设置为 OLD 时，CMake 将生成一个链接行，例如

      ... -L/path/to /path/to/libA.so -lB ...

    这将允许找到库 B，因为它以前所做的那样。当此策略设置为 NEW 时，CMake 将生成一个链接行，例如

      ... /path/to/libA.so -lB ...

    它更准确地反映了项目指定的內容。

    生成链接行时使用的此策略设置是目标由 add_executable 或 add_library 命令创建时的实际设置。对于上面描述的示例，代码

      cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4)
      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so B)

    将起作用并抑制对该策略的警告。它还可以更新为使用更正的链接方法

      cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6)
      link_directories(/path/to) # needed to find library B
      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so B)

    更棒的是，库 B 可以用完整路径指定

      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so /path/to/libB.so)

    当链接行上的所有项目都具有已知路径时，CMake 不会检查此策略，因此它没有任何影响。

    请注意，此策略的警告最多会针对一个目标发出。 这样可以避免在设置策略时，由于策略一次可能会修复所有目标，而向用户发送针对每个目标的消息而导致消息泛滥。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0004: 链接的库可能没有前导或尾随空格。

    CMake 2.4 及更低版本会从使用类似以下代码链接的库中静默移除前导和尾随空格

      target_link_libraries(myexe " A ")

    这可能会导致用户项目中出现细微错误。

    此策略的旧行为是静默移除前导和尾随空格。 此策略的新行为是将此类空格的存在诊断为错误。 在检查库名称时使用的此策略设置是在通过 add_executable 或 add_library 命令创建目标时生效的设置。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0005: 预处理器定义值现在会自动转义。

    此策略确定 CMake 是否应生成通过 add_definitions 添加的转义预处理器定义值。 CMake 2.4 及更低版本假定在 add_definitions 调用中只会为宏提供简单值。 它没有尝试在生成的构建规则中转义诸如字符串文字之类的非简单值。 CMake 2.6 及更高版本支持转义大多数值，但不能假设用户尚未添加转义以解决早期版本中的限制。

    此策略的旧行为是将直接提供给 add_definitions 的定义值放置在生成的构建规则中，而无需尝试转义任何内容。 此策略的新行为是自动为所有本机构建工具生成正确的转义。 有关转义实现的限制，请参阅 COMPILE_DEFINITIONS 目标属性的文档。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0006: 安装 MACOSX_BUNDLE 目标需要 BUNDLE DESTINATION。

    此策略确定当要求安装具有 MACOSX_BUNDLE 属性设置的目标时，install(TARGETS) 命令是否必须提供 BUNDLE DESTINATION。 CMake 2.4 及更低版本在安装目标时没有区分应用程序包和普通可执行文件。 CMake 2.6 为 install(TARGETS) 命令提供了一个 BUNDLE 选项，该选项指定了适用于 Mac 上应用程序包的特定规则。 项目在安装具有 MACOSX_BUNDLE 属性设置的目标时应使用此选项。

    此策略的旧行为是，如果没有提供 BUNDLE DESTINATION，则回退到 RUNTIME DESTINATION。 此策略的新行为是在没有 BUNDLE DESTINATION 的情况下安装包目标时产生错误。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0007: list 命令不再忽略空元素。

    此策略确定 list 命令是否会忽略列表中的空元素。 CMake 2.4 及更低版本的 list 命令会忽略列表中的所有空元素。 例如，a;b;;c 的长度为 3，而不是 4。 此策略的旧行为是忽略空列表元素。 此策略的新行为是正确地计算列表中的空元素。

    此策略是在 CMake 2.6.0 版本中引入的。CMake 2.6 版本在策略未设置且使用 OLD 行为时会发出警告。使用 cmake_policy 命令将其显式设置为 OLD 或 NEW。

  • CMP0008: 通过完整路径链接的库必须具有有效的库文件名。

    在 CMake 2.4 及更低版本中，可以编写类似以下的代码

      target_link_libraries(myexe /full/path/to/somelib)

    其中“somelib”应该是一个有效的库文件名，例如“libsomelib.a”或“somelib.lib”。 对于 Makefile 生成器，这会在构建时产生错误，因为找不到对完整路径的依赖项。 对于 VS IDE 和 Xcode 生成器，这以前是通过意外方式起作用的，因为 CMake 始终会拆分库目录，并要求链接器按名称搜索库（-lsomelib 或 somelib.lib）。 尽管 Makefiles 会失败，但一些项目具有类似的代码，并且只使用 VS 和/或 Xcode 进行构建。 此版本的 CMake 优先直接将完整路径传递给本机构建工具，在这种情况下它会失败，因为它没有命名有效的库文件。

    此策略确定如何处理似乎没有命名有效库文件的完整路径。 此策略的旧行为是拆分库名称和路径，并要求链接器搜索库。 此策略的新行为是信任给定的路径，并将其直接传递给本机构建工具，而不进行更改。

    此策略是在 CMake 版本 2.6.1 中引入的。 CMake 版本 2.6 在未设置策略时发出警告，并使用旧行为。 使用 cmake_policy 命令将其明确设置为 OLD 或 NEW。

  • CMP0009: FILE GLOB_RECURSE 调用默认情况下不应跟随符号链接。

    在 CMake 2.6.1 及更低版本中，FILE GLOB_RECURSE 调用会跟随符号链接，有时会生成意外的大结果集，因为符号链接指向包含数十万个文件的顶层目录。

    此策略确定在 FILE GLOB_RECURSE 调用期间遇到符号链接时是否跟随符号链接。 此策略的旧行为是跟随符号链接。 此策略的新行为是默认情况下不跟随符号链接，而仅在将 FOLLOW_SYMLINKS 作为 FILE 命令的附加参数提供时才跟随。

    此策略是在 CMake 版本 2.6.2 中引入的。 CMake 版本 2.6 在未设置策略时发出警告，并使用旧行为。 使用 cmake_policy 命令将其明确设置为 OLD 或 NEW。

  • CMP0010: 错误的变量引用语法是一个错误。

    在 CMake 2.6.2 及更低版本中，不正确的变量引用语法（例如缺少右大括号 (“${FOO”) 会被报告，但不会停止处理 CMake 代码。 此策略确定错误的变量引用是否是一个错误。 此策略的旧行为是警告错误，保留字符串不变，并继续执行。 此策略的新行为是报告错误。

    此策略是在 CMake 版本 2.6.3 中引入的。 CMake 版本 2.6 在未设置策略时发出警告，并使用旧行为。 使用 cmake_policy 命令将其明确设置为 OLD 或 NEW。

  • CMP0011: 包含的脚本会自动执行 cmake_policy PUSH 和 POP。

    在 CMake 2.6.2 及更低版本中，由 include() 和 find_package() 命令加载的脚本中的 CMake 策略设置会影响包含者。 需要显式调用 cmake_policy(PUSH) 和 cmake_policy(POP) 来隔离策略更改并保护包含者。 虽然某些脚本打算影响其包含者的策略，但大多数脚本不打算这样做。 在 CMake 2.6.3 及更高版本中，include() 和 find_package() 默认情况下会在包含脚本周围的策略堆栈上 PUSH 和 POP 一个条目，但提供 NO_POLICY_SCOPE 选项来禁用它。 此策略确定是否为兼容性暗示 NO_POLICY_SCOPE。 此策略的旧行为是为 include() 和 find_package() 命令暗示 NO_POLICY_SCOPE。 此策略的新行为是允许命令执行其默认的 cmake_policy PUSH 和 POP。

    此策略是在 CMake 版本 2.6.3 中引入的。 CMake 版本 2.6 在未设置策略时发出警告，并使用旧行为。 使用 cmake_policy 命令将其明确设置为 OLD 或 NEW。

变量

更改行为的变量

  • BUILD_SHARED_LIBS: 全局标志，用于在开启时导致 add_library 创建共享库。

    如果存在且为真，这将导致所有库都构建为共享库，除非该库被显式添加为静态库。 此变量通常作为选项添加到项目中，以便项目的每个用户都可以决定是否要使用共享库或静态库构建项目。

  • CMAKE_BACKWARDS_COMPATIBILITY: 构建项目所需的 CMake 版本。

    从向后兼容性的角度来看，这指定了应支持的 CMake 版本。 默认情况下，此值为运行的 CMake 版本号。 可以将其设置为较旧版本的 CMake，以支持项目中 CMake 的已弃用命令，这些项目是针对较旧版本的 CMake 编写的。 这可以由用户设置，也可以在 CMakeLists 文件的开头设置。

  • CMAKE_BUILD_TYPE: 指定基于 make 的生成器的构建类型。

    这指定了将在此树中构建的构建类型。 可能的值为空、Debug、Release、RelWithDebInfo 和 MinSizeRel。 此变量仅支持基于 make 的生成器。 如果支持此变量，则 CMake 还将为名称为 CMAKE_C_FLAGS_[Debug|Release|RelWithDebInfo|MinSizeRel] 的变量提供初始值。 例如，如果 CMAKE_BUILD_TYPE 为 Debug，则 CMAKE_C_FLAGS_DEBUG 将被添加到 CMAKE_C_FLAGS 中。

  • CMAKE_COLOR_MAKEFILE: 使用 Makefile 生成器时启用彩色输出。

    启用后，生成的 Makefile 将产生彩色输出。 默认值为 ON。

  • CMAKE_CONFIGURATION_TYPES: 指定可用的构建类型。

    这指定了哪些构建类型可用，例如 Debug、Release、RelWithDebInfo 等。 这在大多数平台上都有合理的默认值。 但可以扩展以提供其他构建类型。 另请参阅 CMAKE_BUILD_TYPE。

  • CMAKE_FIND_LIBRARY_PREFIXES: 在查找库时要添加的前缀。

    这指定了在 find_library 命令查找库时要添加到库名称的前缀。 在 UNIX 系统上，这通常是 lib，这意味着在尝试查找 foo 库时，它将查找 libfoo。

  • CMAKE_FIND_LIBRARY_SUFFIXES: 在查找库时要添加的后缀。

    这指定了在 find_library 命令查找库时要添加到库名称的后缀。 在 Windows 系统上，这通常是 .lib 和 .dll，这意味着在尝试查找 foo 库时，它将查找 foo.dll 等。

  • CMAKE_INCLUDE_PATH: FIND_FILE() 和 FIND_PATH() 用于搜索的路径。

    指定 FIND_FILE() 和 FIND_PATH() 都将使用的路径。 这两个命令都将检查所包含的每个目录中是否存在当前正在搜索的文件。 默认情况下，它是空的，它应该由项目设置。 另请参阅 CMAKE_SYSTEM_INCLUDE_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_INSTALL_PREFIX: install 使用的安装目录。

    如果调用了“make install”或构建了 INSTALL，则此目录将被预先添加到所有安装目录中。 此变量默认情况下在 UNIX 上为 /usr/local，在 Windows 上为 c:/Program Files。

  • CMAKE_LIBRARY_PATH: FIND_LIBRARY() 用于搜索的路径。

    指定 FIND_LIBRARY() 将使用的路径。 FIND_LIBRARY() 将检查所包含的每个目录中是否存在当前正在搜索的库。 默认情况下，它是空的，它应该由项目设置。 另请参阅 CMAKE_SYSTEM_LIBRARY_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_MFC_FLAG: 告诉 cmake 对可执行文件或 dll 使用 MFC。

    这可以在 CMakeLists.txt 文件中设置，并将启用应用程序中的 MFC。 对于静态 MFC 库，它应设置为 1，对于共享 MFC 库，它应设置为 2。 这用于 Visual Studio 6 和 7 项目文件。 CMakeSetup 对话框使用 MFC，CMakeLists.txt 看起来像这样

    ADD_DEFINITIONS(-D_AFXDLL)

    set(CMAKE_MFC_FLAG 2)

    add_executable(CMakeSetup WIN32 ${SRCS})

  • CMAKE_MODULE_PATH: 用于查找要加载的 cmake 模块的路径。

    指定一个路径来覆盖 CMake 模块的默认搜索路径。 例如，include 命令将首先在此路径中查找要包含的模块。

  • CMAKE_NOT_USING_CONFIG_FLAGS: 如果为真，则跳过 _BUILD_TYPE 标志。

    这是 CMake 中生成器使用的内部标志，用于告诉 CMake 跳过 _BUILD_TYPE 标志。

  • CMAKE_PREFIX_PATH: FIND_XXX() 用于搜索的路径，并添加适当的后缀。

    指定 FIND_XXX() 命令使用的路径。它包含“基础”目录，FIND_XXX() 命令会将适当的子目录追加到这些基础目录。因此 FIND_PROGRAM() 会将 /bin 追加到路径中的每个目录，FIND_LIBRARY() 会将 /lib 追加到每个目录，FIND_PATH() 和 FIND_FILE() 会将 /include 追加到每个目录。默认情况下它是空的，它旨在由项目设置。另见 CMAKE_SYSTEM_PREFIX_PATH、CMAKE_INCLUDE_PATH、CMAKE_LIBRARY_PATH、CMAKE_PROGRAM_PATH。

  • CMAKE_PROGRAM_PATH: FIND_PROGRAM() 用于搜索的路径。

    指定 FIND_PROGRAM() 将使用的路径。FIND_PROGRAM() 将检查每个包含的目录，以查找当前正在搜索的程序是否存在。默认情况下它是空的，它旨在由项目设置。另见 CMAKE_SYSTEM_PROGRAM_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_SYSTEM_INCLUDE_PATH: FIND_FILE() 和 FIND_PATH() 用于搜索的路径。

    指定 FIND_FILE() 和 FIND_PATH() 将使用的路径。这两个命令将检查每个包含的目录，以查找当前正在搜索的文件是否存在。默认情况下，它包含当前系统标准目录。项目不应修改它，请使用 CMAKE_INCLUDE_PATH 代替。另见 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_SYSTEM_LIBRARY_PATH: FIND_LIBRARY() 用于搜索的路径。

    指定 FIND_LIBRARY() 将使用的路径。FIND_LIBRARY() 将检查每个包含的目录，以查找当前正在搜索的库是否存在。默认情况下，它包含当前系统标准目录。项目不应修改它，请使用 CMAKE_SYSTEM_LIBRARY_PATH 代替。另见 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_SYSTEM_PREFIX_PATH: FIND_XXX() 用于搜索的路径，并添加了适当的后缀。

    指定 FIND_XXX() 命令使用的路径。它包含“基础”目录，FIND_XXX() 命令会将适当的子目录追加到这些基础目录。因此 FIND_PROGRAM() 会将 /bin 追加到路径中的每个目录，FIND_LIBRARY() 会将 /lib 追加到每个目录，FIND_PATH() 和 FIND_FILE() 会将 /include 追加到每个目录。默认情况下，它包含当前系统的标准目录。项目不应修改它，请使用 CMAKE_PREFIX_PATH 代替。另见 CMAKE_SYSTEM_INCLUDE_PATH、CMAKE_SYSTEM_LIBRARY_PATH、CMAKE_SYSTEM_PROGRAM_PATH。

  • CMAKE_SYSTEM_PROGRAM_PATH: FIND_PROGRAM() 用于搜索的路径。

    指定 FIND_PROGRAM() 将使用的路径。FIND_PROGRAM() 将检查每个包含的目录，以查找当前正在搜索的程序是否存在。默认情况下，它包含当前系统的标准目录。项目不应修改它，请使用 CMAKE_PROGRAM_PATH 代替。另见 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_USER_MAKE_RULES_OVERRIDE: 指定一个文件，该文件可以更改构建规则变量。

    如果设置了此变量，它应指向一个 CMakeLists.txt 文件，CMake 将在设置完所有系统设置后读取该文件，但在使用它们之前。这将允许你覆盖需要更改的任何变量以适应特殊项目。

描述系统的变量

  • APPLE: 如果在 Mac OSX 上运行，则为真。

    在 Mac OSX 上设置为真。

  • BORLAND: 如果正在使用 borland 编译器，则为真。

    如果正在使用 Borland 编译器，则将其设置为真。

  • CMAKE_CL_64: 使用 Microsoft 的 64 位编译器。

    当使用 Microsoft 的 64 位 cl 编译器时设置为真。

  • CMAKE_COMPILER_2005: 使用 Microsoft 的 Visual Studio 2005 编译器。

    当使用 Microsoft 的 Visual Studio 2005 编译器时设置为真。

  • CMAKE_HOST_APPLE: 适用于 Apple OSX 操作系统。

    当主机系统为 Apple OSX 时设置为真。

  • CMAKE_HOST_SYSTEM: CMake 正在运行的系统名称。

    与 CMAKE_SYSTEM 相同，但用于交叉编译时的主机系统，而不是目标系统。

  • CMAKE_HOST_SYSTEM_NAME: CMake 正在运行的 OS 名称。

    与 CMAKE_SYSTEM_NAME 相同，但用于交叉编译时的主机系统，而不是目标系统。

  • CMAKE_HOST_SYSTEM_PROCESSOR: CMake 正在运行的 CPU 名称。

    与 CMAKE_SYSTEM_PROCESSOR 相同，但用于交叉编译时的主机系统，而不是目标系统。

  • CMAKE_HOST_SYSTEM_VERSION: CMake 正在运行的 OS 版本。

    与 CMAKE_SYSTEM_VERSION 相同，但用于交叉编译时的主机系统，而不是目标系统。

  • CMAKE_HOST_UNIX: 适用于 UNIX 和类 UNIX 操作系统。

    当主机系统为 UNIX 或类 UNIX（即 APPLE 和 CYGWIN）时设置为真。

  • CMAKE_HOST_WIN32: 适用于 Windows 系统，包括 win64。

    当主机系统为 Windows 以及在 cygwin 上时设置为真。

  • CMAKE_OBJECT_PATH_MAX: 本机构建工具允许的最大对象文件完整路径长度。

    CMake 为每个源文件计算一个对象文件名，该文件名对源文件是唯一的，并且相对于源文件的完整路径是确定的。这允许目标中的多个源文件在位于不同目录时共享同一个名称，而无需在添加或删除一个文件时重建。但是，在某些情况下它可能会生成较长的完整路径，因此 CMake 使用哈希方案缩短路径，当对象文件的完整路径超过限制时。CMake 为每个平台都有一个内置限制，这对于常见工具来说已经足够了，但某些本机工具可能会有更低的限制。可以设置此变量来显式指定限制。该值必须是大于或等于 128 的整数。

  • CMAKE_SYSTEM: CMake 正在为其编译的系统名称。

    此变量是 CMAKE_SYSTEM_NAME 和 CMAKE_SYSTEM_VERSION 的组合，像这样 ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}。如果未设置 CMAKE_SYSTEM_VERSION，则 CMAKE_SYSTEM 与 CMAKE_SYSTEM_NAME 相同。

  • CMAKE_SYSTEM_NAME: CMake 正在为其构建的 OS 名称。

    这是 CMake 目标操作系统的名称。在支持 uname 命令的系统上，此变量设置为 uname -s 的输出。Linux、Windows 和 Darwin（适用于 Mac OSX）是在三大操作系统上找到的值。

  • CMAKE_SYSTEM_PROCESSOR: CMake 正在为其构建的 CPU 名称。

    在支持 uname 的系统上，此变量设置为 uname -p 的输出，在 Windows 上，它设置为环境变量 PROCESSOR_ARCHITECTURE 的值。

  • CMAKE_SYSTEM_VERSION: CMake 正在为其构建的 OS 版本。

    系统的数字版本字符串，在支持 uname 的系统上，此变量设置为 uname -r 的输出。在其他系统上，它设置为主版本-次版本号。

  • CYGWIN: 适用于 cygwin。

    当使用 CYGWIN 时设置为真。

  • MSVC: 当使用 Microsoft Visual C 时为真。

    当编译器为 Microsoft Visual C 的某个版本时设置为真。

  • MSVC80: 当使用 Microsoft Visual C 8.0 时为真。

    当编译器为 Microsoft Visual C 的 8.0 版时设置为真。

  • MSVC_IDE: 当使用 Microsoft Visual C IDE 时为真。

    当目标平台为 Microsoft Visual C IDE 时设置为真，而不是命令行编译器。

  • MSVC_VERSION: 如果存在，则为正在使用的 Microsoft Visual C/C++ 版本。

    如果存在，则为正在使用的 Microsoft Visual C/C++ 版本。例如，1300 是 MSVC 6.0。

  • UNIX: 适用于 UNIX 和类 UNIX 操作系统。

    当目标系统为 UNIX 或类 UNIX（即 APPLE 和 CYGWIN）时设置为真。

  • WIN32: 适用于 Windows 系统，包括 win64。

    当目标系统为 Windows 以及在 cygwin 上时设置为真。

语言变量

  • CMAKE_<LANG>_ARCHIVE_APPEND: 用于追加到静态归档文件的规则变量。

    这是一个规则变量，它告诉 CMake 如何追加到静态归档文件。它在某些平台上代替 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支持大量对象计数。另见 CMAKE_<LANG>_ARCHIVE_CREATE 和 CMAKE_<LANG>_ARCHIVE_FINISH。

  • CMAKE_<LANG>_ARCHIVE_CREATE: 用于创建新的静态归档文件的规则变量。

    这是一个规则变量，它告诉 CMake 如何创建静态归档文件。它在某些平台上代替 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支持大量对象计数。另见 CMAKE_<LANG>_ARCHIVE_APPEND 和 CMAKE_<LANG>_ARCHIVE_FINISH。

  • CMAKE_<LANG>_ARCHIVE_FINISH: 用于完成现有静态归档文件的规则变量。

    这是一个规则变量，它告诉 CMake 如何完成静态归档文件。它在某些平台上代替 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支持大量对象计数。另见 CMAKE_<LANG>_ARCHIVE_CREATE 和 CMAKE_<LANG>_ARCHIVE_APPEND。

  • CMAKE_<LANG>_COMPILER: LANG 编译器的完整路径。

    这是将用作 <LANG> 编译器的命令。设置后，你无法更改此变量。

  • CMAKE_<LANG>_COMPILER_ABI: 一个内部变量，可能会发生更改。

    这用于确定编译器 ABI，可能会发生更改。

  • CMAKE_<LANG>_COMPILER_ID: 一个内部变量，可能会发生更改。

    这用于确定编译器，可能会发生更改。

  • CMAKE_<LANG>_COMPILE_OBJECT: 用于编译单个目标文件的规则变量。

    这是一个规则变量，它告诉 CMake 如何为 <LANG> 语言编译单个目标文件。

  • CMAKE_<LANG>_CREATE_SHARED_LIBRARY: 用于创建共享库的规则变量。

    这是一个规则变量，它告诉 CMake 如何为 <LANG> 语言创建共享库。

  • CMAKE_<LANG>_CREATE_SHARED_MODULE: 用于创建共享模块的规则变量。

    这是一个规则变量，它告诉 CMake 如何为 <LANG> 语言创建共享库。

  • CMAKE_<LANG>_CREATE_STATIC_LIBRARY: 用于创建静态库的规则变量。

    这是一个规则变量，它告诉 CMake 如何为 <LANG> 语言创建静态库。

  • CMAKE_<LANG>_FLAGS_DEBUG: 调试构建类型或配置的标志。

    当 CMAKE_BUILD_TYPE 为 Debug 时使用的 <LANG> 标志。

  • CMAKE_<LANG>_FLAGS_MINSIZEREL: MinSizeRel 构建类型或配置的标志。

    当 CMAKE_BUILD_TYPE 为 MinSizeRel 时使用的 <LANG> 标志。缩写为最小尺寸发布版。

  • CMAKE_<LANG>_FLAGS_RELEASE: 发布构建类型或配置的标志。

    当 CMAKE_BUILD_TYPE 为 Release 时使用的 <LANG> 标志

  • CMAKE_<LANG>_FLAGS_RELWITHDEBINFO: RelWithDebInfo 类型或配置的标志。

    当 CMAKE_BUILD_TYPE 为 RelWithDebInfo 时使用的 <LANG> 标志。缩写为带调试信息的发布版。

  • CMAKE_<LANG>_IGNORE_EXTENSIONS: 构建时应忽略的文件扩展名。

    这是一个文件扩展名列表，这些扩展名可能是特定语言项目的组成部分，但不会被编译。

  • CMAKE_<LANG>_LINKER_PREFERENCE: 确定是否应使用某种语言进行链接。

    如果为“Preferred”，则如果存在混合语言共享库或可执行文件，则将使用此语言的链接器命令。

  • CMAKE_<LANG>_LINK_EXECUTABLE : 用于链接可执行文件的规则变量。

    用于为给定语言链接可执行文件的规则变量。

  • CMAKE_<LANG>_OUTPUT_EXTENSION: 编译单个文件的输出扩展名。

    这是给定 <LANG> 的目标文件扩展名。例如，Windows 上的 C 为 .obj。

  • CMAKE_<LANG>_PLATFORM_ID: 一个内部变量，可能发生变化。

    这用于确定平台，可能会发生变化。

  • CMAKE_<LANG>_SIZEOF_DATA_PTR: 一个内部变量，可能发生变化。

    这用于确定架构，可能会发生变化。

  • CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS: 给定语言的源文件的扩展名。

    这是给定语言源文件的扩展名列表。

  • CMAKE_COMPILER_IS_GNU<LANG>: 如果编译器为 GNU，则为 True。

    如果选择的 <LANG> 编译器为 GNU 编译器，则为 TRUE，否则为 FALSE。

  • CMAKE_INTERNAL_PLATFORM_ABI: 一个内部变量，可能发生变化。

    这用于确定编译器 ABI，可能会发生更改。

  • CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>: 指定可以更改构建规则变量的文件。

    如果设置了此变量，则它应指向一个 CMakeLists.txt 文件，CMake 将在设置所有系统设置后但在使用它们之前读取该文件。这使您可以覆盖需要更改的任何语言变量。

控制构建的变量

  • CMAKE_<CONFIG>_POSTFIX: 配置 <CONFIG> 下库的默认文件名后缀。

    创建非可执行目标时，其 <CONFIG>_POSTFIX 目标属性将使用此变量的值进行初始化（如果设置了该值）。

  • CMAKE_ARCHIVE_OUTPUT_DIRECTORY: 构建时放置所有 ARCHIVE 目标的位置。

    此变量用于初始化所有目标的 ARCHIVE_OUTPUT_DIRECTORY 属性。有关更多信息，请参阅该目标属性。

  • CMAKE_BUILD_WITH_INSTALL_RPATH: 使用安装路径作为 RPATH

    通常，CMake 在构建使用 RPATH 的系统上的可执行文件等时，会使用构建树作为 RPATH。安装软件时，CMake 会重新链接可执行文件等，使其具有安装 RPATH。如果将此变量设置为 true，则软件始终使用安装路径作为 RPATH 进行构建，无需在安装时重新链接。

  • CMAKE_DEBUG_POSTFIX: 请参阅变量 CMAKE_<CONFIG>_POSTFIX。

    此变量是更通用的 CMAKE_<CONFIG>_POSTFIX 变量的特殊情况，用于 DEBUG 配置。

  • CMAKE_EXE_LINKER_FLAGS: 用于创建可执行文件的链接器标志。

    创建可执行文件时链接器使用的标志。

  • CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]: 链接可执行文件时使用的标志。

    与 CMAKE_C_FLAGS_* 相同，但由链接器在创建可执行文件时使用。

  • CMAKE_Fortran_MODULE_DIRECTORY: Fortran 模块输出目录。

    此变量用于初始化所有目标的 Fortran_MODULE_DIRECTORY 属性。有关更多信息，请参阅该目标属性。

  • CMAKE_INSTALL_NAME_DIR: Mac OSX 中安装目标的目录名称。

    CMAKE_INSTALL_NAME_DIR 用于初始化所有目标的 INSTALL_NAME_DIR 属性。有关更多信息，请参阅该目标属性。

  • CMAKE_INSTALL_RPATH: 用于安装目标的 rpath。

    一个用分号分隔的列表，指定在安装目标中使用的 rpath（对于支持它的平台）。这用于初始化所有目标的 INSTALL_RPATH 目标属性。

  • CMAKE_INSTALL_RPATH_USE_LINK_PATH: 将路径添加到链接器搜索路径和安装 rpath。

    CMAKE_INSTALL_RPATH_USE_LINK_PATH 是一个布尔值，如果设置为 true，则将链接器搜索路径和项目外部的目录附加到 INSTALL_RPATH。这用于初始化所有目标的 INSTALL_RPATH_USE_LINK_PATH 目标属性。

  • CMAKE_LIBRARY_OUTPUT_DIRECTORY: 构建时放置所有 LIBRARY 目标的位置。

    此变量用于初始化所有目标的 LIBRARY_OUTPUT_DIRECTORY 属性。有关更多信息，请参阅该目标属性。

  • CMAKE_LIBRARY_PATH_FLAG: 用于将库搜索路径添加到编译器的标志。

    用于向编译器指定库目录的标志。在大多数编译器中，它为“-L”。

  • CMAKE_LINK_DEF_FILE_FLAG : 用于指定 .def 文件以创建 dll 的链接器标志。

    在 Windows 上创建 dll 时用于添加 .def 文件的标志，此标志仅在 Windows 上定义。

  • CMAKE_LINK_LIBRARY_FILE_FLAG: 用于链接由文件路径指定的库的标志。

    在向链接器提供库文件路径之前使用的标志。这仅在极少数平台上需要。

  • CMAKE_LINK_LIBRARY_FLAG: 用于将库链接到可执行文件的标志。

    用于指定要链接到可执行文件的库的标志。在大多数编译器中，它为“-l”。

  • CMAKE_RUNTIME_OUTPUT_DIRECTORY: 构建时放置所有 RUNTIME 目标的位置。

    此变量用于初始化所有目标的 RUNTIME_OUTPUT_DIRECTORY 属性。有关更多信息，请参阅该目标属性。

  • CMAKE_SKIP_BUILD_RPATH: 不要在构建树中包含 RPATH。

    通常，CMake 在构建使用 RPATH 的系统上的可执行文件等时，会使用构建树作为 RPATH。安装软件时，CMake 会重新链接可执行文件等，使其具有安装 RPATH。如果将此变量设置为 true，则软件始终在不使用 RPATH 的情况下构建。

  • CMAKE_USE_RELATIVE_PATHS: 使用相对路径（可能无法正常工作！）。

    如果将其设置为 TRUE，则 CMake 将在源树和二进制树之间使用相对路径。此选项不适用于更复杂的项目，并且会在可能的情况下使用相对路径。一般而言，无论此变量的值如何，都无法将 CMake 生成的 makefile 移动到其他位置。

  • EXECUTABLE_OUTPUT_PATH: 旧的可执行文件位置变量。

    从 CMake 2.6 开始，不再应使用此变量。请改用 RUNTIME_OUTPUT_DIRECTORY 目标属性。如果设置了该属性，则它将覆盖此变量。

    如果设置了该变量，则这是构建过程中所有可执行文件放置的目录。

  • LIBRARY_OUTPUT_PATH: 旧的库位置变量。

    从 CMake 2.6 开始，不再应使用此变量。请改用 ARCHIVE_OUTPUT_DIRECTORY、LIBRARY_OUTPUT_DIRECTORY 和 RUNTIME_OUTPUT_DIRECTORY 目标属性。如果设置了这些属性，则它们将覆盖此变量。

    如果设置了该变量，则这是构建过程中所有库放置的目录。

提供信息的变量

由 cmake 定义的变量，提供有关项目和 cmake 的信息

  • CMAKE_AR: 用于静态库的归档工具的名称。

    这指定了创建存档或静态库的程序的名称。

  • CMAKE_BINARY_DIR: 构建树顶层的路径。

    这是当前 CMake 构建树顶层的完整路径。对于源代码构建，这将与 CMAKE_SOURCE_DIR 相同。

  • CMAKE_BUILD_TOOL: 用于实际构建过程的工具。

    此变量设置为用于构建 CMake 输出的程序。如果选择的生成器是 Visual Studio 6，则 CMAKE_MAKE_PROGRAM 将设置为 msdev，对于 Unix makefile，它将设置为 make 或 gmake，对于 Visual Studio 7，它将设置为 devenv。对于 Nmake Makefiles，该值为 nmake。这对于根据最终构建环境添加特殊标志和命令很有用。

  • CMAKE_CACHEFILE_DIR: 包含 CMakeCache.txt 文件的目录。

    这是包含 CMakeCache.txt 文件的目录的完整路径。这与 CMAKE_BINARY_DIR 相同。

  • CMAKE_CACHE_MAJOR_VERSION: 用于创建 CMakeCache.txt 文件的 CMake 主版本。

    此变量存储用于写入 CMake 缓存文件的 CMake 主版本。仅当在先前创建的缓存文件上运行不同版本的 CMake 时，它才会不同。

  • CMAKE_CACHE_MINOR_VERSION: 用于创建 CMakeCache.txt 文件的 CMake 次版本。

    此变量存储用于写入 CMake 缓存文件的 CMake 次版本。仅当在先前创建的缓存文件上运行不同版本的 CMake 时，它才会不同。

  • CMAKE_CACHE_RELEASE_VERSION: 用于创建 CMakeCache.txt 文件的 CMake 发行版本。

    此变量存储用于写入 CMake 缓存文件的 CMake 发行版本。仅当在先前创建的缓存文件上运行不同版本的 CMake 时，它才会不同。

  • CMAKE_CFG_INTDIR: 项目的构建时配置目录。

    这是一个变量，用于为开发人员提供对 Visual Studio IDE 项目使用的中间目录的访问权限。例如，如果构建调试，所有可执行文件和库最终都会出现在调试目录中。在 UNIX 系统上，此变量设置为“.”。但是，使用 Visual Studio，此变量将设置为 $(IntDir)。$(IntDir) 仅由 IDE 展开。因此，此变量仅应在构建过程中运行的自定义命令中使用。此变量不应直接在 CMake 命令中使用。CMake 无法知道 IDE 是否会为构建类型选择调试或发布。如果程序需要知道它是在哪个目录中构建的，它可以使用 CMAKE_INTDIR。CMAKE_INTDIR 是在编译器命令行上定义的 C/C++ 预处理器宏。如果它有值，它将是用于构建文件的中间目录。这样，可执行文件或库就可以找到位于构建目录中的文件。

  • CMAKE_COMMAND: cmake 可执行文件的完整路径。

    这是 CMake 可执行文件 cmake 的完整路径，它在想要使用 cmake -E 选项进行可移植系统命令的自定义命令中很有用。（例如 /usr/local/bin/cmake

  • CMAKE_CROSSCOMPILING: CMake 当前是否正在交叉编译。

    如果 CMake 正在交叉编译，此变量将由 CMake 设置为 true。具体来说，如果构建平台与目标平台不同。

  • CMAKE_CTEST_COMMAND: 与 cmake 一起安装的 ctest 命令的完整路径。

    这是 CTest 可执行文件 ctest 的完整路径，它在想要使用 cmake -E 选项进行可移植系统命令的自定义命令中很有用。

  • CMAKE_CURRENT_BINARY_DIR: 当前正在处理的二进制目录的路径。

    这是 cmake 当前正在处理的构建目录的完整路径。由 add_subdirectory 添加的每个目录将在构建树中创建一个二进制目录，并且在处理过程中，此变量将被设置。对于源代码构建，这是当前正在处理的源代码目录。

  • CMAKE_CURRENT_LIST_FILE: 当前正在处理的列表文件的完整路径。

    当 CMake 处理项目中的列表文件时，此变量将始终设置为当前正在处理的列表文件。另请参阅 CMAKE_PARENT_LIST_FILE。

  • CMAKE_CURRENT_LIST_LINE: 当前正在处理的文件的行号。

    这是 cmake 当前正在处理的文件的行号。

  • CMAKE_CURRENT_SOURCE_DIR: 当前正在处理的源代码目录的路径。

    这是 cmake 当前正在处理的源代码目录的完整路径。

  • CMAKE_DL_LIBS: 包含 dlopen 和 dlcose 的库的名称。

    包含 dlopen 和 dlclose 的库的名称，通常是大多数 UNIX 机器上的 -ldl。

  • CMAKE_EDIT_COMMAND: CMakeSetup 或 ccmake 的完整路径。

    这是可以以图形方式编辑缓存的 CMake 可执行文件的完整路径。例如，CMakeSetup、ccmake 或 cmake -i。

  • CMAKE_EXECUTABLE_SUFFIX: 此平台上可执行文件的扩展名。

    如果在可执行文件末尾使用任何扩展名，则使用该扩展名，在 Windows 上为 .exe。

  • CMAKE_GENERATOR: 用于构建项目的生成器。

    用于生成构建文件的生成器的名称。（例如“Unix Makefiles”、“Visual Studio 6”等）

  • CMAKE_HOME_DIRECTORY: 源代码树顶层的路径。

    这是源代码树顶层的路径。

  • CMAKE_IMPORT_LIBRARY_PREFIX: 您链接到的导入库的前缀。

    如果在此平台上使用，则用于导入库名称的前缀。

  • CMAKE_IMPORT_LIBRARY_SUFFIX: 您链接到的导入库的扩展名。

    如果在此平台上使用，则用于导入库末尾的扩展名。

  • CMAKE_LINK_LIBRARY_SUFFIX: 您链接到的库的扩展名。

    用于库末尾的扩展名，在 Windows 上为 .lib。

  • CMAKE_MAJOR_VERSION: cmake 的主版本（即 2.X.X 中的 2）

    这指定了正在运行的 CMake 可执行文件的主版本。

  • CMAKE_MAKE_PROGRAM: 请参阅 CMAKE_BUILD_TOOL。

    此变量是为了向后兼容，请参阅 CMAKE_BUILD_TOOL。

  • CMAKE_MINOR_VERSION: cmake 的次版本（即 X.4.X 中的 4）。

    这指定了正在运行的 CMake 可执行文件的次版本。

  • CMAKE_PARENT_LIST_FILE: 当前正在处理的父列表文件的完整路径。

    当 CMake 处理项目中的列表文件时，此变量将始终设置为包含或以某种方式调用当前正在处理的列表文件的列表文件。另请参阅 CMAKE_CURRENT_LIST_FILE。

  • CMAKE_PATCH_VERSION: cmake 的补丁版本（即 X.X.3 中的 3）。

    这指定了正在运行的 CMake 可执行文件的补丁版本。

  • CMAKE_PROJECT_NAME: 当前项目的名称。

    这指定了从最近继承的 PROJECT 命令获得的当前项目的名称。

  • CMAKE_RANLIB: 静态库的随机化工具的名称。

    这指定了在 UNIX 上随机化库的程序的名称，在 Windows 上未使用，但可能存在。

  • CMAKE_ROOT: 运行 cmake 的安装目录。

    这是运行 CMake 的安装根目录，Modules 目录可以在这里找到。通常使用这种格式：${CMAKE_ROOT}/Modules

  • CMAKE_SHARED_LIBRARY_PREFIX: 您链接到的共享库的前缀。

    用于共享库名称的前缀，在 UNIX 上为 lib。

  • CMAKE_SHARED_LIBRARY_SUFFIX: 您链接到的共享库的扩展名。

    用于共享库末尾的扩展名，在 Windows 上为 .dll。

  • CMAKE_SHARED_MODULE_PREFIX: 您链接的可加载模块的前缀。

    用于在此平台上可加载模块名称的前缀。

  • CMAKE_SHARED_MODULE_SUFFIX: 您链接到的共享库的扩展名。

    用于在此平台上可加载模块末尾的扩展名。

  • CMAKE_SIZEOF_VOID_P: 空指针的大小。

    这设置为机器上指针的大小，并通过尝试编译来确定。如果找到 64 位大小，则库搜索路径将修改为首先查找 64 位库。

  • CMAKE_SKIP_RPATH: 如果为真，则不添加运行时路径信息。

    如果将其设置为 TRUE，则不会将 rpath 信息添加到编译的可执行文件中。默认情况下是如果平台支持，则添加 rpath 信息。这允许从构建树中轻松运行。

  • CMAKE_SOURCE_DIR: 源代码树顶层的路径。

    这是当前 CMake 源代码树顶层的完整路径。对于源代码构建，这将与 CMAKE_BINARY_DIR 相同。

  • CMAKE_STANDARD_LIBRARIES: 链接到每个可执行文件和共享库的库。

    这是链接到所有可执行文件和库的库列表。

  • CMAKE_STATIC_LIBRARY_PREFIX: 您链接到的静态库的前缀。

    用于静态库名称的前缀，在 UNIX 上为 lib。

  • CMAKE_STATIC_LIBRARY_SUFFIX: 您链接到的静态库的扩展名。

    用于静态库末尾的扩展名，在 Windows 上为 .lib。

  • CMAKE_USING_VC_FREE_TOOLS: 如果使用免费的 Visual Studio 工具，则为真。

    如果编译器是 Visual Studio 免费工具，则将其设置为 true。

  • CMAKE_VERBOSE_MAKEFILE: 如果打开，则创建详细的 Makefile。

    此变量默认值为 false。您可以将此变量设置为 true，使 CMake 生成详细的 Makefile，其中显示每个使用的命令行。

  • CMAKE_VERSION: CMake 的完整版本号，格式为 major.minor.patch。

    此变量指定正在运行的 CMake 可执行文件的完整版本。此变量由 2.6.3 及更高版本定义。有关各个版本组件，请参见变量 CMAKE_MAJOR_VERSION、CMAKE_MINOR_VERSION 和 CMAKE_PATCH_VERSION。

  • PROJECT_BINARY_DIR: 项目构建目录的完整路径。

    这是最近 PROJECT 命令的二进制目录。

  • PROJECT_NAME: 提供给 project 命令的项目名称。

    这是提供给最近 PROJECT 命令的名称。

  • PROJECT_SOURCE_DIR: 当前项目的顶级源代码目录。

    这是最近 PROJECT 命令的源代码目录。

  • [项目名称]_BINARY_DIR: 指定项目的顶级二进制目录。

    使用 PROJECT 命令中的名称创建一个变量，它是项目的二进制目录。当使用 SUBDIR 连接多个项目时，这很有用。

  • [项目名称]_SOURCE_DIR: 指定项目的顶级源代码目录。

    使用 PROJECT 命令中的名称创建一个变量，它是项目的源代码目录。当使用 add_subdirectory 连接多个项目时，这很有用。

版权

版权所有 (c) 2002 Kitware, Inc., Insight Consortium。保留所有权利。

在满足以下条件的情况下，允许以源代码和二进制形式重新分发和使用本软件，无论是否修改：

源代码的重新分发必须保留上述版权声明、此条件列表和以下免责声明。

二进制形式的重新分发必须在随分发提供的文档和/或其他材料中复制上述版权声明、此条件列表和以下免责声明。

未经明确事先书面许可，不得使用 Kitware, Inc.、Insight Consortium 或任何联盟成员的名称，或任何贡献者的名称来认可或推广源自本软件的产品。

修改后的源代码版本必须明确标明为修改版本，并且不得被误认为是原始软件。

本软件由版权持有人和贡献者“按现状”提供，任何明示或暗示的保证（包括但不限于适销性和特定用途适用性的暗示保证）均被免除。在任何情况下，作者或贡献者均不对因使用本软件而导致的任何直接的、间接的、偶然的、特殊的、示范性的或后果性的损害（包括但不限于采购替代商品或服务的损害；使用、数据或利润的损失；或业务中断）负责，无论其原因如何以及在任何责任理论下，无论是基于合同、严格责任还是侵权行为（包括疏忽或其他原因），即使已告知可能发生此类损害。

另请参阅

以下资源可用于获得使用 CMake 的帮助

有用链接摘要

  Home: http://www.cmake.org
  Docs: http://www.cmake.org/HTML/Documentation.html
  Mail: http://www.cmake.org/HTML/MailingLists.html
  FAQ:  http://www.cmake.org/Wiki/CMake_FAQ