为什么 CMake 区分“目标”和“命令”？

在 CMake 语义学中，“目标”和命令之间存在某种区别，这让我很困惑。在 Makefiles，没有这样的区别:

targetname:dependency
command

也就是说，目标对应于生成的同名文件。

在 CMake 中，像“ add _ custom_ command”和“ add _ custom_ target”这样的命令有重叠的功能，甚至在官方文档中，语义也是混乱的，比如在“ MasteringCMake，第5版”第110页的“添加一个自定义目标”中:

DEPENDS 参数设置自定义目标之间的依赖项 和自定义命令。

我的理解是，目标(生成的文件)具有依赖项(其他文件，生成或不生成) ，以及一个实际执行生成的命令。说目标依赖于命令是毫无意义的。更糟糕的是，有两种类型的“ add _ custom_ command”，它们要么向现有目标附加一个额外的命令，要么将该命令发送出去。

有人能解释一下为什么会有这种区别吗？

47541 次浏览
小开

Targets

In general, targets comprise executables or libraries which are defined by calling add_executable or add_library and which can have many properties set.

They can have dependencies on one another, which for targets such as these just means that dependent ones will be built after their dependencies.

However, you can also define "custom targets" via add_custom_target. From the docs:

Adds a target with the given name that executes the given commands. The target has no output file and is ALWAYS CONSIDERED OUT OF DATE even if the commands try to create a file with the name of the target. Use ADD_CUSTOM_COMMAND to generate a file with dependencies. By default nothing depends on the custom target. Use ADD_DEPENDENCIES to add dependencies to or from other targets.

So these are different from "normal" targets in that they don't represent things which will produce an exe or lib, but they still benefit from all the properties that targets can have, including having or being dependencies. They appear as a target which can be built (e.g. make MyCustomTarget or msbuild MyCustomTarget.vcxproj). When you build them, you're simply invoking the commands that have been set for them. If they have dependencies on other targets (normal or custom), then these will be built first.


Custom Commands

A custom command defined via add_custom_command is quite different in that it's not a "buildable" object, and doesn't have settable properties in the way that a target does - it's not a named object which can be explicitly referred to again after it's added in the CMakeLists.txt.

It is basically a command (or set of commands) which will be invoked before building a dependent target. That's all that "depends" really means here (at least that's how I view it) - it's just saying that if A depends on B, then B will be built/executed before A is built.

The dependees of a custom command can be either set explicitly using the add_custom_command(TARGET target ... form, or implicitly by creating targets which include the files generated via the add_custom_command(OUTPUT output1 ... form.

In the first case, every time target is built, the custom command is executed first.

In the second case, it's a little more complex. If the custom command has targets which depend on its output file (and the output file doesn't already exist), it is invoked before these dependent objects are built. The dependencies are implicitly created when you do e.g. add_library(MyLib output1.h ... ) where output1.h is a file generated via add_custom_command(OUTPUT output1.h ... ).

小开

add_custom_command adds a callable function that can have defined outputs (using the OUTPUT and BYPRODUCTS arguments). It can also have dependencies that will be run before the function is called.

Notice that it does NOT do things that you may think it does due to strange documentation (the makefile examples are very misleading). In particular, it does not have any guarantees about numbers of times it executes. For example, imagine this:

add_custom_command(OUTPUT /tmp/touched COMMAND echo touch COMMAND touch /tmp/touched)
add_custom_target(touched-one ALL DEPENDS /tmp/touched)
add_custom_target(touched-two ALL DEPENDS /tmp/touched)

How many times will "touch" be printed? You don't know, since it's not specified anywhere; make -j2 will print it twice, probably, but it's timing-dependent:

Scanning dependencies of target touched-two
Scanning dependencies of target touched-one
[ 50%] Generating touched
touch
[100%] Generating touched
touch
[100%] Built target touched-two
[100%] Built target touched-one

But Ninja will only print it once, probably:

# rm -rf * && cmake -GNinja ../c ; cmake --build . -- -j 5
[1/1] Generating touched
touch

Usually, you'll do an add_custom_command to do some work and that defines an OUTPUT, and then you'll have an add_custom_target that depends on the output of the custom command. Anyone who wants the output depends on the target, and that does give you the guarantees you want.

Caveat: see this bug for an great example of why building cross-platform metabuild tools is REALLY HARD.


提交答案