一、generator
1、generator的类型
在每次调用cmake(可执行文件)的时候，会创建一个对应的cmake(源码中的cmake类)实例，并调用这个它的Run接口。从这个类的定义可以看到，它的成员中只有一个
std::unique_ptr<cmGlobalGenerator> GlobalGenerator;
实例指针，所以说单次构建只有一个GlobalGenerator。而这个具体是VisualStudio、UnixMakefile、XCode等，这个通常在cmake编译的时候就已经确定。例如，windows下默认是VS、Mach下默认为XCode、而LInux下默认为UnixMakefile。当然，不使用默认的情况下可以通过命令行选项中的-G指定
-G <generator-name> = Specify a build system generator.
在cmake的help文档中，还可以看到当前可执行文件支持的所有generator类型以及当前的缺省类型。
Generators
The following generators are available on this platform (* marks default):
* Unix Makefiles = Generates standard UNIX makefiles.
Green Hills MULTI = Generates Green Hills MULTI files
(experimental, work-in-progress).
Ninja = Generates build.ninja files.
2、cmake类部分代码
/** \brief Represents a cmake invocation.
*
* This class represents a cmake invocation. It is the top level class when
* running cmake. Most cmake based GUIs should primarily create an instance
* of this class and communicate with it.
*
* The basic process for a GUI is as follows:
*
* -# Create a cmake instance
* -# Set the Home directories, generator, and cmake command. this
* can be done using the Set methods or by using SetArgs and passing in
* command line arguments.
* -# Load the cache by calling LoadCache (duh)
* -# if you are using command line arguments with -D or -C flags then
* call SetCacheArgs (or if for some other reason you want to modify the
* cache), do it now.
* -# Finally call Configure
* -# Let the user change values and go back to step 5
* -# call Generate
* If your GUI allows the user to change the home directories then
* you must at a minimum redo steps 2 through 7.
*/
class cmake
{
……
std::stack<std::string> CheckInProgressMessages;
std::unique_ptr<cmGlobalGenerator> GlobalGenerator;
……
}
3、cmake对脚本的读取
当globalgenerator执行Configure的时候，它首先(毫无意外的)读取并解析cmake自定义的脚本文件，相关结构为cmMakefile类型
void cmGlobalGenerator::Configure()
{
……
auto dirMfu = cm::make_unique<cmMakefile>(this, snapshot);
auto* dirMf = dirMfu.get();
this->Makefiles.push_back(std::move(dirMfu));
dirMf->SetRecursionDepth(this->RecursionDepth);
this->IndexMakefile(dirMf);
this->BinaryDirectories.insert(
this->CMakeInstance->GetHomeOutputDirectory());
// now do it
this->ConfigureDoneCMP0026AndCMP0024 = false;
dirMf->Configure();
dirMf->EnforceDirectoryLevelRules();
……
}
二、cmMakefile
1、Configure流程
这里可以看到，脚本文件使用的是CMakeLists.txt，接下来会在构建文件夹下创建一个对应的CMakeFiles文件夹。这也意味着：每个有CMakeLists.txt的文件夹，在构建文件夹中必定有一个对应的/CMakeFiles文件夹。所以，CMakeLists.txt所在文件夹的结构决定了构建输出文件夹的框架结构。
cmake-3.20.6\Source\cmMakefile.cxx
void cmMakefile::Configure()
{
std::string currentStart = cmStrCat(
this->StateSnapshot.GetDirectory().GetCurrentSource(), "/CMakeLists.txt");
// Add the bottom of all backtraces within this directory.
// We will never pop this scope because it should be available
// for messages during the generate step too.
this->Backtrace = this->Backtrace.Push(currentStart);
BuildsystemFileScope scope(this);
// make sure the CMakeFiles dir is there
std::string filesDir = cmStrCat(
this->StateSnapshot.GetDirectory().GetCurrentBinary(), "/CMakeFiles");
cmSystemTools::MakeDirectory(filesDir);
assert(cmSystemTools::FileExists(currentStart, true));
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart);
cmListFile listFile;
if (!listFile.ParseFile(currentStart.c_str(), this->GetMessenger(),
this->Backtrace)) {
return;
}
……
}
三、LocalGenerator
1、对应的概念
这个LocalGenerator从概念上理解比较直观，简言之，它对应一个本地构建工具识别的脚本文件。对于Unix这种类型，也就是一个Makefile语法格式的文件。
cmake-3.20.6\Source\cmGlobalGenerator.cxx
void cmGlobalGenerator::CreateLocalGenerators()
{
this->LocalGeneratorSearchIndex.clear();
this->LocalGenerators.clear();
this->LocalGenerators.reserve(this->Makefiles.size());
for (const auto& m : this->Makefiles) {
auto lg = this->CreateLocalGenerator(m.get());
this->IndexLocalGenerator(lg.get());
this->LocalGenerators.push_back(std::move(lg));
}
}
2、文件名
这种本地文件，对于unix系统来说，默认就是Makefile，这意味着：对于每个CMakeLists.txt文件，它的构建文件夹中不仅有一个CMakeFiles文件夹，还会有一个Makefile文件。
void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
{
// generate the includes
std::string ruleFileName = "Makefile";
……
}
四、target
1、从target到cmGeneratorTarget
一个CMakeLists.txt文件中，可以通过add_library、add_executable命令添加任意多的构建目标。这个在Makefile的语法中，对应一个单独的构建目标。所以，这些target就是在遇到CMakeLists.txt中的add_library、add_executable时创建。
cmake-3.20.6\Source\cmGlobalGenerator.cxx
void cmGlobalGenerator::CreateGeneratorTargets(
TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg,
std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
{
if (targetTypes == AllTargets) {
for (auto& target : mf->GetTargets()) {
cmTarget* t = &target.second;
lg->AddGeneratorTarget(cm::make_unique<cmGeneratorTarget>(t, lg));
}
}
for (cmTarget* t : mf->GetImportedTargets()) {
lg->AddImportedGeneratorTarget(importedMap.find(t)->second);
}
}
2、从target到文件夹
从这个地方可以看到，每个target在文件夹系统中对应一个${target}.dir格式的文件夹。
cmake-3.20.6\Source\cmGeneratorTarget.cxx
std::string cmGeneratorTarget::GetSupportDirectory() const
{
std::string dir = cmStrCat(this->LocalGenerator->GetCurrentBinaryDirectory(),
"/CMakeFiles/", this->GetName());
#if defined(__VMS)
dir += "_dir";
#else
dir += ".dir";
#endif
return dir;
}
3、每个目标使用的本地Makefile
可以看到，每个目标对应一个build.make文件，这个文件是Makefile格式文件。
cmake-3.20.6\Source\cmMakefileTargetGenerator.cxx
void cmMakefileTargetGenerator::CreateRuleFile()
{
// Create a directory for this target.
this->TargetBuildDirectory =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->TargetBuildDirectoryFull =
this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory);
cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull);
// Construct the rule file name.
this->BuildFileName = cmStrCat(this->TargetBuildDirectory, "/build.make");
this->BuildFileNameFull =
cmStrCat(this->TargetBuildDirectoryFull, "/build.make");
// Construct the rule file name.
this->ProgressFileNameFull =
cmStrCat(this->TargetBuildDirectoryFull, "/progress.make");
……
}
五、举个栗子
1、源代码project结构
tsecer@harry: tree
.
├── build
└── src
├── CMakeLists.txt
├── foo
│ └── bar
│ ├── bar.cpp
│ └── CMakeLists.txt
└── main.cpp
4 directories, 4 files
tsecer@harry: cat src/CMakeLists.txt
cmake_minimum_required(VERSION 2.8)
project(tsecer)
add_executable(main main.cpp)
add_subdirectory(foo/bar)
tsecer@harry: cat src/foo/bar/CMakeLists.txt
cmake_minimum_required(VERSION 2.8)
add_library(simple bar.cpp)
add_library(complex bar.cpp)
tsecer@harry:
2、在build文件夹加执行cmake
tsecer@harry: cd build/
tsecer@harry: cmake ../src/
-- The C compiler identification is GNU 7.3.1
-- The CXX compiler identification is GNU 7.3.1
-- Check for working C compiler: /usr/lib64/ccache/cc
-- Check for working C compiler: /usr/lib64/ccache/cc - works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/lib64/ccache/c++
-- Check for working CXX compiler: /usr/lib64/ccache/c++ - works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/harry/study/cmake.gen.layout/build
tsecer@harry: tree
.
├── CMakeCache.txt
├── CMakeFiles
│ ├── 3.17.5
│ │ ├── CMakeCCompiler.cmake
│ │ ├── CMakeCXXCompiler.cmake
│ │ ├── CMakeDetermineCompilerABI_C.bin
│ │ ├── CMakeDetermineCompilerABI_CXX.bin
│ │ ├── CMakeSystem.cmake
│ │ ├── CompilerIdC
│ │ │ ├── a.out
│ │ │ ├── CMakeCCompilerId.c
│ │ │ └── tmp
│ │ └── CompilerIdCXX
│ │ ├── a.out
│ │ ├── CMakeCXXCompilerId.cpp
│ │ └── tmp
│ ├── cmake.check_cache
│ ├── CMakeDirectoryInformation.cmake
│ ├── CMakeOutput.log
│ ├── CMakeTmp
│ ├── main.dir
│ │ ├── build.make
│ │ ├── cmake_clean.cmake
│ │ ├── DependInfo.cmake
│ │ ├── depend.make
│ │ ├── flags.make
│ │ ├── link.txt
│ │ └── progress.make
│ ├── Makefile2
│ ├── Makefile.cmake
│ ├── progress.marks
│ └── TargetDirectories.txt
├── cmake_install.cmake
├── foo
│ └── bar
│ ├── CMakeFiles
│ │ ├── CMakeDirectoryInformation.cmake
│ │ ├── complex.dir
│ │ │ ├── build.make
│ │ │ ├── cmake_clean.cmake
│ │ │ ├── cmake_clean_target.cmake
│ │ │ ├── DependInfo.cmake
│ │ │ ├── depend.make
│ │ │ ├── flags.make
│ │ │ ├── link.txt
│ │ │ └── progress.make
│ │ ├── progress.marks
│ │ └── simple.dir
│ │ ├── build.make
│ │ ├── cmake_clean.cmake
│ │ ├── cmake_clean_target.cmake
│ │ ├── DependInfo.cmake
│ │ ├── depend.make
│ │ ├── flags.make
│ │ ├── link.txt
│ │ └── progress.make
│ ├── cmake_install.cmake
│ └── Makefile
└── Makefile
13 directories, 46 files
tsecer@harry:
3、生成构建文件夹结构
可以看到
a、生成文件夹的整体结构是源文件的结构的镜像：在源文件中，foo/bar文件夹在构建文件夹中也有。
b、每个包含CMakeLists.txt文件夹，在对应的构建文件夹中有Makefile和CMakeFiles文件夹。分别对应这个CMakeLists.txt中所有构建指令和构建输出。
c、在bar文件夹下的CMakeLists.txt中有两个目标：simple和complex，它们在CMakeFiles文件夹中有两个独立的、对应的simple.dir和complex.dir文件夹。这两个文件夹中有该目标的构建入口build.make文件