From e587c16adc9978609df13d65bbb6ede619778157 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Peter=20K=C3=BCmmel?= <syntheticpp@gmx.net>
Date: Thu, 11 Oct 2012 22:42:56 +0200
Subject: [PATCH] add source file properties EXTERNAL_SOURCE and
 OBJECT_LOCATION

With these two properties it is much easier to support
precompiled headers. See test SourceFileProperties.
---
 Source/cmLocalGenerator.cxx               | 15 ++++++
 Source/cmMakefileTargetGenerator.cxx      | 52 +++++++++++++++++---
 Source/cmNinjaTargetGenerator.cxx         | 33 ++++++++++++-
 Source/cmSourceFile.cxx                   | 13 +++++
 Tests/CMakeLists.txt                      |  1 +
 Tests/SourceFileProperties/CMakeLists.txt | 81 +++++++++++++++++++++++++++++++
 6 files changed, 187 insertions(+), 8 deletions(-)
 create mode 100644 Tests/SourceFileProperties/CMakeLists.txt

diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index b41f060..fe47bf7 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -2829,6 +2829,21 @@ cmLocalGenerator
                                  std::string const& dir_max,
                                  bool* hasSourceExtension)
 {
+  // A specified OBJECT_LOCATION overwrites the generated file name
+  if (const char* location = source.GetProperty("OBJECT_LOCATION"))
+    {
+    std::string fullPath;
+    if (cmSystemTools::FileIsFullPath(location))
+      {
+      fullPath = location;
+      }
+    else 
+      {
+      fullPath = this->Convert(location, FULL);
+      }
+    return this->Convert(fullPath.c_str(), HOME_OUTPUT)  ;
+    }
+
   // Construct the object file name using the full path to the source
   // file which is its only unique identification.
   const char* fullPath = source.GetFullPath().c_str();
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 9bf6b7d..02feaf3 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -171,7 +171,14 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
         si = this->GeneratorTarget->ExternalObjects.begin();
       si != this->GeneratorTarget->ExternalObjects.end(); ++si)
     {
-    this->ExternalObjects.push_back((*si)->GetFullPath());
+    if (const char* path = (*si)->GetProperty("OBJECT_LOCATION"))
+      {
+      this->Objects.push_back(path);
+      }
+    else
+      {
+      this->ExternalObjects.push_back((*si)->GetFullPath());
+      }
     }
   for(std::vector<cmSourceFile*>::const_iterator
         si = this->GeneratorTarget->ObjectSources.begin();
@@ -417,10 +424,19 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(cmSourceFile& source)
     }
 
   // Get the full path name of the object file.
-  std::string const& objectName = this->GeneratorTarget->Objects[&source];
-  std::string obj = this->LocalGenerator->GetTargetDirectory(*this->Target);
-  obj += "/";
-  obj += objectName;
+  std::string obj;
+  if (source.GetProperty("OBJECT_LOCATION"))
+    {
+    // path is already absolute or HOME_OUTPUT relative
+    obj = this->GeneratorTarget->Objects[&source];
+    }
+  else
+    {
+    std::string const& objectName = this->GeneratorTarget->Objects[&source];
+    obj = this->LocalGenerator->GetTargetDirectory(*this->Target);
+    obj += "/";
+    obj += objectName;
+    }
 
   // Avoid generating duplicate rules.
   if(this->ObjectFiles.find(obj) == this->ObjectFiles.end())
@@ -446,7 +462,10 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(cmSourceFile& source)
     (this->LocalGenerator->ConvertToFullPath(dir).c_str());
 
   // Save this in the target's list of object files.
-  this->Objects.push_back(obj);
+  if (!source.GetPropertyAsBool("EXTERNAL_SOURCE"))
+    {
+    this->Objects.push_back(obj);
+    }
   this->CleanFiles.push_back(obj);
 
   // TODO: Remove
@@ -751,6 +770,27 @@ cmMakefileTargetGenerator
       }
     }
 
+  if(const char* object_location_str =
+     source.GetProperty("OBJECT_LOCATION"))
+    {
+    if (relativeObj != object_location_str)
+      {
+      std::vector<std::string> extra_outputs;
+      cmSystemTools::ExpandListArgument(object_location_str, extra_outputs);
+      for(std::vector<std::string>::const_iterator eoi = extra_outputs.begin();
+          eoi != extra_outputs.end(); ++eoi)
+        {
+        // Register this as an extra output for the object file rule.
+        // This will cause the object file to be rebuilt if the extra
+        // output is missing.
+        this->GenerateExtraOutput(eoi->c_str(), relativeObj.c_str(), false);
+
+        // Register this as an extra file to clean.
+        this->CleanFiles.push_back(eoi->c_str());
+        }
+      }
+    }
+
   bool do_preprocess_rules = lang_is_c_or_cxx &&
     this->LocalGenerator->GetCreatePreprocessedSourceRules();
   bool do_assembly_rules = lang_is_c_or_cxx &&
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 15842e4..1fe1223 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -285,6 +285,12 @@ std::string
 cmNinjaTargetGenerator
 ::GetObjectFilePath(cmSourceFile* source) const
 {
+  if (source->GetProperty("OBJECT_LOCATION"))
+    {
+    // path is already absolute or HOME_OUTPUT relative
+    return this->GeneratorTarget->Objects[source];
+    }
+
   std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
   if(!path.empty())
     path += "/";
@@ -480,7 +486,14 @@ cmNinjaTargetGenerator
         si = this->GeneratorTarget->ExternalObjects.begin();
       si != this->GeneratorTarget->ExternalObjects.end(); ++si)
     {
-    this->Objects.push_back(this->GetSourceFilePath(*si));
+    if (const char* path = (*si)->GetProperty("OBJECT_LOCATION"))
+      {
+      this->Objects.push_back(this->ConvertToNinjaPath(path));
+      }
+    else
+      {
+      this->Objects.push_back(this->GetSourceFilePath(*si));
+      }
     }
   for(std::vector<cmSourceFile*>::const_iterator
         si = this->GeneratorTarget->ObjectSources.begin();
@@ -519,8 +532,10 @@ cmNinjaTargetGenerator
   cmNinjaDeps outputs;
   std::string objectFileName = this->GetObjectFilePath(source);
   outputs.push_back(objectFileName);
+
   // Add this object to the list of object files.
-  this->Objects.push_back(objectFileName);
+  if (!source->GetPropertyAsBool("EXTERNAL_SOURCE"))
+    this->Objects.push_back(objectFileName);
 
   cmNinjaDeps explicitDeps;
   std::string sourceFileName;
@@ -644,6 +659,20 @@ cmNinjaTargetGenerator
                                             outputList,
                                             outputs);
   }
+
+  if(const char* objectLocationStr = source->GetProperty("OBJECT_LOCATION")) {
+    std::string objectLocation = this->GetLocalGenerator()->Convert(objectLocationStr, cmLocalGenerator::HOME_OUTPUT);
+    if (std::find(outputs.begin(), outputs.end(), objectLocation) == outputs.end()) {
+      std::vector<std::string> outputList;
+      cmSystemTools::ExpandListArgument(objectLocation, outputList);
+      std::transform(outputList.begin(), outputList.end(), outputList.begin(),
+                     MapToNinjaPath());
+      cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
+                                              "Location output file.",
+                                              outputList,
+                                              outputs);
+    }
+  }
 }
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index 1d4b0c8..57c61b7 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -437,6 +437,13 @@ void cmSourceFile::DefineProperties(cmake *cm)
      "It will still be linked into the target though.");
 
   cm->DefineProperty
+    ("EXTERNAL_SOURCE", cmProperty::SOURCE_FILE,
+     "If set to true then this is a source file.",
+     "If this property is set to true then file is a source file"
+     "and will be compiled but it will not be linked into the target");
+
+
+  cm->DefineProperty
     ("Fortran_FORMAT", cmProperty::SOURCE_FILE,
      "Set to FIXED or FREE to indicate the Fortran source layout.",
      "This property tells CMake whether a given Fortran source file "
@@ -531,6 +538,12 @@ void cmSourceFile::DefineProperties(cmake *cm)
      "command (if one does not already exist due to linking relationships).");
 
   cm->DefineProperty
+    ("OBJECT_LOCATION", cmProperty::SOURCE_FILE,
+     "Path to output file name.",
+     "The output will be created at the given path."
+     "A relative path is interpreted as relative to CMAKE_BINARY_DIR.");
+
+  cm->DefineProperty
     ("OBJECT_OUTPUTS", cmProperty::SOURCE_FILE,
      "Additional outputs for a Makefile rule.",
      "Additional outputs created by compilation of this source file. "
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index b3302f9..32c6d1d 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -200,6 +200,7 @@ if(BUILD_TESTING)
   ADD_TEST_MACRO(NewlineArgs NewlineArgs)
   ADD_TEST_MACRO(SetLang SetLang)
   ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
+  ADD_TEST_MACRO(SourceFileProperties SourceFileProperties)
   ADD_TEST_MACRO(LoadCommand LoadedCommand)
   ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
   ADD_TEST_MACRO(LinkLanguage LinkLanguage)
diff --git a/Tests/SourceFileProperties/CMakeLists.txt b/Tests/SourceFileProperties/CMakeLists.txt
new file mode 100644
index 0000000..00a90d2
--- /dev/null
+++ b/Tests/SourceFileProperties/CMakeLists.txt
@@ -0,0 +1,81 @@
+cmake_minimum_required (VERSION 2.8)
+
+project (SourceFileProperties)
+
+
+
+# linking with external would fail because of two main() definitions
+set(src ${CMAKE_CURRENT_BINARY_DIR}/src)
+file(WRITE ${src}1.cpp "int main() { return 0; }\n")
+file(WRITE ${src}2.cpp "int main() { return 0; }\n")
+
+set_source_files_properties(${src}2.cpp PROPERTIES EXTERNAL_SOURCE TRUE)
+
+add_executable(SourceFileProperties ${src}1.cpp ${src}2.cpp)
+
+
+
+# build with manual set object file name
+file(WRITE ${src}3.cpp "int main() { return 0; }\n")
+set(obj ${CMAKE_CURRENT_BINARY_DIR}/object_location${CMAKE_C_OUTPUT_EXTENSION})
+
+set_source_files_properties(${src}3.cpp PROPERTIES OBJECT_LOCATION ${obj})
+
+add_executable(SourceFileProperties2 ${src}3.cpp)
+
+
+
+# ensure the defined object filenname was used
+set_source_files_properties(external_object PROPERTIES
+    EXTERNAL_OBJECT TRUE
+    GENERATED TRUE
+    OBJECT_LOCATION ${obj}
+    LANGUAGE CXX)
+
+add_executable(SourceFileProperties3 external_object)
+
+
+
+
+###########################################
+# Precompiled header like tests
+
+set(all_headers ${CMAKE_CURRENT_BINARY_DIR}/all_headers.h)
+set(gch ${all_headers}.gch)
+
+file(WRITE ${all_headers} "#include <string>\n")
+file(WRITE ${src}4.cpp "std::string foo() { return std::string(); }\n")
+
+
+if(NOT MSVC)
+ 
+    set_source_files_properties(${all_headers} PROPERTIES
+        HEADER_FILE_ONLY FALSE
+        LANGUAGE CXX
+        EXTERNAL_SOURCE TRUE
+        OBJECT_LOCATION ${gch})
+
+    set_source_files_properties(${src}4.cpp PROPERTIES
+        COMPILE_FLAGS "-Winvalid-pch -include ${all_headers}"
+        OBJECT_DEPENDS ${gch})
+
+    set(pch_support ${all_headers})
+
+else()
+
+    file(WRITE ${all_headers}.cpp "#include \"${all_headers}\"\n")
+
+    set_source_files_properties(${all_headers}.cpp PROPERTIES
+        COMPILE_FLAGS "/Yc\"${all_headers}\" /Fp${gch}"
+        OBJECT_OUTPUTS ${gch}) 
+        
+     set_source_files_properties(${src}4.cpp PROPERTIES
+        COMPILE_FLAGS "/FI${all_headers} /Yu${all_headers} /Fp${gch}"
+        OBJECT_DEPENDS ${gch})
+
+     set(pch_support ${all_headers}.cpp)
+     
+endif()
+
+add_library(test_with_pch ${src}4.cpp ${pch_support})
+
-- 
1.8.0.msysgit.0