24 files changed, 218 insertions, 185 deletions
diff --git a/Help/manual/cmake-buildsystem.7.rst b/Help/manual/cmake-buildsystem.7.rst
index c456590..aefdb71 100644
--- a/Help/manual/cmake-buildsystem.7.rst
+++ b/Help/manual/cmake-buildsystem.7.rst
@@ -632,7 +632,7 @@ may be enabled, with an equivalent effect to:
 
 .. code-block:: cmake
 
-  set_property(TARGET tgt APPEND PROPERTY
+  set_property(TARGET tgt APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_CURRENT_BINARY_DIR}>
   )
 
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
index f11eb80..98e75c7 100644
--- a/Source/CMakeVersion.cmake
+++ b/Source/CMakeVersion.cmake
@@ -1,5 +1,5 @@
 # CMake version number components.
 set(CMake_VERSION_MAJOR 3)
 set(CMake_VERSION_MINOR 3)
-set(CMake_VERSION_PATCH 20150619)
+set(CMake_VERSION_PATCH 20150623)
 #set(CMake_VERSION_RC 1)
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 0d24ed5..591a2cd 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -426,8 +426,7 @@ int CCONV cmExecuteCommand(void *arg, const char *name,
     {
     // Assume all arguments are quoted.
     lff.Arguments.push_back(
-      cmListFileArgument(args[i], cmListFileArgument::Quoted,
-                         "[CMake-Plugin]", 0));
+      cmListFileArgument(args[i], cmListFileArgument::Quoted, 0));
     }
   cmExecutionStatus status;
   return mf->ExecuteCommand(lff,status);
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index dc6d2d2..b3576c3 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -43,6 +43,7 @@ public:
     newC->Args = this->Args;
     newC->Functions = this->Functions;
     newC->Policies = this->Policies;
+    newC->FilePath = this->FilePath;
     return newC;
   }
 
@@ -71,6 +72,7 @@ public:
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
   cmPolicies::PolicyMap Policies;
+  std::string FilePath;
 };
 
 bool cmFunctionHelperCommand::InvokeInitialPass
@@ -171,19 +173,9 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
       cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
       f->Args = this->Args;
       f->Functions = this->Functions;
+      f->FilePath = this->GetStartingContext().FilePath;
       mf.RecordPolicies(f->Policies);
 
-      // Set the FilePath on the arguments to match the function since it is
-      // not stored and the original values may be freed
-      for (unsigned int i = 0; i < f->Functions.size(); ++i)
-        {
-        for (unsigned int j = 0; j < f->Functions[i].Arguments.size(); ++j)
-          {
-          f->Functions[i].Arguments[j].FilePath =
-            f->Functions[i].FilePath.c_str();
-          }
-        }
-
       std::string newName = "_" + this->Args[0];
       mf.GetState()->RenameCommand(this->Args[0], newName);
       mf.GetState()->AddCommand(f);
@@ -212,7 +204,8 @@ ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    mf.ExpandArguments(lff.Arguments, expandedArguments,
+                       this->GetStartingContext().FilePath.c_str());
     // if the endfunction has arguments then make sure
     // they match the ones in the opening function command
     if ((expandedArguments.empty() ||
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 67d0d54..2f68ab0 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -705,7 +705,8 @@ cmTargetTraceDependencies
           e << "Evaluation output file\n  \"" << sf->GetFullPath()
             << "\"\ndepends on the sources of a target it is used in.  This "
               "is a dependency loop and is not allowed.";
-          this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+          this->GeneratorTarget
+              ->LocalGenerator->IssueMessage(cmake::FATAL_ERROR, e.str());
           return;
           }
         if(emitted.insert(sf).second && this->SourcesQueued.insert(sf).second)
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 4fe52dd..0f61225 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -529,7 +529,7 @@ cmGlobalUnixMakefileGenerator3
                        cmLocalUnixMakefileGenerator3* lg)
 {
   // Only subdirectories need these rules.
-  if(lg->IsRootMakefile())
+  if(lg->GetMakefile()->IsRootMakefile())
     {
     return;
     }
@@ -1034,7 +1034,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
       static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     // for the passed in makefile or if this is the top Makefile wripte out
     // the targets
-    if (lg2 == lg || lg->IsRootMakefile())
+    if (lg2 == lg || lg->GetMakefile()->IsRootMakefile())
       {
       // for each target Generate the rule files for each target.
       cmTargets& targets = lg2->GetMakefile()->GetTargets();
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index ca58314..006ca4c 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -234,8 +234,7 @@ bool cmListFile::ParseFile(const char* filename,
       {
       cmListFileFunction project;
       project.Name = "PROJECT";
-      cmListFileArgument prj("Project", cmListFileArgument::Unquoted,
-                             filename, 0);
+      cmListFileArgument prj("Project", cmListFileArgument::Unquoted, 0);
       project.Arguments.push_back(prj);
       this->Functions.insert(this->Functions.begin(),project);
       }
@@ -375,7 +374,7 @@ bool cmListFileParser::ParseFunction(const char* name, long line)
 bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
                                    cmListFileArgument::Delimiter delim)
 {
-  cmListFileArgument a(token->text, delim, this->FileName, token->line);
+  cmListFileArgument a(token->text, delim, token->line);
   this->Function.Arguments.push_back(a);
   if(this->Separation == SeparationOkay)
     {
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index 4002d94..f5859ec 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -33,12 +33,11 @@ struct cmListFileArgument
     Quoted,
     Bracket
     };
-  cmListFileArgument(): Value(), Delim(Unquoted), FilePath(0), Line(0) {}
-  cmListFileArgument(const cmListFileArgument& r):
-    Value(r.Value), Delim(r.Delim), FilePath(r.FilePath), Line(r.Line) {}
-  cmListFileArgument(const std::string& v, Delimiter d, const char* file,
-                     long line): Value(v), Delim(d),
-                                 FilePath(file), Line(line) {}
+  cmListFileArgument(): Value(), Delim(Unquoted), Line(0) {}
+  cmListFileArgument(const cmListFileArgument& r)
+    : Value(r.Value), Delim(r.Delim), Line(r.Line) {}
+  cmListFileArgument(const std::string& v, Delimiter d, long line)
+    : Value(v), Delim(d), Line(line) {}
   bool operator == (const cmListFileArgument& r) const
     {
     return (this->Value == r.Value) && (this->Delim == r.Delim);
@@ -49,7 +48,6 @@ struct cmListFileArgument
     }
   std::string Value;
   Delimiter Delim;
-  const char* FilePath;
   long Line;
 };
 
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 98accf9..6f98ee2 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -68,9 +68,20 @@ cmLocalGenerator::~cmLocalGenerator()
   delete this->Makefile;
 }
 
-bool cmLocalGenerator::IsRootMakefile() const
+void cmLocalGenerator::IssueMessage(cmake::MessageType t,
+                                    std::string const& text) const
 {
-  return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
+  cmListFileContext lfc;
+  lfc.FilePath = this->StateSnapshot.GetCurrentSourceDirectory();
+  lfc.FilePath += "/CMakeLists.txt";
+
+  if(!this->GlobalGenerator->GetCMakeInstance()->GetIsInTryCompile())
+    {
+    cmOutputConverter converter(this->StateSnapshot);
+    lfc.FilePath = converter.Convert(lfc.FilePath, cmLocalGenerator::HOME);
+    }
+  lfc.Line = 0;
+  this->GlobalGenerator->GetCMakeInstance()->IssueMessage(t, text, lfc);
 }
 
 //----------------------------------------------------------------------------
@@ -98,7 +109,7 @@ void cmLocalGenerator::ComputeObjectMaxPath()
         w << "CMAKE_OBJECT_PATH_MAX is set to " << pmax
           << ", which is less than the minimum of 128.  "
           << "The value will be ignored.";
-        this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+        this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
         }
       }
     else
@@ -107,7 +118,7 @@ void cmLocalGenerator::ComputeObjectMaxPath()
       w << "CMAKE_OBJECT_PATH_MAX is set to \"" << plen
         << "\", which fails to parse as a positive integer.  "
         << "The value will be ignored.";
-      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+      this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
       }
     }
   this->ObjectMaxPathViolations.clear();
@@ -1317,7 +1328,7 @@ void cmLocalGenerator::AddCompileOptions(
         "higher \"" << it->first << "_STANDARD\" \"" << standard << "\".  "
         "This is not permitted. The COMPILE_FEATURES may not both depend on "
         "and be depended on by the link implementation." << std::endl;
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
       }
     }
@@ -1330,7 +1341,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
                                              const std::string& lang,
                                              const std::string& config,
                                              bool stripImplicitInclDirs
-                                            )
+                                            ) const
 {
   // Need to decide whether to automatically include the source and
   // binary directories at the beginning of the include path.
@@ -2041,7 +2052,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
            "dialect \"" << lang << standardProp << "\" "
         << (ext ? "(with compiler extensions)" : "") << ", but CMake "
            "does not know the compile flags to use to enable it.";
-      this->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, e.str());
+      this->IssueMessage(cmake::FATAL_ERROR, e.str());
       }
     else
       {
@@ -2085,7 +2096,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
     std::string e =
       "CMAKE_" + lang + "_STANDARD_DEFAULT is set to invalid value '" +
       std::string(defaultStd) + "'";
-    this->Makefile->IssueMessage(cmake::INTERNAL_ERROR, e);
+    this->IssueMessage(cmake::INTERNAL_ERROR, e);
     return;
     }
 
@@ -2301,7 +2312,7 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
             << flagsVar << " was removed.\n"
             << cmPolicies::GetPolicyWarning(cmPolicies::CMP0018);
 
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
+          this->IssueMessage(cmake::AUTHOR_WARNING, e.str());
           // fall through to OLD behaviour
         }
         case cmPolicies::OLD:
@@ -2813,7 +2824,7 @@ cmLocalGenerator
           << "  " << ssin << "\n"
           << "cannot be safely placed under this directory.  "
           << "The build may not work correctly.";
-        this->Makefile->IssueMessage(cmake::WARNING, m.str());
+        this->IssueMessage(cmake::WARNING, m.str());
         }
       }
 #else
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 6a8c5aa..98f4d3a 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -14,6 +14,7 @@
 
 #include "cmStandardIncludes.h"
 #include "cmState.h"
+#include "cmake.h"
 #include "cmOutputConverter.h"
 
 class cmMakefile;
@@ -39,9 +40,6 @@ public:
                    cmState::Snapshot snapshot);
   virtual ~cmLocalGenerator();
 
-  /// @return whether we are processing the top CMakeLists.txt file.
-  bool IsRootMakefile() const;
-
   /**
    * Generate the makefile for this directory.
    */
@@ -185,7 +183,7 @@ public:
                              cmGeneratorTarget* target,
                              const std::string& lang = "C",
                              const std::string& config = "",
-                             bool stripImplicitInclDirs = true);
+                             bool stripImplicitInclDirs = true) const;
   void AddCompileOptions(std::string& flags, cmTarget* target,
                          const std::string& lang, const std::string& config);
   void AddCompileDefinitions(std::set<std::string>& defines,
@@ -304,6 +302,9 @@ public:
   bool IsMinGWMake() const;
   bool IsNMake() const;
 
+  void IssueMessage(cmake::MessageType t, std::string const& text) const;
+
+
   void ComputeObjectMaxPath();
 protected:
   ///! put all the libraries for a target on into the given stream
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 427ae10..4db36fc 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -58,7 +58,7 @@ void cmLocalNinjaGenerator::Generate()
 #endif
 
   // We do that only once for the top CMakeLists.txt file.
-  if(this->IsRootMakefile())
+  if(this->Makefile->IsRootMakefile())
     {
     this->WriteBuildFileTop();
 
@@ -298,7 +298,7 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
     << "# Write statements declared in CMakeLists.txt:" << std::endl
     << "# "
     << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl;
-  if(this->IsRootMakefile())
+  if(this->Makefile->IsRootMakefile())
     os << "# Which is the root file." << std::endl;
   cmGlobalNinjaGenerator::WriteDivider(os);
   os << std::endl;
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index 4e4d146..b097c95 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -149,9 +149,6 @@ public:
   void AddImplicitDepends(cmTarget const& tgt, const std::string& lang,
                           const char* obj, const char* src);
 
-  void AppendGlobalTargetDepends(std::vector<std::string>& depends,
-                                 cmTarget& target);
-
   // write the target rules for the local Makefile into the stream
   void WriteLocalAllRules(std::ostream& ruleFileStream);
 
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 028ab62..0b945b2 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -122,10 +122,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
     sprintf(argvName,"${ARGV%i}",j);
     argVs.push_back(argvName);
     }
-  if(!this->Functions.empty())
-    {
-    this->FilePath = this->Functions[0].FilePath;
-    }
   // Invoke all the functions that were collected in the block.
   cmListFileFunction newLFF;
   // for each function
@@ -143,10 +139,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
            this->Functions[c].Arguments.begin();
          k != this->Functions[c].Arguments.end(); ++k)
       {
-      // Set the FilePath on the arguments to match the function since it is
-      // not stored and the original values may be freed
-      k->FilePath = this->FilePath.c_str();
-
       cmListFileArgument arg;
       arg.Value = k->Value;
       if(k->Delim != cmListFileArgument::Bracket)
@@ -177,7 +169,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
           }
         }
       arg.Delim = k->Delim;
-      arg.FilePath = k->FilePath;
       arg.Line = k->Line;
       newLFF.Arguments.push_back(arg);
       }
@@ -225,6 +216,7 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
       cmMacroHelperCommand *f = new cmMacroHelperCommand();
       f->Args = this->Args;
       f->Functions = this->Functions;
+      f->FilePath = this->GetStartingContext().FilePath;
       mf.RecordPolicies(f->Policies);
       std::string newName = "_" + this->Args[0];
       mf.GetState()->RenameCommand(this->Args[0], newName);
@@ -254,7 +246,8 @@ ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    mf.ExpandArguments(lff.Arguments, expandedArguments,
+                       this->GetStartingContext().FilePath.c_str());
     // if the endmacro has arguments make sure they
     // match the arguments of the macro
     if ((expandedArguments.empty() ||
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 63dbe27..40c3885 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -105,7 +105,7 @@ public:
     ++it;
     if(it == this->VarStack.rend())
       {
-      cmLocalGenerator* plg = mf->GetLocalGenerator()->GetParent();
+      cmLocalGenerator* plg = mf->LocalGenerator->GetParent();
       if(!plg)
         {
         return false;
@@ -264,8 +264,8 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
 
     if(!this->GetCMakeInstance()->GetIsInTryCompile())
       {
-      lfc.FilePath = this->LocalGenerator->Convert(lfc.FilePath,
-                                                   cmLocalGenerator::HOME);
+      cmOutputConverter converter(this->StateSnapshot);
+      lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
       }
     lfc.Line = 0;
     this->GetCMakeInstance()->IssueMessage(t, text, lfc);
@@ -308,7 +308,7 @@ cmListFileContext cmMakefile::GetExecutionContext() const
 void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
 {
   std::ostringstream msg;
-  msg << lff.FilePath << "(" << lff.Line << "):  ";
+  msg << this->GetExecutionFilePath() << "(" << lff.Line << "):  ";
   msg << lff.Name << "(";
   for(std::vector<cmListFileArgument>::const_iterator i =
         lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
@@ -409,12 +409,12 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
 class cmMakefile::IncludeScope
 {
 public:
-  IncludeScope(cmMakefile* mf, const char* fname, bool noPolicyScope);
+  IncludeScope(cmMakefile* mf, std::string const& filenametoread,
+               bool noPolicyScope);
   ~IncludeScope();
   void Quiet() { this->ReportError = false; }
 private:
   cmMakefile* Makefile;
-  const char* File;
   bool NoPolicyScope;
   bool CheckCMP0011;
   bool ReportError;
@@ -422,9 +422,10 @@ private:
 };
 
 //----------------------------------------------------------------------------
-cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf, const char* fname,
+cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
+                                       std::string const& filenametoread,
                                        bool noPolicyScope):
-  Makefile(mf), File(fname), NoPolicyScope(noPolicyScope),
+  Makefile(mf), NoPolicyScope(noPolicyScope),
   CheckCMP0011(false), ReportError(true)
 {
   if(!this->NoPolicyScope)
@@ -458,6 +459,7 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf, const char* fname,
 
   // The included file cannot pop our policy scope.
   this->Makefile->PushPolicyBarrier();
+  this->Makefile->ListFileStack.push_back(filenametoread);
 }
 
 //----------------------------------------------------------------------------
@@ -487,6 +489,7 @@ cmMakefile::IncludeScope::~IncludeScope()
       this->EnforceCMP0011();
       }
     }
+  this->Makefile->ListFileStack.pop_back();
 }
 
 //----------------------------------------------------------------------------
@@ -501,7 +504,8 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
       {
       std::ostringstream w;
       w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0011) << "\n"
-        << "The included script\n  " << this->File << "\n"
+        << "The included script\n  "
+        << this->Makefile->ListFileStack.back() << "\n"
         << "affects policy settings.  "
         << "CMake is implying the NO_POLICY_SCOPE option for compatibility, "
         << "so the effects are applied to the including context.";
@@ -513,7 +517,8 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
       {
       std::ostringstream e;
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0011) << "\n"
-        << "The included script\n  " << this->File << "\n"
+        << "The included script\n  "
+        << this->Makefile->ListFileStack.back() << "\n"
         << "affects policy settings, so it requires this policy to be set.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       }
@@ -527,39 +532,76 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
     }
 }
 
-bool cmMakefile::ProcessBuildsystemFile(const char* listfile)
+bool cmMakefile::ProcessBuildsystemFile(const char* filename)
 {
-  this->AddDefinition("CMAKE_PARENT_LIST_FILE", listfile);
+  this->AddDefinition("CMAKE_PARENT_LIST_FILE", filename);
   std::string curSrc = this->GetCurrentSourceDirectory();
-  bool result = this->ReadListFile(listfile, true,
-                                   curSrc == this->GetHomeDirectory());
+
+  this->ListFileStack.push_back(filename);
+
+  cmListFile listFile;
+  if (!listFile.ParseFile(filename, curSrc == this->GetHomeDirectory(), this))
+    {
+    return false;
+    }
+
+  this->PushPolicyBarrier();
+  this->ReadListFile(listFile, filename);
+  this->PopPolicyBarrier(!cmSystemTools::GetFatalErrorOccured());
   this->EnforceDirectoryLevelRules();
-  return result;
+  return true;
 }
 
-bool cmMakefile::ReadDependentFile(const char* listfile, bool noPolicyScope)
+bool cmMakefile::ReadDependentFile(const char* filename, bool noPolicyScope)
 {
   this->AddDefinition("CMAKE_PARENT_LIST_FILE",
                       this->GetDefinition("CMAKE_CURRENT_LIST_FILE"));
-  bool result = this->ReadListFile(listfile, noPolicyScope, false);
-  this->ListFileStack.pop_back();
-  return result;
+  std::string filenametoread =
+    cmSystemTools::CollapseFullPath(filename,
+                                    this->GetCurrentSourceDirectory());
+
+  IncludeScope incScope(this, filenametoread, noPolicyScope);
+
+  cmListFile listFile;
+  if (!listFile.ParseFile(filenametoread.c_str(), false, this))
+    {
+    incScope.Quiet();
+    return false;
+    }
+  this->ReadListFile(listFile, filenametoread);
+  if(cmSystemTools::GetFatalErrorOccured())
+    {
+    incScope.Quiet();
+    }
+  return true;
 }
 
-bool cmMakefile::ReadListFile(const char* listfile)
+bool cmMakefile::ReadListFile(const char* filename)
 {
-  bool result = this->ReadListFile(listfile, true, false);
+  std::string filenametoread =
+    cmSystemTools::CollapseFullPath(filename,
+                                    this->GetCurrentSourceDirectory());
+
+  this->ListFileStack.push_back(filenametoread);
+
+  cmListFile listFile;
+  if (!listFile.ParseFile(filenametoread.c_str(), false, this))
+    {
+    return false;
+    }
+
+  this->PushPolicyBarrier();
+  this->ReadListFile(listFile, filenametoread);
+  this->PopPolicyBarrier(!cmSystemTools::GetFatalErrorOccured());
   this->ListFileStack.pop_back();
-  return result;
+  return true;
 }
 
-bool cmMakefile::ReadListFile(const char* listfile,
-                              bool noPolicyScope,
-                              bool requireProjectCommand)
+void cmMakefile::ReadListFile(cmListFile const& listFile,
+                              std::string const& filenametoread)
 {
-  std::string filenametoread =
-    cmSystemTools::CollapseFullPath(listfile,
-                                    this->GetCurrentSourceDirectory());
+  // add this list file to the list of dependencies
+  this->ListFiles.push_back(filenametoread);
 
   std::string currentParentFile
       = this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE");
@@ -574,55 +616,19 @@ bool cmMakefile::ReadListFile(const char* listfile,
   this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
   this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR");
 
-  this->ListFileStack.push_back(filenametoread);
-
-  bool res = this->ReadListFileInternal(filenametoread.c_str(),
-                                        noPolicyScope, requireProjectCommand);
-
-  this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
-  this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str());
-  this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
-                      cmSystemTools::GetFilenamePath(currentFile).c_str());
-  this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
-  this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
-  this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR");
-
-  if (res)
-    {
-    this->CheckForUnusedVariables();
-    }
-
-  return res;
-}
-
-bool cmMakefile::ReadListFileInternal(const char* filenametoread,
-                                      bool noPolicyScope,
-                                      bool requireProjectCommand)
-{
-  cmListFile cacheFile;
-  if( !cacheFile.ParseFile(filenametoread, requireProjectCommand, this) )
-    {
-    return false;
-    }
-  // add this list file to the list of dependencies
-  this->ListFiles.push_back( filenametoread);
-
   // Enforce balanced blocks (if/endif, function/endfunction, etc.).
-  {
   LexicalPushPop lexScope(this);
-  IncludeScope incScope(this, filenametoread, noPolicyScope);
 
   // Run the parsed commands.
-  const size_t numberFunctions = cacheFile.Functions.size();
+  const size_t numberFunctions = listFile.Functions.size();
   for(size_t i =0; i < numberFunctions; ++i)
     {
     cmExecutionStatus status;
-    this->ExecuteCommand(cacheFile.Functions[i],status);
+    this->ExecuteCommand(listFile.Functions[i],status);
     if(cmSystemTools::GetFatalErrorOccured())
       {
       // Exit early due to error.
       lexScope.Quiet();
-      incScope.Quiet();
       break;
       }
     if(status.GetReturnInvoked())
@@ -631,9 +637,15 @@ bool cmMakefile::ReadListFileInternal(const char* filenametoread,
       break;
       }
     }
-  }
+  this->CheckForUnusedVariables();
 
-  return true;
+  this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
+  this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str());
+  this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
+                      cmSystemTools::GetFilenamePath(currentFile).c_str());
+  this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
+  this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
+  this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR");
 }
 
 //----------------------------------------------------------------------------
@@ -1608,6 +1620,11 @@ void cmMakefile::PopMacroScope(bool reportError)
   this->PopFunctionBlockerBarrier(reportError);
 }
 
+bool cmMakefile::IsRootMakefile() const
+{
+  return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
+}
+
 //----------------------------------------------------------------------------
 class cmMakefileCurrent
 {
@@ -1963,8 +1980,8 @@ void cmMakefile::LogUnused(const char* reason,
       lfc.FilePath = path;
       lfc.Line = 0;
       }
-    lfc.FilePath = this->LocalGenerator->Convert(lfc.FilePath,
-                                                 cmLocalGenerator::HOME);
+    cmOutputConverter converter(this->StateSnapshot);
+    lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
 
     if (this->CheckSystemVars ||
         cmSystemTools::IsSubDirectory(path,
@@ -2861,8 +2878,9 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
                 {
                 std::ostringstream msg;
                 cmListFileContext lfc;
-                lfc.FilePath = this->LocalGenerator
-                    ->Convert(filename, cmLocalGenerator::HOME);
+                cmOutputConverter converter(this->StateSnapshot);
+                lfc.FilePath =
+                    converter.Convert(filename, cmOutputConverter::HOME);
                 lfc.Line = line;
                 msg << "uninitialized variable \'" << lookup << "\'";
                 this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING,
@@ -3313,11 +3331,25 @@ bool cmMakefile::IsLoopBlock() const
   return !this->LoopBlockCounter.empty() && this->LoopBlockCounter.top() > 0;
 }
 
+std::string cmMakefile::GetExecutionFilePath() const
+{
+  if (this->CallStack.empty())
+    {
+    return std::string();
+    }
+  return this->CallStack.back().Context->FilePath;
+}
+
 //----------------------------------------------------------------------------
 bool cmMakefile::ExpandArguments(
   std::vector<cmListFileArgument> const& inArgs,
-  std::vector<std::string>& outArgs) const
+  std::vector<std::string>& outArgs, const char* filename) const
 {
+  std::string efp = this->GetExecutionFilePath();
+  if (!filename)
+    {
+    filename = efp.c_str();
+    }
   std::vector<cmListFileArgument>::const_iterator i;
   std::string value;
   outArgs.reserve(inArgs.size());
@@ -3332,8 +3364,7 @@ bool cmMakefile::ExpandArguments(
     // Expand the variables in the argument.
     value = i->Value;
     this->ExpandVariablesInString(value, false, false, false,
-                                  i->FilePath, i->Line,
-                                  false, false);
+                                  filename, i->Line, false, false);
 
     // If the argument is quoted, it should be one argument.
     // Otherwise, it may be a list of arguments.
@@ -3352,8 +3383,13 @@ bool cmMakefile::ExpandArguments(
 //----------------------------------------------------------------------------
 bool cmMakefile::ExpandArguments(
   std::vector<cmListFileArgument> const& inArgs,
-  std::vector<cmExpandedCommandArgument>& outArgs) const
+  std::vector<cmExpandedCommandArgument>& outArgs, const char* filename) const
 {
+  std::string efp = this->GetExecutionFilePath();
+  if (!filename)
+    {
+    filename = efp.c_str();
+    }
   std::vector<cmListFileArgument>::const_iterator i;
   std::string value;
   outArgs.reserve(inArgs.size());
@@ -3368,8 +3404,7 @@ bool cmMakefile::ExpandArguments(
     // Expand the variables in the argument.
     value = i->Value;
     this->ExpandVariablesInString(value, false, false, false,
-                                  i->FilePath, i->Line,
-                                  false, false);
+                                  filename, i->Line, false, false);
 
     // If the argument is quoted, it should be one argument.
     // Otherwise, it may be a list of arguments.
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 86bde0c..b3ab273 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -79,17 +79,20 @@ public:
    */
   ~cmMakefile();
 
-  bool ReadListFile(const char* listfile);
+  bool ReadListFile(const char* filename);
 
-  bool ReadDependentFile(const char* listfile, bool noPolicyScope = true);
+  bool ReadDependentFile(const char* filename, bool noPolicyScope = true);
 
-  bool ProcessBuildsystemFile(const char* listfile);
+  bool ProcessBuildsystemFile(const char* filename);
 
   /**
    * Add a function blocker to this makefile
    */
   void AddFunctionBlocker(cmFunctionBlocker* fb);
 
+  /// @return whether we are processing the top CMakeLists.txt file.
+  bool IsRootMakefile() const;
+
   /**
    * Remove the function blocker whose scope ends with the given command.
    * This returns ownership of the function blocker object.
@@ -662,10 +665,12 @@ public:
    * variable replacement and list expansion.
    */
   bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
-                       std::vector<std::string>& outArgs) const;
+                       std::vector<std::string>& outArgs,
+                       const char* filename = 0) const;
 
   bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
-                       std::vector<cmExpandedCommandArgument>& outArgs) const;
+                       std::vector<cmExpandedCommandArgument>& outArgs,
+                       const char* filename = 0) const;
 
   /**
    * Get the instance
@@ -840,6 +845,8 @@ public:
 
   const char* GetDefineFlagsCMP0059() const;
 
+  std::string GetExecutionFilePath() const;
+
 protected:
   // add link libraries and directories to the target
   void AddGlobalLinkInformation(const std::string& name, cmTarget& target);
@@ -914,13 +921,8 @@ private:
 
   cmState::Snapshot StateSnapshot;
 
-  bool ReadListFile(const char* listfile,
-                    bool noPolicyScope,
-                    bool requireProjectCommand);
-
-  bool ReadListFileInternal(const char* filenametoread,
-                            bool noPolicyScope,
-                            bool requireProjectCommand);
+  void ReadListFile(cmListFile const& listFile,
+                    const std::string& filenametoread);
 
   bool ParseDefineFlag(std::string const& definition, bool remove);
 
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index db73a34..b0a30a1 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -27,7 +27,7 @@ cmOutputConverter::cmOutputConverter(cmState::Snapshot snapshot)
 std::string
 cmOutputConverter::ConvertToOutputForExistingCommon(const std::string& remote,
                                                     std::string const& result,
-                                                    OutputFormat format)
+                                                    OutputFormat format) const
 {
   // If this is a windows shell, the result has a space, and the path
   // already exists, we can use a short-path to reference it without a
@@ -50,7 +50,7 @@ cmOutputConverter::ConvertToOutputForExistingCommon(const std::string& remote,
 std::string
 cmOutputConverter::ConvertToOutputForExisting(const std::string& remote,
                                               RelativeRoot local,
-                                              OutputFormat format)
+                                              OutputFormat format) const
 {
   static_cast<void>(local);
 
@@ -65,7 +65,7 @@ cmOutputConverter::ConvertToOutputForExisting(const std::string& remote,
 std::string
 cmOutputConverter::ConvertToOutputForExisting(RelativeRoot remote,
                                               const std::string& local,
-                                              OutputFormat format)
+                                              OutputFormat format) const
 {
   // Perform standard conversion.
   std::string result = this->Convert(remote, local, format, true);
@@ -76,7 +76,7 @@ cmOutputConverter::ConvertToOutputForExisting(RelativeRoot remote,
 }
 
 //----------------------------------------------------------------------------
-const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot)
+const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot) const
 {
   switch (relroot)
     {
@@ -91,7 +91,7 @@ const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot)
 
 std::string cmOutputConverter::Convert(const std::string& source,
                                        RelativeRoot relative,
-                                       OutputFormat output)
+                                       OutputFormat output) const
 {
   // Convert the path to a relative path.
   std::string result = source;
@@ -125,7 +125,7 @@ std::string cmOutputConverter::Convert(const std::string& source,
 
 //----------------------------------------------------------------------------
 std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source,
-                                                     OutputFormat output)
+                                                     OutputFormat output) const
 {
   std::string result = source;
   // Convert it to an output path.
@@ -163,7 +163,7 @@ std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source,
 std::string cmOutputConverter::Convert(RelativeRoot remote,
                                       const std::string& local,
                                       OutputFormat output,
-                                      bool optional)
+                                      bool optional) const
 {
   const char* remotePath = this->GetRelativeRootPath(remote);
 
@@ -192,7 +192,7 @@ static bool cmOutputConverterNotAbove(const char* a, const char* b)
 std::string
 cmOutputConverter::ConvertToRelativePath(const std::vector<std::string>& local,
                                         const std::string& in_remote,
-                                        bool force)
+                                        bool force) const
 {
   // The path should never be quoted.
   assert(in_remote[0] != '\"');
@@ -318,7 +318,7 @@ static bool cmOutputConverterIsShellOperator(const std::string& str)
 std::string cmOutputConverter::EscapeForShell(const std::string& str,
                                              bool makeVars,
                                              bool forEcho,
-                                             bool useWatcomQuote)
+                                             bool useWatcomQuote) const
 {
   // Do not escape shell operators.
   if(cmOutputConverterIsShellOperator(str))
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index 1d3f8c7..482a64b 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -39,35 +39,35 @@ public:
   enum RelativeRoot { NONE, FULL, HOME, START, HOME_OUTPUT, START_OUTPUT };
   enum OutputFormat { UNCHANGED, MAKERULE, SHELL, WATCOMQUOTE, RESPONSE };
   std::string ConvertToOutputFormat(const std::string& source,
-                                    OutputFormat output);
+                                    OutputFormat output) const;
   std::string Convert(const std::string& remote, RelativeRoot local,
-                      OutputFormat output = UNCHANGED);
+                      OutputFormat output = UNCHANGED) const;
   std::string Convert(RelativeRoot remote, const std::string& local,
                       OutputFormat output = UNCHANGED,
-                      bool optional = false);
+                      bool optional = false) const;
 
   /**
     * Get path for the specified relative root.
     */
-  const char* GetRelativeRootPath(RelativeRoot relroot);
+  const char* GetRelativeRootPath(RelativeRoot relroot) const;
 
   ///! for existing files convert to output path and short path if spaces
   std::string ConvertToOutputForExisting(const std::string& remote,
                                          RelativeRoot local = START_OUTPUT,
-                                         OutputFormat format = SHELL);
+                                         OutputFormat format = SHELL) const;
 
   /** For existing path identified by RelativeRoot convert to output
       path and short path if spaces.  */
   std::string ConvertToOutputForExisting(RelativeRoot remote,
                                          const std::string& local = "",
-                                         OutputFormat format = SHELL);
+                                         OutputFormat format = SHELL) const;
 
   void SetLinkScriptShell(bool linkScriptShell);
 
   std::string EscapeForShell(const std::string& str,
                                     bool makeVars = false,
                                     bool forEcho = false,
-                                    bool useWatcomQuote = false);
+                                    bool useWatcomQuote = false) const;
 
   static std::string EscapeForCMake(const std::string& str);
 
@@ -88,14 +88,14 @@ public:
    */
   std::string ConvertToRelativePath(const std::vector<std::string>& local,
                                     const std::string& in_remote,
-                                    bool force = false);
+                                    bool force = false) const;
 
 private:
   cmState* GetState() const;
 
   std::string ConvertToOutputForExistingCommon(const std::string& remote,
                                                std::string const& result,
-                                               OutputFormat format);
+                                               OutputFormat format) const;
 
 private:
   cmState::Snapshot StateSnapshot;
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index 90bc111..46d7e01 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -53,7 +53,7 @@ bool cmProjectCommand
   // CMAKE_PROJECT_NAME will match PROJECT_NAME, and cmake --build
   // will work.
   if(!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME")
-     || (this->Makefile->GetLocalGenerator()->IsRootMakefile()))
+     || (this->Makefile->IsRootMakefile()))
     {
     this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", args[0].c_str());
     this->Makefile->AddCacheDefinition
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index d8f826c..f05b382 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -368,8 +368,7 @@ bool cmQtAutoGenerators::InitializeAutogenTarget(cmTarget* target)
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   bool usePRE_BUILD = false;
-  cmLocalGenerator* localGen = makefile->GetLocalGenerator();
-  cmGlobalGenerator* gg = localGen->GetGlobalGenerator();
+  cmGlobalGenerator* gg = makefile->GetGlobalGenerator();
   if(gg->GetName().find("Visual Studio") != std::string::npos)
     {
     cmGlobalVisualStudioGenerator* vsgg =
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index a13c13f..58500cc 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -219,13 +219,13 @@ void cmState::RemoveCacheEntryProperty(std::string const& key,
        ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0);
 }
 
-void cmState::Reset()
+cmState::Snapshot cmState::Reset()
 {
   this->GlobalProperties.clear();
   this->PropertyDefinitions.clear();
 
   this->BuildsystemDirectory.Truncate();
-  this->SnapshotData.Truncate();
+  PositionType pos = this->SnapshotData.Truncate();
 
   this->DefineProperty
     ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY,
@@ -246,6 +246,8 @@ void cmState::Reset()
   this->DefineProperty
     ("RULE_LAUNCH_CUSTOM", cmProperty::TARGET,
      "", "", true);
+
+  return Snapshot(this, pos);
 }
 
 void cmState::DefineProperty(const std::string& name,
@@ -741,14 +743,14 @@ void cmState::Snapshot::SetCurrentBinaryDirectory(std::string const& dir)
 }
 
 std::vector<std::string> const&
-cmState::Snapshot::GetCurrentSourceDirectoryComponents()
+cmState::Snapshot::GetCurrentSourceDirectoryComponents() const
 {
   return this->Position->BuildSystemDirectory
       ->CurrentSourceDirectoryComponents;
 }
 
 std::vector<std::string> const&
-cmState::Snapshot::GetCurrentBinaryDirectoryComponents()
+cmState::Snapshot::GetCurrentBinaryDirectoryComponents() const
 {
   return this->Position->BuildSystemDirectory
       ->CurrentBinaryDirectoryComponents;
diff --git a/Source/cmState.h b/Source/cmState.h
index 353a6c6..9c7574f 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -43,8 +43,10 @@ public:
     const char* GetCurrentBinaryDirectory() const;
     void SetCurrentBinaryDirectory(std::string const& dir);
 
-    std::vector<std::string> const& GetCurrentSourceDirectoryComponents();
-    std::vector<std::string> const& GetCurrentBinaryDirectoryComponents();
+    std::vector<std::string> const&
+    GetCurrentSourceDirectoryComponents() const;
+    std::vector<std::string> const&
+    GetCurrentBinaryDirectoryComponents() const;
 
     const char* GetRelativePathTopSource() const;
     const char* GetRelativePathTopBinary() const;
@@ -103,7 +105,7 @@ public:
   void RemoveCacheEntryProperty(std::string const& key,
                                 std::string const& propertyName);
 
-  void Reset();
+  Snapshot Reset();
   // Define a property
   void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
                       const char *ShortDescription,
diff --git a/Source/cmVariableWatchCommand.cxx b/Source/cmVariableWatchCommand.cxx
index 09cef5e..6521c04 100644
--- a/Source/cmVariableWatchCommand.cxx
+++ b/Source/cmVariableWatchCommand.cxx
@@ -49,21 +49,21 @@ static void cmVariableWatchCommandVariableAccessed(
     newLFF.Arguments.clear();
     newLFF.Arguments.push_back(
       cmListFileArgument(variable, cmListFileArgument::Quoted,
-                         "unknown", 9999));
+                         9999));
     newLFF.Arguments.push_back(
       cmListFileArgument(accessString, cmListFileArgument::Quoted,
-                         "unknown", 9999));
+                         9999));
     newLFF.Arguments.push_back(
       cmListFileArgument(newValue?newValue:"", cmListFileArgument::Quoted,
-                         "unknown", 9999));
+                         9999));
     newLFF.Arguments.push_back(
       cmListFileArgument(currentListFile, cmListFileArgument::Quoted,
-                         "unknown", 9999));
+                         9999));
     newLFF.Arguments.push_back(
       cmListFileArgument(stack, cmListFileArgument::Quoted,
-                         "unknown", 9999));
+                         9999));
     newLFF.Name = data->Command;
-    newLFF.FilePath = "Some weird path";
+    newLFF.FilePath = "unknown";
     newLFF.Line = 9999;
     cmExecutionStatus status;
     if(!makefile->ExecuteCommand(newLFF,status))
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index eeb6575..e51b260 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -186,7 +186,7 @@ cmake::~cmake()
 
 void cmake::CleanupCommandsAndMacros()
 {
-  this->State->Reset();
+  this->CurrentSnapshot = this->State->Reset();
   this->State->RemoveUserDefinedCommands();
 }
 
@@ -370,6 +370,7 @@ void cmake::ReadListFile(const std::vector<std::string>& args,
   // read in the list file to fill the cache
   if(path)
     {
+    this->CurrentSnapshot = this->State->Reset();
     std::string homeDir = this->GetHomeDirectory();
     std::string homeOutputDir = this->GetHomeOutputDirectory();
     this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index 1dfa648..ebcfc0f 100644
--- a/Tests/QtAutogen/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -34,8 +34,8 @@ else()
   include_directories(${Qt5Widgets_INCLUDE_DIRS})
   set(QT_LIBRARIES Qt5::Widgets)
 
-  if(Qt5_POSITION_INDEPENDENT_CODE)
-    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  if(Qt5_POSITION_INDEPENDENT_CODE AND CMAKE_CXX_COMPILE_OPTIONS_PIC)
+    add_definitions(${CMAKE_CXX_COMPILE_OPTIONS_PIC})
   endif()
 
   macro(qtx_wrap_cpp)