VS6: Port to cmGeneratorTarget.

Source/cmGlobalVisualStudio6Generator.cxx

@@ -223,7 +223,7 @@ void cmGlobalVisualStudio6Generator
         tt = orderedProjectTargets.begin();
       tt != orderedProjectTargets.end(); ++tt)
     {
-    cmTarget const* target = (*tt)->Target;
+    cmGeneratorTarget const* target = *tt;
     if(target->GetType() == cmState::INTERFACE_LIBRARY)
       {
       continue;
@@ -235,14 +235,15 @@ void cmGlobalVisualStudio6Generator
       std::string project = target->GetName();
       std::string location = expath;
       this->WriteExternalProject(fout, project.c_str(),
-                                 location.c_str(), target->GetUtilities());
+          location.c_str(), target->Target->GetUtilities());
       }
     else
       {
       std::string dspname = GetVS6TargetName(target->GetName());
-      std::string dir = target->GetMakefile()->GetCurrentBinaryDirectory();
+      std::string dir =
+          target->GetLocalGenerator()->GetCurrentBinaryDirectory();
       dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT);
-      this->WriteProject(fout, dspname.c_str(), dir.c_str(), *target);
+      this->WriteProject(fout, dspname.c_str(), dir.c_str(), target);
       }
     }
 
@@ -287,9 +288,9 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile()
 // Note, that dependencies from executables to
 // the libraries it uses are also done here
 void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
-                                                  const std::string& dspname,
-                                                  const char* dir,
-                                                  cmTarget const& target)
+                                            const std::string& dspname,
+                                            const char* dir,
+                                            const cmGeneratorTarget *target)
 {
   fout << "#########################################################"
     "######################\n\n";
@@ -298,7 +299,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
   fout << "Package=<5>\n{{{\n}}}\n\n";
   fout << "Package=<4>\n";
   fout << "{{{\n";
-  VSDependSet const& depends = this->VSTargetDepends[&target];
+  VSDependSet const& depends = this->VSTargetDepends[target->Target];
   for(VSDependSet::const_iterator di = depends.begin();
       di != depends.end(); ++di)
     {
@@ -309,7 +310,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
     }
   fout << "}}}\n\n";
 
-  UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target);
+  UtilityDependsMap::iterator ui = this->UtilityDepends.find(target->Target);
   if(ui != this->UtilityDepends.end())
     {
     const char* uname = ui->second.c_str();
@@ -382,7 +383,7 @@ void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout)
 
 //----------------------------------------------------------------------------
 std::string
-cmGlobalVisualStudio6Generator::WriteUtilityDepend(cmTarget const* target)
+cmGlobalVisualStudio6Generator::WriteUtilityDepend(const cmTarget *target)
 {
   std::string pname = target->GetName();
   pname += "_UTILITY";

Source/cmGlobalVisualStudio6Generator.h

@@ -15,8 +15,6 @@
 #include "cmGlobalVisualStudioGenerator.h"
 #include "cmGlobalGeneratorFactory.h"
 
-class cmTarget;
-
 /** \class cmGlobalVisualStudio6Generator
  * \brief Write a Unix makefiles.
  *
@@ -94,7 +92,7 @@ private:
   void WriteDSWHeader(std::ostream& fout);
   void WriteProject(std::ostream& fout,
                     const std::string& name, const char* path,
-                    cmTarget const& t);
+                    cmGeneratorTarget const* t);
   void WriteExternalProject(std::ostream& fout,
                             const std::string& name, const char* path,
                             const std::set<std::string>& dependencies);

Source/cmLocalVisualStudio6Generator.cxx

@@ -98,7 +98,7 @@ void cmLocalVisualStudio6Generator::AddCMakeListsRules()
       this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
     if (!cmSystemTools::IsOn(suppRegenRule))
       {
-      this->AddDSPBuildRule(*(*l)->Target);
+      this->AddDSPBuildRule(*l);
       }
     }
 }
@@ -133,21 +133,21 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
       case cmState::STATIC_LIBRARY:
       case cmState::OBJECT_LIBRARY:
         this->SetBuildType(STATIC_LIBRARY,
-                           (*l)->GetName().c_str(), *(*l)->Target);
+                           (*l)->GetName().c_str(), *l);
         break;
       case cmState::SHARED_LIBRARY:
       case cmState::MODULE_LIBRARY:
         this->SetBuildType(DLL,
-                           (*l)->GetName().c_str(), *(*l)->Target);
+                           (*l)->GetName().c_str(), *l);
         break;
       case cmState::EXECUTABLE:
         this->SetBuildType(EXECUTABLE,
-                           (*l)->GetName().c_str(), *(*l)->Target);
+                           (*l)->GetName().c_str(), *l);
         break;
       case cmState::UTILITY:
       case cmState::GLOBAL_TARGET:
         this->SetBuildType(UTILITY,
-                           (*l)->GetName().c_str(), *(*l)->Target);
+                           (*l)->GetName().c_str(), *l);
         break;
       case cmState::INTERFACE_LIBRARY:
         continue;
@@ -173,7 +173,7 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
           cmSystemTools::Error("Error creating directory: ", dir.c_str());
           }
         }
-      this->CreateSingleDSP((*l)->GetName().c_str(), *(*l)->Target);
+      this->CreateSingleDSP((*l)->GetName().c_str(), *l);
       }
     }
 }
@@ -184,7 +184,7 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
 extern std::string GetVS6TargetName(const std::string& targetName);
 
 void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname,
-                                                    cmTarget &target)
+                                                    cmGeneratorTarget* target)
 {
   // add to the list of projects
   std::string pname = GetVS6TargetName(lname);
@@ -211,9 +211,9 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname,
 }
 
 
-void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
+void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmGeneratorTarget *tgt)
 {
-  std::string dspname = GetVS6TargetName(tgt.GetName());
+  std::string dspname = GetVS6TargetName(tgt->GetName());
   dspname += ".dsp.cmake";
   cmCustomCommandLine commandLine;
   commandLine.push_back(cmSystemTools::GetCMakeCommand());
@@ -245,8 +245,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
                                            no_working_directory, true);
   if(this->Makefile->GetSource(makefileIn.c_str()))
     {
-    cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(&tgt);
-    gt->AddSource(makefileIn);
+    tgt->AddSource(makefileIn);
     }
   else
     {
@@ -257,7 +256,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
 
 void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
                                                  const std::string& libName,
-                                                 cmTarget &target)
+                                                 cmGeneratorTarget *target)
 {
   // For utility targets need custom command since pre- and post-
   // build does not do anything in Visual Studio 6.  In order for the
@@ -265,23 +264,23 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
   // special care for dependencies.  The first rule must depend on all
   // the dependencies of all the rules.  The later rules must each
   // depend only on the previous rule.
-  if ((target.GetType() == cmState::UTILITY ||
-      target.GetType() == cmState::GLOBAL_TARGET) &&
-      (!target.GetPreBuildCommands().empty() ||
-       !target.GetPostBuildCommands().empty()))
+  if ((target->GetType() == cmState::UTILITY ||
+      target->GetType() == cmState::GLOBAL_TARGET) &&
+      (!target->Target->GetPreBuildCommands().empty() ||
+       !target->Target->GetPostBuildCommands().empty()))
     {
     // Accumulate the dependencies of all the commands.
     std::vector<std::string> depends;
     for (std::vector<cmCustomCommand>::const_iterator cr =
-           target.GetPreBuildCommands().begin();
-         cr != target.GetPreBuildCommands().end(); ++cr)
+           target->Target->GetPreBuildCommands().begin();
+         cr != target->Target->GetPreBuildCommands().end(); ++cr)
       {
       depends.insert(depends.end(),
                      cr->GetDepends().begin(), cr->GetDepends().end());
       }
     for (std::vector<cmCustomCommand>::const_iterator cr =
-           target.GetPostBuildCommands().begin();
-         cr != target.GetPostBuildCommands().end(); ++cr)
+           target->Target->GetPostBuildCommands().begin();
+         cr != target->Target->GetPostBuildCommands().end(); ++cr)
       {
       depends.insert(depends.end(),
                      cr->GetDepends().begin(), cr->GetDepends().end());
@@ -290,14 +289,14 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
     // Add the pre- and post-build commands in order.
     int count = 1;
     for (std::vector<cmCustomCommand>::const_iterator cr =
-           target.GetPreBuildCommands().begin();
-         cr != target.GetPreBuildCommands().end(); ++cr)
+           target->Target->GetPreBuildCommands().begin();
+         cr != target->Target->GetPreBuildCommands().end(); ++cr)
       {
       this->AddUtilityCommandHack(target, count++, depends, *cr);
       }
     for (std::vector<cmCustomCommand>::const_iterator cr =
-           target.GetPostBuildCommands().begin();
-         cr != target.GetPostBuildCommands().end(); ++cr)
+           target->Target->GetPostBuildCommands().begin();
+         cr != target->Target->GetPostBuildCommands().end(); ++cr)
       {
       this->AddUtilityCommandHack(target, count++, depends, *cr);
       }
@@ -306,12 +305,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
   // We may be modifying the source groups temporarily, so make a copy.
   std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
 
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
-
   // get the classes from the source lists then add them to the groups
   std::vector<cmSourceFile*> classes;
-  if (!gt->GetConfigCommonSourceFiles(classes))
+  if (!target->GetConfigCommonSourceFiles(classes))
     {
     return;
     }
@@ -375,11 +371,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
 }
 
 void cmLocalVisualStudio6Generator
-::WriteGroup(const cmSourceGroup *sg, cmTarget& target,
+::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
              std::ostream &fout, const std::string& libName)
 {
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
   const std::vector<const cmSourceFile *> &sourceFiles =
     sg->GetSourceFiles();
   // If the group is empty, don't write it at all.
@@ -411,9 +405,10 @@ void cmLocalVisualStudio6Generator
     std::string compileFlags;
     std::vector<std::string> depends;
     std::string objectNameDir;
-    if(gt->HasExplicitObjectName(*sf))
+    if(target->HasExplicitObjectName(*sf))
       {
-      objectNameDir = cmSystemTools::GetFilenamePath(gt->GetObjectName(*sf));
+      objectNameDir =
+          cmSystemTools::GetFilenamePath(target->GetObjectName(*sf));
       }
 
     // Add per-source file flags.
@@ -484,8 +479,8 @@ void cmLocalVisualStudio6Generator
       cmSystemTools::ExpandListArgument(dependsValue, depends);
       }
     if (GetVS6TargetName(source) != libName ||
-      target.GetType() == cmState::UTILITY ||
-      target.GetType() == cmState::GLOBAL_TARGET)
+      target->GetType() == cmState::UTILITY ||
+      target->GetType() == cmState::GLOBAL_TARGET)
       {
       fout << "# Begin Source File\n\n";
 
@@ -575,15 +570,15 @@ void cmLocalVisualStudio6Generator
 
 void
 cmLocalVisualStudio6Generator
-::AddUtilityCommandHack(cmTarget& target, int count,
+::AddUtilityCommandHack(cmGeneratorTarget *target, int count,
                         std::vector<std::string>& depends,
                         const cmCustomCommand& origCommand)
 {
   // Create a fake output that forces the rule to run.
   char* output = new char[(strlen(this->GetCurrentBinaryDirectory())
-                           + target.GetName().size() + 30)];
+                           + target->GetName().size() + 30)];
   sprintf(output,"%s/%s_force_%i", this->GetCurrentBinaryDirectory(),
-          target.GetName().c_str(), count);
+          target->GetName().c_str(), count);
   const char* comment = origCommand.GetComment();
   if(!comment && origCommand.GetOutputs().empty())
     {
@@ -598,8 +593,7 @@ cmLocalVisualStudio6Generator
        origCommand.GetCommandLines(), comment,
        origCommand.GetWorkingDirectory().c_str()))
     {
-    cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(&target);
-    gt->AddSource(outsf->GetFullPath());
+    target->AddSource(outsf->GetFullPath());
     }
 
   // Replace the dependencies with the output of this rule so that the
@@ -715,7 +709,7 @@ void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout)
 
 void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
                                                  const std::string& libName,
-                                                 cmTarget& target)
+                                                 cmGeneratorTarget *target)
 {
   std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
   const char *def=
@@ -747,7 +741,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
       this->DSPFooterTemplate += "/DLLFooter.dsptemplate";
       break;
     case EXECUTABLE:
-      if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
+      if ( target->GetPropertyAsBool("WIN32_EXECUTABLE") )
         {
         this->DSPHeaderTemplate = root;
         this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
@@ -799,19 +793,16 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
 
 //----------------------------------------------------------------------------
 cmsys::auto_ptr<cmCustomCommand>
-cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target,
+cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmGeneratorTarget* target,
                                                     const std::string& config)
 {
   cmsys::auto_ptr<cmCustomCommand> pcc;
 
   // VS6 forgets to create the output directory for archives if it
   // differs from the intermediate directory.
-  if(target.GetType() != cmState::STATIC_LIBRARY) { return pcc; }
-
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
+  if(target->GetType() != cmState::STATIC_LIBRARY) { return pcc; }
 
-  std::string outDir = gt->GetDirectory(config, false);
+  std::string outDir = target->GetDirectory(config, false);
 
   // Add a pre-link event to create the directory.
   cmCustomCommandLine command;
@@ -833,11 +824,11 @@ cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target,
 
 // look for custom rules on a target and collect them together
 std::string
-cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
+cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target,
                                               const std::string& configName,
                                               const std::string& /* libName */)
 {
-  if (target.GetType() >= cmState::UTILITY )
+  if (target->GetType() >= cmState::UTILITY )
     {
     return "";
     }
@@ -847,10 +838,10 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
 
   // Write the pre-build and pre-link together (VS6 does not support both).
   event.Start("PreLink");
-  event.Write(target.GetPreBuildCommands());
-  event.Write(target.GetPreLinkCommands());
+  event.Write(target->Target->GetPreBuildCommands());
+  event.Write(target->Target->GetPreLinkCommands());
   cmsys::auto_ptr<cmCustomCommand> pcc(
-    this->MaybeCreateImplibDir(target, configName, false));
+    this->MaybeCreateImplibDir(*target->Target, configName, false));
   if(pcc.get())
     {
     event.Write(*pcc);
@@ -864,7 +855,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
 
   // Write the post-build rules.
   event.Start("PostBuild");
-  event.Write(target.GetPostBuildCommands());
+  event.Write(target->Target->GetPostBuildCommands());
   event.Finish();
 
   customRuleCode += "# End Special Build Tool\n";
@@ -883,7 +874,8 @@ inline std::string removeQuotes(const std::string& s)
 
 
 std::string
-cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
+cmLocalVisualStudio6Generator::GetTargetIncludeOptions(
+        cmGeneratorTarget *target,
                                                   const std::string& config)
 {
   std::string includeOptions;
@@ -894,12 +886,10 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
   unsigned int maxIncludeLength = 3000;
   bool useShortPath = false;
 
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
   for(int j=0; j < 2; ++j)
     {
     std::vector<std::string> includes;
-    this->GetIncludeDirectories(includes, gt, "C", config);
+    this->GetIncludeDirectories(includes, target, "C", config);
 
     std::vector<std::string>::iterator i;
     for(i = includes.begin(); i != includes.end(); ++i)
@@ -947,11 +937,11 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
 
 void cmLocalVisualStudio6Generator
 ::WriteDSPHeader(std::ostream& fout,
-                 const std::string& libName, cmTarget &target,
+                 const std::string& libName, cmGeneratorTarget* target,
                  std::vector<cmSourceGroup> &)
 {
-  bool targetBuilds = (target.GetType() >= cmState::EXECUTABLE &&
-                       target.GetType() <= cmState::MODULE_LIBRARY);
+  bool targetBuilds = (target->GetType() >= cmState::EXECUTABLE &&
+                       target->GetType() <= cmState::MODULE_LIBRARY);
 #ifdef CM_USE_OLD_VS6
   // Lookup the library and executable output directories.
   std::string libPath;
@@ -1061,7 +1051,8 @@ void cmLocalVisualStudio6Generator
       }
     }
   std::vector<std::string>::const_iterator i;
-  const std::vector<std::string>& libdirs = target.GetLinkDirectories();
+  const std::vector<std::string>& libdirs =
+      target->Target->GetLinkDirectories();
   for(i = libdirs.begin(); i != libdirs.end(); ++i)
     {
     std::string path = *i;
@@ -1103,19 +1094,19 @@ void cmLocalVisualStudio6Generator
     }
   // find link libraries
   const cmTarget::LinkLibraryVectorType& libs =
-    target.GetLinkLibrariesForVS6();
+    target->Target->GetLinkLibrariesForVS6();
   cmTarget::LinkLibraryVectorType::const_iterator j;
   for(j = libs.begin(); j != libs.end(); ++j)
     {
     // add libraries to executables and dlls (but never include
     // a library in a library, bad recursion)
     // NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES
-    if ((target.GetType() != cmState::SHARED_LIBRARY
-         && target.GetType() != cmState::STATIC_LIBRARY
-         && target.GetType() != cmState::MODULE_LIBRARY) ||
-        (target.GetType()==cmState::SHARED_LIBRARY
+    if ((target->GetType() != cmState::SHARED_LIBRARY
+         && target->GetType() != cmState::STATIC_LIBRARY
+         && target->GetType() != cmState::MODULE_LIBRARY) ||
+        (target->GetType()==cmState::SHARED_LIBRARY
          && libName != GetVS6TargetName(j->first)) ||
-        (target.GetType()==cmState::MODULE_LIBRARY
+        (target->GetType()==cmState::MODULE_LIBRARY
          && libName != GetVS6TargetName(j->first)))
       {
       // Compute the proper name to use to link this library.
@@ -1197,7 +1188,7 @@ void cmLocalVisualStudio6Generator
   std::string extraLinkOptionsRelease;
   std::string extraLinkOptionsMinSizeRel;
   std::string extraLinkOptionsRelWithDebInfo;
-  if(target.GetType() == cmState::EXECUTABLE)
+  if(target->GetType() == cmState::EXECUTABLE)
     {
     extraLinkOptions = this->Makefile->
       GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
@@ -1210,7 +1201,7 @@ void cmLocalVisualStudio6Generator
     extraLinkOptionsRelWithDebInfo = this->Makefile->
       GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO");
     }
-  if(target.GetType() == cmState::SHARED_LIBRARY)
+  if(target->GetType() == cmState::SHARED_LIBRARY)
     {
     extraLinkOptions = this->Makefile->
       GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
@@ -1223,7 +1214,7 @@ void cmLocalVisualStudio6Generator
     extraLinkOptionsRelWithDebInfo = this->Makefile->
       GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO");
     }
-  if(target.GetType() == cmState::MODULE_LIBRARY)
+  if(target->GetType() == cmState::MODULE_LIBRARY)
     {
     extraLinkOptions = this->Makefile->
       GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
@@ -1238,63 +1229,61 @@ void cmLocalVisualStudio6Generator
     }
 
   // Get extra linker options for this target.
-  if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"))
+  if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS"))
     {
     extraLinkOptions += " ";
     extraLinkOptions += targetLinkFlags;
     }
 
-  if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_DEBUG"))
+  if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_DEBUG"))
     {
     extraLinkOptionsDebug += " ";
     extraLinkOptionsDebug += targetLinkFlags;
     }
 
-  if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_RELEASE"))
+  if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_RELEASE"))
     {
     extraLinkOptionsRelease += " ";
     extraLinkOptionsRelease += targetLinkFlags;
     }
 
-  if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_MINSIZEREL"))
+  if(const char* targetLinkFlags =
+     target->GetProperty("LINK_FLAGS_MINSIZEREL"))
     {
     extraLinkOptionsMinSizeRel += " ";
     extraLinkOptionsMinSizeRel += targetLinkFlags;
     }
 
   if(const char* targetLinkFlags =
-     target.GetProperty("LINK_FLAGS_RELWITHDEBINFO"))
+     target->GetProperty("LINK_FLAGS_RELWITHDEBINFO"))
     {
     extraLinkOptionsRelWithDebInfo += " ";
     extraLinkOptionsRelWithDebInfo += targetLinkFlags;
     }
 
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
-
   // Get standard libraries for this language.
   if(targetBuilds)
     {
     // Get the language to use for linking.
     std::vector<std::string> configs;
-    target.GetMakefile()->GetConfigurations(configs);
+    target->Target->GetMakefile()->GetConfigurations(configs);
     std::vector<std::string>::const_iterator it = configs.begin();
-    const std::string& linkLanguage = gt->GetLinkerLanguage(*it);
+    const std::string& linkLanguage = target->GetLinkerLanguage(*it);
     for ( ; it != configs.end(); ++it)
       {
-      const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it);
+      const std::string& configLinkLanguage = target->GetLinkerLanguage(*it);
       if (configLinkLanguage != linkLanguage)
         {
         cmSystemTools::Error
           ("Linker language must not vary by configuration for target: ",
-          target.GetName().c_str());
+          target->GetName().c_str());
         }
       }
     if(linkLanguage.empty())
       {
       cmSystemTools::Error
         ("CMake can not determine linker language for target: ",
-         target.GetName().c_str());
+         target->GetName().c_str());
       return;
       }
 
@@ -1315,13 +1304,13 @@ void cmLocalVisualStudio6Generator
 
   // Compute version number information.
   std::string targetVersionFlag;
-  if(target.GetType() == cmState::EXECUTABLE ||
-     target.GetType() == cmState::SHARED_LIBRARY ||
-     target.GetType() == cmState::MODULE_LIBRARY)
+  if(target->GetType() == cmState::EXECUTABLE ||
+     target->GetType() == cmState::SHARED_LIBRARY ||
+     target->GetType() == cmState::MODULE_LIBRARY)
     {
     int major;
     int minor;
-    gt->GetTargetVersion(major, minor);
+    target->GetTargetVersion(major, minor);
     std::ostringstream targetVersionStream;
     targetVersionStream << "/version:" << major << "." << minor;
     targetVersionFlag = targetVersionStream.str();
@@ -1334,20 +1323,20 @@ void cmLocalVisualStudio6Generator
   std::string outputNameRelease = outputName;
   std::string outputNameMinSizeRel = outputName;
   std::string outputNameRelWithDebInfo = outputName;
-  if(target.GetType() == cmState::EXECUTABLE ||
-     target.GetType() == cmState::STATIC_LIBRARY ||
-     target.GetType() == cmState::SHARED_LIBRARY ||
-     target.GetType() == cmState::MODULE_LIBRARY)
+  if(target->GetType() == cmState::EXECUTABLE ||
+     target->GetType() == cmState::STATIC_LIBRARY ||
+     target->GetType() == cmState::SHARED_LIBRARY ||
+     target->GetType() == cmState::MODULE_LIBRARY)
     {
-    outputName = gt->GetFullName();
-    outputNameDebug = gt->GetFullName("Debug");
-    outputNameRelease = gt->GetFullName("Release");
-    outputNameMinSizeRel = gt->GetFullName("MinSizeRel");
-    outputNameRelWithDebInfo = gt->GetFullName("RelWithDebInfo");
+    outputName = target->GetFullName();
+    outputNameDebug = target->GetFullName("Debug");
+    outputNameRelease = target->GetFullName("Release");
+    outputNameMinSizeRel = target->GetFullName("MinSizeRel");
+    outputNameRelWithDebInfo = target->GetFullName("RelWithDebInfo");
     }
-  else if(target.GetType() == cmState::OBJECT_LIBRARY)
+  else if(target->GetType() == cmState::OBJECT_LIBRARY)
     {
-    outputName = target.GetName();
+    outputName = target->GetName();
     outputName += ".lib";
     outputNameDebug = outputName;
     outputNameRelease = outputName;
@@ -1361,30 +1350,30 @@ void cmLocalVisualStudio6Generator
   std::string outputDirRelease;
   std::string outputDirMinSizeRel;
   std::string outputDirRelWithDebInfo;
-  if(target.GetType() == cmState::EXECUTABLE ||
-     target.GetType() == cmState::STATIC_LIBRARY ||
-     target.GetType() == cmState::SHARED_LIBRARY ||
-     target.GetType() == cmState::MODULE_LIBRARY)
+  if(target->GetType() == cmState::EXECUTABLE ||
+     target->GetType() == cmState::STATIC_LIBRARY ||
+     target->GetType() == cmState::SHARED_LIBRARY ||
+     target->GetType() == cmState::MODULE_LIBRARY)
     {
 #ifdef CM_USE_OLD_VS6
     outputDirOld =
       removeQuotes(this->ConvertToOutputFormat
-                   (gt->GetDirectory().c_str(), SHELL));
+                   (target->GetDirectory().c_str(), SHELL));
 #endif
     outputDirDebug =
         removeQuotes(this->ConvertToOutputFormat(
-                       gt->GetDirectory("Debug").c_str(), SHELL));
+                       target->GetDirectory("Debug").c_str(), SHELL));
     outputDirRelease =
         removeQuotes(this->ConvertToOutputFormat(
-                 gt->GetDirectory("Release").c_str(), SHELL));
+                 target->GetDirectory("Release").c_str(), SHELL));
     outputDirMinSizeRel =
         removeQuotes(this->ConvertToOutputFormat(
-                 gt->GetDirectory("MinSizeRel").c_str(), SHELL));
+                 target->GetDirectory("MinSizeRel").c_str(), SHELL));
     outputDirRelWithDebInfo =
         removeQuotes(this->ConvertToOutputFormat(
-                 gt->GetDirectory("RelWithDebInfo").c_str(), SHELL));
+                 target->GetDirectory("RelWithDebInfo").c_str(), SHELL));
     }
-  else if(target.GetType() == cmState::OBJECT_LIBRARY)
+  else if(target->GetType() == cmState::OBJECT_LIBRARY)
     {
     std::string outputDir = cmake::GetCMakeFilesDirectoryPostSlash();
     outputDirDebug = outputDir + "Debug";
@@ -1398,9 +1387,9 @@ void cmLocalVisualStudio6Generator
   std::string optionsRelease;
   std::string optionsMinSizeRel;
   std::string optionsRelWithDebInfo;
-  if(target.GetType() == cmState::EXECUTABLE ||
-     target.GetType() == cmState::SHARED_LIBRARY ||
-     target.GetType() == cmState::MODULE_LIBRARY)
+  if(target->GetType() == cmState::EXECUTABLE ||
+     target->GetType() == cmState::SHARED_LIBRARY ||
+     target->GetType() == cmState::MODULE_LIBRARY)
     {
     extraLinkOptionsDebug =
       extraLinkOptions + " " + extraLinkOptionsDebug;
@@ -1426,24 +1415,24 @@ void cmLocalVisualStudio6Generator
   std::string targetImplibFlagRelease;
   std::string targetImplibFlagMinSizeRel;
   std::string targetImplibFlagRelWithDebInfo;
-  if(target.GetType() == cmState::SHARED_LIBRARY ||
-     target.GetType() == cmState::MODULE_LIBRARY ||
-     target.GetType() == cmState::EXECUTABLE)
+  if(target->GetType() == cmState::SHARED_LIBRARY ||
+     target->GetType() == cmState::MODULE_LIBRARY ||
+     target->GetType() == cmState::EXECUTABLE)
     {
-    std::string fullPathImpDebug = gt->GetDirectory("Debug", true);
-    std::string fullPathImpRelease = gt->GetDirectory("Release", true);
+    std::string fullPathImpDebug = target->GetDirectory("Debug", true);
+    std::string fullPathImpRelease = target->GetDirectory("Release", true);
     std::string fullPathImpMinSizeRel =
-      gt->GetDirectory("MinSizeRel", true);
+      target->GetDirectory("MinSizeRel", true);
     std::string fullPathImpRelWithDebInfo =
-      gt->GetDirectory("RelWithDebInfo", true);
+      target->GetDirectory("RelWithDebInfo", true);
     fullPathImpDebug += "/";
     fullPathImpRelease += "/";
     fullPathImpMinSizeRel += "/";
     fullPathImpRelWithDebInfo += "/";
-    fullPathImpDebug += gt->GetFullName("Debug", true);
-    fullPathImpRelease += gt->GetFullName("Release", true);
-    fullPathImpMinSizeRel += gt->GetFullName("MinSizeRel", true);
-    fullPathImpRelWithDebInfo += gt->GetFullName("RelWithDebInfo", true);
+    fullPathImpDebug += target->GetFullName("Debug", true);
+    fullPathImpRelease += target->GetFullName("Release", true);
+    fullPathImpMinSizeRel += target->GetFullName("MinSizeRel", true);
+    fullPathImpRelWithDebInfo += target->GetFullName("RelWithDebInfo", true);
 
     targetImplibFlagDebug = "/implib:";
     targetImplibFlagRelease = "/implib:";
@@ -1496,7 +1485,7 @@ void cmLocalVisualStudio6Generator
   std::string staticLibOptionsRelease;
   std::string staticLibOptionsMinSizeRel;
   std::string staticLibOptionsRelWithDebInfo;
-  if(target.GetType() == cmState::STATIC_LIBRARY )
+  if(target->GetType() == cmState::STATIC_LIBRARY )
     {
     const char *libflagsGlobal =
       this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS");
@@ -1515,7 +1504,7 @@ void cmLocalVisualStudio6Generator
     this->AppendFlags(staticLibOptionsRelWithDebInfo, this->Makefile->
       GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO"));
 
-    const char *libflags = target.GetProperty("STATIC_LIBRARY_FLAGS");
+    const char *libflags = target->GetProperty("STATIC_LIBRARY_FLAGS");
     this->AppendFlags(staticLibOptions, libflags);
     this->AppendFlags(staticLibOptionsDebug, libflags);
     this->AppendFlags(staticLibOptionsRelease, libflags);
@@ -1523,13 +1512,13 @@ void cmLocalVisualStudio6Generator
     this->AppendFlags(staticLibOptionsRelWithDebInfo, libflags);
 
     this->AppendFlags(staticLibOptionsDebug,
-      target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"));
+      target->GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"));
     this->AppendFlags(staticLibOptionsRelease,
-      target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"));
+      target->GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"));
     this->AppendFlags(staticLibOptionsMinSizeRel,
-      target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"));
+      target->GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"));
     this->AppendFlags(staticLibOptionsRelWithDebInfo,
-      target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"));
+      target->GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"));
 
     std::string objects;
     this->OutputObjects(target, "LIB", objects);
@@ -1545,7 +1534,7 @@ void cmLocalVisualStudio6Generator
 
   // Add the export symbol definition for shared library objects.
   std::string exportSymbol;
-  if(const char* exportMacro = gt->GetExportMacro())
+  if(const char* exportMacro = target->GetExportMacro())
     {
     exportSymbol = exportMacro;
     }
@@ -1569,8 +1558,8 @@ void cmLocalVisualStudio6Generator
                                  libnameExports.c_str());
     cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG",
                                  mfcFlag);
-    if(target.GetType() == cmState::STATIC_LIBRARY ||
-       target.GetType() == cmState::OBJECT_LIBRARY)
+    if(target->GetType() == cmState::STATIC_LIBRARY ||
+       target->GetType() == cmState::OBJECT_LIBRARY)
       {
       cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS_DEBUG",
                                    staticLibOptionsDebug.c_str());
@@ -1676,7 +1665,7 @@ void cmLocalVisualStudio6Generator
                     (exePath.c_str(), SHELL)).c_str());
 #endif
 
-    if(targetBuilds || target.GetType() == cmState::OBJECT_LIBRARY)
+    if(targetBuilds || target->GetType() == cmState::OBJECT_LIBRARY)
       {
       cmSystemTools::ReplaceString(line, "OUTPUT_DIRECTORY_DEBUG",
                                    outputDirDebug.c_str());
@@ -1700,8 +1689,8 @@ void cmLocalVisualStudio6Generator
       = this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
     cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX",
                                  debugPostfix?debugPostfix:"");
-    if(target.GetType() >= cmState::EXECUTABLE &&
-       target.GetType() <= cmState::OBJECT_LIBRARY)
+    if(target->GetType() >= cmState::EXECUTABLE &&
+       target->GetType() <= cmState::OBJECT_LIBRARY)
       {
       // store flags for each configuration
       std::string flags = " ";
@@ -1710,24 +1699,24 @@ void cmLocalVisualStudio6Generator
       std::string flagsDebug = " ";
       std::string flagsRelWithDebInfo = " ";
       std::vector<std::string> configs;
-      target.GetMakefile()->GetConfigurations(configs);
+      target->Target->GetMakefile()->GetConfigurations(configs);
       std::vector<std::string>::const_iterator it = configs.begin();
-      const std::string& linkLanguage = gt->GetLinkerLanguage(*it);
+      const std::string& linkLanguage = target->GetLinkerLanguage(*it);
       for ( ; it != configs.end(); ++it)
         {
-        const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it);
+        const std::string& configLinkLanguage = target->GetLinkerLanguage(*it);
         if (configLinkLanguage != linkLanguage)
           {
           cmSystemTools::Error
             ("Linker language must not vary by configuration for target: ",
-            target.GetName().c_str());
+            target->GetName().c_str());
           }
         }
       if(linkLanguage.empty())
         {
         cmSystemTools::Error
           ("CMake can not determine linker language for target: ",
-           target.GetName().c_str());
+           target->GetName().c_str());
         return;
         }
       // if CXX is on and the target contains cxx code then add the cxx flags
@@ -1752,12 +1741,12 @@ void cmLocalVisualStudio6Generator
       flagsRelWithDebInfo = this->Makefile->GetSafeDefinition(flagVar.c_str());
       flagsRelWithDebInfo += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" ";
 
-      this->AddCompileOptions(flags, gt, linkLanguage, "");
-      this->AddCompileOptions(flagsDebug, gt, linkLanguage, "Debug");
-      this->AddCompileOptions(flagsRelease, gt, linkLanguage, "Release");
-      this->AddCompileOptions(flagsMinSizeRel, gt, linkLanguage,
+      this->AddCompileOptions(flags, target, linkLanguage, "");
+      this->AddCompileOptions(flagsDebug, target, linkLanguage, "Debug");
+      this->AddCompileOptions(flagsRelease, target, linkLanguage, "Release");
+      this->AddCompileOptions(flagsMinSizeRel, target, linkLanguage,
                               "MinSizeRel");
-      this->AddCompileOptions(flagsRelWithDebInfo, gt, linkLanguage,
+      this->AddCompileOptions(flagsRelWithDebInfo, target, linkLanguage,
                               "RelWithDebInfo");
 
       // if _UNICODE and _SBCS are not found, then add -D_MBCS
@@ -1777,14 +1766,14 @@ void cmLocalVisualStudio6Generator
       std::set<std::string> minsizeDefinesSet;
       std::set<std::string> debugrelDefinesSet;
 
-      this->AddCompileDefinitions(definesSet, gt, "", linkLanguage);
-      this->AddCompileDefinitions(debugDefinesSet, gt,
+      this->AddCompileDefinitions(definesSet, target, "", linkLanguage);
+      this->AddCompileDefinitions(debugDefinesSet, target,
                                   "DEBUG", linkLanguage);
-      this->AddCompileDefinitions(releaseDefinesSet, gt,
+      this->AddCompileDefinitions(releaseDefinesSet, target,
                                   "RELEASE", linkLanguage);
-      this->AddCompileDefinitions(minsizeDefinesSet, gt,
+      this->AddCompileDefinitions(minsizeDefinesSet, target,
                                   "MINSIZEREL", linkLanguage);
-      this->AddCompileDefinitions(debugrelDefinesSet, gt,
+      this->AddCompileDefinitions(debugrelDefinesSet, target,
                                   "RELWITHDEBINFO", linkLanguage);
 
       std::string defines = " ";
@@ -1852,15 +1841,13 @@ void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout)
 
 //----------------------------------------------------------------------------
 void cmLocalVisualStudio6Generator
-::ComputeLinkOptions(cmTarget& target,
+::ComputeLinkOptions(cmGeneratorTarget *target,
                      const std::string& configName,
                      const std::string extraOptions,
                      std::string& options)
 {
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
   // Compute the link information for this configuration.
-  cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
+  cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
   if(!pcli)
     {
     return;
@@ -1919,15 +1906,13 @@ void cmLocalVisualStudio6Generator
 
 //----------------------------------------------------------------------------
 void cmLocalVisualStudio6Generator
-::OutputObjects(cmTarget& target, const char* tool,
+::OutputObjects(cmGeneratorTarget* target, const char* tool,
                 std::string& options)
 {
   // VS 6 does not support per-config source locations so we
   // list object library content on the link line instead.
-  cmGeneratorTarget* gt =
-    this->GlobalGenerator->GetGeneratorTarget(&target);
   std::vector<std::string> objs;
-  gt->UseObjectLibraries(objs, "");
+  target->UseObjectLibraries(objs, "");
   for(std::vector<std::string>::const_iterator
         oi = objs.begin(); oi != objs.end(); ++oi)
     {

Source/cmLocalVisualStudio6Generator.h

@@ -14,7 +14,6 @@
 
 #include "cmLocalVisualStudioGenerator.h"
 
-class cmTarget;
 class cmSourceFile;
 class cmSourceGroup;
 class cmCustomCommand;
@@ -47,7 +46,7 @@ public:
   /**
    * Specify the type of the build: static, dll, or executable.
    */
-  void SetBuildType(BuildType, const std::string& libName, cmTarget&);
+  void SetBuildType(BuildType, const std::string& libName, cmGeneratorTarget*);
 
   virtual
   std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
@@ -56,41 +55,42 @@ private:
   std::string DSPHeaderTemplate;
   std::string DSPFooterTemplate;
 
-  void CreateSingleDSP(const std::string& lname, cmTarget &tgt);
+  void CreateSingleDSP(const std::string& lname, cmGeneratorTarget* tgt);
   void WriteDSPFile(std::ostream& fout, const std::string& libName,
-                    cmTarget &tgt);
+                    cmGeneratorTarget* tgt);
   void WriteDSPBeginGroup(std::ostream& fout,
                           const char* group,
                           const char* filter);
   void WriteDSPEndGroup(std::ostream& fout);
 
   void WriteDSPHeader(std::ostream& fout, const std::string& libName,
-                      cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
+                      cmGeneratorTarget* tgt, std::vector<cmSourceGroup> &sgs);
 
   void WriteDSPFooter(std::ostream& fout);
-  void AddDSPBuildRule(cmTarget& tgt);
+  void AddDSPBuildRule(cmGeneratorTarget* tgt);
   void WriteCustomRule(std::ostream& fout,
                        const char* source,
                        const cmCustomCommand& command,
                        const char* flags);
-  void AddUtilityCommandHack(cmTarget& target, int count,
+  void AddUtilityCommandHack(cmGeneratorTarget* target, int count,
                              std::vector<std::string>& depends,
                              const cmCustomCommand& origCommand);
-  void WriteGroup(const cmSourceGroup *sg, cmTarget& target,
+  void WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
                   std::ostream &fout, const std::string& libName);
   class EventWriter;
   friend class EventWriter;
   cmsys::auto_ptr<cmCustomCommand>
-  MaybeCreateOutputDir(cmTarget& target, const std::string& config);
-  std::string CreateTargetRules(cmTarget &target,
+  MaybeCreateOutputDir(cmGeneratorTarget *target, const std::string& config);
+  std::string CreateTargetRules(cmGeneratorTarget* target,
                                 const std::string& configName,
                                 const std::string& libName);
-  void ComputeLinkOptions(cmTarget& target, const std::string& configName,
+  void ComputeLinkOptions(cmGeneratorTarget* target,
+                          const std::string& configName,
                           const std::string extraOptions,
                           std::string& options);
-  void OutputObjects(cmTarget& target, const char* tool,
+  void OutputObjects(cmGeneratorTarget* target, const char* tool,
                      std::string& options);
-  std::string GetTargetIncludeOptions(cmTarget &target,
+  std::string GetTargetIncludeOptions(cmGeneratorTarget* target,
                                       const std::string& config);
   std::vector<std::string> Configurations;