You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
350 lines
11 KiB
350 lines
11 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmTargetSourcesCommand.h"
|
|
|
|
#include <sstream>
|
|
#include <utility>
|
|
|
|
#include <cm/string_view>
|
|
#include <cmext/string_view>
|
|
|
|
#include "cmArgumentParser.h"
|
|
#include "cmArgumentParserTypes.h"
|
|
#include "cmExperimental.h"
|
|
#include "cmFileSet.h"
|
|
#include "cmGeneratorExpression.h"
|
|
#include "cmListFileCache.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmMessageType.h"
|
|
#include "cmPolicies.h"
|
|
#include "cmStateTypes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTargetPropCommandBase.h"
|
|
|
|
namespace {
|
|
|
|
struct FileSetArgs
|
|
{
|
|
std::string Type;
|
|
std::string FileSet;
|
|
ArgumentParser::MaybeEmpty<std::vector<std::string>> BaseDirs;
|
|
ArgumentParser::MaybeEmpty<std::vector<std::string>> Files;
|
|
};
|
|
|
|
auto const FileSetArgsParser = cmArgumentParser<FileSetArgs>()
|
|
.Bind("TYPE"_s, &FileSetArgs::Type)
|
|
.Bind("FILE_SET"_s, &FileSetArgs::FileSet)
|
|
.Bind("BASE_DIRS"_s, &FileSetArgs::BaseDirs)
|
|
.Bind("FILES"_s, &FileSetArgs::Files);
|
|
|
|
struct FileSetsArgs
|
|
{
|
|
std::vector<std::vector<std::string>> FileSets;
|
|
};
|
|
|
|
auto const FileSetsArgsParser =
|
|
cmArgumentParser<FileSetsArgs>().Bind("FILE_SET"_s, &FileSetsArgs::FileSets);
|
|
|
|
class TargetSourcesImpl : public cmTargetPropCommandBase
|
|
{
|
|
public:
|
|
using cmTargetPropCommandBase::cmTargetPropCommandBase;
|
|
|
|
protected:
|
|
void HandleInterfaceContent(cmTarget* tgt,
|
|
const std::vector<std::string>& content,
|
|
bool prepend, bool system) override
|
|
{
|
|
this->cmTargetPropCommandBase::HandleInterfaceContent(
|
|
tgt,
|
|
this->ConvertToAbsoluteContent(tgt, content, IsInterface::Yes,
|
|
CheckCMP0076::Yes),
|
|
prepend, system);
|
|
}
|
|
|
|
private:
|
|
void HandleMissingTarget(const std::string& name) override
|
|
{
|
|
this->Makefile->IssueMessage(
|
|
MessageType::FATAL_ERROR,
|
|
cmStrCat("Cannot specify sources for target \"", name,
|
|
"\" which is not built by this project."));
|
|
}
|
|
|
|
bool HandleDirectContent(cmTarget* tgt,
|
|
const std::vector<std::string>& content,
|
|
bool /*prepend*/, bool /*system*/) override
|
|
{
|
|
tgt->AppendProperty("SOURCES",
|
|
this->Join(this->ConvertToAbsoluteContent(
|
|
tgt, content, IsInterface::No, CheckCMP0076::Yes)),
|
|
this->Makefile->GetBacktrace());
|
|
return true; // Successfully handled.
|
|
}
|
|
|
|
bool PopulateTargetProperties(const std::string& scope,
|
|
const std::vector<std::string>& content,
|
|
bool prepend, bool system) override
|
|
{
|
|
if (!content.empty() && content.front() == "FILE_SET"_s) {
|
|
return this->HandleFileSetMode(scope, content);
|
|
}
|
|
return this->cmTargetPropCommandBase::PopulateTargetProperties(
|
|
scope, content, prepend, system);
|
|
}
|
|
|
|
std::string Join(const std::vector<std::string>& content) override
|
|
{
|
|
return cmJoin(content, ";");
|
|
}
|
|
|
|
enum class IsInterface
|
|
{
|
|
Yes,
|
|
No,
|
|
};
|
|
enum class CheckCMP0076
|
|
{
|
|
Yes,
|
|
No,
|
|
};
|
|
std::vector<std::string> ConvertToAbsoluteContent(
|
|
cmTarget* tgt, const std::vector<std::string>& content,
|
|
IsInterface isInterfaceContent, CheckCMP0076 checkCmp0076);
|
|
|
|
bool HandleFileSetMode(const std::string& scope,
|
|
const std::vector<std::string>& content);
|
|
bool HandleOneFileSet(const std::string& scope,
|
|
const std::vector<std::string>& content);
|
|
};
|
|
|
|
std::vector<std::string> TargetSourcesImpl::ConvertToAbsoluteContent(
|
|
cmTarget* tgt, const std::vector<std::string>& content,
|
|
IsInterface isInterfaceContent, CheckCMP0076 checkCmp0076)
|
|
{
|
|
// Skip conversion in case old behavior has been explicitly requested
|
|
if (checkCmp0076 == CheckCMP0076::Yes &&
|
|
this->Makefile->GetPolicyStatus(cmPolicies::CMP0076) ==
|
|
cmPolicies::OLD) {
|
|
return content;
|
|
}
|
|
|
|
bool changedPath = false;
|
|
std::vector<std::string> absoluteContent;
|
|
absoluteContent.reserve(content.size());
|
|
for (std::string const& src : content) {
|
|
std::string absoluteSrc;
|
|
if (cmSystemTools::FileIsFullPath(src) ||
|
|
cmGeneratorExpression::Find(src) == 0 ||
|
|
(isInterfaceContent == IsInterface::No &&
|
|
(this->Makefile->GetCurrentSourceDirectory() ==
|
|
tgt->GetMakefile()->GetCurrentSourceDirectory()))) {
|
|
absoluteSrc = src;
|
|
} else {
|
|
changedPath = true;
|
|
absoluteSrc =
|
|
cmStrCat(this->Makefile->GetCurrentSourceDirectory(), '/', src);
|
|
}
|
|
absoluteContent.push_back(absoluteSrc);
|
|
}
|
|
|
|
if (!changedPath) {
|
|
return content;
|
|
}
|
|
|
|
bool issueMessage = true;
|
|
bool useAbsoluteContent = false;
|
|
std::ostringstream e;
|
|
if (checkCmp0076 == CheckCMP0076::Yes) {
|
|
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0076)) {
|
|
case cmPolicies::WARN:
|
|
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0076) << "\n";
|
|
break;
|
|
case cmPolicies::OLD:
|
|
issueMessage = false;
|
|
break;
|
|
case cmPolicies::REQUIRED_ALWAYS:
|
|
case cmPolicies::REQUIRED_IF_USED:
|
|
this->Makefile->IssueMessage(
|
|
MessageType::FATAL_ERROR,
|
|
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0076));
|
|
break;
|
|
case cmPolicies::NEW: {
|
|
issueMessage = false;
|
|
useAbsoluteContent = true;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
issueMessage = false;
|
|
useAbsoluteContent = true;
|
|
}
|
|
|
|
if (issueMessage) {
|
|
if (isInterfaceContent == IsInterface::Yes) {
|
|
e << "An interface source of target \"" << tgt->GetName()
|
|
<< "\" has a relative path.";
|
|
} else {
|
|
e << "A private source from a directory other than that of target \""
|
|
<< tgt->GetName() << "\" has a relative path.";
|
|
}
|
|
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, e.str());
|
|
}
|
|
|
|
return useAbsoluteContent ? absoluteContent : content;
|
|
}
|
|
|
|
bool TargetSourcesImpl::HandleFileSetMode(
|
|
const std::string& scope, const std::vector<std::string>& content)
|
|
{
|
|
auto args = FileSetsArgsParser.Parse(content, /*unparsedArguments=*/nullptr);
|
|
|
|
for (auto& argList : args.FileSets) {
|
|
argList.emplace(argList.begin(), "FILE_SET"_s);
|
|
if (!this->HandleOneFileSet(scope, argList)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TargetSourcesImpl::HandleOneFileSet(
|
|
const std::string& scope, const std::vector<std::string>& content)
|
|
{
|
|
std::vector<std::string> unparsed;
|
|
auto args = FileSetArgsParser.Parse(content, &unparsed);
|
|
|
|
if (!unparsed.empty()) {
|
|
this->SetError(
|
|
cmStrCat("Unrecognized keyword: \"", unparsed.front(), "\""));
|
|
return false;
|
|
}
|
|
|
|
if (args.FileSet.empty()) {
|
|
this->SetError("FILE_SET must not be empty");
|
|
return false;
|
|
}
|
|
|
|
if (this->Target->GetType() == cmStateEnums::UTILITY) {
|
|
this->SetError("FILE_SETs may not be added to custom targets");
|
|
return false;
|
|
}
|
|
if (this->Target->IsFrameworkOnApple()) {
|
|
this->SetError("FILE_SETs may not be added to FRAMEWORK targets");
|
|
return false;
|
|
}
|
|
|
|
bool const isDefault = args.Type == args.FileSet ||
|
|
(args.Type.empty() && args.FileSet[0] >= 'A' && args.FileSet[0] <= 'Z');
|
|
std::string type = isDefault ? args.FileSet : args.Type;
|
|
|
|
cmFileSetVisibility visibility =
|
|
cmFileSetVisibilityFromName(scope, this->Makefile);
|
|
|
|
auto fileSet =
|
|
this->Target->GetOrCreateFileSet(args.FileSet, type, visibility);
|
|
if (fileSet.second) {
|
|
if (!isDefault) {
|
|
if (!cmFileSet::IsValidName(args.FileSet)) {
|
|
this->SetError("Non-default file set name must contain only letters, "
|
|
"numbers, and underscores, and must not start with a "
|
|
"capital letter or underscore");
|
|
return false;
|
|
}
|
|
}
|
|
if (type.empty()) {
|
|
this->SetError("Must specify a TYPE when creating file set");
|
|
return false;
|
|
}
|
|
bool const supportCxx20FileSetTypes = cmExperimental::HasSupportEnabled(
|
|
*this->Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
|
|
|
|
if (supportCxx20FileSetTypes) {
|
|
if (type != "HEADERS"_s && type != "CXX_MODULES"_s &&
|
|
type != "CXX_MODULE_HEADER_UNITS"_s) {
|
|
this->SetError(
|
|
R"(File set TYPE may only be "HEADERS", "CXX_MODULES", or "CXX_MODULE_HEADER_UNITS")");
|
|
return false;
|
|
}
|
|
|
|
if (cmFileSetVisibilityIsForInterface(visibility) &&
|
|
!cmFileSetVisibilityIsForSelf(visibility) &&
|
|
!this->Target->IsImported()) {
|
|
if (type == "CXX_MODULES"_s || type == "CXX_MODULE_HEADER_UNITS"_s) {
|
|
this->SetError(
|
|
R"(File set TYPEs "CXX_MODULES" and "CXX_MODULE_HEADER_UNITS" may not have "INTERFACE" visibility)");
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
if (type != "HEADERS"_s) {
|
|
this->SetError("File set TYPE may only be \"HEADERS\"");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (args.BaseDirs.empty()) {
|
|
args.BaseDirs.emplace_back(this->Makefile->GetCurrentSourceDirectory());
|
|
}
|
|
} else {
|
|
type = fileSet.first->GetType();
|
|
if (!args.Type.empty() && args.Type != type) {
|
|
this->SetError(cmStrCat(
|
|
"Type \"", args.Type, "\" for file set \"", fileSet.first->GetName(),
|
|
"\" does not match original type \"", type, "\""));
|
|
return false;
|
|
}
|
|
|
|
if (visibility != fileSet.first->GetVisibility()) {
|
|
this->SetError(
|
|
cmStrCat("Scope ", scope, " for file set \"", args.FileSet,
|
|
"\" does not match original scope ",
|
|
cmFileSetVisibilityToName(fileSet.first->GetVisibility())));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto files = this->Join(this->ConvertToAbsoluteContent(
|
|
this->Target, args.Files, IsInterface::Yes, CheckCMP0076::No));
|
|
if (!files.empty()) {
|
|
fileSet.first->AddFileEntry(
|
|
BT<std::string>(files, this->Makefile->GetBacktrace()));
|
|
}
|
|
|
|
auto baseDirectories = this->Join(this->ConvertToAbsoluteContent(
|
|
this->Target, args.BaseDirs, IsInterface::Yes, CheckCMP0076::No));
|
|
if (!baseDirectories.empty()) {
|
|
fileSet.first->AddDirectoryEntry(
|
|
BT<std::string>(baseDirectories, this->Makefile->GetBacktrace()));
|
|
if (type == "HEADERS"_s || type == "CXX_MODULE_HEADER_UNITS"_s) {
|
|
for (auto const& dir : cmExpandedList(baseDirectories)) {
|
|
auto interfaceDirectoriesGenex =
|
|
cmStrCat("$<BUILD_INTERFACE:", dir, ">");
|
|
if (cmFileSetVisibilityIsForSelf(visibility)) {
|
|
this->Target->AppendProperty("INCLUDE_DIRECTORIES",
|
|
interfaceDirectoriesGenex,
|
|
this->Makefile->GetBacktrace());
|
|
}
|
|
if (cmFileSetVisibilityIsForInterface(visibility)) {
|
|
this->Target->AppendProperty("INTERFACE_INCLUDE_DIRECTORIES",
|
|
interfaceDirectoriesGenex,
|
|
this->Makefile->GetBacktrace());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool cmTargetSourcesCommand(std::vector<std::string> const& args,
|
|
cmExecutionStatus& status)
|
|
{
|
|
return TargetSourcesImpl(status).HandleArguments(args, "SOURCES");
|
|
}
|