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, 114 insertions, 158 deletions

diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx
index 2f7982d..ff86ed9 100644
--- a/Source/cmQTWrapUICommand.cxx
+++ b/Source/cmQTWrapUICommand.cxx
@@ -24,191 +24,147 @@ bool cmQTWrapUICommand::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, 3);
 
-  // what is the current source dir
-  std::string cdir = this->Makefile->GetCurrentDirectory();
-
-  // keep the library name
-  this->LibraryName = args[0];
-  this->HeaderList = args[1];
-  this->SourceList = args[2];
-  std::string sourceListValue;
-  std::string headerListValue;
-  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
-  if (def)
-    {
-    sourceListValue = def;
-    }
- 
-  // get the list of classes for this library
+  // Get the uic and moc executables to run in the custom commands.
+  const char* uic_exe =
+    this->Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
+  const char* moc_exe =
+    this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
+
+  // Get the variable holding the list of sources.
+  std::string const& headerList = args[1];
+  std::string const& sourceList = args[2];
+  std::string headerListValue =
+    this->Makefile->GetSafeDefinition(headerList.c_str());
+  std::string sourceListValue =
+    this->Makefile->GetSafeDefinition(sourceList.c_str());
+
+  // Create rules for all sources listed.
   for(std::vector<std::string>::iterator j = (args.begin() + 3);
       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 header_file;
-      cmSourceFile source_file;
-      cmSourceFile moc_file;
-      std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
-      header_file.SetName(srcName.c_str(), 
-                          this->Makefile->GetCurrentOutputDirectory(),
-                          "h",false);
-      source_file.SetName(srcName.c_str(), 
-                          this->Makefile->GetCurrentOutputDirectory(),
-                          "cxx",false);
-      std::string moc_source_name("moc_");
-      moc_source_name = moc_source_name + srcName;
-      moc_file.SetName(moc_source_name.c_str(), 
-                       this->Makefile->GetCurrentOutputDirectory(),
-                       "cxx",false);
-      std::string origname;
-      if ( (*j)[0] == '/' || (*j)[1] == ':' )
+      // Compute the name of the files to generate.
+      std::string srcName =
+        cmSystemTools::GetFilenameWithoutLastExtension(*j);
+      std::string hName = this->Makefile->GetCurrentOutputDirectory();
+      hName += "/";
+      hName += srcName;
+      hName += ".h";
+      std::string cxxName = this->Makefile->GetCurrentOutputDirectory();
+      cxxName += "/";
+      cxxName += srcName;
+      cxxName += ".cxx";
+      std::string mocName = this->Makefile->GetCurrentOutputDirectory();
+      mocName += "/moc_";
+      mocName += srcName;
+      mocName += ".cxx";
+
+      // Compute the name of the ui file from which to generate others.
+      std::string uiName;
+      if(cmSystemTools::FileIsFullPath(j->c_str()))
         {
-        origname = *j;
+        uiName = *j;
         }
       else
         {
-        if ( curr && curr->GetPropertyAsBool("GENERATED") )
+        if(curr && curr->GetPropertyAsBool("GENERATED"))
           {
-          origname = std::string(this->Makefile->GetCurrentOutputDirectory()) 
-            + "/" + *j;
+          uiName = this->Makefile->GetCurrentOutputDirectory();
           }
         else
           {
-          origname = cdir + "/" + *j;
+          uiName = this->Makefile->GetCurrentDirectory();
           }
+        uiName += "/";
+        uiName += *j;
         }
-      std::string hname = header_file.GetFullPath();
-      this->WrapUserInterface.push_back(origname);
-      // add starting depends
-      moc_file.AddDepend(hname.c_str());
-      source_file.AddDepend(hname.c_str());
-      source_file.AddDepend(origname.c_str());
-      header_file.AddDepend(origname.c_str());
-      this->WrapHeadersClasses.push_back(header_file);
-      this->WrapSourcesClasses.push_back(source_file);
-      this->WrapMocClasses.push_back(moc_file);
-      this->Makefile->AddSource(header_file);
-      this->Makefile->AddSource(source_file);
-      this->Makefile->AddSource(moc_file);
-      
-      // create the list of headers 
-      if (headerListValue.size() > 0)
+
+      // create the list of headers
+      if(!headerListValue.empty())
         {
         headerListValue += ";";
         }
-      headerListValue += header_file.GetFullPath();
-      
+      headerListValue += hName;
+
       // create the list of sources
-      if (sourceListValue.size() > 0)
+      if(!sourceListValue.empty())
         {
         sourceListValue += ";";
         }
-      sourceListValue += source_file.GetFullPath();
+      sourceListValue += cxxName;
       sourceListValue += ";";
-      sourceListValue += moc_file.GetFullPath();
+      sourceListValue += mocName;
+
+      // set up .ui to .h and .cxx command
+      cmCustomCommandLine hCommand;
+      hCommand.push_back(uic_exe);
+      hCommand.push_back("-o");
+      hCommand.push_back(hName);
+      hCommand.push_back(uiName);
+      cmCustomCommandLines hCommandLines;
+      hCommandLines.push_back(hCommand);
+
+      cmCustomCommandLine cxxCommand;
+      cxxCommand.push_back(uic_exe);
+      cxxCommand.push_back("-impl");
+      cxxCommand.push_back(hName);
+      cxxCommand.push_back("-o");
+      cxxCommand.push_back(cxxName);
+      cxxCommand.push_back(uiName);
+      cmCustomCommandLines cxxCommandLines;
+      cxxCommandLines.push_back(cxxCommand);
+
+      cmCustomCommandLine mocCommand;
+      mocCommand.push_back(moc_exe);
+      mocCommand.push_back("-o");
+      mocCommand.push_back(mocName);
+      mocCommand.push_back(hName);
+      cmCustomCommandLines mocCommandLines;
+      mocCommandLines.push_back(mocCommand);
+
+      std::vector<std::string> depends;
+      depends.push_back(uiName);
+      const char* no_main_dependency = 0;
+      const char* no_comment = 0;
+      const char* no_working_dir = 0;
+      this->Makefile->AddCustomCommandToOutput(hName.c_str(),
+                                               depends,
+                                               no_main_dependency,
+                                               hCommandLines,
+                                               no_comment,
+                                               no_working_dir);
+
+      depends.push_back(hName);
+      this->Makefile->AddCustomCommandToOutput(cxxName.c_str(),
+                                               depends,
+                                               no_main_dependency,
+                                               cxxCommandLines,
+                                               no_comment,
+                                               no_working_dir);
+
+      depends.clear();
+      depends.push_back(hName);
+      this->Makefile->AddCustomCommandToOutput(mocName.c_str(),
+                                               depends,
+                                               no_main_dependency,
+                                               mocCommandLines,
+                                               no_comment,
+                                               no_working_dir);
       }
     }
-  
-  this->Makefile->AddDefinition(this->SourceList.c_str(),
-                                sourceListValue.c_str());  
-  this->Makefile->AddDefinition(this->HeaderList.c_str(),
-                                headerListValue.c_str());  
-  return true;
-}
-
-void cmQTWrapUICommand::FinalPass() 
-{
-
-  // first we add the rules for all the .ui to .h and .cxx files
-  size_t lastHeadersClass = this->WrapHeadersClasses.size();
-  std::vector<std::string> depends;
-  const char* uic_exe =
-    this->Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
-  const char* moc_exe =
-    this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
-
-  // wrap all the .h files
-  depends.push_back(uic_exe);
 
-  for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
-    {
-    // set up .ui to .h and .cxx command
-    std::string hres = this->Makefile->GetCurrentOutputDirectory();
-    hres += "/";
-    hres += this->WrapHeadersClasses[classNum].GetSourceName() + "." +
-        this->WrapHeadersClasses[classNum].GetSourceExtension();
-
-    std::string cxxres = this->Makefile->GetCurrentOutputDirectory();
-    cxxres += "/";
-    cxxres += this->WrapSourcesClasses[classNum].GetSourceName() + "." +
-        this->WrapSourcesClasses[classNum].GetSourceExtension();
-
-    std::string mocres = this->Makefile->GetCurrentOutputDirectory();
-    mocres += "/";
-    mocres += this->WrapMocClasses[classNum].GetSourceName() + "." +
-        this->WrapMocClasses[classNum].GetSourceExtension();
-
-    cmCustomCommandLine hCommand;
-    hCommand.push_back(uic_exe);
-    hCommand.push_back("-o");
-    hCommand.push_back(hres);
-    hCommand.push_back(this->WrapUserInterface[classNum]);
-    cmCustomCommandLines hCommandLines;
-    hCommandLines.push_back(hCommand);
-
-    cmCustomCommandLine cxxCommand;
-    cxxCommand.push_back(uic_exe);
-    cxxCommand.push_back("-impl");
-    cxxCommand.push_back(hres);
-    cxxCommand.push_back("-o");
-    cxxCommand.push_back(cxxres);
-    cxxCommand.push_back(this->WrapUserInterface[classNum]);
-    cmCustomCommandLines cxxCommandLines;
-    cxxCommandLines.push_back(cxxCommand);
-
-    cmCustomCommandLine mocCommand;
-    mocCommand.push_back(moc_exe);
-    mocCommand.push_back("-o");
-    mocCommand.push_back(mocres);
-    mocCommand.push_back(hres);
-    cmCustomCommandLines mocCommandLines;
-    mocCommandLines.push_back(mocCommand);
-
-    depends.clear();
-    depends.push_back(this->WrapUserInterface[classNum]);
-    const char* no_main_dependency = 0;
-    const char* no_comment = 0;
-    const char* no_working_dir = 0;
-    this->Makefile->AddCustomCommandToOutput(hres.c_str(),
-                                         depends,
-                                         no_main_dependency,
-                                         hCommandLines,
-                                         no_comment,
-                                         no_working_dir);
-
-    depends.push_back(hres);
-
-    this->Makefile->AddCustomCommandToOutput(cxxres.c_str(),
-                                         depends,
-                                         no_main_dependency,
-                                         cxxCommandLines,
-                                         no_comment,
-                                         no_working_dir);
-
-    depends.clear();
-    depends.push_back(hres);
-
-    this->Makefile->AddCustomCommandToOutput(mocres.c_str(),
-                                         depends,
-                                         no_main_dependency,
-                                         mocCommandLines,
-                                         no_comment,
-                                         no_working_dir);
-    }
+  // Store the final list of source files and headers.
+  this->Makefile->AddDefinition(sourceList.c_str(),
+                                sourceListValue.c_str());
+  this->Makefile->AddDefinition(headerList.c_str(),
+                                headerListValue.c_str());
+  return true;
 }