Mirror
/
Kitware-CMake
mirror of https://github.com/Kitware/CMake.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Merge topic 'revert-server-iface-sources' 

284a38e42f cmake-server: Revert "Support codemodel filegroups for INTERFACE_SOURCES"

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2495
pull/324/head
Brad King 7 years ago
committed by Kitware Robot
parent
aab69ccd9b 284a38e42f
commit
5b47557c82
4 changed files with 40 additions and 189 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      Help/manual/cmake-server.7.rst
  2. 1
      Source/cmJsonObjectDictionary.h
  3. 214
      Source/cmJsonObjects.cxx
  4. 7
      Source/cmServerProtocol.cxx

7
Help/manual/cmake-server.7.rst
View File

@ -308,9 +308,6 @@ which will result in a response type "reply"::
indicating that the server is ready for action.
Protocol version 1.3 introduces an optional flag on the target filegroup
that indicates if the filegroup represents :prop_tgt:`INTERFACE_SOURCES`.
Type "globalSettings"
^^^^^^^^^^^^^^^^^^^^^
@ -527,8 +524,6 @@ FileGroups are used to group sources using similar settings together.
Each fileGroup object may contain the following keys:
"isInterfaceSources"
true if the fileGroup represents :prop_tgt:`INTERFACE_SOURCES`.
"language"
contains the programming language used by all files in the group.
"compileFlags"
@ -543,8 +538,6 @@ Each fileGroup object may contain the following keys:
"defines"
with a list of defines in the form "SOMEVALUE" or "SOMEVALUE=42". This
value is encoded in the system's native shell format.
"isGenerated"
true if the files were generated.
"sources"
with a list of source files.

1
Source/cmJsonObjectDictionary.h
View File

@ -43,4 +43,3 @@ static const std::string kCTEST_COMMAND = "ctestCommand";
static const std::string kCTEST_INFO = "ctestInfo";
static const std::string kMINIMUM_CMAKE_VERSION = "minimumCMakeVersion";
static const std::string kIS_GENERATOR_PROVIDED_KEY = "isGeneratorProvided";
static const std::string kIS_INTERFACE_SOURCES_KEY = "isInterfaceSources";

214
Source/cmJsonObjects.cxx
View File

@ -150,8 +150,6 @@ Json::Value cmDumpCMakeInputs(const cmake* cm)
return array;
}
const std::string kInterfaceSourcesLanguageDataKey =
"INTERFACE_SOURCES_LD_KEY";
class LanguageData
{
public:
@ -184,12 +182,6 @@ void LanguageData::SetDefines(const std::set<std::string>& defines)
Defines = std::move(result);
}
struct FileGroupSources
{
bool IsInterfaceSources;
std::vector<std::string> Files;
};
namespace std {
template <>
@ -217,35 +209,31 @@ struct hash<LanguageData>
} // namespace std
static Json::Value DumpSourceFileGroup(const LanguageData& data,
bool isInterfaceSource,
const std::vector<std::string>& files,
const std::string& baseDir)
{
Json::Value result = Json::objectValue;
if (isInterfaceSource) {
result[kIS_INTERFACE_SOURCES_KEY] = true;
}
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 const& i : data.IncludePathList) {
Json::Value tmp = Json::objectValue;
tmp[kPATH_KEY] = i.first;
if (i.second) {
tmp[kIS_SYSTEM_KEY] = i.second;
if (!data.Flags.empty()) {
result[kCOMPILE_FLAGS_KEY] = data.Flags;
}
if (!data.IncludePathList.empty()) {
Json::Value includes = Json::arrayValue;
for (auto const& 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);
}
includes.append(tmp);
result[kINCLUDE_PATH_KEY] = includes;
}
if (!data.Defines.empty()) {
result[kDEFINES_KEY] = fromStringList(data.Defines);
}
result[kINCLUDE_PATH_KEY] = includes;
}
if (!data.Defines.empty()) {
result[kDEFINES_KEY] = fromStringList(data.Defines);
}
result[kIS_GENERATED_KEY] = data.IsGenerated;
@ -260,19 +248,21 @@ static Json::Value DumpSourceFileGroup(const LanguageData& data,
return result;
}
static void PopulateFileGroupData(
cmGeneratorTarget* target, bool isInterfaceSources,
const std::vector<cmSourceFile*>& files, const std::string& config,
const std::map<std::string, LanguageData>& languageDataMap,
std::unordered_map<LanguageData, FileGroupSources>& fileGroups)
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() || isInterfaceSources) {
const LanguageData& ld = isInterfaceSources
? languageDataMap.at(kInterfaceSourcesLanguageDataKey)
: languageDataMap.at(fileData.Language);
if (!fileData.Language.empty()) {
const LanguageData& ld = languageDataMap.at(fileData.Language);
cmLocalGenerator* lg = target->GetLocalGenerator();
cmGeneratorExpressionInterpreter genexInterpreter(lg, config, target,
fileData.Language);
@ -300,14 +290,10 @@ static void PopulateFileGroupData(
lg->AppendIncludeDirectories(includes, evaluatedIncludes, *file);
for (const auto& include : includes) {
// INTERFACE_LIBRARY targets do not support the
// IsSystemIncludeDirectory call so just set it to false.
const bool isSystemInclude = isInterfaceSources
? false
: target->IsSystemIncludeDirectory(include, config,
fileData.Language);
fileData.IncludePathList.push_back(
std::make_pair(include, isSystemInclude));
std::make_pair(include,
target->IsSystemIncludeDirectory(
include, config, fileData.Language)));
}
}
@ -336,71 +322,14 @@ static void PopulateFileGroupData(
}
fileData.IsGenerated = file->GetPropertyAsBool("GENERATED");
FileGroupSources& groupFileList = fileGroups[fileData];
groupFileList.IsInterfaceSources = isInterfaceSources;
groupFileList.Files.push_back(file->GetFullPath());
}
}
static Json::Value DumpSourceFilesList(
cmGeneratorTarget* target, const std::string& config,
const std::map<std::string, LanguageData>& languageDataMap)
{
const cmStateEnums::TargetType type = target->GetType();
std::unordered_map<LanguageData, FileGroupSources> fileGroups;
// Collect sourcefile groups:
std::vector<cmSourceFile*> files;
if (type == cmStateEnums::INTERFACE_LIBRARY) {
// INTERFACE_LIBRARY targets do not create all the data structures
// associated with regular targets. If properties are explicitly specified
// for files in INTERFACE_SOURCES then we can get them through the Makefile
// rather than the target.
files = target->Makefile->GetSourceFiles();
} else {
target->GetSourceFiles(files, config);
PopulateFileGroupData(target, false /* isInterfaceSources */, files,
config, languageDataMap, fileGroups);
}
// Collect interface sourcefile groups:
auto targetProp = target->Target->GetProperty("INTERFACE_SOURCES");
if (targetProp != nullptr) {
cmGeneratorExpressionInterpreter genexInterpreter(
target->GetLocalGenerator(), config, target);
auto evaluatedSources = cmsys::SystemTools::SplitString(
genexInterpreter.Evaluate(targetProp, "INTERFACE_SOURCES"), ';');
std::map<std::string, cmSourceFile*> filesMap;
for (auto file : files) {
filesMap[file->GetFullPath()] = file;
}
std::vector<cmSourceFile*> interfaceSourceFiles;
for (const std::string& interfaceSourceFilePath : evaluatedSources) {
auto entry = filesMap.find(interfaceSourceFilePath);
if (entry != filesMap.end()) {
// use what we have since it has all the associated properties
interfaceSourceFiles.push_back(entry->second);
} else {
interfaceSourceFiles.push_back(
new cmSourceFile(target->Makefile, interfaceSourceFilePath));
}
}
PopulateFileGroupData(target, true /* isInterfaceSources */,
interfaceSourceFiles, config, languageDataMap,
fileGroups);
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 const& it : fileGroups) {
Json::Value group = DumpSourceFileGroup(
it.first, it.second.IsInterfaceSources, it.second.Files, baseDir);
Json::Value group = DumpSourceFileGroup(it.first, it.second, baseDir);
if (!group.isNull()) {
result.append(group);
}
@ -517,58 +446,6 @@ Json::Value cmDumpCTestInfo(const cmake* cm)
return result;
}
static void GetTargetProperty(
cmGeneratorExpressionInterpreter& genexInterpreter,
cmGeneratorTarget* target, const char* propertyName,
std::vector<std::string>& propertyValue)
{
auto targetProp = target->Target->GetProperty(propertyName);
if (targetProp != nullptr) {
propertyValue = cmsys::SystemTools::SplitString(
genexInterpreter.Evaluate(targetProp, propertyName), ';');
}
}
static void CreateInterfaceSourcesEntry(
cmLocalGenerator* lg, cmGeneratorTarget* target, const std::string& config,
std::map<std::string, LanguageData>& languageDataMap)
{
LanguageData& ld = languageDataMap[kInterfaceSourcesLanguageDataKey];
ld.Language = "";
cmGeneratorExpressionInterpreter genexInterpreter(lg, config, target);
std::vector<std::string> propertyValue;
GetTargetProperty(genexInterpreter, target, "INTERFACE_INCLUDE_DIRECTORIES",
propertyValue);
for (std::string const& i : propertyValue) {
ld.IncludePathList.push_back(
std::make_pair(i, false /* isSystemInclude */));
}
propertyValue.clear();
GetTargetProperty(genexInterpreter, target,
"INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", propertyValue);
for (std::string const& i : propertyValue) {
ld.IncludePathList.push_back(
std::make_pair(i, true /* isSystemInclude */));
}
propertyValue.clear();
GetTargetProperty(genexInterpreter, target, "INTERFACE_COMPILE_OPTIONS",
propertyValue);
for (const auto& s : propertyValue) {
ld.Flags += " " + s;
}
propertyValue.clear();
GetTargetProperty(genexInterpreter, target, "INTERFACE_COMPILE_DEFINITIONS",
propertyValue);
if (!propertyValue.empty()) {
std::set<std::string> defines(propertyValue.begin(), propertyValue.end());
ld.SetDefines(defines);
}
}
static Json::Value DumpTarget(cmGeneratorTarget* target,
const std::string& config)
{
@ -598,6 +475,11 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
result[kTYPE_KEY] = typeName;
result[kSOURCE_DIRECTORY_KEY] = lg->GetCurrentSourceDirectory();
result[kBUILD_DIRECTORY_KEY] = lg->GetCurrentBinaryDirectory();
if (type == cmStateEnums::INTERFACE_LIBRARY) {
return result;
}
result[kFULL_NAME_KEY] = target->GetFullName(config);
if (target->Target->GetHaveInstallRule()) {
@ -684,21 +566,8 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
}
std::set<std::string> languages;
target->GetLanguages(languages, config);
std::map<std::string, LanguageData> languageDataMap;
if (type == cmStateEnums::INTERFACE_LIBRARY) {
// INTERFACE_LIBRARY targets do not create all the data structures
// associated with regular targets. If properties are explicitly specified
// for files in INTERFACE_SOURCES then we can get them through the Makefile
// rather than the target.
for (auto file : target->Makefile->GetSourceFiles()) {
const std::string& language = file->GetLanguage();
if (!language.empty()) {
languages.insert(language);
}
}
} else {
target->GetLanguages(languages, config);
}
for (std::string const& lang : languages) {
LanguageData& ld = languageDataMap[lang];
@ -715,11 +584,6 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
}
}
if (target->Target->GetProperty("INTERFACE_SOURCES") != nullptr) {
// Create an entry in the languageDataMap for interface sources.
CreateInterfaceSourcesEntry(lg, target, config, languageDataMap);
}
Json::Value sourceGroupsValue =
DumpSourceFilesList(target, config, languageDataMap);
if (!sourceGroupsValue.empty()) {

7
Source/cmServerProtocol.cxx
View File

@ -164,12 +164,7 @@ bool cmServerProtocol::DoActivate(const cmServerRequest& /*request*/,
std::pair<int, int> cmServerProtocol1::ProtocolVersion() const
{
// Revision history
// 1, 1 - Report backtraces in codemodel response
// 1, 2 - Add target install destinations to codemodel
// 1, 3 - Add a flag to target filegroups indicating whether or not the
// filegroup is for INTERFACE_SOURCES
return std::make_pair(1, 3);
return std::make_pair(1, 2);
}
static void setErrorMessage(std::string* errorMessage, const std::string& text)

Write Preview
Loading…
Cancel
Save