summaryrefslogtreecommitdiff
path: root/Source
diff options
context:
space:
mode:
Diffstat (limited to 'Source')
-rw-r--r--Source/cmListFileCache.cxx171
-rw-r--r--Source/cmListFileCache.h56
-rw-r--r--Source/cmMakefile.cxx140
-rw-r--r--Source/cmMakefile.h2
-rw-r--r--Source/cmState.cxx28
-rw-r--r--Source/cmState.h16
6 files changed, 231 insertions, 182 deletions
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index f198ac3021..1cc66f47a9 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -398,73 +398,172 @@ bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
}
}
-cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot,
- cmCommandContext const& cc)
- : Snapshot(snapshot)
+struct cmListFileBacktrace::Entry: public cmListFileContext
{
- if (!this->Snapshot.IsValid())
+ Entry(cmListFileContext const& lfc, Entry* up):
+ cmListFileContext(lfc), Up(up), RefCount(0)
{
- return;
+ if (this->Up)
+ {
+ this->Up->Ref();
+ }
}
-
- // Record the entire call stack now so that the `Snapshot` we
- // save for later refers to a long-lived scope. This avoids
- // having to keep short-lived scopes around just to extract
- // their backtrace information later.
-
- cmListFileContext lfc =
- cmListFileContext::FromCommandContext(
- cc, this->Snapshot.GetExecutionListFile());
- this->push_back(lfc);
-
- cmState::Snapshot parent = this->Snapshot.GetCallStackParent();
- while (parent.IsValid())
+ ~Entry()
+ {
+ if (this->Up)
+ {
+ this->Up->Unref();
+ }
+ }
+ void Ref()
+ {
+ ++this->RefCount;
+ }
+ void Unref()
{
- lfc.Name = this->Snapshot.GetEntryPointCommand();
- lfc.Line = this->Snapshot.GetEntryPointLine();
- lfc.FilePath = parent.GetExecutionListFile();
- if (lfc.FilePath.empty())
+ if (--this->RefCount == 0)
{
- break;
+ delete this;
}
- this->push_back(lfc);
+ }
+ Entry* Up;
+ unsigned int RefCount;
+};
- this->Snapshot = parent;
- parent = parent.GetCallStackParent();
+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();
+ }
+}
- this->Snapshot = this->Snapshot.GetCallStackBottom();
+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->empty())
+ if (!this->Cur)
{
return;
}
- cmOutputConverter converter(this->Snapshot);
- cmListFileContext lfc = this->front();
- lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
+ 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->size() <= 1)
+ if (!this->Cur || !this->Cur->Up)
{
return;
}
- out << "Call Stack (most recent call first):\n";
- cmOutputConverter converter(this->Snapshot);
- for (const_iterator i = this->begin() + 1; i != this->end(); ++i)
+ 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";
+ }
cmListFileContext lfc = *i;
- lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
+ if (!this->Bottom.GetState()->GetIsInTryCompile())
+ {
+ lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
+ }
out << " " << lfc << "\n";
}
}
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index d3cab22bab..9fa858510b 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -87,17 +87,53 @@ struct cmListFileFunction: public cmCommandContext
std::vector<cmListFileArgument> Arguments;
};
-class cmListFileBacktrace: private std::vector<cmListFileContext>
+// 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());
- ~cmListFileBacktrace();
-
- void PrintTitle(std::ostream& out) const;
- void PrintCallStack(std::ostream& out) const;
- private:
- cmState::Snapshot Snapshot;
+public:
+ // 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:
+ struct Entry;
+ cmState::Snapshot Bottom;
+ Entry* Cur;
+ cmListFileBacktrace(cmState::Snapshot bottom, Entry* up,
+ cmListFileContext const& lfc);
+ cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur);
};
struct cmListFile
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 13bcdac4aa..3a56c2aac5 100644
--- a/Source/cmMakefile.cxx
+++ b/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)
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 72179442f6..089a83d128 100644
--- a/Source/cmMakefile.h
+++ b/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;
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index bec56822df..f4ca113417 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -845,14 +845,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 +882,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 +904,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 +920,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 +935,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 +955,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(
diff --git a/Source/cmState.h b/Source/cmState.h
index 507d500eaf..5ceaf24d01 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -192,27 +192,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);
View Lorry Controller Status