Merge topic 'refactor-cmListFileBacktrace'

0f96ef00 Remove unused cmake::IssueMessage overload
563bf9dd cmState: Remove unused entry point fields from snapshot data
7c36d206 cmListFileBacktrace: Refactor storage to provide efficient value semantics
1f6bd8a9 cmState: Avoid accumulating snapshot storage for backtraces
18b6676b cmState: Add Snapshot method to get bottom of call stack

Source/cmListFileCache.cxx

@@ -398,65 +398,173 @@ bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
     }
 }
 
-cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot,
-                                         cmCommandContext const& cc)
-  : Context(cc)
-  , Snapshot(snapshot)
+struct cmListFileBacktrace::Entry: public cmListFileContext
 {
-  if (this->Snapshot.IsValid())
+  Entry(cmListFileContext const& lfc, Entry* up):
+    cmListFileContext(lfc), Up(up), RefCount(0)
     {
-    this->Snapshot.Keep();
+    if (this->Up)
+      {
+      this->Up->Ref();
       }
     }
+  ~Entry()
+    {
+    if (this->Up)
+      {
+      this->Up->Unref();
+      }
+    }
+  void Ref()
+    {
+    ++this->RefCount;
+    }
+  void Unref()
+    {
+    if (--this->RefCount == 0)
+      {
+      delete this;
+      }
+    }
+  Entry* Up;
+  unsigned int RefCount;
+};
+
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom,
+                                         Entry* up,
+                                         cmListFileContext const& lfc):
+  Bottom(bottom), Cur(new Entry(lfc, up))
+{
+  assert(this->Bottom.IsValid());
+  this->Cur->Ref();
+}
+
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur):
+  Bottom(bottom), Cur(cur)
+{
+  if (this->Cur)
+    {
+    assert(this->Bottom.IsValid());
+    this->Cur->Ref();
+    }
+}
+
+cmListFileBacktrace::cmListFileBacktrace(): Bottom(), Cur(0)
+{
+}
+
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot):
+  Bottom(snapshot.GetCallStackBottom()), Cur(0)
+{
+}
+
+cmListFileBacktrace::cmListFileBacktrace(cmListFileBacktrace const& r):
+  Bottom(r.Bottom), Cur(r.Cur)
+{
+  if (this->Cur)
+    {
+    assert(this->Bottom.IsValid());
+    this->Cur->Ref();
+    }
+}
+
+cmListFileBacktrace&
+cmListFileBacktrace::operator=(cmListFileBacktrace const& r)
+{
+  cmListFileBacktrace tmp(r);
+  std::swap(this->Cur, tmp.Cur);
+  std::swap(this->Bottom, tmp.Bottom);
+  return *this;
+}
 
 cmListFileBacktrace::~cmListFileBacktrace()
 {
+  if (this->Cur)
+    {
+    this->Cur->Unref();
+    }
+}
+
+cmListFileBacktrace
+cmListFileBacktrace::Push(std::string const& file) const
+{
+  // We are entering a file-level scope but have not yet reached
+  // any specific line or command invocation within it.  This context
+  // is useful to print when it is at the top but otherwise can be
+  // skipped during call stack printing.
+  cmListFileContext lfc;
+  lfc.FilePath = file;
+  return cmListFileBacktrace(this->Bottom, this->Cur, lfc);
+}
+
+cmListFileBacktrace
+cmListFileBacktrace::Push(cmListFileContext const& lfc) const
+{
+  return cmListFileBacktrace(this->Bottom, this->Cur, lfc);
+}
+
+cmListFileBacktrace cmListFileBacktrace::Pop() const
+{
+  assert(this->Cur);
+  return cmListFileBacktrace(this->Bottom, this->Cur->Up);
+}
+
+cmListFileContext const& cmListFileBacktrace::Top() const
+{
+  if (this->Cur)
+    {
+    return *this->Cur;
+    }
+  else
+    {
+    static cmListFileContext const empty;
+    return empty;
+    }
 }
 
 void cmListFileBacktrace::PrintTitle(std::ostream& out) const
 {
-  if (!this->Snapshot.IsValid())
+  if (!this->Cur)
     {
     return;
     }
-  cmOutputConverter converter(this->Snapshot);
-  cmListFileContext lfc =
-      cmListFileContext::FromCommandContext(
-        this->Context, this->Snapshot.GetExecutionListFile());
+  cmOutputConverter converter(this->Bottom);
+  cmListFileContext lfc = *this->Cur;
+  if (!this->Bottom.GetState()->GetIsInTryCompile())
+    {
     lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
+    }
   out << (lfc.Line ? " at " : " in ") << lfc;
 }
 
 void cmListFileBacktrace::PrintCallStack(std::ostream& out) const
 {
-  if (!this->Snapshot.IsValid())
-    {
-    return;
-    }
-  cmState::Snapshot parent = this->Snapshot.GetCallStackParent();
-  if (!parent.IsValid() || parent.GetExecutionListFile().empty())
+  if (!this->Cur || !this->Cur->Up)
     {
     return;
     }
 
-  cmOutputConverter converter(this->Snapshot);
-  std::string commandName = this->Snapshot.GetEntryPointCommand();
-  long commandLine = this->Snapshot.GetEntryPointLine();
-
+  bool first = true;
+  cmOutputConverter converter(this->Bottom);
+  for (Entry* i = this->Cur->Up; i; i = i->Up)
+    {
+    if (i->Name.empty())
+      {
+      // Skip this whole-file scope.  When we get here we already will
+      // have printed a more-specific context within the file.
+      continue;
+      }
+    if (first)
+      {
+      first = false;
       out << "Call Stack (most recent call first):\n";
-  while(parent.IsValid())
+      }
+    cmListFileContext lfc = *i;
+    if (!this->Bottom.GetState()->GetIsInTryCompile())
       {
-    cmListFileContext lfc;
-    lfc.Name = commandName;
-    lfc.Line = commandLine;
-
-    lfc.FilePath = converter.Convert(parent.GetExecutionListFile(),
-                                     cmOutputConverter::HOME);
+      lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
+      }
     out << "  " << lfc << "\n";
-
-    commandName = parent.GetEntryPointCommand();
-    commandLine = parent.GetEntryPointLine();
-    parent = parent.GetCallStackParent();
     }
 }
 

Source/cmListFileCache.h

@@ -87,18 +87,53 @@ struct cmListFileFunction: public cmCommandContext
   std::vector<cmListFileArgument> Arguments;
 };
 
+// Represent a backtrace (call stack).  Provide value semantics
+// but use efficient reference-counting underneath to avoid copies.
 class cmListFileBacktrace
 {
 public:
-    cmListFileBacktrace(cmState::Snapshot snapshot = cmState::Snapshot(),
-                        cmCommandContext const& cc = cmCommandContext());
+  // Default-constructed backtrace may not be used until after
+  // set via assignment from a backtrace constructed with a
+  // valid snapshot.
+  cmListFileBacktrace();
+
+  // Construct an empty backtrace whose bottom sits in the directory
+  // indicated by the given valid snapshot.
+  cmListFileBacktrace(cmState::Snapshot snapshot);
+
+  // Backtraces may be copied and assigned as values.
+  cmListFileBacktrace(cmListFileBacktrace const& r);
+  cmListFileBacktrace& operator=(cmListFileBacktrace const& r);
   ~cmListFileBacktrace();
 
+  // Get a backtrace with the given file scope added to the top.
+  // May not be called until after construction with a valid snapshot.
+  cmListFileBacktrace Push(std::string const& file) const;
+
+  // Get a backtrace with the given call context added to the top.
+  // May not be called until after construction with a valid snapshot.
+  cmListFileBacktrace Push(cmListFileContext const& lfc) const;
+
+  // Get a backtrace with the top level removed.
+  // May not be called until after a matching Push.
+  cmListFileBacktrace Pop() const;
+
+  // Get the context at the top of the backtrace.
+  // Returns an empty context if the backtrace is empty.
+  cmListFileContext const& Top() const;
+
+  // Print the top of the backtrace.
   void PrintTitle(std::ostream& out) const;
+
+  // Print the call stack below the top of the backtrace.
   void PrintCallStack(std::ostream& out) const;
 private:
-    cmCommandContext Context;
-    cmState::Snapshot Snapshot;
+  struct Entry;
+  cmState::Snapshot Bottom;
+  Entry* Cur;
+  cmListFileBacktrace(cmState::Snapshot bottom, Entry* up,
+                      cmListFileContext const& lfc);
+  cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur);
 };
 
 struct cmListFile

Source/cmMakefile.cxx

@@ -46,7 +46,8 @@
 cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator,
                        cmState::Snapshot const& snapshot)
   : GlobalGenerator(globalGenerator),
-    StateSnapshot(snapshot)
+    StateSnapshot(snapshot),
+    Backtrace(snapshot)
 {
   this->IsSourceFileTryCompile = false;
 
@@ -115,24 +116,8 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
       {
       this->ExecutionStatusStack.back()->SetNestedError(true);
       }
-    this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace(),
-                                           force);
-    }
-  else
-    {
-    cmListFileContext lfc;
-    // We are not currently executing a command.  Add whatever context
-    // information we have.
-    lfc.FilePath = this->GetExecutionFilePath();
-
-    if(!this->GetCMakeInstance()->GetIsInTryCompile())
-      {
-      cmOutputConverter converter(this->StateSnapshot);
-      lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
-      }
-    lfc.Line = 0;
-    this->GetCMakeInstance()->IssueMessage(t, text, lfc, force);
     }
+  this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace(), force);
 }
 
 cmStringRange cmMakefile::GetIncludeDirectoriesEntries() const
@@ -170,29 +155,28 @@ cmBacktraceRange cmMakefile::GetCompileDefinitionsBacktraces() const
 //----------------------------------------------------------------------------
 cmListFileBacktrace cmMakefile::GetBacktrace() const
 {
-  cmListFileBacktrace backtrace;
-  if (!this->ContextStack.empty())
-    {
-    backtrace = cmListFileBacktrace(this->StateSnapshot,
-                                    *this->ContextStack.back());
-    }
-  return backtrace;
+  return this->Backtrace;
 }
 
 //----------------------------------------------------------------------------
-cmListFileBacktrace
-cmMakefile::GetBacktrace(cmCommandContext const& cc) const
+cmListFileBacktrace cmMakefile::GetBacktrace(cmCommandContext const& cc) const
 {
-  cmState::Snapshot snp = this->StateSnapshot;
-  return cmListFileBacktrace(snp, cc);
+  cmListFileContext lfc;
+  lfc.Name = cc.Name;
+  lfc.Line = cc.Line;
+  lfc.FilePath = this->StateSnapshot.GetExecutionListFile();
+  return this->Backtrace.Push(lfc);
 }
 
 //----------------------------------------------------------------------------
 cmListFileContext cmMakefile::GetExecutionContext() const
 {
-  return cmListFileContext::FromCommandContext(
-        *this->ContextStack.back(),
-        this->StateSnapshot.GetExecutionListFile());
+  cmListFileContext const& cur = this->Backtrace.Top();
+  cmListFileContext lfc;
+  lfc.Name = cur.Name;
+  lfc.Line = cur.Line;
+  lfc.FilePath = this->StateSnapshot.GetExecutionListFile();
+  return lfc;
 }
 
 //----------------------------------------------------------------------------
@@ -226,17 +210,20 @@ void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
 class cmMakefileCall
 {
 public:
-  cmMakefileCall(cmMakefile* mf, const cmCommandContext& lfc,
+  cmMakefileCall(cmMakefile* mf, cmCommandContext const& cc,
                  cmExecutionStatus& status): Makefile(mf)
     {
-    this->Makefile->ContextStack.push_back(&lfc);
+    cmListFileContext const& lfc =
+      cmListFileContext::FromCommandContext(
+        cc, this->Makefile->StateSnapshot.GetExecutionListFile());
+    this->Makefile->Backtrace = this->Makefile->Backtrace.Push(lfc);
     this->Makefile->ExecutionStatusStack.push_back(&status);
     }
 
   ~cmMakefileCall()
     {
     this->Makefile->ExecutionStatusStack.pop_back();
-    this->Makefile->ContextStack.pop_back();
+    this->Makefile->Backtrace = this->Makefile->Backtrace.Pop();
     }
 private:
   cmMakefile* Makefile;
@@ -350,13 +337,14 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
   Makefile(mf), NoPolicyScope(noPolicyScope),
   CheckCMP0011(false), ReportError(true)
 {
+  this->Makefile->Backtrace =
+    this->Makefile->Backtrace.Push(filenametoread);
+
   this->Makefile->PushFunctionBlockerBarrier();
 
   this->Makefile->StateSnapshot =
       this->Makefile->GetState()->CreateIncludeFileSnapshot(
         this->Makefile->StateSnapshot,
-        this->Makefile->ContextStack.back()->Name,
-        this->Makefile->ContextStack.back()->Line,
         filenametoread);
   if(!this->NoPolicyScope)
     {
@@ -416,6 +404,8 @@ cmMakefile::IncludeScope::~IncludeScope()
   this->Makefile->PopSnapshot(this->ReportError);
 
   this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
+
+  this->Makefile->Backtrace = this->Makefile->Backtrace.Pop();
 }
 
 //----------------------------------------------------------------------------
@@ -458,25 +448,6 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
     }
 }
 
-class cmParseFileScope
-{
-public:
-  cmParseFileScope(cmMakefile* mf)
-    : Makefile(mf)
-  {
-    this->Makefile->ContextStack.push_back(&this->Context);
-  }
-
-  ~cmParseFileScope()
-  {
-    this->Makefile->ContextStack.pop_back();
-  }
-
-private:
-  cmMakefile* Makefile;
-  cmCommandContext Context;
-};
-
 bool cmMakefile::ReadDependentFile(const char* filename, bool noPolicyScope)
 {
   this->AddDefinition("CMAKE_PARENT_LIST_FILE",
@@ -488,13 +459,10 @@ bool cmMakefile::ReadDependentFile(const char* filename, bool noPolicyScope)
   IncludeScope incScope(this, filenametoread, noPolicyScope);
 
   cmListFile listFile;
-  {
-  cmParseFileScope pfs(this);
   if (!listFile.ParseFile(filenametoread.c_str(), false, this))
     {
     return false;
     }
-  }
 
   this->ReadListFile(listFile, filenametoread);
   if(cmSystemTools::GetFatalErrorOccured())
@@ -510,16 +478,12 @@ public:
   ListFileScope(cmMakefile* mf, std::string const& filenametoread)
     : Makefile(mf), ReportError(true)
   {
-    long line = 0;
-    std::string name;
-    if (!this->Makefile->ContextStack.empty())
-      {
-      line = this->Makefile->ContextStack.back()->Line;
-      name = this->Makefile->ContextStack.back()->Name;
-      }
+    this->Makefile->Backtrace =
+      this->Makefile->Backtrace.Push(filenametoread);
+
     this->Makefile->StateSnapshot =
         this->Makefile->GetState()->CreateInlineListFileSnapshot(
-          this->Makefile->StateSnapshot, name, line, filenametoread);
+          this->Makefile->StateSnapshot, filenametoread);
     assert(this->Makefile->StateSnapshot.IsValid());
 
     this->Makefile->PushFunctionBlockerBarrier();
@@ -529,6 +493,7 @@ public:
   {
     this->Makefile->PopSnapshot(this->ReportError);
     this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
+    this->Makefile->Backtrace = this->Makefile->Backtrace.Pop();
   }
 
   void Quiet() { this->ReportError = false; }
@@ -546,13 +511,10 @@ bool cmMakefile::ReadListFile(const char* filename)
   ListFileScope scope(this, filenametoread);
 
   cmListFile listFile;
-  {
-  cmParseFileScope pfs(this);
   if (!listFile.ParseFile(filenametoread.c_str(), false, this))
     {
     return false;
     }
-  }
 
   this->ReadListFile(listFile, filenametoread);
   if(cmSystemTools::GetFatalErrorOccured())
@@ -1525,9 +1487,7 @@ void cmMakefile::PushFunctionScope(std::string const& fileName,
 {
   this->StateSnapshot =
       this->GetState()->CreateFunctionCallSnapshot(
-        this->StateSnapshot,
-        this->ContextStack.back()->Name, this->ContextStack.back()->Line,
-        fileName);
+        this->StateSnapshot, fileName);
   assert(this->StateSnapshot.IsValid());
 
   this->PushLoopBlockBarrier();
@@ -1563,9 +1523,7 @@ void cmMakefile::PushMacroScope(std::string const& fileName,
 {
   this->StateSnapshot =
       this->GetState()->CreateMacroCallSnapshot(
-        this->StateSnapshot,
-        this->ContextStack.back()->Name, this->ContextStack.back()->Line,
-        fileName);
+        this->StateSnapshot, fileName);
   assert(this->StateSnapshot.IsValid());
 
   this->PushFunctionBlockerBarrier();
@@ -1633,6 +1591,15 @@ private:
 //----------------------------------------------------------------------------
 void cmMakefile::Configure()
 {
+  std::string currentStart =
+      this->StateSnapshot.GetDirectory().GetCurrentSource();
+  currentStart += "/CMakeLists.txt";
+
+  // Add the bottom of all backtraces within this directory.
+  // We will never pop this scope because it should be available
+  // for messages during the generate step too.
+  this->Backtrace = this->Backtrace.Push(currentStart);
+
   BuildsystemFileScope scope(this);
 
   // make sure the CMakeFiles dir is there
@@ -1640,20 +1607,14 @@ void cmMakefile::Configure()
   filesDir += cmake::GetCMakeFilesDirectory();
   cmSystemTools::MakeDirectory(filesDir.c_str());
 
-  std::string currentStart =
-      this->StateSnapshot.GetDirectory().GetCurrentSource();
-  currentStart += "/CMakeLists.txt";
   assert(cmSystemTools::FileExists(currentStart.c_str(), true));
   this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart.c_str());
 
   cmListFile listFile;
-  {
-  cmParseFileScope pfs(this);
   if (!listFile.ParseFile(currentStart.c_str(), this->IsRootMakefile(), this))
     {
     return;
     }
-  }
   this->ReadListFile(listFile, currentStart);
   if(cmSystemTools::GetFatalErrorOccured())
     {
@@ -1740,9 +1701,7 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath,
     }
 
   cmState::Snapshot newSnapshot = this->GetState()
-      ->CreateBuildsystemDirectorySnapshot(this->StateSnapshot,
-                                           this->ContextStack.back()->Name,
-                                           this->ContextStack.back()->Line);
+      ->CreateBuildsystemDirectorySnapshot(this->StateSnapshot);
 
   newSnapshot.GetDirectory().SetCurrentSource(srcPath);
   newSnapshot.GetDirectory().SetCurrentBinary(binPath);
@@ -4128,17 +4087,8 @@ std::string cmMakefile::FormatListFileStack() const
 
 void cmMakefile::PushScope()
 {
-  std::string commandName;
-  long line = 0;
-  if (!this->ContextStack.empty())
-    {
-    commandName = this->ContextStack.back()->Name;
-    line = this->ContextStack.back()->Line;
-    }
   this->StateSnapshot = this->GetState()->CreateVariableScopeSnapshot(
-        this->StateSnapshot,
-        commandName,
-        line);
+        this->StateSnapshot);
   this->PushLoopBlockBarrier();
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)

Source/cmMakefile.h

@@ -835,6 +835,7 @@ private:
   cmMakefile& operator=(const cmMakefile& mf);
 
   cmState::Snapshot StateSnapshot;
+  cmListFileBacktrace Backtrace;
 
   void ReadListFile(cmListFile const& listFile,
                     const std::string& filenametoread);
@@ -862,7 +863,6 @@ private:
 
   std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;
 
-  std::vector<cmCommandContext const*> ContextStack;
   std::vector<cmExecutionStatus*> ExecutionStatusStack;
   friend class cmMakefileCall;
   friend class cmParseFileScope;

Source/cmState.cxx

@@ -35,8 +35,6 @@ struct cmState::SnapshotDataType
   cmLinkedTree<cmDefinitions>::iterator Vars;
   cmLinkedTree<cmDefinitions>::iterator Root;
   cmLinkedTree<cmDefinitions>::iterator Parent;
-  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;
@@ -845,14 +843,10 @@ cmState::Snapshot cmState::CreateBaseSnapshot()
 }
 
 cmState::Snapshot
-cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
-                                    std::string const& entryPointCommand,
-                                    long entryPointLine)
+cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot)
 {
   assert(originSnapshot.IsValid());
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position);
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->DirectoryParent = originSnapshot.Position;
   pos->ScopeParent = originSnapshot.Position;
   pos->SnapshotType = BuildsystemDirectoryType;
@@ -886,15 +880,11 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
 
 cmState::Snapshot
 cmState::CreateFunctionCallSnapshot(cmState::Snapshot originSnapshot,
-                                    std::string const& entryPointCommand,
-                                    long entryPointLine,
                                     std::string const& fileName)
 {
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
                                              *originSnapshot.Position);
   pos->ScopeParent = originSnapshot.Position;
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->SnapshotType = FunctionCallType;
   pos->Keep = false;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
@@ -912,14 +902,10 @@ cmState::CreateFunctionCallSnapshot(cmState::Snapshot originSnapshot,
 
 cmState::Snapshot
 cmState::CreateMacroCallSnapshot(cmState::Snapshot originSnapshot,
-                                    std::string const& entryPointCommand,
-                                    long entryPointLine,
                                     std::string const& fileName)
 {
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
                                              *originSnapshot.Position);
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->SnapshotType = MacroCallType;
   pos->Keep = false;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
@@ -932,14 +918,10 @@ cmState::CreateMacroCallSnapshot(cmState::Snapshot originSnapshot,
 
 cmState::Snapshot
 cmState::CreateIncludeFileSnapshot(cmState::Snapshot originSnapshot,
-                                   const std::string& entryPointCommand,
-                                   long entryPointLine,
                                    const std::string& fileName)
 {
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
                                              *originSnapshot.Position);
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->SnapshotType = IncludeFileType;
   pos->Keep = true;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
@@ -951,15 +933,11 @@ cmState::CreateIncludeFileSnapshot(cmState::Snapshot originSnapshot,
 }
 
 cmState::Snapshot
-cmState::CreateVariableScopeSnapshot(cmState::Snapshot originSnapshot,
-                                     std::string const& entryPointCommand,
-                                     long entryPointLine)
+cmState::CreateVariableScopeSnapshot(cmState::Snapshot originSnapshot)
 {
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
                                              *originSnapshot.Position);
   pos->ScopeParent = originSnapshot.Position;
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->SnapshotType = VariableScopeType;
   pos->Keep = false;
   pos->PolicyScope = originSnapshot.Position->Policies;
@@ -975,14 +953,10 @@ cmState::CreateVariableScopeSnapshot(cmState::Snapshot originSnapshot,
 
 cmState::Snapshot
 cmState::CreateInlineListFileSnapshot(cmState::Snapshot originSnapshot,
-                                      const std::string& entryPointCommand,
-                                      long entryPointLine,
                                       const std::string& fileName)
 {
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
                                              *originSnapshot.Position);
-  pos->EntryPointLine = entryPointLine;
-  pos->EntryPointCommand = entryPointCommand;
   pos->SnapshotType = InlineListFileType;
   pos->Keep = true;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
@@ -1098,11 +1072,6 @@ void cmState::Directory::SetCurrentBinary(std::string const& dir)
   this->Snapshot_.SetDefinition("CMAKE_CURRENT_BINARY_DIR", loc.c_str());
 }
 
-void cmState::Snapshot::Keep()
-{
-  this->Position->Keep = true;
-}
-
 void cmState::Snapshot::SetListFile(const std::string& listfile)
 {
   *this->Position->ExecutionListFile = listfile;
@@ -1145,16 +1114,6 @@ std::string cmState::Snapshot::GetExecutionListFile() const
   return *this->Position->ExecutionListFile;
 }
 
-std::string cmState::Snapshot::GetEntryPointCommand() const
-{
-  return this->Position->EntryPointCommand;
-}
-
-long cmState::Snapshot::GetEntryPointLine() const
-{
-  return this->Position->EntryPointLine;
-}
-
 bool cmState::Snapshot::IsValid() const
 {
   return this->State && this->Position.IsValid()
@@ -1213,6 +1172,21 @@ cmState::Snapshot cmState::Snapshot::GetCallStackParent() const
   return snapshot;
 }
 
+cmState::Snapshot cmState::Snapshot::GetCallStackBottom() const
+{
+  assert(this->State);
+  assert(this->Position != this->State->SnapshotData.Root());
+
+  PositionType pos = this->Position;
+  while (pos->SnapshotType != cmState::BaseType &&
+         pos->SnapshotType != cmState::BuildsystemDirectoryType &&
+         pos != this->State->SnapshotData.Root())
+    {
+    ++pos;
+    }
+  return Snapshot(this->State, pos);
+}
+
 void cmState::Snapshot::PushPolicy(cmPolicies::PolicyMap entry, bool weak)
 {
   PositionType pos = this->Position;

Source/cmState.h

@@ -63,18 +63,16 @@ public:
     std::vector<std::string> ClosureKeys() const;
     bool RaiseScope(std::string const& var, const char* varDef);
 
-    void Keep();
     void SetListFile(std::string const& listfile);
 
     std::string GetExecutionListFile() const;
 
     std::vector<Snapshot> GetChildren();
-    std::string GetEntryPointCommand() const;
-    long GetEntryPointLine() const;
 
     bool IsValid() const;
     Snapshot GetBuildsystemDirectoryParent() const;
     Snapshot GetCallStackParent() const;
+    Snapshot GetCallStackBottom() const;
     SnapshotType GetType() const;
 
     void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
@@ -192,27 +190,15 @@ public:
 
   Snapshot CreateBaseSnapshot();
   Snapshot
-  CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
-                                     std::string const& entryPointCommand,
-                                     long entryPointLine);
+  CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot);
   Snapshot CreateFunctionCallSnapshot(Snapshot originSnapshot,
-                                      std::string const& entryPointCommand,
-                                      long entryPointLine,
                                       std::string const& fileName);
   Snapshot CreateMacroCallSnapshot(Snapshot originSnapshot,
-                                   std::string const& entryPointCommand,
-                                   long entryPointLine,
                                    std::string const& fileName);
   Snapshot CreateIncludeFileSnapshot(Snapshot originSnapshot,
-                                     std::string const& entryPointCommand,
-                                     long entryPointLine,
                                      std::string const& fileName);
-  Snapshot CreateVariableScopeSnapshot(Snapshot originSnapshot,
-                                       std::string const& entryPointCommand,
-                                       long entryPointLine);
+  Snapshot CreateVariableScopeSnapshot(Snapshot originSnapshot);
   Snapshot CreateInlineListFileSnapshot(Snapshot originSnapshot,
-                                        const std::string& entryPointCommand,
-                                        long entryPointLine,
                                         std::string const& fileName);
   Snapshot CreatePolicyScopeSnapshot(Snapshot originSnapshot);
   Snapshot Pop(Snapshot originSnapshot);

Source/cmake.cxx

@@ -2784,41 +2784,6 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
   displayMessage(t, msg);
 }
 
-//----------------------------------------------------------------------------
-void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
-                         cmListFileContext const& lfc,
-                         bool force)
-{
-  if (!force)
-    {
-    // override the message type, if needed, for warnings and errors
-    cmake::MessageType override = this->ConvertMessageType(t);
-    if (override != t)
-      {
-      t = override;
-      force = true;
-      }
-    }
-
-  if (!force && !this->IsMessageTypeVisible(t))
-    {
-    return;
-    }
-
-  std::ostringstream msg;
-  if (!this->PrintMessagePreamble(t, msg))
-    {
-    return;
-    }
-
-  // Add the immediate context.
-  msg << (lfc.Line ? " at " : " in ") << lfc;
-
-  printMessageText(msg, text);
-
-  displayMessage(t, msg);
-}
-
 //----------------------------------------------------------------------------
 std::vector<std::string> cmake::GetDebugConfigs()
 {

Source/cmake.h

@@ -358,9 +358,6 @@ class cmake
   void IssueMessage(cmake::MessageType t, std::string const& text,
         cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
         bool force = false);
-  void IssueMessage(cmake::MessageType t, std::string const& text,
-        cmListFileContext const& lfc,
-        bool force = false);
 
   ///! run the --build option
   int Build(const std::string& dir,

Tests/RunCMake/PolicyScope/NotClosed-stderr.txt

@@ -1,4 +1,4 @@
-^CMake Error at NotClosed.cmake:[0-9]+ \(include\):
+^CMake Error in NotClosed.cmake:
   cmake_policy PUSH without matching POP
 Call Stack \(most recent call first\):
   CMakeLists.txt:[0-9]+ \(include\)$

Tests/RunCMake/Syntax/FunctionUnmatched-stderr.txt

@@ -1,6 +1,8 @@
-^CMake Error at CMakeLists.txt:[0-9]+ \(include\):
+^CMake Error in FunctionUnmatched.cmake:
   A logical block opening on the line
 
     .*/Tests/RunCMake/Syntax/FunctionUnmatched.cmake:[0-9]+ \(function\)
 
-  is not closed.$
+  is not closed.
+Call Stack \(most recent call first\):
+  CMakeLists.txt:[0-9]+ \(include\)$

Tests/RunCMake/Syntax/MacroUnmatched-stderr.txt

@@ -1,6 +1,8 @@
-^CMake Error at CMakeLists.txt:[0-9]+ \(include\):
+^CMake Error in MacroUnmatched.cmake:
   A logical block opening on the line
 
     .*/Tests/RunCMake/Syntax/MacroUnmatched.cmake:[0-9]+ \(macro\)
 
-  is not closed.$
+  is not closed.
+Call Stack \(most recent call first\):
+  CMakeLists.txt:[0-9]+ \(include\)$

Tests/RunCMake/TargetSources/OriginDebugIDE-stderr.txt

@@ -25,7 +25,7 @@ Call Stack \(most recent call first\):
   OriginDebugIDE.cmake:4 \(include\)
   CMakeLists.txt:3 \(include\)
 +
-CMake Debug Log:
+CMake Debug Log in CMakeLists.txt:
   Used sources for target OriginDebug:
 
    * .*CMakeLists.txt

Tests/RunCMake/find_package/PolicyPush-stderr.txt

@@ -1,4 +1,4 @@
-^CMake Error at PolicyPush/PolicyPushConfigVersion.cmake:1 \(find_package\):
+^CMake Error in PolicyPush/PolicyPushConfigVersion.cmake:
   cmake_policy PUSH without matching POP
 Call Stack \(most recent call first\):
   PolicyPush.cmake:1 \(find_package\)

Tests/RunCMake/while/EndMismatch-stderr.txt

@@ -1,4 +1,4 @@
-^CMake Warning \(dev\) at EndMismatch.cmake:3 \(include\):
+^CMake Warning \(dev\) in EndMismatch.cmake:
   A logical block opening on the line
 
     .*/Tests/RunCMake/while/EndMismatch.cmake:1 \(while\)

Tests/RunCMake/while/EndMissing-stderr.txt

@@ -1,6 +1,8 @@
-^CMake Error at CMakeLists.txt:3 \(include\):
+^CMake Error in EndMissing.cmake:
   A logical block opening on the line
 
     .*/Tests/RunCMake/while/EndMissing.cmake:1 \(while\)
 
-  is not closed.$
+  is not closed.
+Call Stack \(most recent call first\):
+  CMakeLists.txt:[0-9]+ \(include\)$