Merge topic 'delay-generator-toolset'

528e8af1 Allow a toolchain file to specify a generator toolset
98afb454 VS: Split user- and generator-provided PlatformToolset
3e9f6e36 Xcode: Rename internal variable {Platform => Generator}Toolset

Help/release/dev/delay-generator-toolset.rst

@@ -0,0 +1,8 @@
+delay-generator-toolset
+-----------------------
+
+* The :variable:`CMAKE_GENERATOR_TOOLSET` variable may now be
+  initialized in a toolchain file specified by the
+  :variable:`CMAKE_TOOLCHAIN_FILE` variable.  This is useful
+  when cross-compiling with the Xcode or Visual Studio
+  generators.

Help/variable/CMAKE_GENERATOR_TOOLSET.rst

@@ -7,3 +7,9 @@ Some CMake generators support a toolset name to be given to the native
 build system to choose a compiler.  If the user specifies a toolset
 name (e.g.  via the cmake -T option) the value will be available in
 this variable.
+
+The value of this variable should never be modified by project code.
+A toolchain file specified by the :variable:`CMAKE_TOOLCHAIN_FILE`
+variable may initialize ``CMAKE_GENERATOR_TOOLSET``.  Once a given
+build tree has been initialized with a particular value for this
+variable, changing the value has undefined behavior.

Source/cmGlobalGenerator.cxx

@@ -76,7 +76,8 @@ cmGlobalGenerator::~cmGlobalGenerator()
     }
 }
 
-bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts)
+bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts,
+                                            cmMakefile* mf)
 {
   cmOStringStream e;
   e <<
@@ -85,8 +86,7 @@ bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts)
     "does not support toolset specification, but toolset\n"
     "  " << ts << "\n"
     "was specified.";
-  this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                                    cmListFileBacktrace());
+  mf->IssueMessage(cmake::FATAL_ERROR, e.str());
   return false;
 }
 
@@ -448,6 +448,15 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     mf->ReadListFile(0,fpath.c_str());
     }
 
+  // Tell the generator about the toolset, if any.
+  std::string toolset = mf->GetSafeDefinition("CMAKE_GENERATOR_TOOLSET");
+  if(!toolset.empty() &&
+     !this->SetGeneratorToolset(toolset, mf))
+    {
+    cmSystemTools::SetFatalErrorOccured();
+    return;
+    }
+
   // **** Load the system specific initialization if not yet loaded
   if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED"))
     {

Source/cmGlobalGenerator.h

@@ -63,7 +63,7 @@ public:
 
   /** Set the generator-specific toolset name.  Returns true if toolset
       is supported and false otherwise.  */
-  virtual bool SetGeneratorToolset(std::string const& ts);
+  virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
 
   /**
    * Create LocalGenerators and process the CMakeLists files. This does not

Source/cmGlobalVisualStudio10Generator.cxx

@@ -116,9 +116,11 @@ cmGlobalVisualStudio10Generator::MatchesGeneratorName(
 
 //----------------------------------------------------------------------------
 bool
-cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts)
+cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts,
+                                                     cmMakefile* mf)
 {
-  this->PlatformToolset = ts;
+  this->GeneratorToolset = ts;
+  this->AddVSPlatformToolsetDefinition(mf);
   return true;
 }
 
@@ -126,10 +128,16 @@ cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts)
 void cmGlobalVisualStudio10Generator::AddPlatformDefinitions(cmMakefile* mf)
 {
   cmGlobalVisualStudio8Generator::AddPlatformDefinitions(mf);
-  if(!this->PlatformToolset.empty())
+  this->AddVSPlatformToolsetDefinition(mf);
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalVisualStudio10Generator
+::AddVSPlatformToolsetDefinition(cmMakefile* mf) const
+{
+  if(const char* toolset = this->GetPlatformToolset())
     {
-    mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET",
-                      this->PlatformToolset.c_str());
+    mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET", toolset);
     }
 }
 
@@ -215,11 +223,15 @@ void cmGlobalVisualStudio10Generator
 }
 
 //----------------------------------------------------------------------------
-const char* cmGlobalVisualStudio10Generator::GetPlatformToolset()
+const char* cmGlobalVisualStudio10Generator::GetPlatformToolset() const
 {
-  if(!this->PlatformToolset.empty())
+  if(!this->GeneratorToolset.empty())
     {
-    return this->PlatformToolset.c_str();
+    return this->GeneratorToolset.c_str();
+    }
+  if(!this->DefaultPlatformToolset.empty())
+    {
+    return this->DefaultPlatformToolset.c_str();
     }
   return 0;
 }
@@ -417,7 +429,7 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
 //----------------------------------------------------------------------------
 bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
 {
-  if(!this->PlatformToolset.empty())
+  if(this->GetPlatformToolset())
     {
     return true;
     }
@@ -435,7 +447,7 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
     cmOStringStream m;
     m << "Found Windows SDK v7.1: " << winSDK_7_1;
     mf->DisplayStatus(m.str().c_str(), -1);
-    this->PlatformToolset = "Windows7.1SDK";
+    this->DefaultPlatformToolset = "Windows7.1SDK";
     return true;
     }
   else

Source/cmGlobalVisualStudio10Generator.h

@@ -31,7 +31,7 @@ public:
 
   virtual bool MatchesGeneratorName(const std::string& name) const;
 
-  virtual bool SetGeneratorToolset(std::string const& ts);
+  virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
 
   virtual void GenerateBuildCommand(
     std::vector<std::string>& makeCommand,
@@ -66,7 +66,7 @@ public:
   bool IsMasmEnabled() const { return this->MasmEnabled; }
 
   /** The toolset name for the target platform.  */
-  const char* GetPlatformToolset();
+  const char* GetPlatformToolset() const;
 
   /**
    * Where does this version of Visual Studio look for macros for the
@@ -99,7 +99,8 @@ protected:
 
   std::string const& GetMSBuildCommand();
 
-  std::string PlatformToolset;
+  std::string GeneratorToolset;
+  std::string DefaultPlatformToolset;
   bool ExpressEdition;
   bool MasmEnabled;
 
@@ -122,5 +123,6 @@ private:
   virtual std::string FindMSBuildCommand();
   virtual std::string FindDevEnvCommand();
   virtual std::string GetVSMakeProgram() { return this->GetMSBuildCommand(); }
+  void AddVSPlatformToolsetDefinition(cmMakefile* mf) const;
 };
 #endif

Source/cmGlobalVisualStudio11Generator.cxx

@@ -117,7 +117,7 @@ cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\11.0\\Setup\\VC;"
     "ProductDir", vc11Express, cmSystemTools::KeyWOW64_32);
-  this->PlatformToolset = "v110";
+  this->DefaultPlatformToolset = "v110";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio12Generator.cxx

@@ -92,7 +92,7 @@ cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\12.0\\Setup\\VC;"
     "ProductDir", vc12Express, cmSystemTools::KeyWOW64_32);
-  this->PlatformToolset = "v120";
+  this->DefaultPlatformToolset = "v120";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalXCodeGenerator.cxx

@@ -202,16 +202,19 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
 }
 
 //----------------------------------------------------------------------------
-bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts)
+bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
+                                                 cmMakefile* mf)
 {
   if(this->XcodeVersion >= 30)
     {
-    this->PlatformToolset = ts;
+    this->GeneratorToolset = ts;
+    mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
+                      this->GeneratorToolset.c_str());
     return true;
     }
   else
     {
-    return cmGlobalGenerator::SetGeneratorToolset(ts);
+    return cmGlobalGenerator::SetGeneratorToolset(ts, mf);
     }
 }
 
@@ -239,11 +242,6 @@ void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
       }
     }
   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
-  if(!this->PlatformToolset.empty())
-    {
-    mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
-                      this->PlatformToolset.c_str());
-    }
   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
     const char* osxArch =
       mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
@@ -3363,10 +3361,10 @@ void cmGlobalXCodeGenerator
     buildSettings->AddAttribute("MACOSX_DEPLOYMENT_TARGET",
                                 this->CreateString(deploymentTarget));
     }
-  if(!this->PlatformToolset.empty())
+  if(!this->GeneratorToolset.empty())
     {
     buildSettings->AddAttribute("GCC_VERSION",
-      this->CreateString(this->PlatformToolset.c_str()));
+      this->CreateString(this->GeneratorToolset.c_str()));
     }
 
   // Put this last so it can override existing settings

Source/cmGlobalXCodeGenerator.h

@@ -89,7 +89,7 @@ public:
       i.e. "Can I build Debug and Release in the same tree?" */
   virtual bool IsMultiConfig();
 
-  virtual bool SetGeneratorToolset(std::string const& ts);
+  virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
   void AppendFlag(std::string& flags, std::string const& flag);
 private:
   cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
@@ -246,7 +246,7 @@ private:
   std::map<std::string, cmXCodeObject* > TargetGroup;
   std::map<std::string, cmXCodeObject* > FileRefs;
   std::vector<std::string> Architectures;
-  std::string PlatformToolset;
+  std::string GeneratorToolset;
 };
 
 #endif

Source/cmake.cxx

@@ -1462,11 +1462,6 @@ int cmake::ActualConfigure()
                                       "Name of generator toolset.",
                                       cmCacheManager::INTERNAL);
     }
-  if(!this->GeneratorToolset.empty() &&
-     !this->GlobalGenerator->SetGeneratorToolset(this->GeneratorToolset))
-    {
-    return -2;
-    }
 
   // reset any system configuration information, except for when we are
   // InTryCompile. With TryCompile the system info is taken from the parent's

Tests/RunCMake/GeneratorToolset/BadToolset-stderr.txt

@@ -1,4 +1,4 @@
-CMake Error:
+CMake Error at CMakeLists.txt:[0-9]+ \(project\):
   Generator
 
     .*

Tests/RunCMake/GeneratorToolset/BadToolset-toolchain.cmake

@@ -0,0 +1 @@
+set(CMAKE_GENERATOR_TOOLSET "Bad Toolset")

Tests/RunCMake/GeneratorToolset/BadToolsetToolchain-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/GeneratorToolset/BadToolsetToolchain-stderr.txt

@@ -0,0 +1,10 @@
+CMake Error at CMakeLists.txt:[0-9]+ \(project\):
+  Generator
+
+    .*
+
+  does not support toolset specification, but toolset
+
+    Bad Toolset
+
+  was specified.$

Tests/RunCMake/GeneratorToolset/BadToolsetToolchain.cmake

@@ -0,0 +1 @@
+message(FATAL_ERROR "This should not be reached!")

Tests/RunCMake/GeneratorToolset/RunCMakeTest.cmake

@@ -12,6 +12,17 @@ else()
 endif()
 
 set(RunCMake_GENERATOR_TOOLSET "")
+
 set(RunCMake_TEST_OPTIONS -T "Extra Toolset")
 run_cmake(TwoToolsets)
 unset(RunCMake_TEST_OPTIONS)
+
+if("${RunCMake_GENERATOR}" MATCHES "Visual Studio 1[012]|Xcode" AND NOT XCODE_BELOW_3)
+  set(RunCMake_TEST_OPTIONS -DCMAKE_TOOLCHAIN_FILE=${RunCMake_SOURCE_DIR}/TestToolset-toolchain.cmake)
+  run_cmake(TestToolsetToolchain)
+  unset(RunCMake_TEST_OPTIONS)
+else()
+  set(RunCMake_TEST_OPTIONS -DCMAKE_TOOLCHAIN_FILE=${RunCMake_SOURCE_DIR}/BadToolset-toolchain.cmake)
+  run_cmake(BadToolsetToolchain)
+  unset(RunCMake_TEST_OPTIONS)
+endif()

Tests/RunCMake/GeneratorToolset/TestToolset-toolchain.cmake

@@ -0,0 +1 @@
+set(CMAKE_GENERATOR_TOOLSET "Test Toolset")

Tests/RunCMake/GeneratorToolset/TestToolsetToolchain-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/GeneratorToolset/TestToolsetToolchain-stderr.txt

@@ -0,0 +1,9 @@
+CMake Error at TestToolsetToolchain.cmake:[0-9]+ \(message\):
+  CMAKE_GENERATOR_TOOLSET is "Test Toolset" as expected.
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)
++
+CMake Error at TestToolsetToolchain.cmake:[0-9]+ \(message\):
+  CMAKE_(VS|XCODE)_PLATFORM_TOOLSET is "Test Toolset" as expected.
+Call Stack \(most recent call first\):
+  CMakeLists.txt:3 \(include\)

Tests/RunCMake/GeneratorToolset/TestToolsetToolchain.cmake

@@ -0,0 +1,25 @@
+if("x${CMAKE_GENERATOR_TOOLSET}" STREQUAL "xTest Toolset")
+  message(SEND_ERROR "CMAKE_GENERATOR_TOOLSET is \"Test Toolset\" as expected.")
+else()
+  message(FATAL_ERROR
+    "CMAKE_GENERATOR_TOOLSET is \"${CMAKE_GENERATOR_TOOLSET}\" "
+    "but should be \"Test Toolset\"!")
+endif()
+if(CMAKE_GENERATOR MATCHES "Visual Studio")
+  if("x${CMAKE_VS_PLATFORM_TOOLSET}" STREQUAL "xTest Toolset")
+    message(SEND_ERROR "CMAKE_VS_PLATFORM_TOOLSET is \"Test Toolset\" as expected.")
+  else()
+    message(FATAL_ERROR
+      "CMAKE_VS_PLATFORM_TOOLSET is \"${CMAKE_VS_PLATFORM_TOOLSET}\" "
+      "but should be \"Test Toolset\"!")
+  endif()
+endif()
+if(CMAKE_GENERATOR MATCHES "Xcode")
+  if("x${CMAKE_XCODE_PLATFORM_TOOLSET}" STREQUAL "xTest Toolset")
+    message(SEND_ERROR "CMAKE_XCODE_PLATFORM_TOOLSET is \"Test Toolset\" as expected.")
+  else()
+    message(FATAL_ERROR
+      "CMAKE_XCODE_PLATFORM_TOOLSET is \"${CMAKE_XCODE_PLATFORM_TOOLSET}\" "
+      "but should be \"Test Toolset\"!")
+  endif()
+endif()