|
|
@@ -3,9 +3,13 @@
|
|
|
#include "cmServerProtocol.h"
|
|
|
|
|
|
#include "cmExternalMakefileProjectGenerator.h"
|
|
|
+#include "cmGeneratorTarget.h"
|
|
|
#include "cmGlobalGenerator.h"
|
|
|
+#include "cmLocalGenerator.h"
|
|
|
+#include "cmMakefile.h"
|
|
|
#include "cmServer.h"
|
|
|
#include "cmServerDictionary.h"
|
|
|
+#include "cmSourceFile.h"
|
|
|
#include "cmSystemTools.h"
|
|
|
#include "cmake.h"
|
|
|
|
|
|
@@ -16,6 +20,49 @@
|
|
|
#include "cm_jsoncpp_value.h"
|
|
|
#endif
|
|
|
|
|
|
+#include <algorithm>
|
|
|
+#include <string>
|
|
|
+#include <vector>
|
|
|
+
|
|
|
+// Get rid of some windows macros:
|
|
|
+#undef max
|
|
|
+
|
|
|
+namespace {
|
|
|
+
|
|
|
+static std::vector<std::string> getConfigurations(const cmake* cm)
|
|
|
+{
|
|
|
+ std::vector<std::string> configurations;
|
|
|
+ auto makefiles = cm->GetGlobalGenerator()->GetMakefiles();
|
|
|
+ if (makefiles.empty()) {
|
|
|
+ return configurations;
|
|
|
+ }
|
|
|
+
|
|
|
+ makefiles[0]->GetConfigurations(configurations);
|
|
|
+ if (configurations.empty())
|
|
|
+ configurations.push_back("");
|
|
|
+ return configurations;
|
|
|
+}
|
|
|
+
|
|
|
+static bool hasString(const Json::Value& v, const std::string& s)
|
|
|
+{
|
|
|
+ return !v.isNull() &&
|
|
|
+ std::find_if(v.begin(), v.end(), [s](const Json::Value& i) {
|
|
|
+ return i.asString() == s;
|
|
|
+ }) != v.end();
|
|
|
+}
|
|
|
+
|
|
|
+template <class T>
|
|
|
+static Json::Value fromStringList(const T& in)
|
|
|
+{
|
|
|
+ Json::Value result = Json::arrayValue;
|
|
|
+ for (const std::string& i : in) {
|
|
|
+ result.append(i);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace
|
|
|
+
|
|
|
cmServerRequest::cmServerRequest(cmServer* server, const std::string& t,
|
|
|
const std::string& c, const Json::Value& d)
|
|
|
: Type(t)
|
|
|
@@ -270,6 +317,9 @@ const cmServerResponse cmServerProtocol1_0::Process(
|
|
|
{
|
|
|
assert(this->m_State >= STATE_ACTIVE);
|
|
|
|
|
|
+ if (request.Type == kCODE_MODEL_TYPE) {
|
|
|
+ return this->ProcessCodeModel(request);
|
|
|
+ }
|
|
|
if (request.Type == kCOMPUTE_TYPE) {
|
|
|
return this->ProcessCompute(request);
|
|
|
}
|
|
|
@@ -291,6 +341,342 @@ bool cmServerProtocol1_0::IsExperimental() const
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
+class LanguageData
|
|
|
+{
|
|
|
+public:
|
|
|
+ bool operator==(const LanguageData& other) const;
|
|
|
+
|
|
|
+ void SetDefines(const std::set<std::string>& defines);
|
|
|
+
|
|
|
+ bool IsGenerated = false;
|
|
|
+ std::string Language;
|
|
|
+ std::string Flags;
|
|
|
+ std::vector<std::string> Defines;
|
|
|
+ std::vector<std::pair<std::string, bool> > IncludePathList;
|
|
|
+};
|
|
|
+
|
|
|
+bool LanguageData::operator==(const LanguageData& other) const
|
|
|
+{
|
|
|
+ return Language == other.Language && Defines == other.Defines &&
|
|
|
+ Flags == other.Flags && IncludePathList == other.IncludePathList &&
|
|
|
+ IsGenerated == other.IsGenerated;
|
|
|
+}
|
|
|
+
|
|
|
+void LanguageData::SetDefines(const std::set<std::string>& defines)
|
|
|
+{
|
|
|
+ std::vector<std::string> result;
|
|
|
+ for (auto i : defines) {
|
|
|
+ result.push_back(i);
|
|
|
+ }
|
|
|
+ std::sort(result.begin(), result.end());
|
|
|
+ Defines = result;
|
|
|
+}
|
|
|
+
|
|
|
+namespace std {
|
|
|
+
|
|
|
+template <>
|
|
|
+struct hash<LanguageData>
|
|
|
+{
|
|
|
+ std::size_t operator()(const LanguageData& in) const
|
|
|
+ {
|
|
|
+ using std::hash;
|
|
|
+ size_t result =
|
|
|
+ hash<std::string>()(in.Language) ^ hash<std::string>()(in.Flags);
|
|
|
+ for (auto i : in.IncludePathList) {
|
|
|
+ result = result ^ (hash<std::string>()(i.first) ^
|
|
|
+ (i.second ? std::numeric_limits<size_t>::max() : 0));
|
|
|
+ }
|
|
|
+ for (auto i : in.Defines) {
|
|
|
+ result = result ^ hash<std::string>()(i);
|
|
|
+ }
|
|
|
+ result =
|
|
|
+ result ^ (in.IsGenerated ? std::numeric_limits<size_t>::max() : 0);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+} // namespace std
|
|
|
+
|
|
|
+static Json::Value DumpSourceFileGroup(const LanguageData& data,
|
|
|
+ const std::vector<std::string>& files,
|
|
|
+ const std::string& baseDir)
|
|
|
+{
|
|
|
+ Json::Value result = Json::objectValue;
|
|
|
+
|
|
|
+ if (!data.Language.empty()) {
|
|
|
+ result[kLANGUAGE_KEY] = data.Language;
|
|
|
+ if (!data.Flags.empty()) {
|
|
|
+ result[kCOMPILE_FLAGS_KEY] = data.Flags;
|
|
|
+ }
|
|
|
+ if (!data.IncludePathList.empty()) {
|
|
|
+ Json::Value includes = Json::arrayValue;
|
|
|
+ for (auto i : data.IncludePathList) {
|
|
|
+ Json::Value tmp = Json::objectValue;
|
|
|
+ tmp[kPATH_KEY] = i.first;
|
|
|
+ if (i.second) {
|
|
|
+ tmp[kIS_SYSTEM_KEY] = i.second;
|
|
|
+ }
|
|
|
+ includes.append(tmp);
|
|
|
+ }
|
|
|
+ result[kINCLUDE_PATH_KEY] = includes;
|
|
|
+ }
|
|
|
+ if (!data.Defines.empty()) {
|
|
|
+ result[kDEFINES_KEY] = fromStringList(data.Defines);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ result[kIS_GENERATED_KEY] = data.IsGenerated;
|
|
|
+
|
|
|
+ Json::Value sourcesValue = Json::arrayValue;
|
|
|
+ for (auto i : files) {
|
|
|
+ const std::string relPath =
|
|
|
+ cmSystemTools::RelativePath(baseDir.c_str(), i.c_str());
|
|
|
+ sourcesValue.append(relPath.size() < i.size() ? relPath : i);
|
|
|
+ }
|
|
|
+
|
|
|
+ result[kSOURCES_KEY] = sourcesValue;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpSourceFilesList(
|
|
|
+ cmGeneratorTarget* target, const std::string& config,
|
|
|
+ const std::map<std::string, LanguageData>& languageDataMap)
|
|
|
+{
|
|
|
+ // Collect sourcefile groups:
|
|
|
+
|
|
|
+ std::vector<cmSourceFile*> files;
|
|
|
+ target->GetSourceFiles(files, config);
|
|
|
+
|
|
|
+ std::unordered_map<LanguageData, std::vector<std::string> > fileGroups;
|
|
|
+ for (cmSourceFile* file : files) {
|
|
|
+ LanguageData fileData;
|
|
|
+ fileData.Language = file->GetLanguage();
|
|
|
+ if (!fileData.Language.empty()) {
|
|
|
+ const LanguageData& ld = languageDataMap.at(fileData.Language);
|
|
|
+ cmLocalGenerator* lg = target->GetLocalGenerator();
|
|
|
+
|
|
|
+ std::string compileFlags = ld.Flags;
|
|
|
+ lg->AppendFlags(compileFlags, file->GetProperty("COMPILE_FLAGS"));
|
|
|
+ fileData.Flags = compileFlags;
|
|
|
+
|
|
|
+ fileData.IncludePathList = ld.IncludePathList;
|
|
|
+
|
|
|
+ std::set<std::string> defines;
|
|
|
+ lg->AppendDefines(defines, file->GetProperty("COMPILE_DEFINITIONS"));
|
|
|
+ const std::string defPropName =
|
|
|
+ "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config);
|
|
|
+ lg->AppendDefines(defines, file->GetProperty(defPropName));
|
|
|
+ defines.insert(ld.Defines.begin(), ld.Defines.end());
|
|
|
+
|
|
|
+ fileData.SetDefines(defines);
|
|
|
+ }
|
|
|
+
|
|
|
+ fileData.IsGenerated = file->GetPropertyAsBool("GENERATED");
|
|
|
+ std::vector<std::string>& groupFileList = fileGroups[fileData];
|
|
|
+ groupFileList.push_back(file->GetFullPath());
|
|
|
+ }
|
|
|
+
|
|
|
+ const std::string baseDir = target->Makefile->GetCurrentSourceDirectory();
|
|
|
+ Json::Value result = Json::arrayValue;
|
|
|
+ for (auto it = fileGroups.begin(); it != fileGroups.end(); ++it) {
|
|
|
+ Json::Value group = DumpSourceFileGroup(it->first, it->second, baseDir);
|
|
|
+ if (!group.isNull())
|
|
|
+ result.append(group);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpTarget(cmGeneratorTarget* target,
|
|
|
+ const std::string& config)
|
|
|
+{
|
|
|
+ cmLocalGenerator* lg = target->GetLocalGenerator();
|
|
|
+ const cmState* state = lg->GetState();
|
|
|
+
|
|
|
+ const cmState::TargetType type = target->GetType();
|
|
|
+ const std::string typeName = state->GetTargetTypeName(type);
|
|
|
+
|
|
|
+ Json::Value ttl = Json::arrayValue;
|
|
|
+ ttl.append("EXECUTABLE");
|
|
|
+ ttl.append("STATIC_LIBRARY");
|
|
|
+ ttl.append("SHARED_LIBRARY");
|
|
|
+ ttl.append("MODULE_LIBRARY");
|
|
|
+ ttl.append("OBJECT_LIBRARY");
|
|
|
+ ttl.append("UTILITY");
|
|
|
+ ttl.append("INTERFACE_LIBRARY");
|
|
|
+
|
|
|
+ if (!hasString(ttl, typeName) || target->IsImported()) {
|
|
|
+ return Json::Value();
|
|
|
+ }
|
|
|
+
|
|
|
+ Json::Value result = Json::objectValue;
|
|
|
+ result[kNAME_KEY] = target->GetName();
|
|
|
+
|
|
|
+ result[kTYPE_KEY] = typeName;
|
|
|
+ result[kFULL_NAME_KEY] = target->GetFullName(config);
|
|
|
+ result[kSOURCE_DIRECTORY_KEY] = lg->GetCurrentSourceDirectory();
|
|
|
+ result[kBUILD_DIRECTORY_KEY] = lg->GetCurrentBinaryDirectory();
|
|
|
+
|
|
|
+ if (target->HaveWellDefinedOutputFiles()) {
|
|
|
+ Json::Value artifacts = Json::arrayValue;
|
|
|
+ artifacts.append(target->GetFullPath(config, false));
|
|
|
+ if (target->IsDLLPlatform()) {
|
|
|
+ artifacts.append(target->GetFullPath(config, true));
|
|
|
+ const cmGeneratorTarget::OutputInfo* output =
|
|
|
+ target->GetOutputInfo(config);
|
|
|
+ if (output && !output->PdbDir.empty()) {
|
|
|
+ artifacts.append(output->PdbDir + '/' + target->GetPDBName(config));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ result[kARTIFACTS_KEY] = artifacts;
|
|
|
+
|
|
|
+ result[kLINKER_LANGUAGE_KEY] = target->GetLinkerLanguage(config);
|
|
|
+
|
|
|
+ std::string linkLibs;
|
|
|
+ std::string linkFlags;
|
|
|
+ std::string linkLanguageFlags;
|
|
|
+ std::string frameworkPath;
|
|
|
+ std::string linkPath;
|
|
|
+ lg->GetTargetFlags(config, linkLibs, linkLanguageFlags, linkFlags,
|
|
|
+ frameworkPath, linkPath, target, false);
|
|
|
+
|
|
|
+ linkLibs = cmSystemTools::TrimWhitespace(linkLibs);
|
|
|
+ linkFlags = cmSystemTools::TrimWhitespace(linkFlags);
|
|
|
+ linkLanguageFlags = cmSystemTools::TrimWhitespace(linkLanguageFlags);
|
|
|
+ frameworkPath = cmSystemTools::TrimWhitespace(frameworkPath);
|
|
|
+ linkPath = cmSystemTools::TrimWhitespace(linkPath);
|
|
|
+
|
|
|
+ if (!cmSystemTools::TrimWhitespace(linkLibs).empty()) {
|
|
|
+ result[kLINK_LIBRARIES_KEY] = linkLibs;
|
|
|
+ }
|
|
|
+ if (!cmSystemTools::TrimWhitespace(linkFlags).empty()) {
|
|
|
+ result[kLINK_FLAGS_KEY] = linkFlags;
|
|
|
+ }
|
|
|
+ if (!cmSystemTools::TrimWhitespace(linkLanguageFlags).empty()) {
|
|
|
+ result[kLINK_LANGUAGE_FLAGS_KEY] = linkLanguageFlags;
|
|
|
+ }
|
|
|
+ if (!frameworkPath.empty()) {
|
|
|
+ result[kFRAMEWORK_PATH_KEY] = frameworkPath;
|
|
|
+ }
|
|
|
+ if (!linkPath.empty()) {
|
|
|
+ result[kLINK_PATH_KEY] = linkPath;
|
|
|
+ }
|
|
|
+ const std::string sysroot =
|
|
|
+ lg->GetMakefile()->GetSafeDefinition("CMAKE_SYSROOT");
|
|
|
+ if (!sysroot.empty()) {
|
|
|
+ result[kSYSROOT_KEY] = sysroot;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ std::set<std::string> languages;
|
|
|
+ target->GetLanguages(languages, config);
|
|
|
+ std::map<std::string, LanguageData> languageDataMap;
|
|
|
+ for (auto lang : languages) {
|
|
|
+ LanguageData& ld = languageDataMap[lang];
|
|
|
+ ld.Language = lang;
|
|
|
+ lg->GetTargetCompileFlags(target, config, lang, ld.Flags);
|
|
|
+ std::set<std::string> defines;
|
|
|
+ lg->GetTargetDefines(target, config, lang, defines);
|
|
|
+ ld.SetDefines(defines);
|
|
|
+ std::vector<std::string> includePathList;
|
|
|
+ lg->GetIncludeDirectories(includePathList, target, lang, config, true);
|
|
|
+ for (auto i : includePathList) {
|
|
|
+ ld.IncludePathList.push_back(
|
|
|
+ std::make_pair(i, target->IsSystemIncludeDirectory(i, config)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Json::Value sourceGroupsValue =
|
|
|
+ DumpSourceFilesList(target, config, languageDataMap);
|
|
|
+ if (!sourceGroupsValue.empty()) {
|
|
|
+ result[kFILE_GROUPS_KEY] = sourceGroupsValue;
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpTargetsList(
|
|
|
+ const std::vector<cmLocalGenerator*>& generators, const std::string& config)
|
|
|
+{
|
|
|
+ Json::Value result = Json::arrayValue;
|
|
|
+
|
|
|
+ std::vector<cmGeneratorTarget*> targetList;
|
|
|
+ for (const auto& lgIt : generators) {
|
|
|
+ auto list = lgIt->GetGeneratorTargets();
|
|
|
+ targetList.insert(targetList.end(), list.begin(), list.end());
|
|
|
+ }
|
|
|
+ std::sort(targetList.begin(), targetList.end());
|
|
|
+
|
|
|
+ for (cmGeneratorTarget* target : targetList) {
|
|
|
+ Json::Value tmp = DumpTarget(target, config);
|
|
|
+ if (!tmp.isNull()) {
|
|
|
+ result.append(tmp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpProjectList(const cmake* cm, const std::string config)
|
|
|
+{
|
|
|
+ Json::Value result = Json::arrayValue;
|
|
|
+
|
|
|
+ auto globalGen = cm->GetGlobalGenerator();
|
|
|
+
|
|
|
+ for (const auto& projectIt : globalGen->GetProjectMap()) {
|
|
|
+ Json::Value pObj = Json::objectValue;
|
|
|
+ pObj[kNAME_KEY] = projectIt.first;
|
|
|
+
|
|
|
+ assert(projectIt.second.size() >
|
|
|
+ 0); // All Projects must have at least one local generator
|
|
|
+ const cmLocalGenerator* lg = projectIt.second.at(0);
|
|
|
+
|
|
|
+ // Project structure information:
|
|
|
+ const cmMakefile* mf = lg->GetMakefile();
|
|
|
+ pObj[kSOURCE_DIRECTORY_KEY] = mf->GetCurrentSourceDirectory();
|
|
|
+ pObj[kBUILD_DIRECTORY_KEY] = mf->GetCurrentBinaryDirectory();
|
|
|
+ pObj[kTARGETS_KEY] = DumpTargetsList(projectIt.second, config);
|
|
|
+
|
|
|
+ result.append(pObj);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpConfiguration(const cmake* cm,
|
|
|
+ const std::string& config)
|
|
|
+{
|
|
|
+ Json::Value result = Json::objectValue;
|
|
|
+ result[kNAME_KEY] = config;
|
|
|
+
|
|
|
+ result[kPROJECTS_KEY] = DumpProjectList(cm, config);
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Json::Value DumpConfigurationsList(const cmake* cm)
|
|
|
+{
|
|
|
+ Json::Value result = Json::arrayValue;
|
|
|
+
|
|
|
+ for (const std::string& c : getConfigurations(cm)) {
|
|
|
+ result.append(DumpConfiguration(cm, c));
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+cmServerResponse cmServerProtocol1_0::ProcessCodeModel(
|
|
|
+ const cmServerRequest& request)
|
|
|
+{
|
|
|
+ if (this->m_State != STATE_COMPUTED) {
|
|
|
+ return request.ReportError("No build system was generated yet.");
|
|
|
+ }
|
|
|
+
|
|
|
+ Json::Value result = Json::objectValue;
|
|
|
+ result[kCONFIGURATIONS_KEY] = DumpConfigurationsList(this->CMakeInstance());
|
|
|
+ return request.Reply(result);
|
|
|
+}
|
|
|
+
|
|
|
cmServerResponse cmServerProtocol1_0::ProcessCompute(
|
|
|
const cmServerRequest& request)
|
|
|
{
|
Tobias Hunger