|
|
@@ -2,6 +2,8 @@
|
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
#include "cmState.h"
|
|
|
|
|
|
+#include "cmStatePrivate.h"
|
|
|
+
|
|
|
#include "cmAlgorithms.h"
|
|
|
#include "cmCacheManager.h"
|
|
|
#include "cmCommand.h"
|
|
|
@@ -9,7 +11,6 @@
|
|
|
#include "cmListFileCache.h"
|
|
|
#include "cmSystemTools.h"
|
|
|
#include "cmTypeMacro.h"
|
|
|
-#include "cmVersion.h"
|
|
|
#include "cmake.h"
|
|
|
|
|
|
#include <algorithm>
|
|
|
@@ -20,85 +21,6 @@
|
|
|
#include <string.h>
|
|
|
#include <utility>
|
|
|
|
|
|
-static std::string const kBINARY_DIR = "BINARY_DIR";
|
|
|
-static std::string const kBUILDSYSTEM_TARGETS = "BUILDSYSTEM_TARGETS";
|
|
|
-static std::string const kSOURCE_DIR = "SOURCE_DIR";
|
|
|
-static std::string const kSUBDIRECTORIES = "SUBDIRECTORIES";
|
|
|
-
|
|
|
-struct cmStateDetail::SnapshotDataType
|
|
|
-{
|
|
|
- cmStateDetail::PositionType ScopeParent;
|
|
|
- cmStateDetail::PositionType DirectoryParent;
|
|
|
- cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator Policies;
|
|
|
- cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator PolicyRoot;
|
|
|
- cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator PolicyScope;
|
|
|
- cmStateEnums::SnapshotType SnapshotType;
|
|
|
- bool Keep;
|
|
|
- cmLinkedTree<std::string>::iterator ExecutionListFile;
|
|
|
- cmLinkedTree<cmStateDetail::BuildsystemDirectoryStateType>::iterator
|
|
|
- BuildSystemDirectory;
|
|
|
- cmLinkedTree<cmDefinitions>::iterator Vars;
|
|
|
- cmLinkedTree<cmDefinitions>::iterator Root;
|
|
|
- cmLinkedTree<cmDefinitions>::iterator Parent;
|
|
|
- std::vector<std::string>::size_type IncludeDirectoryPosition;
|
|
|
- std::vector<std::string>::size_type CompileDefinitionsPosition;
|
|
|
- std::vector<std::string>::size_type CompileOptionsPosition;
|
|
|
-};
|
|
|
-
|
|
|
-struct cmStateDetail::PolicyStackEntry : public cmPolicies::PolicyMap
|
|
|
-{
|
|
|
- typedef cmPolicies::PolicyMap derived;
|
|
|
- PolicyStackEntry(bool w = false)
|
|
|
- : derived()
|
|
|
- , Weak(w)
|
|
|
- {
|
|
|
- }
|
|
|
- PolicyStackEntry(derived const& d, bool w)
|
|
|
- : derived(d)
|
|
|
- , Weak(w)
|
|
|
- {
|
|
|
- }
|
|
|
- PolicyStackEntry(PolicyStackEntry const& r)
|
|
|
- : derived(r)
|
|
|
- , Weak(r.Weak)
|
|
|
- {
|
|
|
- }
|
|
|
- bool Weak;
|
|
|
-};
|
|
|
-
|
|
|
-struct cmStateDetail::BuildsystemDirectoryStateType
|
|
|
-{
|
|
|
- cmStateDetail::PositionType DirectoryEnd;
|
|
|
-
|
|
|
- std::string Location;
|
|
|
- std::string OutputLocation;
|
|
|
-
|
|
|
- // The top-most directories for relative path conversion. Both the
|
|
|
- // source and destination location of a relative path conversion
|
|
|
- // must be underneath one of these directories (both under source or
|
|
|
- // both under binary) in order for the relative path to be evaluated
|
|
|
- // safely by the build tools.
|
|
|
- std::string RelativePathTopSource;
|
|
|
- std::string RelativePathTopBinary;
|
|
|
-
|
|
|
- std::vector<std::string> IncludeDirectories;
|
|
|
- std::vector<cmListFileBacktrace> IncludeDirectoryBacktraces;
|
|
|
-
|
|
|
- std::vector<std::string> CompileDefinitions;
|
|
|
- std::vector<cmListFileBacktrace> CompileDefinitionsBacktraces;
|
|
|
-
|
|
|
- std::vector<std::string> CompileOptions;
|
|
|
- std::vector<cmListFileBacktrace> CompileOptionsBacktraces;
|
|
|
-
|
|
|
- std::vector<std::string> NormalTargetNames;
|
|
|
-
|
|
|
- std::string ProjectName;
|
|
|
-
|
|
|
- cmPropertyMap Properties;
|
|
|
-
|
|
|
- std::vector<cmStateSnapshot> Children;
|
|
|
-};
|
|
|
-
|
|
|
cmState::cmState()
|
|
|
: IsInTryCompile(false)
|
|
|
, WindowsShell(false)
|
|
|
@@ -676,70 +598,6 @@ const char* cmState::GetBinaryDirectory() const
|
|
|
return this->BinaryDirectory.c_str();
|
|
|
}
|
|
|
|
|
|
-void cmStateDirectory::ComputeRelativePathTopSource()
|
|
|
-{
|
|
|
- // Relative path conversion inside the source tree is not used to
|
|
|
- // construct relative paths passed to build tools so it is safe to use
|
|
|
- // even when the source is a network path.
|
|
|
-
|
|
|
- cmStateSnapshot snapshot = this->Snapshot_;
|
|
|
- std::vector<cmStateSnapshot> snapshots;
|
|
|
- snapshots.push_back(snapshot);
|
|
|
- while (true) {
|
|
|
- snapshot = snapshot.GetBuildsystemDirectoryParent();
|
|
|
- if (snapshot.IsValid()) {
|
|
|
- snapshots.push_back(snapshot);
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- std::string result = snapshots.front().GetDirectory().GetCurrentSource();
|
|
|
-
|
|
|
- for (std::vector<cmStateSnapshot>::const_iterator it = snapshots.begin() + 1;
|
|
|
- it != snapshots.end(); ++it) {
|
|
|
- std::string currentSource = it->GetDirectory().GetCurrentSource();
|
|
|
- if (cmSystemTools::IsSubDirectory(result, currentSource)) {
|
|
|
- result = currentSource;
|
|
|
- }
|
|
|
- }
|
|
|
- this->DirectoryState->RelativePathTopSource = result;
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::ComputeRelativePathTopBinary()
|
|
|
-{
|
|
|
- cmStateSnapshot snapshot = this->Snapshot_;
|
|
|
- std::vector<cmStateSnapshot> snapshots;
|
|
|
- snapshots.push_back(snapshot);
|
|
|
- while (true) {
|
|
|
- snapshot = snapshot.GetBuildsystemDirectoryParent();
|
|
|
- if (snapshot.IsValid()) {
|
|
|
- snapshots.push_back(snapshot);
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- std::string result = snapshots.front().GetDirectory().GetCurrentBinary();
|
|
|
-
|
|
|
- for (std::vector<cmStateSnapshot>::const_iterator it = snapshots.begin() + 1;
|
|
|
- it != snapshots.end(); ++it) {
|
|
|
- std::string currentBinary = it->GetDirectory().GetCurrentBinary();
|
|
|
- if (cmSystemTools::IsSubDirectory(result, currentBinary)) {
|
|
|
- result = currentBinary;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // The current working directory on Windows cannot be a network
|
|
|
- // path. Therefore relative paths cannot work when the binary tree
|
|
|
- // is a network path.
|
|
|
- if (result.size() < 2 || result.substr(0, 2) != "//") {
|
|
|
- this->DirectoryState->RelativePathTopBinary = result;
|
|
|
- } else {
|
|
|
- this->DirectoryState->RelativePathTopBinary = "";
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
cmStateSnapshot cmState::CreateBaseSnapshot()
|
|
|
{
|
|
|
cmStateDetail::PositionType pos =
|
|
|
@@ -923,854 +781,6 @@ cmStateSnapshot cmState::Pop(cmStateSnapshot originSnapshot)
|
|
|
return cmStateSnapshot(this, prevPos);
|
|
|
}
|
|
|
|
|
|
-cmStateSnapshot::cmStateSnapshot(cmState* state)
|
|
|
- : State(state)
|
|
|
- , Position()
|
|
|
-{
|
|
|
-}
|
|
|
-
|
|
|
-std::vector<cmStateSnapshot> cmStateSnapshot::GetChildren()
|
|
|
-{
|
|
|
- return this->Position->BuildSystemDirectory->Children;
|
|
|
-}
|
|
|
-
|
|
|
-cmStateSnapshot::cmStateSnapshot(cmState* state,
|
|
|
- cmStateDetail::PositionType position)
|
|
|
- : State(state)
|
|
|
- , Position(position)
|
|
|
-{
|
|
|
-}
|
|
|
-
|
|
|
-cmStateEnums::SnapshotType cmStateSnapshot::GetType() const
|
|
|
-{
|
|
|
- return this->Position->SnapshotType;
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetCurrentSource() const
|
|
|
-{
|
|
|
- return this->DirectoryState->Location.c_str();
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetCurrentSource(std::string const& dir)
|
|
|
-{
|
|
|
- std::string& loc = this->DirectoryState->Location;
|
|
|
- loc = dir;
|
|
|
- cmSystemTools::ConvertToUnixSlashes(loc);
|
|
|
- loc = cmSystemTools::CollapseFullPath(loc);
|
|
|
-
|
|
|
- this->ComputeRelativePathTopSource();
|
|
|
-
|
|
|
- this->Snapshot_.SetDefinition("CMAKE_CURRENT_SOURCE_DIR", loc);
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetCurrentBinary() const
|
|
|
-{
|
|
|
- return this->DirectoryState->OutputLocation.c_str();
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetCurrentBinary(std::string const& dir)
|
|
|
-{
|
|
|
- std::string& loc = this->DirectoryState->OutputLocation;
|
|
|
- loc = dir;
|
|
|
- cmSystemTools::ConvertToUnixSlashes(loc);
|
|
|
- loc = cmSystemTools::CollapseFullPath(loc);
|
|
|
-
|
|
|
- this->ComputeRelativePathTopBinary();
|
|
|
-
|
|
|
- this->Snapshot_.SetDefinition("CMAKE_CURRENT_BINARY_DIR", loc);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetListFile(const std::string& listfile)
|
|
|
-{
|
|
|
- *this->Position->ExecutionListFile = listfile;
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetRelativePathTopSource() const
|
|
|
-{
|
|
|
- return this->DirectoryState->RelativePathTopSource.c_str();
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetRelativePathTopBinary() const
|
|
|
-{
|
|
|
- return this->DirectoryState->RelativePathTopBinary.c_str();
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetRelativePathTopSource(const char* dir)
|
|
|
-{
|
|
|
- this->DirectoryState->RelativePathTopSource = dir;
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetRelativePathTopBinary(const char* dir)
|
|
|
-{
|
|
|
- this->DirectoryState->RelativePathTopBinary = dir;
|
|
|
-}
|
|
|
-
|
|
|
-std::string cmStateSnapshot::GetExecutionListFile() const
|
|
|
-{
|
|
|
- return *this->Position->ExecutionListFile;
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::IsValid() const
|
|
|
-{
|
|
|
- return this->State && this->Position.IsValid()
|
|
|
- ? this->Position != this->State->SnapshotData.Root()
|
|
|
- : false;
|
|
|
-}
|
|
|
-
|
|
|
-cmStateSnapshot cmStateSnapshot::GetBuildsystemDirectoryParent() const
|
|
|
-{
|
|
|
- cmStateSnapshot snapshot;
|
|
|
- if (!this->State || this->Position == this->State->SnapshotData.Root()) {
|
|
|
- return snapshot;
|
|
|
- }
|
|
|
- cmStateDetail::PositionType parentPos = this->Position->DirectoryParent;
|
|
|
- if (parentPos != this->State->SnapshotData.Root()) {
|
|
|
- snapshot = cmStateSnapshot(this->State,
|
|
|
- parentPos->BuildSystemDirectory->DirectoryEnd);
|
|
|
- }
|
|
|
-
|
|
|
- return snapshot;
|
|
|
-}
|
|
|
-
|
|
|
-cmStateSnapshot cmStateSnapshot::GetCallStackParent() const
|
|
|
-{
|
|
|
- assert(this->State);
|
|
|
- assert(this->Position != this->State->SnapshotData.Root());
|
|
|
-
|
|
|
- cmStateSnapshot snapshot;
|
|
|
- cmStateDetail::PositionType parentPos = this->Position;
|
|
|
- while (parentPos->SnapshotType == cmStateEnums::PolicyScopeType ||
|
|
|
- parentPos->SnapshotType == cmStateEnums::VariableScopeType) {
|
|
|
- ++parentPos;
|
|
|
- }
|
|
|
- if (parentPos->SnapshotType == cmStateEnums::BuildsystemDirectoryType ||
|
|
|
- parentPos->SnapshotType == cmStateEnums::BaseType) {
|
|
|
- return snapshot;
|
|
|
- }
|
|
|
-
|
|
|
- ++parentPos;
|
|
|
- while (parentPos->SnapshotType == cmStateEnums::PolicyScopeType ||
|
|
|
- parentPos->SnapshotType == cmStateEnums::VariableScopeType) {
|
|
|
- ++parentPos;
|
|
|
- }
|
|
|
-
|
|
|
- if (parentPos == this->State->SnapshotData.Root()) {
|
|
|
- return snapshot;
|
|
|
- }
|
|
|
-
|
|
|
- snapshot = cmStateSnapshot(this->State, parentPos);
|
|
|
- return snapshot;
|
|
|
-}
|
|
|
-
|
|
|
-cmStateSnapshot cmStateSnapshot::GetCallStackBottom() const
|
|
|
-{
|
|
|
- assert(this->State);
|
|
|
- assert(this->Position != this->State->SnapshotData.Root());
|
|
|
-
|
|
|
- cmStateDetail::PositionType pos = this->Position;
|
|
|
- while (pos->SnapshotType != cmStateEnums::BaseType &&
|
|
|
- pos->SnapshotType != cmStateEnums::BuildsystemDirectoryType &&
|
|
|
- pos != this->State->SnapshotData.Root()) {
|
|
|
- ++pos;
|
|
|
- }
|
|
|
- return cmStateSnapshot(this->State, pos);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::PushPolicy(cmPolicies::PolicyMap entry, bool weak)
|
|
|
-{
|
|
|
- cmStateDetail::PositionType pos = this->Position;
|
|
|
- pos->Policies = this->State->PolicyStack.Push(
|
|
|
- pos->Policies, cmStateDetail::PolicyStackEntry(entry, weak));
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::PopPolicy()
|
|
|
-{
|
|
|
- cmStateDetail::PositionType pos = this->Position;
|
|
|
- if (pos->Policies == pos->PolicyScope) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- pos->Policies = this->State->PolicyStack.Pop(pos->Policies);
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::CanPopPolicyScope()
|
|
|
-{
|
|
|
- return this->Position->Policies == this->Position->PolicyScope;
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetPolicy(cmPolicies::PolicyID id,
|
|
|
- cmPolicies::PolicyStatus status)
|
|
|
-{
|
|
|
- // Update the policy stack from the top to the top-most strong entry.
|
|
|
- bool previous_was_weak = true;
|
|
|
- for (cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator psi =
|
|
|
- this->Position->Policies;
|
|
|
- previous_was_weak && psi != this->Position->PolicyRoot; ++psi) {
|
|
|
- psi->Set(id, status);
|
|
|
- previous_was_weak = psi->Weak;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-cmPolicies::PolicyStatus cmStateSnapshot::GetPolicy(
|
|
|
- cmPolicies::PolicyID id) const
|
|
|
-{
|
|
|
- cmPolicies::PolicyStatus status = cmPolicies::GetPolicyStatus(id);
|
|
|
-
|
|
|
- if (status == cmPolicies::REQUIRED_ALWAYS ||
|
|
|
- status == cmPolicies::REQUIRED_IF_USED) {
|
|
|
- return status;
|
|
|
- }
|
|
|
-
|
|
|
- cmLinkedTree<cmStateDetail::BuildsystemDirectoryStateType>::iterator dir =
|
|
|
- this->Position->BuildSystemDirectory;
|
|
|
-
|
|
|
- while (true) {
|
|
|
- assert(dir.IsValid());
|
|
|
- cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator leaf =
|
|
|
- dir->DirectoryEnd->Policies;
|
|
|
- cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator root =
|
|
|
- dir->DirectoryEnd->PolicyRoot;
|
|
|
- for (; leaf != root; ++leaf) {
|
|
|
- if (leaf->IsDefined(id)) {
|
|
|
- status = leaf->Get(id);
|
|
|
- return status;
|
|
|
- }
|
|
|
- }
|
|
|
- cmStateDetail::PositionType e = dir->DirectoryEnd;
|
|
|
- cmStateDetail::PositionType p = e->DirectoryParent;
|
|
|
- if (p == this->State->SnapshotData.Root()) {
|
|
|
- break;
|
|
|
- }
|
|
|
- dir = p->BuildSystemDirectory;
|
|
|
- }
|
|
|
- return status;
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::HasDefinedPolicyCMP0011()
|
|
|
-{
|
|
|
- return !this->Position->Policies->IsEmpty();
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateSnapshot::GetDefinition(std::string const& name) const
|
|
|
-{
|
|
|
- assert(this->Position->Vars.IsValid());
|
|
|
- return cmDefinitions::Get(name, this->Position->Vars, this->Position->Root);
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::IsInitialized(std::string const& name) const
|
|
|
-{
|
|
|
- return cmDefinitions::HasKey(name, this->Position->Vars,
|
|
|
- this->Position->Root);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetDefinition(std::string const& name,
|
|
|
- std::string const& value)
|
|
|
-{
|
|
|
- this->Position->Vars->Set(name, value.c_str());
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::RemoveDefinition(std::string const& name)
|
|
|
-{
|
|
|
- this->Position->Vars->Set(name, CM_NULLPTR);
|
|
|
-}
|
|
|
-
|
|
|
-std::vector<std::string> cmStateSnapshot::UnusedKeys() const
|
|
|
-{
|
|
|
- return this->Position->Vars->UnusedKeys();
|
|
|
-}
|
|
|
-
|
|
|
-std::vector<std::string> cmStateSnapshot::ClosureKeys() const
|
|
|
-{
|
|
|
- return cmDefinitions::ClosureKeys(this->Position->Vars,
|
|
|
- this->Position->Root);
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::RaiseScope(std::string const& var, const char* varDef)
|
|
|
-{
|
|
|
- if (this->Position->ScopeParent == this->Position->DirectoryParent) {
|
|
|
- cmStateSnapshot parentDir = this->GetBuildsystemDirectoryParent();
|
|
|
- if (!parentDir.IsValid()) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- // Update the definition in the parent directory top scope. This
|
|
|
- // directory's scope was initialized by the closure of the parent
|
|
|
- // scope, so we do not need to localize the definition first.
|
|
|
- if (varDef) {
|
|
|
- parentDir.SetDefinition(var, varDef);
|
|
|
- } else {
|
|
|
- parentDir.RemoveDefinition(var);
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- // First localize the definition in the current scope.
|
|
|
- cmDefinitions::Raise(var, this->Position->Vars, this->Position->Root);
|
|
|
-
|
|
|
- // Now update the definition in the parent scope.
|
|
|
- this->Position->Parent->Set(var, varDef);
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-static const std::string cmPropertySentinal = std::string();
|
|
|
-
|
|
|
-template <typename T, typename U, typename V>
|
|
|
-void InitializeContentFromParent(T& parentContent, T& thisContent,
|
|
|
- U& parentBacktraces, U& thisBacktraces,
|
|
|
- V& contentEndPosition)
|
|
|
-{
|
|
|
- std::vector<std::string>::const_iterator parentBegin = parentContent.begin();
|
|
|
- std::vector<std::string>::const_iterator parentEnd = parentContent.end();
|
|
|
-
|
|
|
- std::vector<std::string>::const_reverse_iterator parentRbegin =
|
|
|
- cmMakeReverseIterator(parentEnd);
|
|
|
- std::vector<std::string>::const_reverse_iterator parentRend =
|
|
|
- parentContent.rend();
|
|
|
- parentRbegin = std::find(parentRbegin, parentRend, cmPropertySentinal);
|
|
|
- std::vector<std::string>::const_iterator parentIt = parentRbegin.base();
|
|
|
-
|
|
|
- thisContent = std::vector<std::string>(parentIt, parentEnd);
|
|
|
-
|
|
|
- std::vector<cmListFileBacktrace>::const_iterator btIt =
|
|
|
- parentBacktraces.begin() + std::distance(parentBegin, parentIt);
|
|
|
- std::vector<cmListFileBacktrace>::const_iterator btEnd =
|
|
|
- parentBacktraces.end();
|
|
|
-
|
|
|
- thisBacktraces = std::vector<cmListFileBacktrace>(btIt, btEnd);
|
|
|
-
|
|
|
- contentEndPosition = thisContent.size();
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetDefaultDefinitions()
|
|
|
-{
|
|
|
-/* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set.
|
|
|
- With CMake must separate between target and host platform. In most cases
|
|
|
- the tests for WIN32, UNIX and APPLE will be for the target system, so an
|
|
|
- additional set of variables for the host system is required ->
|
|
|
- CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE.
|
|
|
- WIN32, UNIX and APPLE are now set in the platform files in
|
|
|
- Modules/Platforms/.
|
|
|
- To keep cmake scripts (-P) and custom language and compiler modules
|
|
|
- working, these variables are still also set here in this place, but they
|
|
|
- will be reset in CMakeSystemSpecificInformation.cmake before the platform
|
|
|
- files are executed. */
|
|
|
-#if defined(_WIN32)
|
|
|
- this->SetDefinition("WIN32", "1");
|
|
|
- this->SetDefinition("CMAKE_HOST_WIN32", "1");
|
|
|
-#else
|
|
|
- this->SetDefinition("UNIX", "1");
|
|
|
- this->SetDefinition("CMAKE_HOST_UNIX", "1");
|
|
|
-#endif
|
|
|
-#if defined(__CYGWIN__)
|
|
|
- std::string legacy;
|
|
|
- if (cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32", legacy) &&
|
|
|
- cmSystemTools::IsOn(legacy.c_str())) {
|
|
|
- this->SetDefinition("WIN32", "1");
|
|
|
- this->SetDefinition("CMAKE_HOST_WIN32", "1");
|
|
|
- }
|
|
|
-#endif
|
|
|
-#if defined(__APPLE__)
|
|
|
- this->SetDefinition("APPLE", "1");
|
|
|
- this->SetDefinition("CMAKE_HOST_APPLE", "1");
|
|
|
-#endif
|
|
|
-#if defined(__sun__)
|
|
|
- this->SetDefinition("CMAKE_HOST_SOLARIS", "1");
|
|
|
-#endif
|
|
|
-
|
|
|
- char temp[1024];
|
|
|
- sprintf(temp, "%d", cmVersion::GetMinorVersion());
|
|
|
- this->SetDefinition("CMAKE_MINOR_VERSION", temp);
|
|
|
- sprintf(temp, "%d", cmVersion::GetMajorVersion());
|
|
|
- this->SetDefinition("CMAKE_MAJOR_VERSION", temp);
|
|
|
- sprintf(temp, "%d", cmVersion::GetPatchVersion());
|
|
|
- this->SetDefinition("CMAKE_PATCH_VERSION", temp);
|
|
|
- sprintf(temp, "%d", cmVersion::GetTweakVersion());
|
|
|
- this->SetDefinition("CMAKE_TWEAK_VERSION", temp);
|
|
|
- this->SetDefinition("CMAKE_VERSION", cmVersion::GetCMakeVersion());
|
|
|
-
|
|
|
- this->SetDefinition("CMAKE_FILES_DIRECTORY",
|
|
|
- cmake::GetCMakeFilesDirectory());
|
|
|
-
|
|
|
- // Setup the default include file regular expression (match everything).
|
|
|
- this->Position->BuildSystemDirectory->Properties.SetProperty(
|
|
|
- "INCLUDE_REGULAR_EXPRESSION", "^.*$");
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetDirectoryDefinitions()
|
|
|
-{
|
|
|
- this->SetDefinition("CMAKE_SOURCE_DIR", this->State->GetSourceDirectory());
|
|
|
- this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR",
|
|
|
- this->State->GetSourceDirectory());
|
|
|
- this->SetDefinition("CMAKE_BINARY_DIR", this->State->GetBinaryDirectory());
|
|
|
- this->SetDefinition("CMAKE_CURRENT_BINARY_DIR",
|
|
|
- this->State->GetBinaryDirectory());
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::InitializeFromParent()
|
|
|
-{
|
|
|
- cmStateDetail::PositionType parent = this->Position->DirectoryParent;
|
|
|
- assert(this->Position->Vars.IsValid());
|
|
|
- assert(parent->Vars.IsValid());
|
|
|
-
|
|
|
- *this->Position->Vars =
|
|
|
- cmDefinitions::MakeClosure(parent->Vars, parent->Root);
|
|
|
-
|
|
|
- InitializeContentFromParent(
|
|
|
- parent->BuildSystemDirectory->IncludeDirectories,
|
|
|
- this->Position->BuildSystemDirectory->IncludeDirectories,
|
|
|
- parent->BuildSystemDirectory->IncludeDirectoryBacktraces,
|
|
|
- this->Position->BuildSystemDirectory->IncludeDirectoryBacktraces,
|
|
|
- this->Position->IncludeDirectoryPosition);
|
|
|
-
|
|
|
- InitializeContentFromParent(
|
|
|
- parent->BuildSystemDirectory->CompileDefinitions,
|
|
|
- this->Position->BuildSystemDirectory->CompileDefinitions,
|
|
|
- parent->BuildSystemDirectory->CompileDefinitionsBacktraces,
|
|
|
- this->Position->BuildSystemDirectory->CompileDefinitionsBacktraces,
|
|
|
- this->Position->CompileDefinitionsPosition);
|
|
|
-
|
|
|
- InitializeContentFromParent(
|
|
|
- parent->BuildSystemDirectory->CompileOptions,
|
|
|
- this->Position->BuildSystemDirectory->CompileOptions,
|
|
|
- parent->BuildSystemDirectory->CompileOptionsBacktraces,
|
|
|
- this->Position->BuildSystemDirectory->CompileOptionsBacktraces,
|
|
|
- this->Position->CompileOptionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmState* cmStateSnapshot::GetState() const
|
|
|
-{
|
|
|
- return this->State;
|
|
|
-}
|
|
|
-
|
|
|
-cmStateDirectory cmStateSnapshot::GetDirectory() const
|
|
|
-{
|
|
|
- return cmStateDirectory(this->Position->BuildSystemDirectory, *this);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::SetProjectName(const std::string& name)
|
|
|
-{
|
|
|
- this->Position->BuildSystemDirectory->ProjectName = name;
|
|
|
-}
|
|
|
-
|
|
|
-std::string cmStateSnapshot::GetProjectName() const
|
|
|
-{
|
|
|
- return this->Position->BuildSystemDirectory->ProjectName;
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateSnapshot::InitializeFromParent_ForSubdirsCommand()
|
|
|
-{
|
|
|
- std::string currentSrcDir = this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR");
|
|
|
- std::string currentBinDir = this->GetDefinition("CMAKE_CURRENT_BINARY_DIR");
|
|
|
- this->InitializeFromParent();
|
|
|
- this->SetDefinition("CMAKE_SOURCE_DIR", this->State->GetSourceDirectory());
|
|
|
- this->SetDefinition("CMAKE_BINARY_DIR", this->State->GetBinaryDirectory());
|
|
|
-
|
|
|
- this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", currentSrcDir);
|
|
|
- this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", currentBinDir);
|
|
|
-}
|
|
|
-
|
|
|
-cmStateDirectory::cmStateDirectory(
|
|
|
- cmLinkedTree<cmStateDetail::BuildsystemDirectoryStateType>::iterator iter,
|
|
|
- const cmStateSnapshot& snapshot)
|
|
|
- : DirectoryState(iter)
|
|
|
- , Snapshot_(snapshot)
|
|
|
-{
|
|
|
-}
|
|
|
-
|
|
|
-template <typename T, typename U>
|
|
|
-cmStringRange GetPropertyContent(T const& content, U contentEndPosition)
|
|
|
-{
|
|
|
- std::vector<std::string>::const_iterator end =
|
|
|
- content.begin() + contentEndPosition;
|
|
|
-
|
|
|
- std::vector<std::string>::const_reverse_iterator rbegin =
|
|
|
- cmMakeReverseIterator(end);
|
|
|
- rbegin = std::find(rbegin, content.rend(), cmPropertySentinal);
|
|
|
-
|
|
|
- return cmMakeRange(rbegin.base(), end);
|
|
|
-}
|
|
|
-
|
|
|
-template <typename T, typename U, typename V>
|
|
|
-cmBacktraceRange GetPropertyBacktraces(T const& content, U const& backtraces,
|
|
|
- V contentEndPosition)
|
|
|
-{
|
|
|
- std::vector<std::string>::const_iterator entryEnd =
|
|
|
- content.begin() + contentEndPosition;
|
|
|
-
|
|
|
- std::vector<std::string>::const_reverse_iterator rbegin =
|
|
|
- cmMakeReverseIterator(entryEnd);
|
|
|
- rbegin = std::find(rbegin, content.rend(), cmPropertySentinal);
|
|
|
-
|
|
|
- std::vector<cmListFileBacktrace>::const_iterator it =
|
|
|
- backtraces.begin() + std::distance(content.begin(), rbegin.base());
|
|
|
-
|
|
|
- std::vector<cmListFileBacktrace>::const_iterator end = backtraces.end();
|
|
|
- return cmMakeRange(it, end);
|
|
|
-}
|
|
|
-
|
|
|
-template <typename T, typename U, typename V>
|
|
|
-void AppendEntry(T& content, U& backtraces, V& endContentPosition,
|
|
|
- const std::string& value, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- if (value.empty()) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- assert(endContentPosition == content.size());
|
|
|
-
|
|
|
- content.push_back(value);
|
|
|
- backtraces.push_back(lfbt);
|
|
|
-
|
|
|
- endContentPosition = content.size();
|
|
|
-}
|
|
|
-
|
|
|
-template <typename T, typename U, typename V>
|
|
|
-void SetContent(T& content, U& backtraces, V& endContentPosition,
|
|
|
- const std::string& vec, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- assert(endContentPosition == content.size());
|
|
|
-
|
|
|
- content.resize(content.size() + 2);
|
|
|
- backtraces.resize(backtraces.size() + 2);
|
|
|
-
|
|
|
- content.back() = vec;
|
|
|
- backtraces.back() = lfbt;
|
|
|
-
|
|
|
- endContentPosition = content.size();
|
|
|
-}
|
|
|
-
|
|
|
-template <typename T, typename U, typename V>
|
|
|
-void ClearContent(T& content, U& backtraces, V& endContentPosition)
|
|
|
-{
|
|
|
- assert(endContentPosition == content.size());
|
|
|
-
|
|
|
- content.resize(content.size() + 1);
|
|
|
- backtraces.resize(backtraces.size() + 1);
|
|
|
-
|
|
|
- endContentPosition = content.size();
|
|
|
-}
|
|
|
-
|
|
|
-cmStringRange cmStateDirectory::GetIncludeDirectoriesEntries() const
|
|
|
-{
|
|
|
- return GetPropertyContent(
|
|
|
- this->DirectoryState->IncludeDirectories,
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmBacktraceRange cmStateDirectory::GetIncludeDirectoriesEntryBacktraces() const
|
|
|
-{
|
|
|
- return GetPropertyBacktraces(
|
|
|
- this->DirectoryState->IncludeDirectories,
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces,
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::AppendIncludeDirectoriesEntry(
|
|
|
- const std::string& vec, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- AppendEntry(this->DirectoryState->IncludeDirectories,
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces,
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::PrependIncludeDirectoriesEntry(
|
|
|
- const std::string& vec, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- std::vector<std::string>::iterator entryEnd =
|
|
|
- this->DirectoryState->IncludeDirectories.begin() +
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition;
|
|
|
-
|
|
|
- std::vector<std::string>::reverse_iterator rend =
|
|
|
- this->DirectoryState->IncludeDirectories.rend();
|
|
|
- std::vector<std::string>::reverse_iterator rbegin =
|
|
|
- cmMakeReverseIterator(entryEnd);
|
|
|
- rbegin = std::find(rbegin, rend, cmPropertySentinal);
|
|
|
-
|
|
|
- std::vector<std::string>::iterator entryIt = rbegin.base();
|
|
|
- std::vector<std::string>::iterator entryBegin =
|
|
|
- this->DirectoryState->IncludeDirectories.begin();
|
|
|
-
|
|
|
- std::vector<cmListFileBacktrace>::iterator btIt =
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces.begin() +
|
|
|
- std::distance(entryBegin, entryIt);
|
|
|
-
|
|
|
- this->DirectoryState->IncludeDirectories.insert(entryIt, vec);
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces.insert(btIt, lfbt);
|
|
|
-
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition =
|
|
|
- this->DirectoryState->IncludeDirectories.size();
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetIncludeDirectories(const std::string& vec,
|
|
|
- const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- SetContent(this->DirectoryState->IncludeDirectories,
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces,
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::ClearIncludeDirectories()
|
|
|
-{
|
|
|
- ClearContent(this->DirectoryState->IncludeDirectories,
|
|
|
- this->DirectoryState->IncludeDirectoryBacktraces,
|
|
|
- this->Snapshot_.Position->IncludeDirectoryPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmStringRange cmStateDirectory::GetCompileDefinitionsEntries() const
|
|
|
-{
|
|
|
- return GetPropertyContent(
|
|
|
- this->DirectoryState->CompileDefinitions,
|
|
|
- this->Snapshot_.Position->CompileDefinitionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmBacktraceRange cmStateDirectory::GetCompileDefinitionsEntryBacktraces() const
|
|
|
-{
|
|
|
- return GetPropertyBacktraces(
|
|
|
- this->DirectoryState->CompileDefinitions,
|
|
|
- this->DirectoryState->CompileDefinitionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileDefinitionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::AppendCompileDefinitionsEntry(
|
|
|
- const std::string& vec, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- AppendEntry(this->DirectoryState->CompileDefinitions,
|
|
|
- this->DirectoryState->CompileDefinitionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileDefinitionsPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetCompileDefinitions(const std::string& vec,
|
|
|
- const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- SetContent(this->DirectoryState->CompileDefinitions,
|
|
|
- this->DirectoryState->CompileDefinitionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileDefinitionsPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::ClearCompileDefinitions()
|
|
|
-{
|
|
|
- ClearContent(this->DirectoryState->CompileDefinitions,
|
|
|
- this->DirectoryState->CompileDefinitionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileDefinitionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmStringRange cmStateDirectory::GetCompileOptionsEntries() const
|
|
|
-{
|
|
|
- return GetPropertyContent(this->DirectoryState->CompileOptions,
|
|
|
- this->Snapshot_.Position->CompileOptionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-cmBacktraceRange cmStateDirectory::GetCompileOptionsEntryBacktraces() const
|
|
|
-{
|
|
|
- return GetPropertyBacktraces(
|
|
|
- this->DirectoryState->CompileOptions,
|
|
|
- this->DirectoryState->CompileOptionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileOptionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::AppendCompileOptionsEntry(
|
|
|
- const std::string& vec, const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- AppendEntry(this->DirectoryState->CompileOptions,
|
|
|
- this->DirectoryState->CompileOptionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileOptionsPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetCompileOptions(const std::string& vec,
|
|
|
- const cmListFileBacktrace& lfbt)
|
|
|
-{
|
|
|
- SetContent(this->DirectoryState->CompileOptions,
|
|
|
- this->DirectoryState->CompileOptionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileOptionsPosition, vec, lfbt);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::ClearCompileOptions()
|
|
|
-{
|
|
|
- ClearContent(this->DirectoryState->CompileOptions,
|
|
|
- this->DirectoryState->CompileOptionsBacktraces,
|
|
|
- this->Snapshot_.Position->CompileOptionsPosition);
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateSnapshot::StrictWeakOrder::operator()(
|
|
|
- const cmStateSnapshot& lhs, const cmStateSnapshot& rhs) const
|
|
|
-{
|
|
|
- return lhs.Position.StrictWeakOrdered(rhs.Position);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::SetProperty(const std::string& prop, const char* value,
|
|
|
- cmListFileBacktrace const& lfbt)
|
|
|
-{
|
|
|
- if (prop == "INCLUDE_DIRECTORIES") {
|
|
|
- if (!value) {
|
|
|
- this->ClearIncludeDirectories();
|
|
|
- return;
|
|
|
- }
|
|
|
- this->SetIncludeDirectories(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (prop == "COMPILE_OPTIONS") {
|
|
|
- if (!value) {
|
|
|
- this->ClearCompileOptions();
|
|
|
- return;
|
|
|
- }
|
|
|
- this->SetCompileOptions(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (prop == "COMPILE_DEFINITIONS") {
|
|
|
- if (!value) {
|
|
|
- this->ClearCompileDefinitions();
|
|
|
- return;
|
|
|
- }
|
|
|
- this->SetCompileDefinitions(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- this->DirectoryState->Properties.SetProperty(prop, value);
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::AppendProperty(const std::string& prop,
|
|
|
- const char* value, bool asString,
|
|
|
- cmListFileBacktrace const& lfbt)
|
|
|
-{
|
|
|
- if (prop == "INCLUDE_DIRECTORIES") {
|
|
|
- this->AppendIncludeDirectoriesEntry(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (prop == "COMPILE_OPTIONS") {
|
|
|
- this->AppendCompileOptionsEntry(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (prop == "COMPILE_DEFINITIONS") {
|
|
|
- this->AppendCompileDefinitionsEntry(value, lfbt);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- this->DirectoryState->Properties.AppendProperty(prop, value, asString);
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetProperty(const std::string& prop) const
|
|
|
-{
|
|
|
- const bool chain =
|
|
|
- this->Snapshot_.State->IsPropertyChained(prop, cmProperty::DIRECTORY);
|
|
|
- return this->GetProperty(prop, chain);
|
|
|
-}
|
|
|
-
|
|
|
-const char* cmStateDirectory::GetProperty(const std::string& prop,
|
|
|
- bool chain) const
|
|
|
-{
|
|
|
- static std::string output;
|
|
|
- output = "";
|
|
|
- if (prop == "PARENT_DIRECTORY") {
|
|
|
- cmStateSnapshot parent = this->Snapshot_.GetBuildsystemDirectoryParent();
|
|
|
- if (parent.IsValid()) {
|
|
|
- return parent.GetDirectory().GetCurrentSource();
|
|
|
- }
|
|
|
- return "";
|
|
|
- }
|
|
|
- if (prop == kBINARY_DIR) {
|
|
|
- output = this->GetCurrentBinary();
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == kSOURCE_DIR) {
|
|
|
- output = this->GetCurrentSource();
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == kSUBDIRECTORIES) {
|
|
|
- std::vector<std::string> child_dirs;
|
|
|
- std::vector<cmStateSnapshot> const& children =
|
|
|
- this->DirectoryState->Children;
|
|
|
- for (std::vector<cmStateSnapshot>::const_iterator ci = children.begin();
|
|
|
- ci != children.end(); ++ci) {
|
|
|
- child_dirs.push_back(ci->GetDirectory().GetCurrentSource());
|
|
|
- }
|
|
|
- output = cmJoin(child_dirs, ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == kBUILDSYSTEM_TARGETS) {
|
|
|
- output = cmJoin(this->DirectoryState->NormalTargetNames, ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
-
|
|
|
- if (prop == "LISTFILE_STACK") {
|
|
|
- std::vector<std::string> listFiles;
|
|
|
- cmStateSnapshot snp = this->Snapshot_;
|
|
|
- while (snp.IsValid()) {
|
|
|
- listFiles.push_back(snp.GetExecutionListFile());
|
|
|
- snp = snp.GetCallStackParent();
|
|
|
- }
|
|
|
- std::reverse(listFiles.begin(), listFiles.end());
|
|
|
- output = cmJoin(listFiles, ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == "CACHE_VARIABLES") {
|
|
|
- output = cmJoin(this->Snapshot_.State->GetCacheEntryKeys(), ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == "VARIABLES") {
|
|
|
- std::vector<std::string> res = this->Snapshot_.ClosureKeys();
|
|
|
- std::vector<std::string> cacheKeys =
|
|
|
- this->Snapshot_.State->GetCacheEntryKeys();
|
|
|
- res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
|
|
|
- std::sort(res.begin(), res.end());
|
|
|
- output = cmJoin(res, ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == "INCLUDE_DIRECTORIES") {
|
|
|
- output = cmJoin(this->GetIncludeDirectoriesEntries(), ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == "COMPILE_OPTIONS") {
|
|
|
- output = cmJoin(this->GetCompileOptionsEntries(), ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
- if (prop == "COMPILE_DEFINITIONS") {
|
|
|
- output = cmJoin(this->GetCompileDefinitionsEntries(), ";");
|
|
|
- return output.c_str();
|
|
|
- }
|
|
|
-
|
|
|
- const char* retVal = this->DirectoryState->Properties.GetPropertyValue(prop);
|
|
|
- if (!retVal && chain) {
|
|
|
- cmStateSnapshot parentSnapshot =
|
|
|
- this->Snapshot_.GetBuildsystemDirectoryParent();
|
|
|
- if (parentSnapshot.IsValid()) {
|
|
|
- return parentSnapshot.GetDirectory().GetProperty(prop, chain);
|
|
|
- }
|
|
|
- return this->Snapshot_.State->GetGlobalProperty(prop);
|
|
|
- }
|
|
|
-
|
|
|
- return retVal;
|
|
|
-}
|
|
|
-
|
|
|
-bool cmStateDirectory::GetPropertyAsBool(const std::string& prop) const
|
|
|
-{
|
|
|
- return cmSystemTools::IsOn(this->GetProperty(prop));
|
|
|
-}
|
|
|
-
|
|
|
-std::vector<std::string> cmStateDirectory::GetPropertyKeys() const
|
|
|
-{
|
|
|
- std::vector<std::string> keys;
|
|
|
- keys.reserve(this->DirectoryState->Properties.size());
|
|
|
- for (cmPropertyMap::const_iterator it =
|
|
|
- this->DirectoryState->Properties.begin();
|
|
|
- it != this->DirectoryState->Properties.end(); ++it) {
|
|
|
- keys.push_back(it->first);
|
|
|
- }
|
|
|
- return keys;
|
|
|
-}
|
|
|
-
|
|
|
-void cmStateDirectory::AddNormalTargetName(std::string const& name)
|
|
|
-{
|
|
|
- this->DirectoryState->NormalTargetNames.push_back(name);
|
|
|
-}
|
|
|
-
|
|
|
-bool operator==(const cmStateSnapshot& lhs, const cmStateSnapshot& rhs)
|
|
|
-{
|
|
|
- return lhs.Position == rhs.Position;
|
|
|
-}
|
|
|
-
|
|
|
-bool operator!=(const cmStateSnapshot& lhs, const cmStateSnapshot& rhs)
|
|
|
-{
|
|
|
- return lhs.Position != rhs.Position;
|
|
|
-}
|
|
|
-
|
|
|
static bool ParseEntryWithoutType(const std::string& entry, std::string& var,
|
|
|
std::string& value)
|
|
|
{
|
Stephen Kelly