cmState: Host some state from the cmGlobalGenerator.

Source/cmGlobalBorlandMakefileGenerator.cxx

@@ -22,7 +22,7 @@ cmGlobalBorlandMakefileGenerator::cmGlobalBorlandMakefileGenerator(cmake* cm)
   this->ForceUnixPaths = false;
   this->ToolSupportsColor = true;
   this->UseLinkScript = false;
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
   this->IncludeDirective = "!include";
   this->DefineWindowsNULL = true;
   this->PassMakeflags = true;

Source/cmGlobalGenerator.cxx

@@ -72,13 +72,6 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm)
   this->ExtraGenerator = 0;
   this->CurrentLocalGenerator = 0;
   this->TryCompileOuterMakefile = 0;
-
-  this->WindowsShell = false;
-  this->WindowsVSIDE = false;
-  this->WatcomWMake = false;
-  this->MinGWMake = false;
-  this->NMake = false;
-  this->MSYSShell = false;
 }
 
 cmGlobalGenerator::~cmGlobalGenerator()

Source/cmGlobalGenerator.h

@@ -355,13 +355,6 @@ public:
 #endif
 
   std::string MakeSilentFlag;
-  bool WindowsShell;
-  bool WindowsVSIDE;
-  bool WatcomWMake;
-  bool MinGWMake;
-  bool NMake;
-  bool MSYSShell;
-
 protected:
   virtual void Generate();
 

Source/cmGlobalJOMMakefileGenerator.cxx

@@ -20,8 +20,8 @@ cmGlobalJOMMakefileGenerator::cmGlobalJOMMakefileGenerator(cmake* cm)
   this->ForceUnixPaths = false;
   this->ToolSupportsColor = true;
   this->UseLinkScript = false;
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
-  this->NMake = true;
+  cm->GetState()->SetNMake(true);
   this->DefineWindowsNULL = true;
   this->PassMakeflags = true;
   this->UnixCD = false;

Source/cmGlobalMSYSMakefileGenerator.cxx

@@ -22,7 +22,7 @@ cmGlobalMSYSMakefileGenerator::cmGlobalMSYSMakefileGenerator(cmake* cm)
   this->ForceUnixPaths = true;
   this->ToolSupportsColor = true;
   this->UseLinkScript = false;
-  this->MSYSShell = true;
+  cm->GetState()->SetMSYSShell(true);
 }
 
 std::string

Source/cmGlobalMinGWMakefileGenerator.cxx

@@ -20,8 +20,8 @@ cmGlobalMinGWMakefileGenerator::cmGlobalMinGWMakefileGenerator(cmake* cm)
   this->ForceUnixPaths = true;
   this->ToolSupportsColor = true;
   this->UseLinkScript = true;
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
-  this->MinGWMake = true;
+  cm->GetState()->SetMinGWMake(true);
 }
 
 void cmGlobalMinGWMakefileGenerator

Source/cmGlobalNMakeMakefileGenerator.cxx

@@ -20,8 +20,8 @@ cmGlobalNMakeMakefileGenerator::cmGlobalNMakeMakefileGenerator(cmake* cm)
   this->ForceUnixPaths = false;
   this->ToolSupportsColor = true;
   this->UseLinkScript = false;
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
-  this->NMake = true;
+  cm->GetState()->SetNMake(true);
   this->DefineWindowsNULL = true;
   this->PassMakeflags = true;
   this->UnixCD = false;

Source/cmGlobalNinjaGenerator.cxx

@@ -517,7 +517,7 @@ cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
   , PolicyCMP0058(cmPolicies::WARN)
 {
 #ifdef _WIN32
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
 #endif
   // // Ninja is not ported to non-Unix OS yet.
   // this->ForceUnixPaths = true;

Source/cmGlobalVisualStudioGenerator.cxx

@@ -24,8 +24,8 @@
 cmGlobalVisualStudioGenerator::cmGlobalVisualStudioGenerator(cmake* cm)
   : cmGlobalGenerator(cm)
 {
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
-  this->WindowsVSIDE = true;
+  cm->GetState()->SetWindowsVSIDE(true);
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalWatcomWMakeGenerator.cxx

@@ -24,9 +24,9 @@ cmGlobalWatcomWMakeGenerator::cmGlobalWatcomWMakeGenerator(cmake* cm)
   this->NeedSymbolicMark = true;
   this->EmptyRuleHackCommand = "@cd .";
 #ifdef _WIN32
-  this->WindowsShell = true;
+  cm->GetState()->SetWindowsShell(true);
 #endif
-  this->WatcomWMake = true;
+  cm->GetState()->SetWatcomWMake(true);
   this->IncludeDirective = "!include";
   this->DefineWindowsNULL = true;
   this->UnixCD = false;

Source/cmLocalGenerator.cxx

@@ -1179,7 +1179,7 @@ cmLocalGenerator::ConvertToOutputForExistingCommon(const std::string& remote,
   // 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
   // space.
-  if(this->GlobalGenerator->WindowsShell && result.find(' ') != result.npos &&
+  if(this->GetState()->UseWindowsShell() && result.find(' ') != result.npos &&
      cmSystemTools::FileExists(remote.c_str()))
     {
     std::string tmp;
@@ -2551,7 +2551,7 @@ void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
     {
     // Append the definition with proper escaping.
     std::string def = dflag;
-    if(this->GlobalGenerator->WatcomWMake)
+    if(this->GetState()->UseWatcomWMake())
       {
       // The Watcom compiler does its own command line parsing instead
       // of using the windows shell rules.  Definitions are one of
@@ -2721,7 +2721,7 @@ std::string cmLocalGenerator::ConvertToOutputFormat(const std::string& source,
         // For the MSYS shell convert drive letters to posix paths, so
     // that c:/some/path becomes /c/some/path.  This is needed to
     // avoid problems with the shell path translation.
-    if(this->GlobalGenerator->MSYSShell && !this->LinkScriptShell)
+    if(this->GetState()->UseMSYSShell() && !this->LinkScriptShell)
       {
       if(result.size() > 2 && result[1] == ':')
         {
@@ -2729,7 +2729,7 @@ std::string cmLocalGenerator::ConvertToOutputFormat(const std::string& source,
         result[0] = '/';
         }
       }
-    if(this->GlobalGenerator->WindowsShell)
+    if(this->GetState()->UseWindowsShell())
       {
       std::replace(result.begin(), result.end(), '/', '\\');
       }
@@ -3144,22 +3144,22 @@ void cmLocalGenerator::ComputeObjectFilenames(
 
 bool cmLocalGenerator::IsWindowsShell() const
 {
-  return this->GlobalGenerator->WindowsShell;
+  return this->GetState()->UseWindowsShell();
 }
 
 bool cmLocalGenerator::IsWatcomWMake() const
 {
-  return this->GlobalGenerator->WatcomWMake;
+  return this->GetState()->UseWatcomWMake();
 }
 
 bool cmLocalGenerator::IsMinGWMake() const
 {
-  return this->GlobalGenerator->MinGWMake;
+  return this->GetState()->UseMinGWMake();
 }
 
 bool cmLocalGenerator::IsNMake() const
 {
-  return this->GlobalGenerator->NMake;
+  return this->GetState()->UseNMake();
 }
 
 void cmLocalGenerator::SetConfiguredCMP0014(bool configured)
@@ -3310,7 +3310,7 @@ std::string cmLocalGenerator::EscapeForShell(const std::string& str,
 
   // Compute the flags for the target shell environment.
   int flags = 0;
-  if(this->GlobalGenerator->WindowsVSIDE)
+  if(this->GetState()->UseWindowsVSIDE())
     {
     flags |= cmsysSystem_Shell_Flag_VSIDE;
     }
@@ -3330,27 +3330,27 @@ std::string cmLocalGenerator::EscapeForShell(const std::string& str,
     {
     flags |= cmsysSystem_Shell_Flag_WatcomQuote;
     }
-  if(this->GlobalGenerator->WatcomWMake)
+  if(this->GetState()->UseWatcomWMake())
     {
     flags |= cmsysSystem_Shell_Flag_WatcomWMake;
     }
-  if(this->GlobalGenerator->MinGWMake)
+  if(this->GetState()->UseMinGWMake())
     {
     flags |= cmsysSystem_Shell_Flag_MinGWMake;
     }
-  if(this->GlobalGenerator->NMake)
+  if(this->GetState()->UseNMake())
     {
     flags |= cmsysSystem_Shell_Flag_NMake;
     }
 
   // Compute the buffer size needed.
-  int size = (this->GlobalGenerator->WindowsShell ?
+  int size = (this->GetState()->UseWindowsShell() ?
               cmsysSystem_Shell_GetArgumentSizeForWindows(str.c_str(), flags) :
               cmsysSystem_Shell_GetArgumentSizeForUnix(str.c_str(), flags));
 
   // Compute the shell argument itself.
   std::vector<char> arg(size);
-  if(this->GlobalGenerator->WindowsShell)
+  if(this->GetState()->UseWindowsShell())
     {
     cmsysSystem_Shell_GetArgumentForWindows(str.c_str(), &arg[0], flags);
     }

Source/cmState.cxx

@@ -20,7 +20,13 @@
 
 cmState::cmState(cmake* cm)
   : CMakeInstance(cm),
-    IsInTryCompile(false)
+    IsInTryCompile(false),
+    WindowsShell(false),
+    WindowsVSIDE(false),
+    WatcomWMake(false),
+    MinGWMake(false),
+    NMake(false),
+    MSYSShell(false)
 {
 }
 
@@ -503,6 +509,66 @@ void cmState::SetBinaryDirectory(std::string const& binaryDirectory)
         this->BinaryDirectoryComponents);
 }
 
+void cmState::SetWindowsShell(bool windowsShell)
+{
+  this->WindowsShell = windowsShell;
+}
+
+bool cmState::UseWindowsShell() const
+{
+  return this->WindowsShell;
+}
+
+void cmState::SetWindowsVSIDE(bool windowsVSIDE)
+{
+  this->WindowsVSIDE = windowsVSIDE;
+}
+
+bool cmState::UseWindowsVSIDE() const
+{
+  return this->WindowsVSIDE;
+}
+
+void cmState::SetWatcomWMake(bool watcomWMake)
+{
+  this->WatcomWMake = watcomWMake;
+}
+
+bool cmState::UseWatcomWMake() const
+{
+  return this->WatcomWMake;
+}
+
+void cmState::SetMinGWMake(bool minGWMake)
+{
+  this->MinGWMake = minGWMake;
+}
+
+bool cmState::UseMinGWMake() const
+{
+  return this->MinGWMake;
+}
+
+void cmState::SetNMake(bool nMake)
+{
+  this->NMake = nMake;
+}
+
+bool cmState::UseNMake() const
+{
+  return this->NMake;
+}
+
+void cmState::SetMSYSShell(bool mSYSShell)
+{
+  this->MSYSShell = mSYSShell;
+}
+
+bool cmState::UseMSYSShell() const
+{
+  return this->MSYSShell;
+}
+
 const char* cmState::GetBinaryDirectory() const
 {
   return this->BinaryDirectory.c_str();

Source/cmState.h

@@ -138,6 +138,19 @@ public:
   std::vector<std::string> const& GetSourceDirectoryComponents() const;
   std::vector<std::string> const& GetBinaryDirectoryComponents() const;
 
+  void SetWindowsShell(bool windowsShell);
+  bool UseWindowsShell() const;
+  void SetWindowsVSIDE(bool windowsVSIDE);
+  bool UseWindowsVSIDE() const;
+  void SetWatcomWMake(bool watcomWMake);
+  bool UseWatcomWMake() const;
+  void SetMinGWMake(bool minGWMake);
+  bool UseMinGWMake() const;
+  void SetNMake(bool nMake);
+  bool UseNMake() const;
+  void SetMSYSShell(bool mSYSShell);
+  bool UseMSYSShell() const;
+
 private:
   std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
   std::vector<std::string> EnabledLanguages;
@@ -163,6 +176,12 @@ private:
   std::string SourceDirectory;
   std::string BinaryDirectory;
   bool IsInTryCompile;
+  bool WindowsShell;
+  bool WindowsVSIDE;
+  bool WatcomWMake;
+  bool MinGWMake;
+  bool NMake;
+  bool MSYSShell;
 };
 
 #endif