kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'cmState-policies' 

757a1f54 cmState: Move PolicyState from cmMakefile.
52dbe654 cmState: Record the end position of each directory.
65a5e0c6 cmLinkedTree: Add Clear API.
34835433 cmState: Add Type for policy scope.
af0de01c cmState: Remove call stack parent tracking.
6ae8b30b cmMakefile: Move policy barriers inside cmState scopes.
a5fc17b5 cmMakefile: Re-order policy entries and barriers.
0a01e6c6 cmState: Add Snapshot Type accessor.
f0005bb4 Tests: Verify generate-time policy scope behavior.
This commit is contained in:
Brad King 2015-08-06 09:38:24 -04:00 committed by CMake Topic Stage
parent 370e2c6785 757a1f5408
commit 73e3de381d
16 changed files with 248 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/cmLinkedTree.h
View File

@ -155,6 +155,12 @@ public:
return iterator(this, 1);
}
void Clear()
{
this->UpPositions.clear();
this->Data.clear();
}
private:
T& GetReference(PositionType pos)
{

130
Source/cmMakefile.cxx
View File

@ -190,12 +190,12 @@ cmMakefile::cmMakefile(cmLocalGenerator* localGenerator)
this->cmAtVarRegex.compile("(@[A-Za-z_0-9/.+-]+@)");
this->cmNamedCurly.compile("^[A-Za-z0-9/_.+-]+{");
this->StateSnapshot = this->StateSnapshot.GetState()
->CreatePolicyScopeSnapshot(this->StateSnapshot);
// Enter a policy level for this directory.
this->PushPolicy();
// Protect the directory-level policies.
this->PushPolicyBarrier();
// push empty loop block
this->PushLoopBlockBarrier();
@ -240,11 +240,6 @@ cmMakefile::~cmMakefile()
this->EvaluationFiles.clear();
this->FunctionBlockers.clear();
if (this->PolicyStack.size() != 1)
{
cmSystemTools::Error("Internal CMake Error, Policy Stack has not been"
" popped properly");
}
}
//----------------------------------------------------------------------------
@ -472,6 +467,14 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
Makefile(mf), NoPolicyScope(noPolicyScope),
CheckCMP0011(false), ReportError(true)
{
this->Makefile->PushFunctionBlockerBarrier();
this->Makefile->StateSnapshot =
this->Makefile->GetState()->CreateCallStackSnapshot(
this->Makefile->StateSnapshot,
this->Makefile->ContextStack.back()->Name,
this->Makefile->ContextStack.back()->Line,
filenametoread);
if(!this->NoPolicyScope)
{
// Check CMP0011 to determine the policy scope type.
@ -500,37 +503,19 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
break;
}
}
// The included file cannot pop our policy scope.
this->Makefile->PushPolicyBarrier();
this->Makefile->PushFunctionBlockerBarrier();
this->Makefile->StateSnapshot =
this->Makefile->GetState()->CreateCallStackSnapshot(
this->Makefile->StateSnapshot,
this->Makefile->ContextStack.back()->Name,
this->Makefile->ContextStack.back()->Line,
filenametoread);
}
//----------------------------------------------------------------------------
cmMakefile::IncludeScope::~IncludeScope()
{
this->Makefile->StateSnapshot =
this->Makefile->GetState()->Pop(this->Makefile->StateSnapshot);
assert(this->Makefile->StateSnapshot.IsValid());
this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
// Enforce matching policy scopes inside the included file.
this->Makefile->PopPolicyBarrier(this->ReportError);
if(!this->NoPolicyScope)
{
// If we need to enforce policy CMP0011 then the top entry is the
// one we pushed above. If the entry is empty, then the included
// script did not set any policies that might affect the includer so
// we do not need to enforce the policy.
if(this->CheckCMP0011 && this->Makefile->PolicyStack.back().IsEmpty())
if(this->CheckCMP0011
&& !this->Makefile->StateSnapshot.HasDefinedPolicyCMP0011())
{
this->CheckCMP0011 = false;
}
@ -545,6 +530,9 @@ cmMakefile::IncludeScope::~IncludeScope()
this->EnforceCMP0011();
}
}
this->Makefile->PopPolicyBarrier(this->ReportError);
this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
}
//----------------------------------------------------------------------------
@ -639,8 +627,6 @@ public:
ListFileScope(cmMakefile* mf, std::string const& filenametoread)
: Makefile(mf), ReportError(true)
{
this->Makefile->PushPolicyBarrier();
long line = 0;
std::string name;
if (!this->Makefile->ContextStack.empty())
@ -652,17 +638,14 @@ public:
this->Makefile->GetState()->CreateInlineListFileSnapshot(
this->Makefile->StateSnapshot, name, line, filenametoread);
assert(this->Makefile->StateSnapshot.IsValid());
this->Makefile->PushFunctionBlockerBarrier();
}
~ListFileScope()
{
this->Makefile->StateSnapshot =
this->Makefile->GetState()->Pop(this->Makefile->StateSnapshot);
assert(this->Makefile->StateSnapshot.IsValid());
this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
this->Makefile->PopPolicyBarrier(this->ReportError);
this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
}
void Quiet() { this->ReportError = false; }
@ -1662,16 +1645,13 @@ void cmMakefile::PushFunctionScope(std::string const& fileName,
this->PushFunctionBlockerBarrier();
this->PushPolicy(true, pm);
this->PushPolicyBarrier();
}
void cmMakefile::PopFunctionScope(bool reportError)
{
this->PopPolicyBarrier(reportError);
this->PopPolicy();
this->StateSnapshot = this->GetState()->Pop(this->StateSnapshot);
assert(this->StateSnapshot.IsValid());
this->PopPolicyBarrier(reportError);
this->PopFunctionBlockerBarrier(reportError);
@ -1699,16 +1679,12 @@ void cmMakefile::PushMacroScope(std::string const& fileName,
this->PushFunctionBlockerBarrier();
this->PushPolicy(true, pm);
this->PushPolicyBarrier();
}
void cmMakefile::PopMacroScope(bool reportError)
{
this->PopPolicyBarrier(reportError);
this->PopPolicy();
this->StateSnapshot = this->GetState()->Pop(this->StateSnapshot);
assert(this->StateSnapshot.IsValid());
this->PopPolicyBarrier(reportError);
this->PopFunctionBlockerBarrier(reportError);
}
@ -1728,7 +1704,8 @@ public:
this->Makefile->StateSnapshot.GetDirectory().GetCurrentSource();
currentStart += "/CMakeLists.txt";
this->Makefile->StateSnapshot.SetListFile(currentStart);
this->Makefile->PushPolicyBarrier();
this->Makefile->StateSnapshot = this->Makefile->StateSnapshot.GetState()
->CreatePolicyScopeSnapshot(this->Makefile->StateSnapshot);
this->Makefile->PushFunctionBlockerBarrier();
this->GG = mf->GetGlobalGenerator();
@ -4775,30 +4752,7 @@ const char* cmMakefile::GetDefineFlagsCMP0059() const
cmPolicies::PolicyStatus
cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id) const
{
cmPolicies::PolicyStatus status = cmPolicies::GetPolicyStatus(id);
if(status == cmPolicies::REQUIRED_ALWAYS ||
status == cmPolicies::REQUIRED_IF_USED)
{
return status;
}
cmLocalGenerator* lg = this->LocalGenerator;
while(lg)
{
cmMakefile const* mf = lg->GetMakefile();
for(PolicyStackType::const_reverse_iterator psi =
mf->PolicyStack.rbegin(); psi != mf->PolicyStack.rend(); ++psi)
{
if(psi->IsDefined(id))
{
status = psi->Get(id);
return status;
}
}
lg = lg->GetParent();
}
return status;
return this->StateSnapshot.GetPolicy(id);
}
//----------------------------------------------------------------------------
@ -4847,15 +4801,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
return false;
}
// Update the policy stack from the top to the top-most strong entry.
bool previous_was_weak = true;
for(PolicyStackType::reverse_iterator psi = this->PolicyStack.rbegin();
previous_was_weak && psi != this->PolicyStack.rend(); ++psi)
{
psi->Set(id, status);
previous_was_weak = psi->Weak;
}
this->StateSnapshot.SetPolicy(id, status);
return true;
}
@ -4864,50 +4810,38 @@ cmMakefile::PolicyPushPop::PolicyPushPop(cmMakefile* m, bool weak,
cmPolicies::PolicyMap const& pm):
Makefile(m), ReportError(true)
{
this->Makefile->StateSnapshot = this->Makefile->StateSnapshot.GetState()
->CreatePolicyScopeSnapshot(this->Makefile->StateSnapshot);
this->Makefile->PushPolicy(weak, pm);
this->Makefile->PushPolicyBarrier();
}
//----------------------------------------------------------------------------
cmMakefile::PolicyPushPop::~PolicyPushPop()
{
this->Makefile->PopPolicyBarrier(this->ReportError);
this->Makefile->PopPolicy();
this->Makefile->PopPolicyBarrier(this->ReportError);
}
//----------------------------------------------------------------------------
void cmMakefile::PushPolicy(bool weak, cmPolicies::PolicyMap const& pm)
{
// Allocate a new stack entry.
this->PolicyStack.push_back(PolicyStackEntry(pm, weak));
this->StateSnapshot.PushPolicy(pm, weak);
}
//----------------------------------------------------------------------------
void cmMakefile::PopPolicy()
{
if(this->PolicyStack.size() > this->PolicyBarriers.back())
{
this->PolicyStack.pop_back();
}
else
if (!this->StateSnapshot.PopPolicy())
{
this->IssueMessage(cmake::FATAL_ERROR,
"cmake_policy POP without matching PUSH");
}
}
//----------------------------------------------------------------------------
void cmMakefile::PushPolicyBarrier()
{
this->PolicyBarriers.push_back(this->PolicyStack.size());
}
//----------------------------------------------------------------------------
void cmMakefile::PopPolicyBarrier(bool reportError)
{
// Remove any extra entries pushed on the barrier.
PolicyStackType::size_type barrier = this->PolicyBarriers.back();
while(this->PolicyStack.size() > barrier)
while (!this->StateSnapshot.CanPopPolicyScope())
{
if(reportError)
{
@ -4918,8 +4852,8 @@ void cmMakefile::PopPolicyBarrier(bool reportError)
this->PopPolicy();
}
// Remove the barrier.
this->PolicyBarriers.pop_back();
this->StateSnapshot = this->GetState()->Pop(this->StateSnapshot);
assert(this->StateSnapshot.IsValid());
}
//----------------------------------------------------------------------------

13
Source/cmMakefile.h
View File

@ -918,7 +918,6 @@ private:
void PushPolicy(bool weak = false,
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
void PopPolicy();
void PushPolicyBarrier();
void PopPolicyBarrier(bool reportError = true);
friend class cmCMakePolicyCommand;
class IncludeScope;
@ -928,18 +927,6 @@ private:
class BuildsystemFileScope;
friend class BuildsystemFileScope;
// stack of policy settings
struct PolicyStackEntry: public cmPolicies::PolicyMap
{
typedef cmPolicies::PolicyMap derived;
PolicyStackEntry(bool w = false): derived(), Weak(w) {}
PolicyStackEntry(derived const& d, bool w = false): derived(d), Weak(w) {}
PolicyStackEntry(PolicyStackEntry const& r): derived(r), Weak(r.Weak) {}
bool Weak;
};
typedef std::vector<PolicyStackEntry> PolicyStackType;
PolicyStackType PolicyStack;
std::vector<PolicyStackType::size_type> PolicyBarriers;
// CMP0053 == old
cmake::MessageType ExpandVariablesInStringOld(

171
Source/cmState.cxx
View File

@ -20,8 +20,10 @@
struct cmState::SnapshotDataType
{
cmState::PositionType CallStackParent;
cmState::PositionType DirectoryParent;
cmLinkedTree<cmState::PolicyStackEntry>::iterator Policies;
cmLinkedTree<cmState::PolicyStackEntry>::iterator PolicyRoot;
cmLinkedTree<cmState::PolicyStackEntry>::iterator PolicyScope;
cmState::SnapshotType SnapshotType;
cmLinkedTree<std::string>::iterator ExecutionListFile;
cmLinkedTree<cmState::BuildsystemDirectoryStateType>::iterator
@ -33,8 +35,19 @@ struct cmState::SnapshotDataType
std::vector<std::string>::size_type CompileOptionsPosition;
};
struct cmState::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 cmState::BuildsystemDirectoryStateType
{
cmState::PositionType DirectoryEnd;
std::string Location;
std::string OutputLocation;
@ -240,6 +253,9 @@ cmState::Snapshot cmState::Reset()
this->GlobalProperties.clear();
this->PropertyDefinitions.clear();
PositionType pos = this->SnapshotData.Truncate();
this->ExecutionListFiles.Truncate();
{
cmLinkedTree<BuildsystemDirectoryStateType>::iterator it =
this->BuildsystemDirectory.Truncate();
@ -249,9 +265,15 @@ cmState::Snapshot cmState::Reset()
it->CompileDefinitionsBacktraces.clear();
it->CompileOptions.clear();
it->CompileOptionsBacktraces.clear();
it->DirectoryEnd = pos;
}
PositionType pos = this->SnapshotData.Truncate();
this->ExecutionListFiles.Truncate();
this->PolicyStack.Clear();
pos->Policies = this->PolicyStack.Root();
pos->PolicyRoot = this->PolicyStack.Root();
pos->PolicyScope = this->PolicyStack.Root();
assert(pos->Policies.IsValid());
assert(pos->PolicyRoot.IsValid());
this->DefineProperty
("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY,
@ -722,6 +744,12 @@ cmState::Snapshot cmState::CreateBaseSnapshot()
pos->IncludeDirectoryPosition = 0;
pos->CompileDefinitionsPosition = 0;
pos->CompileOptionsPosition = 0;
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->Policies = this->PolicyStack.Root();
pos->PolicyRoot = this->PolicyStack.Root();
pos->PolicyScope = this->PolicyStack.Root();
assert(pos->Policies.IsValid());
assert(pos->PolicyRoot.IsValid());
return cmState::Snapshot(this, pos);
}
@ -732,7 +760,6 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
{
assert(originSnapshot.IsValid());
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position);
pos->CallStackParent = originSnapshot.Position;
pos->EntryPointLine = entryPointLine;
pos->EntryPointCommand = entryPointCommand;
pos->DirectoryParent = originSnapshot.Position;
@ -743,6 +770,12 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
pos->ExecutionListFile =
this->ExecutionListFiles.Extend(
originSnapshot.Position->ExecutionListFile);
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->Policies = originSnapshot.Position->Policies;
pos->PolicyRoot = originSnapshot.Position->Policies;
pos->PolicyScope = originSnapshot.Position->Policies;
assert(pos->Policies.IsValid());
assert(pos->PolicyRoot.IsValid());
return cmState::Snapshot(this, pos);
}
@ -754,12 +787,13 @@ cmState::CreateFunctionCallSnapshot(cmState::Snapshot originSnapshot,
{
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position,
*originSnapshot.Position);
pos->CallStackParent = originSnapshot.Position;
pos->EntryPointLine = entryPointLine;
pos->EntryPointCommand = entryPointCommand;
pos->SnapshotType = FunctionCallType;
pos->ExecutionListFile = this->ExecutionListFiles.Extend(
originSnapshot.Position->ExecutionListFile, fileName);
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->PolicyScope = originSnapshot.Position->Policies;
return cmState::Snapshot(this, pos);
}
@ -772,12 +806,13 @@ cmState::CreateMacroCallSnapshot(cmState::Snapshot originSnapshot,
{
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position,
*originSnapshot.Position);
pos->CallStackParent = originSnapshot.Position;
pos->EntryPointLine = entryPointLine;
pos->EntryPointCommand = entryPointCommand;
pos->SnapshotType = MacroCallType;
pos->ExecutionListFile = this->ExecutionListFiles.Extend(
originSnapshot.Position->ExecutionListFile, fileName);
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->PolicyScope = originSnapshot.Position->Policies;
return cmState::Snapshot(this, pos);
}
@ -789,12 +824,13 @@ cmState::CreateCallStackSnapshot(cmState::Snapshot originSnapshot,
{
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position,
*originSnapshot.Position);
pos->CallStackParent = originSnapshot.Position;
pos->EntryPointLine = entryPointLine;
pos->EntryPointCommand = entryPointCommand;
pos->SnapshotType = CallStackType;
pos->ExecutionListFile = this->ExecutionListFiles.Extend(
originSnapshot.Position->ExecutionListFile, fileName);
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->PolicyScope = originSnapshot.Position->Policies;
return cmState::Snapshot(this, pos);
}
@ -806,12 +842,24 @@ cmState::CreateInlineListFileSnapshot(cmState::Snapshot originSnapshot,
{
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position,
*originSnapshot.Position);
pos->CallStackParent = originSnapshot.Position;
pos->EntryPointLine = entryPointLine;
pos->EntryPointCommand = entryPointCommand;
pos->SnapshotType = InlineListFileType;
pos->ExecutionListFile = this->ExecutionListFiles.Extend(
originSnapshot.Position->ExecutionListFile, fileName);
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->PolicyScope = originSnapshot.Position->Policies;
return cmState::Snapshot(this, pos);
}
cmState::Snapshot
cmState::CreatePolicyScopeSnapshot(cmState::Snapshot originSnapshot)
{
PositionType pos = this->SnapshotData.Extend(originSnapshot.Position,
*originSnapshot.Position);
pos->SnapshotType = PolicyScopeType;
pos->BuildSystemDirectory->DirectoryEnd = pos;
pos->PolicyScope = originSnapshot.Position->Policies;
return cmState::Snapshot(this, pos);
}
@ -826,12 +874,9 @@ cmState::Snapshot cmState::Pop(cmState::Snapshot originSnapshot)
prevPos->BuildSystemDirectory->CompileDefinitions.size();
prevPos->CompileOptionsPosition =
prevPos->BuildSystemDirectory->CompileOptions.size();
prevPos->BuildSystemDirectory->DirectoryEnd = prevPos;
if (prevPos == this->SnapshotData.Root())
{
return Snapshot(this, prevPos);
}
return Snapshot(this, originSnapshot.Position->CallStackParent);
return Snapshot(this, prevPos);
}
cmState::Snapshot::Snapshot(cmState* state)
@ -847,6 +892,11 @@ cmState::Snapshot::Snapshot(cmState* state, PositionType position)
}
cmState::SnapshotType cmState::Snapshot::GetType() const
{
return this->Position->SnapshotType;
}
const char* cmState::Directory::GetCurrentSource() const
{
return this->DirectoryState->Location.c_str();
@ -964,13 +1014,22 @@ cmState::Snapshot cmState::Snapshot::GetCallStackParent() const
assert(this->Position != this->State->SnapshotData.Root());
Snapshot snapshot;
if (this->Position->SnapshotType == cmState::BuildsystemDirectoryType)
PositionType parentPos = this->Position;
while(parentPos->SnapshotType == cmState::PolicyScopeType)
{
++parentPos;
}
if (parentPos->SnapshotType == cmState::BuildsystemDirectoryType)
{
return snapshot;
}
PositionType parentPos = this->Position;
++parentPos;
while(parentPos->SnapshotType == cmState::PolicyScopeType)
{
++parentPos;
}
if (parentPos == this->State->SnapshotData.Root())
{
return snapshot;
@ -980,6 +1039,88 @@ cmState::Snapshot cmState::Snapshot::GetCallStackParent() const
return snapshot;
}
void cmState::Snapshot::PushPolicy(cmPolicies::PolicyMap entry, bool weak)
{
PositionType pos = this->Position;
pos->Policies =
this->State->PolicyStack.Extend(pos->Policies,
PolicyStackEntry(entry, weak));
}
bool cmState::Snapshot::PopPolicy()
{
PositionType pos = this->Position;
if (pos->Policies == pos->PolicyScope)
{
return false;
}
++pos->Policies;
return true;
}
bool cmState::Snapshot::CanPopPolicyScope()
{
return this->Position->Policies == this->Position->PolicyScope;
}
void cmState::Snapshot::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<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
cmState::Snapshot::GetPolicy(cmPolicies::PolicyID id) const
{
cmPolicies::PolicyStatus status = cmPolicies::GetPolicyStatus(id);
if(status == cmPolicies::REQUIRED_ALWAYS ||
status == cmPolicies::REQUIRED_IF_USED)
{
return status;
}
cmLinkedTree<BuildsystemDirectoryStateType>::iterator dir =
this->Position->BuildSystemDirectory;
while (true)
{
assert(dir.IsValid());
cmLinkedTree<PolicyStackEntry>::iterator leaf =
dir->DirectoryEnd->Policies;
cmLinkedTree<PolicyStackEntry>::iterator root =
dir->DirectoryEnd->PolicyRoot;
for( ; leaf != root; ++leaf)
{
if(leaf->IsDefined(id))
{
status = leaf->Get(id);
return status;
}
}
cmState::PositionType e = dir->DirectoryEnd;
cmState::PositionType p = e->DirectoryParent;
if (p == this->State->SnapshotData.Root())
{
break;
}
dir = p->BuildSystemDirectory;
}
return status;
}
bool cmState::Snapshot::HasDefinedPolicyCMP0011()
{
return !this->Position->Policies->IsEmpty();
}
static const std::string cmPropertySentinal = std::string();
template<typename T, typename U, typename V>

15
Source/cmState.h
View File

@ -17,6 +17,7 @@
#include "cmPropertyMap.h"
#include "cmLinkedTree.h"
#include "cmAlgorithms.h"
#include "cmPolicies.h"
class cmake;
class cmCommand;
@ -24,6 +25,7 @@ class cmCommand;
class cmState
{
struct SnapshotDataType;
struct PolicyStackEntry;
struct BuildsystemDirectoryStateType;
typedef cmLinkedTree<SnapshotDataType>::iterator PositionType;
friend class Snapshot;
@ -37,7 +39,8 @@ public:
FunctionCallType,
MacroCallType,
CallStackType,
InlineListFileType
InlineListFileType,
PolicyScopeType
};
class Directory;
@ -56,9 +59,17 @@ public:
bool IsValid() const;
Snapshot GetBuildsystemDirectoryParent() const;
Snapshot GetCallStackParent() const;
SnapshotType GetType() const;
void InitializeFromParent();
void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id) const;
bool HasDefinedPolicyCMP0011();
void PushPolicy(cmPolicies::PolicyMap entry, bool weak);
bool PopPolicy();
bool CanPopPolicyScope();
cmState* GetState() const;
Directory GetDirectory() const;
@ -147,6 +158,7 @@ public:
const std::string& entryPointCommand,
long entryPointLine,
std::string const& fileName);
Snapshot CreatePolicyScopeSnapshot(Snapshot originSnapshot);
Snapshot Pop(Snapshot originSnapshot);
enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
@ -254,6 +266,7 @@ private:
cmLinkedTree<std::string> ExecutionListFiles;
cmLinkedTree<PolicyStackEntry> PolicyStack;
cmLinkedTree<SnapshotDataType> SnapshotData;
std::vector<std::string> SourceDirectoryComponents;

1
Tests/RunCMake/CMakeLists.txt
View File

@ -146,6 +146,7 @@ add_RunCMake_test(TargetSources)
add_RunCMake_test(find_dependency)
add_RunCMake_test(CompileDefinitions)
add_RunCMake_test(CompileFeatures)
add_RunCMake_test(PolicyScope)
add_RunCMake_test(WriteCompilerDetectionHeader)
if(NOT WIN32)
add_RunCMake_test(PositionIndependentCode)

3
Tests/RunCMake/PolicyScope/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
cmake_minimum_required(VERSION 2.8.12)
project(${RunCMake_TEST} NONE)
include(${RunCMake_TEST}.cmake NO_POLICY_SCOPE)

4
Tests/RunCMake/PolicyScope/RunCMakeTest.cmake Normal file
View File

@ -0,0 +1,4 @@
include(RunCMake)
run_cmake(parent-dir-generate-time)
run_cmake(dir-in-macro-generate-time)

1
Tests/RunCMake/PolicyScope/dir-in-macro-generate-time-result.txt Normal file
View File

@ -0,0 +1 @@
0

5
Tests/RunCMake/PolicyScope/dir-in-macro-generate-time-stderr.txt Normal file
View File

@ -0,0 +1,5 @@
CMake Warning \(dev\) at dir1/CMakeLists.txt:5 \(target_compile_definitions\):
Policy CMP0044 is not set: Case sensitive <LANG>_COMPILER_ID generator
expressions. Run "cmake --help-policy CMP0044" for policy details. Use
the cmake_policy command to set the policy and suppress this warning.
This warning is for project developers. Use -Wno-dev to suppress it.

2
Tests/RunCMake/PolicyScope/dir-in-macro-generate-time.cmake Normal file
View File

@ -0,0 +1,2 @@
include(dir-in-macro-include.cmake)

6
Tests/RunCMake/PolicyScope/dir-in-macro-include.cmake Normal file
View File

@ -0,0 +1,6 @@
enable_language(CXX)
# This does not affect dir1 despite being set before the add_subdirectory.
cmake_policy(SET CMP0044 NEW)
add_subdirectory(dir1)

5
Tests/RunCMake/PolicyScope/dir1/CMakeLists.txt Normal file
View File

@ -0,0 +1,5 @@
add_library(foo STATIC foo.cpp)
string(TOLOWER ${CMAKE_CXX_COMPILER_ID} compiler_id)
target_compile_definitions(foo PRIVATE Foo=$<CXX_COMPILER_ID:${compiler_id}>)

5
Tests/RunCMake/PolicyScope/dir1/foo.cpp Normal file
View File

@ -0,0 +1,5 @@
int main()
{
return 0;
}

1
Tests/RunCMake/PolicyScope/parent-dir-generate-time-result.txt Normal file
View File

@ -0,0 +1 @@
0

7
Tests/RunCMake/PolicyScope/parent-dir-generate-time.cmake Normal file
View File

@ -0,0 +1,7 @@
enable_language(CXX)
add_subdirectory(dir1)
# This affects dir1 despite being set after the add_subdirectory.
cmake_policy(SET CMP0044 NEW)