[Cmake-commits] CMake branch, next, updated. v3.3.0-1327-g9ab64be
Stephen Kelly
steveire at gmail.com
Sat Jul 25 08:54:19 EDT 2015
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via 9ab64be4926fc764e76a96a33186ac7c28202c0b (commit)
via bbb507aebcb3559ae6e7d34ef02443e2d6ec3869 (commit)
via 6ed9c7e024d66d89ab303ba0d299fa4ee099f91b (commit)
via 8f0a5d84e3fa894c687089d5f6dd6463c47968d8 (commit)
from 08bce458d60eece4a22c3e1a56a881fc3b3357b2 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=9ab64be4926fc764e76a96a33186ac7c28202c0b
commit 9ab64be4926fc764e76a96a33186ac7c28202c0b
Merge: 08bce45 bbb507a
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sat Jul 25 08:54:18 2015 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Sat Jul 25 08:54:18 2015 -0400
Merge topic 'refactor-cmMakefile-properties' into next
bbb507ae cmMakefile: Move the InitializeFromParent method
6ed9c7e0 cmState: Host buildsystem properties for directories.
8f0a5d84 cmState: Fix compilation on IBM XL compiler
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=bbb507aebcb3559ae6e7d34ef02443e2d6ec3869
commit bbb507aebcb3559ae6e7d34ef02443e2d6ec3869
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Wed Jul 22 20:52:02 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Sat Jul 25 14:53:06 2015 +0200
cmMakefile: Move the InitializeFromParent method
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index c54f972..9a28c7c 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1554,13 +1554,13 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent)
// Initialize definitions with the closure of the parent scope.
this->Internal->InitializeDefinitions(parent);
+ this->StateSnapshot.InitializeFromParent();
+
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
this->GetCurrentSourceDirectory());
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
this->GetCurrentBinaryDirectory());
- this->StateSnapshot.InitializeFromParent();
-
this->SystemIncludeDirectories = parent->SystemIncludeDirectories;
// define flags
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=6ed9c7e024d66d89ab303ba0d299fa4ee099f91b
commit 6ed9c7e024d66d89ab303ba0d299fa4ee099f91b
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sat Jul 18 12:28:49 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Sat Jul 25 14:53:05 2015 +0200
cmState: Host buildsystem properties for directories.
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 9575aff..c54f972 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -273,68 +273,36 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
}
}
-template<typename Range, typename T>
-typename Range::const_iterator find_backwards(Range const& range, T t)
-{
- typename Range::const_reverse_iterator rend =
- std::find(range.rbegin(), range.rend(), t);
- return rend.base();
-}
-
-static const std::string cmPropertySentinal = std::string();
-
cmStringRange cmMakefile::GetIncludeDirectoriesEntries() const
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->IncludeDirectoriesEntries, cmPropertySentinal);
- return cmMakeRange(it, this->IncludeDirectoriesEntries.end());
+ return this->StateSnapshot.GetDirectory().GetIncludeDirectoriesEntries();
}
cmBacktraceRange cmMakefile::GetIncludeDirectoriesBacktraces() const
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->IncludeDirectoriesEntries, cmPropertySentinal);
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- this->IncludeDirectoriesEntryBacktraces.begin()
- + std::distance(this->IncludeDirectoriesEntries.begin(), it);
- return cmMakeRange(
- btIt, this->IncludeDirectoriesEntryBacktraces.end());
+ return this->StateSnapshot.GetDirectory()
+ .GetIncludeDirectoriesEntryBacktraces();
}
cmStringRange cmMakefile::GetCompileOptionsEntries() const
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileOptionsEntries, cmPropertySentinal);
- return cmMakeRange(it, this->CompileOptionsEntries.end());
+ return this->StateSnapshot.GetDirectory().GetCompileOptionsEntries();
}
cmBacktraceRange cmMakefile::GetCompileOptionsBacktraces() const
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileOptionsEntries, cmPropertySentinal);
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- this->CompileOptionsEntryBacktraces.begin()
- + std::distance(this->CompileOptionsEntries.begin(), it);
- return cmMakeRange(
- btIt, this->CompileOptionsEntryBacktraces.end());
+ return this->StateSnapshot.GetDirectory().GetCompileOptionsEntryBacktraces();
}
cmStringRange cmMakefile::GetCompileDefinitionsEntries() const
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileDefinitionsEntries, cmPropertySentinal);
- return cmMakeRange(it, this->CompileDefinitionsEntries.end());
+ return this->StateSnapshot.GetDirectory().GetCompileDefinitionsEntries();
}
cmBacktraceRange cmMakefile::GetCompileDefinitionsBacktraces() const
{
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- this->CompileDefinitionsEntryBacktraces.begin();
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileDefinitionsEntries, cmPropertySentinal)
- + std::distance(this->CompileDefinitionsEntries.begin(), it);
- return cmMakeRange(
- btIt, this->CompileDefinitionsEntryBacktraces.end());
+ return this->StateSnapshot.GetDirectory()
+ .GetCompileDefinitionsEntryBacktraces();
}
//----------------------------------------------------------------------------
@@ -1591,62 +1559,7 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent)
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
this->GetCurrentBinaryDirectory());
- {
- std::vector<std::string>::const_iterator it =
- find_backwards(parent->IncludeDirectoriesEntries, cmPropertySentinal);
- std::vector<std::string>::const_iterator begin =
- parent->IncludeDirectoriesEntries.begin();
- std::vector<std::string>::const_iterator end =
- parent->IncludeDirectoriesEntries.end();
- this->IncludeDirectoriesEntries.insert(
- this->IncludeDirectoriesEntries.end(), it, end);
-
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- parent->IncludeDirectoriesEntryBacktraces.begin()
- + std::distance(begin, it);
- std::vector<cmListFileBacktrace>::const_iterator btEnd =
- parent->IncludeDirectoriesEntryBacktraces.end();
- this->IncludeDirectoriesEntryBacktraces.insert(
- this->IncludeDirectoriesEntryBacktraces.end(), btIt, btEnd);
- }
-
- {
- std::vector<std::string>::const_iterator it =
- find_backwards(parent->CompileOptionsEntries, cmPropertySentinal);
- std::vector<std::string>::const_iterator begin =
- parent->CompileOptionsEntries.begin();
- std::vector<std::string>::const_iterator end =
- parent->CompileOptionsEntries.end();
- this->CompileOptionsEntries.insert(
- this->CompileOptionsEntries.end(), it, end);
-
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- parent->CompileOptionsEntryBacktraces.begin()
- + std::distance(begin, it);
- std::vector<cmListFileBacktrace>::const_iterator btEnd =
- parent->CompileOptionsEntryBacktraces.end();
- this->CompileOptionsEntryBacktraces.insert(
- this->CompileOptionsEntryBacktraces.end(), btIt, btEnd);
- }
-
- {
- std::vector<std::string>::const_iterator it =
- find_backwards(parent->CompileDefinitionsEntries, cmPropertySentinal);
- std::vector<std::string>::const_iterator begin =
- parent->CompileDefinitionsEntries.begin();
- std::vector<std::string>::const_iterator end =
- parent->CompileDefinitionsEntries.end();
- this->CompileDefinitionsEntries.insert(
- this->CompileDefinitionsEntries.end(), it, end);
-
- std::vector<cmListFileBacktrace>::const_iterator btIt =
- parent->CompileDefinitionsEntryBacktraces.begin()
- + std::distance(begin, it);
- std::vector<cmListFileBacktrace>::const_iterator btEnd =
- parent->CompileDefinitionsEntryBacktraces.end();
- this->CompileDefinitionsEntryBacktraces.insert(
- this->CompileDefinitionsEntryBacktraces.end(), btIt, btEnd);
- }
+ this->StateSnapshot.InitializeFromParent();
this->SystemIncludeDirectories = parent->SystemIncludeDirectories;
@@ -1990,17 +1903,18 @@ void cmMakefile::AddIncludeDirectories(const std::vector<std::string> &incs,
return;
}
- std::vector<std::string>::iterator position =
- before ? this->IncludeDirectoriesEntries.begin()
- : this->IncludeDirectoriesEntries.end();
- std::vector<cmListFileBacktrace>::iterator btPos =
- this->IncludeDirectoriesEntryBacktraces.begin()
- + std::distance(this->IncludeDirectoriesEntries.begin(), position);
-
cmListFileBacktrace lfbt = this->GetBacktrace();
std::string entryString = cmJoin(incs, ";");
- this->IncludeDirectoriesEntries.insert(position, entryString);
- this->IncludeDirectoriesEntryBacktraces.insert(btPos, lfbt);
+ if (before)
+ {
+ this->StateSnapshot.GetDirectory()
+ .PrependIncludeDirectoriesEntry(entryString, lfbt);
+ }
+ else
+ {
+ this->StateSnapshot.GetDirectory()
+ .AppendIncludeDirectoriesEntry(entryString, lfbt);
+ }
// Property on each target:
for (cmTargets::iterator l = this->Targets.begin();
@@ -4226,41 +4140,35 @@ void cmMakefile::SetProperty(const std::string& prop, const char* value)
{
if (prop == "INCLUDE_DIRECTORIES")
{
- this->IncludeDirectoriesEntries.push_back(cmPropertySentinal);
- this->IncludeDirectoriesEntryBacktraces.push_back(cmListFileBacktrace());
if (!value)
{
+ this->StateSnapshot.GetDirectory().ClearIncludeDirectories();
return;
}
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->IncludeDirectoriesEntries.push_back(value);
- this->IncludeDirectoriesEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().SetIncludeDirectories(value, lfbt);
return;
}
if (prop == "COMPILE_OPTIONS")
{
- this->CompileOptionsEntries.push_back(cmPropertySentinal);
- this->CompileDefinitionsEntryBacktraces.push_back(cmListFileBacktrace());
if (!value)
{
+ this->StateSnapshot.GetDirectory().ClearCompileOptions();
return;
}
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->CompileOptionsEntries.push_back(value);
- this->CompileOptionsEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().SetCompileOptions(value, lfbt);
return;
}
if (prop == "COMPILE_DEFINITIONS")
{
- this->CompileDefinitionsEntries.push_back(cmPropertySentinal);
- this->CompileDefinitionsEntryBacktraces.push_back(cmListFileBacktrace());
if (!value)
{
+ this->StateSnapshot.GetDirectory().ClearCompileDefinitions();
return;
}
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->CompileDefinitionsEntries.push_back(value);
- this->CompileDefinitionsEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().SetCompileDefinitions(value, lfbt);
return;
}
@@ -4274,22 +4182,21 @@ void cmMakefile::AppendProperty(const std::string& prop,
if (prop == "INCLUDE_DIRECTORIES")
{
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->IncludeDirectoriesEntries.push_back(value);
- this->IncludeDirectoriesEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().AppendIncludeDirectoriesEntry(value,
+ lfbt);
return;
}
if (prop == "COMPILE_OPTIONS")
{
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->CompileOptionsEntries.push_back(value);
- this->CompileOptionsEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().AppendCompileOptionsEntry(value, lfbt);
return;
}
if (prop == "COMPILE_DEFINITIONS")
{
cmListFileBacktrace lfbt = this->GetBacktrace();
- this->CompileDefinitionsEntries.push_back(value);
- this->CompileDefinitionsEntryBacktraces.push_back(lfbt);
+ this->StateSnapshot.GetDirectory().AppendCompileDefinitionsEntry(value,
+ lfbt);
return;
}
@@ -4344,25 +4251,20 @@ const char *cmMakefile::GetProperty(const std::string& prop,
}
else if (prop == "INCLUDE_DIRECTORIES")
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->IncludeDirectoriesEntries, cmPropertySentinal);
- output = cmJoin(cmMakeRange(it, this->IncludeDirectoriesEntries.end()),
- ";");
+ output = cmJoin(this->StateSnapshot.GetDirectory()
+ .GetIncludeDirectoriesEntries(), ";");
return output.c_str();
}
else if (prop == "COMPILE_OPTIONS")
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileOptionsEntries, cmPropertySentinal);
- output = cmJoin(cmMakeRange(it, this->CompileOptionsEntries.end()), ";");
+ output = cmJoin(this->StateSnapshot.GetDirectory()
+ .GetCompileOptionsEntries(), ";");
return output.c_str();
}
else if (prop == "COMPILE_DEFINITIONS")
{
- std::vector<std::string>::const_iterator it =
- find_backwards(this->CompileDefinitionsEntries, cmPropertySentinal);
- output = cmJoin(cmMakeRange(it, this->CompileDefinitionsEntries.end()),
- ";");
+ output = cmJoin(this->StateSnapshot.GetDirectory()
+ .GetCompileDefinitionsEntries(), ";");
return output.c_str();
}
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 27911a9..c335a33 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -846,13 +846,6 @@ protected:
std::vector<std::string> HeaderFileExtensions;
std::string DefineFlags;
- std::vector<std::string> IncludeDirectoriesEntries;
- std::vector<cmListFileBacktrace> IncludeDirectoriesEntryBacktraces;
- std::vector<std::string> CompileOptionsEntries;
- std::vector<cmListFileBacktrace> CompileOptionsEntryBacktraces;
- std::vector<std::string> CompileDefinitionsEntries;
- std::vector<cmListFileBacktrace> CompileDefinitionsEntryBacktraces;
-
// Track the value of the computed DEFINITIONS property.
void AddDefineFlag(const char*, std::string&);
void RemoveDefineFlag(const char*, std::string::size_type, std::string&);
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index d73148d..d8f8306 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -28,6 +28,9 @@ struct cmState::SnapshotDataType
BuildSystemDirectory;
std::string EntryPointCommand;
long EntryPointLine;
+ std::vector<std::string>::size_type IncludeDirectoryPosition;
+ std::vector<std::string>::size_type CompileDefinitionsPosition;
+ std::vector<std::string>::size_type CompileOptionsPosition;
};
struct cmState::BuildsystemDirectoryStateType
@@ -44,6 +47,15 @@ struct cmState::BuildsystemDirectoryStateType
// 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;
};
cmState::cmState(cmake* cm)
@@ -228,7 +240,16 @@ cmState::Snapshot cmState::Reset()
this->GlobalProperties.clear();
this->PropertyDefinitions.clear();
- this->BuildsystemDirectory.Truncate();
+ {
+ cmLinkedTree<BuildsystemDirectoryStateType>::iterator it =
+ this->BuildsystemDirectory.Truncate();
+ it->IncludeDirectories.clear();
+ it->IncludeDirectoryBacktraces.clear();
+ it->CompileDefinitions.clear();
+ it->CompileDefinitionsBacktraces.clear();
+ it->CompileOptions.clear();
+ it->CompileOptionsBacktraces.clear();
+ }
PositionType pos = this->SnapshotData.Truncate();
this->ExecutionListFiles.Truncate();
@@ -698,6 +719,9 @@ cmState::Snapshot cmState::CreateBaseSnapshot()
this->BuildsystemDirectory.Extend(this->BuildsystemDirectory.Root());
pos->ExecutionListFile =
this->ExecutionListFiles.Extend(this->ExecutionListFiles.Root());
+ pos->IncludeDirectoryPosition = 0;
+ pos->CompileDefinitionsPosition = 0;
+ pos->CompileOptionsPosition = 0;
return cmState::Snapshot(this, pos);
}
@@ -796,6 +820,13 @@ cmState::Snapshot cmState::Pop(cmState::Snapshot originSnapshot)
PositionType pos = originSnapshot.Position;
PositionType prevPos = pos;
++prevPos;
+ prevPos->IncludeDirectoryPosition =
+ prevPos->BuildSystemDirectory->IncludeDirectories.size();
+ prevPos->CompileDefinitionsPosition =
+ prevPos->BuildSystemDirectory->CompileDefinitions.size();
+ prevPos->CompileOptionsPosition =
+ prevPos->BuildSystemDirectory->CompileOptions.size();
+
if (prevPos == this->SnapshotData.Root())
{
return Snapshot(this, prevPos);
@@ -949,6 +980,62 @@ cmState::Snapshot cmState::Snapshot::GetCallStackParent() const
return snapshot;
}
+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 cmState::Snapshot::InitializeFromParent()
+{
+ PositionType parent = this->Position->DirectoryParent;
+
+ 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* cmState::Snapshot::GetState() const
{
return this->State;
@@ -966,3 +1053,220 @@ cmState::Directory::Directory(
{
}
+
+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& vec, const cmListFileBacktrace& lfbt)
+{
+ assert(endContentPosition == content.size());
+
+ content.push_back(vec);
+ 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
+cmState::Directory::GetIncludeDirectoriesEntries() const
+{
+ return GetPropertyContent(this->DirectoryState->IncludeDirectories,
+ this->Snapshot_.Position->IncludeDirectoryPosition);
+}
+
+cmBacktraceRange
+cmState::Directory::GetIncludeDirectoriesEntryBacktraces() const
+{
+ return GetPropertyBacktraces(this->DirectoryState->IncludeDirectories,
+ this->DirectoryState->IncludeDirectoryBacktraces,
+ this->Snapshot_.Position->IncludeDirectoryPosition);
+}
+
+void cmState::Directory::AppendIncludeDirectoriesEntry(
+ const std::string& vec, const cmListFileBacktrace& lfbt)
+{
+ AppendEntry(this->DirectoryState->IncludeDirectories,
+ this->DirectoryState->IncludeDirectoryBacktraces,
+ this->Snapshot_.Position->IncludeDirectoryPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::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>::const_reverse_iterator rend =
+ this->DirectoryState->IncludeDirectories.rend();
+ std::vector<std::string>::reverse_iterator rbegin =
+ cmMakeReverseIterator(entryEnd);
+ std::vector<std::string>::const_reverse_iterator crbegin = rbegin;
+ crbegin = std::find(crbegin, rend, cmPropertySentinal);
+
+ std::vector<std::string>::const_iterator entryIt = crbegin.base();
+ std::vector<std::string>::const_iterator entryBegin =
+ this->DirectoryState->IncludeDirectories.begin();
+
+ std::vector<cmListFileBacktrace>::iterator btIt =
+ this->DirectoryState->IncludeDirectoryBacktraces.begin()
+ + std::distance(entryBegin, entryIt);
+
+ this->DirectoryState->IncludeDirectories.insert(rbegin.base(), vec);
+ this->DirectoryState->IncludeDirectoryBacktraces.insert(btIt, lfbt);
+
+ this->Snapshot_.Position->IncludeDirectoryPosition =
+ this->DirectoryState->IncludeDirectories.size();
+}
+
+void cmState::Directory::SetIncludeDirectories(
+ const std::string& vec, const cmListFileBacktrace& lfbt)
+{
+ SetContent(this->DirectoryState->IncludeDirectories,
+ this->DirectoryState->IncludeDirectoryBacktraces,
+ this->Snapshot_.Position->IncludeDirectoryPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::ClearIncludeDirectories()
+{
+ ClearContent(this->DirectoryState->IncludeDirectories,
+ this->DirectoryState->IncludeDirectoryBacktraces,
+ this->Snapshot_.Position->IncludeDirectoryPosition);
+}
+
+cmStringRange cmState::Directory::GetCompileDefinitionsEntries() const
+{
+ return GetPropertyContent(this->DirectoryState->CompileDefinitions,
+ this->Snapshot_.Position->CompileDefinitionsPosition);
+}
+
+cmBacktraceRange
+cmState::Directory::GetCompileDefinitionsEntryBacktraces() const
+{
+ return GetPropertyBacktraces(this->DirectoryState->CompileDefinitions,
+ this->DirectoryState->CompileDefinitionsBacktraces,
+ this->Snapshot_.Position->CompileDefinitionsPosition);
+}
+
+void cmState::Directory::AppendCompileDefinitionsEntry(const std::string& vec,
+ const cmListFileBacktrace& lfbt)
+{
+ AppendEntry(this->DirectoryState->CompileDefinitions,
+ this->DirectoryState->CompileDefinitionsBacktraces,
+ this->Snapshot_.Position->CompileDefinitionsPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::SetCompileDefinitions(const std::string& vec,
+ const cmListFileBacktrace& lfbt)
+{
+ SetContent(this->DirectoryState->CompileDefinitions,
+ this->DirectoryState->CompileDefinitionsBacktraces,
+ this->Snapshot_.Position->CompileDefinitionsPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::ClearCompileDefinitions()
+{
+ ClearContent(this->DirectoryState->CompileDefinitions,
+ this->DirectoryState->CompileDefinitionsBacktraces,
+ this->Snapshot_.Position->CompileDefinitionsPosition);
+}
+
+cmStringRange cmState::Directory::GetCompileOptionsEntries() const
+{
+ return GetPropertyContent(this->DirectoryState->CompileOptions,
+ this->Snapshot_.Position->CompileOptionsPosition);
+}
+
+cmBacktraceRange cmState::Directory::GetCompileOptionsEntryBacktraces() const
+{
+ return GetPropertyBacktraces(this->DirectoryState->CompileOptions,
+ this->DirectoryState->CompileOptionsBacktraces,
+ this->Snapshot_.Position->CompileOptionsPosition);
+}
+
+void
+cmState::Directory::AppendCompileOptionsEntry(const std::string& vec,
+ const cmListFileBacktrace& lfbt)
+{
+ AppendEntry(this->DirectoryState->CompileOptions,
+ this->DirectoryState->CompileOptionsBacktraces,
+ this->Snapshot_.Position->CompileOptionsPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::SetCompileOptions(const std::string& vec,
+ const cmListFileBacktrace& lfbt)
+{
+ SetContent(this->DirectoryState->CompileOptions,
+ this->DirectoryState->CompileOptionsBacktraces,
+ this->Snapshot_.Position->CompileOptionsPosition,
+ vec, lfbt);
+}
+
+void cmState::Directory::ClearCompileOptions()
+{
+ ClearContent(this->DirectoryState->CompileOptions,
+ this->DirectoryState->CompileOptionsBacktraces,
+ this->Snapshot_.Position->CompileOptionsPosition);
+}
diff --git a/Source/cmState.h b/Source/cmState.h
index 17ee6ec..0d5300f 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -16,6 +16,7 @@
#include "cmPropertyDefinitionMap.h"
#include "cmPropertyMap.h"
#include "cmLinkedTree.h"
+#include "cmAlgorithms.h"
class cmake;
class cmCommand;
@@ -56,6 +57,8 @@ public:
Snapshot GetBuildsystemDirectoryParent() const;
Snapshot GetCallStackParent() const;
+ void InitializeFromParent();
+
cmState* GetState() const;
Directory GetDirectory() const;
@@ -87,6 +90,32 @@ public:
void SetRelativePathTopSource(const char* dir);
void SetRelativePathTopBinary(const char* dir);
+ cmStringRange GetIncludeDirectoriesEntries() const;
+ cmBacktraceRange GetIncludeDirectoriesEntryBacktraces() const;
+ void AppendIncludeDirectoriesEntry(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void PrependIncludeDirectoriesEntry(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void SetIncludeDirectories(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void ClearIncludeDirectories();
+
+ cmStringRange GetCompileDefinitionsEntries() const;
+ cmBacktraceRange GetCompileDefinitionsEntryBacktraces() const;
+ void AppendCompileDefinitionsEntry(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void SetCompileDefinitions(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void ClearCompileDefinitions();
+
+ cmStringRange GetCompileOptionsEntries() const;
+ cmBacktraceRange GetCompileOptionsEntryBacktraces() const;
+ void AppendCompileOptionsEntry(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void SetCompileOptions(std::string const& vec,
+ cmListFileBacktrace const& lfbt);
+ void ClearCompileOptions();
+
private:
void ComputeRelativePathTopSource();
void ComputeRelativePathTopBinary();
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8f0a5d84e3fa894c687089d5f6dd6463c47968d8
commit 8f0a5d84e3fa894c687089d5f6dd6463c47968d8
Author: Brad King <brad.king at kitware.com>
AuthorDate: Thu Jul 23 09:11:37 2015 -0400
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Sat Jul 25 14:52:05 2015 +0200
cmState: Fix compilation on IBM XL compiler
Delay use of the PositionType constructor until after SnapshotDataType
is fully defined.
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 9cbb841..d73148d 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -803,6 +803,12 @@ cmState::Snapshot cmState::Pop(cmState::Snapshot originSnapshot)
return Snapshot(this, originSnapshot.Position->CallStackParent);
}
+cmState::Snapshot::Snapshot(cmState* state)
+ : State(state)
+ , Position()
+{
+}
+
cmState::Snapshot::Snapshot(cmState* state, PositionType position)
: State(state),
Position(position)
diff --git a/Source/cmState.h b/Source/cmState.h
index acd23a5..17ee6ec 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -43,7 +43,8 @@ public:
class Snapshot {
public:
- Snapshot(cmState* state = 0, PositionType position = PositionType());
+ Snapshot(cmState* state = 0);
+ Snapshot(cmState* state, PositionType position);
void SetListFile(std::string const& listfile);
-----------------------------------------------------------------------
Summary of changes:
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list