cmState: Split auxiliary classes into separate files

Port dependents to the new locations as needed.

Leave behind a cmState.h include in cmListFileCache to reduce noise. It
is removed in a following commit.

1 files changed, 2 insertions, 992 deletions

diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 32fe66c..0d1eb3e 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -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)
 {