ENH: Merging changes from branch CMake-SourceFile2-b between tags

CMake-SourceFile2-bp and CMake-SourceFile2-b-mp1 to trunk.  This
commit is surrounded by tags CMake-SourceFile2-b-mp1-pre and
CMake-SourceFile2-b-mp1-post on the trunk.

The changes re-implement cmSourceFile and the use of it to allow
instances to be created much earlier.  The use of cmSourceFileLocation
allows locating a source file referenced by a user to be much simpler
and more robust.  The two SetName methods are no longer needed so some
duplicate code has been removed.  The strange "SourceName" stuff is
gone.  Code that created cmSourceFile instances on the stack and then
sent them to cmMakefile::AddSource has been simplified and converted
to getting cmSourceFile instances from cmMakefile.  The CPluginAPI has
preserved the old API through a compatibility interface.

Source lists are gone.  Targets now get real instances of cmSourceFile
right away instead of storing a list of strings until the final pass.

TraceVSDependencies has been re-written to avoid the use of
SourceName.  It is now called TraceDependencies since it is not just
for VS.  It is now implemented with a helper object which makes the
code simpler.

1 files changed, 60 insertions, 84 deletions

diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx
index 19033f8..03c4060 100644
--- a/Source/cmQTWrapCPPCommand.cxx
+++ b/Source/cmQTWrapCPPCommand.cxx
@@ -24,120 +24,96 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
+
+  // This command supports source list inputs for compatibility.
   std::vector<std::string> args;
   this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
 
-  // what is the current source dir
-  std::string cdir = this->Makefile->GetCurrentDirectory();
-
-  // keep the library name
-  this->LibraryName = args[0];
-  this->SourceList = args[1];
-  
-  std::string sourceListValue;
+  // Get the moc executable to run in the custom command.
+  const char* moc_exe =
+    this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
 
-  // was the list already populated
-  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
-  if (def)
-    {
-    sourceListValue = def;
-    }
+  // Get the variable holding the list of sources.
+  std::string const& sourceList = args[1];
+  std::string sourceListValue =
+    this->Makefile->GetSafeDefinition(sourceList.c_str());
 
-  // get the list of classes for this library
+  // Create a rule for all sources listed.
   for(std::vector<std::string>::iterator j = (args.begin() + 2);
       j != args.end(); ++j)
-    {   
+    {
     cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
-    
     // if we should wrap the class
-    if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
+    if(!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE")))
       {
-      cmSourceFile file;
+      // Compute the name of the file to generate.
+      std::string srcName =
+        cmSystemTools::GetFilenameWithoutLastExtension(*j);
+      std::string newName = this->Makefile->GetCurrentOutputDirectory();
+      newName += "/moc_";
+      newName += srcName;
+      newName += ".cxx";
+      cmSourceFile* sf =
+        this->Makefile->GetOrCreateSource(newName.c_str(), true);
       if (curr)
         {
-        file.SetProperty("ABSTRACT",curr->GetProperty("ABSTRACT"));
+        sf->SetProperty("ABSTRACT", curr->GetProperty("ABSTRACT"));
         }
-      std::string srcName = 
-        cmSystemTools::GetFilenameWithoutLastExtension(*j);
-      std::string newName = "moc_" + srcName;
-      file.SetName(newName.c_str(), 
-                   this->Makefile->GetCurrentOutputDirectory(),
-                   "cxx",false);
+
+      // Compute the name of the header from which to generate the file.
       std::string hname;
-      if ( (*j)[0] == '/' || (*j)[1] == ':' )
+      if(cmSystemTools::FileIsFullPath(j->c_str()))
         {
         hname = *j;
         }
       else
         {
-        if ( curr && curr->GetPropertyAsBool("GENERATED") )
+        if(curr && curr->GetPropertyAsBool("GENERATED"))
           {
-          hname = std::string(this->Makefile->GetCurrentOutputDirectory()) 
-            + "/" + *j;
+          hname = this->Makefile->GetCurrentOutputDirectory();
           }
         else
           {
-          hname = cdir + "/" + *j;
+          hname = this->Makefile->GetCurrentDirectory();
           }
+        hname += "/";
+        hname += *j;
         }
-      this->WrapHeaders.push_back(hname);
-      // add starting depends
-      file.AddDepend(hname.c_str());
-      this->WrapClasses.push_back(file);
-      if (sourceListValue.size() > 0)
+
+      // Append the generated source file to the list.
+      if(!sourceListValue.empty())
         {
         sourceListValue += ";";
         }
-      sourceListValue += newName + ".cxx";
+      sourceListValue += newName;
+
+      // Create the custom command to generate the file.
+      cmCustomCommandLine commandLine;
+      commandLine.push_back(moc_exe);
+      commandLine.push_back("-o");
+      commandLine.push_back(newName);
+      commandLine.push_back(hname);
+
+      cmCustomCommandLines commandLines;
+      commandLines.push_back(commandLine);
+
+      std::vector<std::string> depends;
+      depends.push_back(moc_exe);
+      depends.push_back(hname);
+
+      const char* no_main_dependency = 0;
+      const char* no_working_dir = 0;
+      this->Makefile->AddCustomCommandToOutput(newName.c_str(),
+                                               depends,
+                                               no_main_dependency,
+                                               commandLines,
+                                               "QT Wrapped File",
+                                               no_working_dir);
       }
     }
-  
-  this->Makefile->AddDefinition(this->SourceList.c_str(), 
+
+  // Store the final list of source files.
+  this->Makefile->AddDefinition(sourceList.c_str(),
                                 sourceListValue.c_str());
   return true;
 }
-
-void cmQTWrapCPPCommand::FinalPass() 
-{
-
-  // first we add the rules for all the .h to Moc files
-  size_t lastClass = this->WrapClasses.size();
-  std::vector<std::string> depends;
-  const char* moc_exe = 
-    this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
-
-  // wrap all the .h files
-  depends.push_back(moc_exe);
-
-  for(size_t classNum = 0; classNum < lastClass; classNum++)
-    {
-    // Add output to build list
-    this->Makefile->AddSource(this->WrapClasses[classNum]);
-
-    // set up moc command
-    std::string res = this->Makefile->GetCurrentOutputDirectory();
-    res += "/";
-    res += this->WrapClasses[classNum].GetSourceName() + ".cxx";
-
-    cmCustomCommandLine commandLine;
-    commandLine.push_back(moc_exe);
-    commandLine.push_back("-o");
-    commandLine.push_back(res);
-    commandLine.push_back(this->WrapHeaders[classNum]);
-
-    cmCustomCommandLines commandLines;
-    commandLines.push_back(commandLine);
-
-    std::vector<std::string> realdepends = depends;
-    realdepends.push_back(this->WrapHeaders[classNum]);
-
-    const char* no_main_dependency = 0;
-    const char* no_working_dir = 0;
-    this->Makefile->AddCustomCommandToOutput(res.c_str(),
-                                         realdepends,
-                                         no_main_dependency,
-                                         commandLines,
-                                         "QT Wrapped File",
-                                         no_working_dir);
-    }
-}