1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmFileAPIToolchains.h"
#include <memory>
#include <string>
#include <vector>
#include <cm3p/json/value.h>
#include "cmFileAPI.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmState.h"
#include "cmStringAlgorithms.h"
#include "cmValue.h"
#include "cmake.h"
namespace {
struct ToolchainVariable
{
std::string ObjectKey;
std::string VariableSuffix;
bool IsList;
};
class Toolchains
{
cmFileAPI& FileAPI;
unsigned long Version;
static const std::vector<ToolchainVariable> CompilerVariables;
static const std::vector<ToolchainVariable> CompilerImplicitVariables;
static const ToolchainVariable SourceFileExtensionsVariable;
Json::Value DumpToolchains();
Json::Value DumpToolchain(std::string const& lang);
Json::Value DumpToolchainVariables(
cmMakefile const* mf, std::string const& lang,
std::vector<ToolchainVariable> const& variables);
void DumpToolchainVariable(cmMakefile const* mf, Json::Value& object,
std::string const& lang,
ToolchainVariable const& variable);
public:
Toolchains(cmFileAPI& fileAPI, unsigned long version);
Json::Value Dump();
};
const std::vector<ToolchainVariable> Toolchains::CompilerVariables{
{ "path", "COMPILER", false },
{ "id", "COMPILER_ID", false },
{ "version", "COMPILER_VERSION", false },
{ "target", "COMPILER_TARGET", false },
};
const std::vector<ToolchainVariable> Toolchains::CompilerImplicitVariables{
{ "includeDirectories", "IMPLICIT_INCLUDE_DIRECTORIES", true },
{ "linkDirectories", "IMPLICIT_LINK_DIRECTORIES", true },
{ "linkFrameworkDirectories", "IMPLICIT_LINK_FRAMEWORK_DIRECTORIES", true },
{ "linkLibraries", "IMPLICIT_LINK_LIBRARIES", true },
};
const ToolchainVariable Toolchains::SourceFileExtensionsVariable{
"sourceFileExtensions", "SOURCE_FILE_EXTENSIONS", true
};
Toolchains::Toolchains(cmFileAPI& fileAPI, unsigned long version)
: FileAPI(fileAPI)
, Version(version)
{
static_cast<void>(this->Version);
}
Json::Value Toolchains::Dump()
{
Json::Value toolchains = Json::objectValue;
toolchains["toolchains"] = this->DumpToolchains();
return toolchains;
}
Json::Value Toolchains::DumpToolchains()
{
Json::Value toolchains = Json::arrayValue;
for (std::string const& lang :
this->FileAPI.GetCMakeInstance()->GetState()->GetEnabledLanguages()) {
toolchains.append(this->DumpToolchain(lang));
}
return toolchains;
}
Json::Value Toolchains::DumpToolchain(std::string const& lang)
{
const auto& mf =
this->FileAPI.GetCMakeInstance()->GetGlobalGenerator()->GetMakefiles()[0];
Json::Value toolchain = Json::objectValue;
toolchain["language"] = lang;
toolchain["compiler"] =
this->DumpToolchainVariables(mf.get(), lang, CompilerVariables);
toolchain["compiler"]["implicit"] =
this->DumpToolchainVariables(mf.get(), lang, CompilerImplicitVariables);
this->DumpToolchainVariable(mf.get(), toolchain, lang,
SourceFileExtensionsVariable);
return toolchain;
}
Json::Value Toolchains::DumpToolchainVariables(
cmMakefile const* mf, std::string const& lang,
std::vector<ToolchainVariable> const& variables)
{
Json::Value object = Json::objectValue;
for (const auto& variable : variables) {
this->DumpToolchainVariable(mf, object, lang, variable);
}
return object;
}
void Toolchains::DumpToolchainVariable(cmMakefile const* mf,
Json::Value& object,
std::string const& lang,
ToolchainVariable const& variable)
{
std::string const variableName =
cmStrCat("CMAKE_", lang, "_", variable.VariableSuffix);
if (variable.IsList) {
std::vector<std::string> values;
if (mf->GetDefExpandList(variableName, values)) {
Json::Value jsonArray = Json::arrayValue;
for (std::string const& value : values) {
jsonArray.append(value);
}
object[variable.ObjectKey] = jsonArray;
}
} else {
cmValue def = mf->GetDefinition(variableName);
if (def) {
object[variable.ObjectKey] = *def;
}
}
}
}
Json::Value cmFileAPIToolchainsDump(cmFileAPI& fileAPI, unsigned long version)
{
Toolchains toolchains(fileAPI, version);
return toolchains.Dump();
}
|
