mirror of
https://github.com/reactos/CMake.git
synced 2025-01-10 05:31:02 +00:00
c3fb0d95ad
The GetProperty method is now just accessing contained data, meaning it can be implemented in cmState. Remove the cmMakefile context from the signature as a result and remove the overload with the same signature. Add a GetComputedProperty to cmTarget so that templates can be properly instantiated. Otherwise the Commands would need to be able to reach the specializations which are currently in cmTarget.cxx. As a side-effect, the CMP0026 warning now gives a backtrace to the target when issued from a generator expression.
345 lines
11 KiB
C++
345 lines
11 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#ifndef cmTarget_h
|
|
#define cmTarget_h
|
|
|
|
#include <cmConfigure.h> // IWYU pragma: keep
|
|
|
|
#include "cmAlgorithms.h"
|
|
#include "cmCustomCommand.h"
|
|
#include "cmListFileCache.h"
|
|
#include "cmPolicies.h"
|
|
#include "cmPropertyMap.h"
|
|
#include "cmState.h"
|
|
#include "cmTargetLinkLibraryType.h"
|
|
|
|
#include <iosfwd>
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
|
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
|
|
#include <unordered_map>
|
|
#else
|
|
#include <cmsys/hash_map.hxx>
|
|
#endif
|
|
#endif
|
|
|
|
class cmMakefile;
|
|
class cmSourceFile;
|
|
class cmGlobalGenerator;
|
|
class cmTargetInternals;
|
|
|
|
class cmTargetInternalPointer
|
|
{
|
|
public:
|
|
cmTargetInternalPointer();
|
|
cmTargetInternalPointer(cmTargetInternalPointer const& r);
|
|
~cmTargetInternalPointer();
|
|
cmTargetInternalPointer& operator=(cmTargetInternalPointer const& r);
|
|
cmTargetInternals* operator->() const { return this->Pointer; }
|
|
cmTargetInternals* Get() const { return this->Pointer; }
|
|
private:
|
|
cmTargetInternals* Pointer;
|
|
};
|
|
|
|
/** \class cmTarget
|
|
* \brief Represent a library or executable target loaded from a makefile.
|
|
*
|
|
* cmTarget represents a target loaded from
|
|
* a makefile.
|
|
*/
|
|
class cmTarget
|
|
{
|
|
public:
|
|
enum Visibility
|
|
{
|
|
VisibilityNormal,
|
|
VisibilityImported,
|
|
VisibilityImportedGlobally
|
|
};
|
|
|
|
cmTarget(std::string const& name, cmState::TargetType type, Visibility vis,
|
|
cmMakefile* mf);
|
|
|
|
enum CustomCommandType
|
|
{
|
|
PRE_BUILD,
|
|
PRE_LINK,
|
|
POST_BUILD
|
|
};
|
|
|
|
/**
|
|
* Return the type of target.
|
|
*/
|
|
cmState::TargetType GetType() const { return this->TargetTypeValue; }
|
|
|
|
cmGlobalGenerator* GetGlobalGenerator() const;
|
|
|
|
///! Set/Get the name of the target
|
|
const std::string& GetName() const { return this->Name; }
|
|
|
|
/** Get the cmMakefile that owns this target. */
|
|
cmMakefile* GetMakefile() const { return this->Makefile; }
|
|
|
|
#define DECLARE_TARGET_POLICY(POLICY) \
|
|
cmPolicies::PolicyStatus GetPolicyStatus##POLICY() const \
|
|
{ \
|
|
return this->PolicyMap.Get(cmPolicies::POLICY); \
|
|
}
|
|
|
|
CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY)
|
|
|
|
#undef DECLARE_TARGET_POLICY
|
|
|
|
/**
|
|
* Get the list of the custom commands for this target
|
|
*/
|
|
std::vector<cmCustomCommand> const& GetPreBuildCommands() const
|
|
{
|
|
return this->PreBuildCommands;
|
|
}
|
|
std::vector<cmCustomCommand> const& GetPreLinkCommands() const
|
|
{
|
|
return this->PreLinkCommands;
|
|
}
|
|
std::vector<cmCustomCommand> const& GetPostBuildCommands() const
|
|
{
|
|
return this->PostBuildCommands;
|
|
}
|
|
void AddPreBuildCommand(cmCustomCommand const& cmd)
|
|
{
|
|
this->PreBuildCommands.push_back(cmd);
|
|
}
|
|
void AddPreLinkCommand(cmCustomCommand const& cmd)
|
|
{
|
|
this->PreLinkCommands.push_back(cmd);
|
|
}
|
|
void AddPostBuildCommand(cmCustomCommand const& cmd)
|
|
{
|
|
this->PostBuildCommands.push_back(cmd);
|
|
}
|
|
|
|
/**
|
|
* Add sources to the target.
|
|
*/
|
|
void AddSources(std::vector<std::string> const& srcs);
|
|
void AddTracedSources(std::vector<std::string> const& srcs);
|
|
cmSourceFile* AddSourceCMP0049(const std::string& src);
|
|
cmSourceFile* AddSource(const std::string& src);
|
|
|
|
//* how we identify a library, by name and type
|
|
typedef std::pair<std::string, cmTargetLinkLibraryType> LibraryID;
|
|
|
|
typedef std::vector<LibraryID> LinkLibraryVectorType;
|
|
const LinkLibraryVectorType& GetOriginalLinkLibraries() const
|
|
{
|
|
return this->OriginalLinkLibraries;
|
|
}
|
|
|
|
/**
|
|
* Clear the dependency information recorded for this target, if any.
|
|
*/
|
|
void ClearDependencyInformation(cmMakefile& mf, const std::string& target);
|
|
|
|
void AddLinkLibrary(cmMakefile& mf, const std::string& lib,
|
|
cmTargetLinkLibraryType llt);
|
|
enum TLLSignature
|
|
{
|
|
KeywordTLLSignature,
|
|
PlainTLLSignature
|
|
};
|
|
bool PushTLLCommandTrace(TLLSignature signature,
|
|
cmListFileContext const& lfc);
|
|
void GetTllSignatureTraces(std::ostream& s, TLLSignature sig) const;
|
|
|
|
const std::vector<std::string>& GetLinkDirectories() const;
|
|
|
|
void AddLinkDirectory(const std::string& d);
|
|
|
|
/**
|
|
* Set the path where this target should be installed. This is relative to
|
|
* INSTALL_PREFIX
|
|
*/
|
|
std::string GetInstallPath() const { return this->InstallPath; }
|
|
void SetInstallPath(const char* name) { this->InstallPath = name; }
|
|
|
|
/**
|
|
* Set the path where this target (if it has a runtime part) should be
|
|
* installed. This is relative to INSTALL_PREFIX
|
|
*/
|
|
std::string GetRuntimeInstallPath() const
|
|
{
|
|
return this->RuntimeInstallPath;
|
|
}
|
|
void SetRuntimeInstallPath(const char* name)
|
|
{
|
|
this->RuntimeInstallPath = name;
|
|
}
|
|
|
|
/**
|
|
* Get/Set whether there is an install rule for this target.
|
|
*/
|
|
bool GetHaveInstallRule() const { return this->HaveInstallRule; }
|
|
void SetHaveInstallRule(bool h) { this->HaveInstallRule = h; }
|
|
|
|
/** Add a utility on which this project depends. A utility is an executable
|
|
* name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE
|
|
* commands. It is not a full path nor does it have an extension.
|
|
*/
|
|
void AddUtility(const std::string& u, cmMakefile* makefile = CM_NULLPTR);
|
|
///! Get the utilities used by this target
|
|
std::set<std::string> const& GetUtilities() const { return this->Utilities; }
|
|
cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
|
|
|
|
///! Set/Get a property of this target file
|
|
void SetProperty(const std::string& prop, const char* value);
|
|
void AppendProperty(const std::string& prop, const char* value,
|
|
bool asString = false);
|
|
const char* GetProperty(const std::string& prop) const;
|
|
bool GetPropertyAsBool(const std::string& prop) const;
|
|
void CheckProperty(const std::string& prop, cmMakefile* context) const;
|
|
const char* GetComputedProperty(const std::string& prop,
|
|
cmMessenger* messenger,
|
|
cmListFileBacktrace const& context) const;
|
|
|
|
bool IsImported() const { return this->IsImportedTarget; }
|
|
bool IsImportedGloballyVisible() const
|
|
{
|
|
return this->ImportedGloballyVisible;
|
|
}
|
|
|
|
// Get the properties
|
|
cmPropertyMap const& GetProperties() const { return this->Properties; }
|
|
|
|
bool GetMappedConfig(std::string const& desired_config, const char** loc,
|
|
const char** imp, std::string& suffix) const;
|
|
|
|
/** Return whether this target is an executable with symbol exports
|
|
enabled. */
|
|
bool IsExecutableWithExports() const;
|
|
|
|
/** Return whether this target is a shared library Framework on
|
|
Apple. */
|
|
bool IsFrameworkOnApple() const;
|
|
|
|
/** Return whether this target is an executable Bundle on Apple. */
|
|
bool IsAppBundleOnApple() const;
|
|
|
|
/** Get a backtrace from the creation of the target. */
|
|
cmListFileBacktrace const& GetBacktrace() const;
|
|
|
|
void InsertInclude(std::string const& entry, cmListFileBacktrace const& bt,
|
|
bool before = false);
|
|
void InsertCompileOption(std::string const& entry,
|
|
cmListFileBacktrace const& bt, bool before = false);
|
|
void InsertCompileDefinition(std::string const& entry,
|
|
cmListFileBacktrace const& bt);
|
|
|
|
void AppendBuildInterfaceIncludes();
|
|
|
|
std::string GetDebugGeneratorExpressions(const std::string& value,
|
|
cmTargetLinkLibraryType llt) const;
|
|
|
|
void AddSystemIncludeDirectories(const std::set<std::string>& incs);
|
|
std::set<std::string> const& GetSystemIncludeDirectories() const
|
|
{
|
|
return this->SystemIncludeDirectories;
|
|
}
|
|
|
|
cmStringRange GetIncludeDirectoriesEntries() const;
|
|
cmBacktraceRange GetIncludeDirectoriesBacktraces() const;
|
|
|
|
cmStringRange GetCompileOptionsEntries() const;
|
|
cmBacktraceRange GetCompileOptionsBacktraces() const;
|
|
|
|
cmStringRange GetCompileFeaturesEntries() const;
|
|
cmBacktraceRange GetCompileFeaturesBacktraces() const;
|
|
|
|
cmStringRange GetCompileDefinitionsEntries() const;
|
|
cmBacktraceRange GetCompileDefinitionsBacktraces() const;
|
|
|
|
cmStringRange GetSourceEntries() const;
|
|
cmBacktraceRange GetSourceBacktraces() const;
|
|
cmStringRange GetLinkImplementationEntries() const;
|
|
cmBacktraceRange GetLinkImplementationBacktraces() const;
|
|
|
|
struct StrictTargetComparison
|
|
{
|
|
bool operator()(cmTarget const* t1, cmTarget const* t2) const;
|
|
};
|
|
|
|
std::string ImportedGetFullPath(const std::string& config,
|
|
bool implib) const;
|
|
|
|
private:
|
|
const char* GetSuffixVariableInternal(bool implib) const;
|
|
const char* GetPrefixVariableInternal(bool implib) const;
|
|
|
|
// Use a makefile variable to set a default for the given property.
|
|
// If the variable is not defined use the given default instead.
|
|
void SetPropertyDefault(const std::string& property,
|
|
const char* default_value);
|
|
|
|
private:
|
|
cmPropertyMap Properties;
|
|
std::set<std::string> SystemIncludeDirectories;
|
|
std::set<std::string> LinkDirectoriesEmmitted;
|
|
std::set<std::string> Utilities;
|
|
std::map<std::string, cmListFileBacktrace> UtilityBacktraces;
|
|
cmPolicies::PolicyMap PolicyMap;
|
|
std::string Name;
|
|
std::string InstallPath;
|
|
std::string RuntimeInstallPath;
|
|
std::vector<std::string> LinkDirectories;
|
|
std::vector<cmCustomCommand> PreBuildCommands;
|
|
std::vector<cmCustomCommand> PreLinkCommands;
|
|
std::vector<cmCustomCommand> PostBuildCommands;
|
|
std::vector<std::pair<TLLSignature, cmListFileContext> > TLLCommands;
|
|
LinkLibraryVectorType OriginalLinkLibraries;
|
|
cmMakefile* Makefile;
|
|
cmTargetInternalPointer Internal;
|
|
cmState::TargetType TargetTypeValue;
|
|
bool HaveInstallRule;
|
|
bool RecordDependencies;
|
|
bool DLLPlatform;
|
|
bool IsAndroid;
|
|
bool IsImportedTarget;
|
|
bool ImportedGloballyVisible;
|
|
bool BuildInterfaceIncludesAppended;
|
|
|
|
std::string ProcessSourceItemCMP0049(const std::string& s);
|
|
|
|
/** Return whether or not the target has a DLL import library. */
|
|
bool HasImportLibrary() const;
|
|
|
|
// Internal representation details.
|
|
friend class cmTargetInternals;
|
|
friend class cmGeneratorTarget;
|
|
friend class cmTargetTraceDependencies;
|
|
|
|
cmListFileBacktrace Backtrace;
|
|
};
|
|
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
|
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
|
|
typedef std::unordered_map<std::string, cmTarget> cmTargets;
|
|
#else
|
|
typedef cmsys::hash_map<std::string, cmTarget> cmTargets;
|
|
#endif
|
|
#else
|
|
typedef std::map<std::string, cmTarget> cmTargets;
|
|
#endif
|
|
|
|
class cmTargetSet : public std::set<std::string>
|
|
{
|
|
};
|
|
class cmTargetManifest : public std::map<std::string, cmTargetSet>
|
|
{
|
|
};
|
|
|
|
#endif
|