Port some of the generator API to cmGeneratorTarget.

Just enough to reach the BuildMacContentDirectory method and the
NeedRelinkBeforeInstall methods.

In the future, those methods can be moved to cmGeneratorTarget.

19 files changed, 154 insertions, 117 deletions

diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index e1af2f9824..6333873995 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -471,23 +471,29 @@ cmGlobalUnixMakefileGenerator3
   // The directory-level rule should depend on the target-level rules
   // for all targets in the directory.
   std::vector<std::string> depends;
-  for(cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
-      l != lg->GetMakefile()->GetTargets().end(); ++l)
+  cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
+  for(cmGeneratorTargetsType::iterator l = targets.begin();
+      l != targets.end(); ++l)
     {
-    if((l->second.GetType() == cmTarget::EXECUTABLE) ||
-       (l->second.GetType() == cmTarget::STATIC_LIBRARY) ||
-       (l->second.GetType() == cmTarget::SHARED_LIBRARY) ||
-       (l->second.GetType() == cmTarget::MODULE_LIBRARY) ||
-       (l->second.GetType() == cmTarget::OBJECT_LIBRARY) ||
-       (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) ||
-       (l->second.GetType() == cmTarget::UTILITY))
+    if((l->second->GetType() == cmTarget::EXECUTABLE) ||
+       (l->second->GetType() == cmTarget::STATIC_LIBRARY) ||
+       (l->second->GetType() == cmTarget::SHARED_LIBRARY) ||
+       (l->second->GetType() == cmTarget::MODULE_LIBRARY) ||
+       (l->second->GetType() == cmTarget::OBJECT_LIBRARY) ||
+       (l->second->GetType() == cmTarget::INTERFACE_LIBRARY) ||
+       (l->second->GetType() == cmTarget::UTILITY))
       {
+      if(l->second->Target->IsImported())
+        {
+        continue;
+        }
       // Add this to the list of depends rules in this directory.
-      if((!check_all || !l->second.GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
+      if((!check_all || !l->second->GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
          (!check_relink ||
-          l->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str())))
+          l->second->Target
+                   ->NeedRelinkBeforeInstall(lg->ConfigurationName.c_str())))
         {
-        std::string tname = lg->GetRelativeTargetDirectory(l->second);
+        std::string tname = lg->GetRelativeTargetDirectory(*l->second->Target);
         tname += "/";
         tname += pass;
         depends.push_back(tname);
@@ -632,49 +638,55 @@ cmGlobalUnixMakefileGenerator3
     lg = static_cast<cmLocalUnixMakefileGenerator3 *>
       (this->LocalGenerators[i]);
     // for each target Generate the rule files for each target.
-    cmTargets& targets = lg->GetMakefile()->GetTargets();
-    for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
+    cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
+    for(cmGeneratorTargetsType::iterator t = targets.begin();
+        t != targets.end(); ++t)
       {
+      if(t->second->Target->IsImported())
+        {
+        continue;
+        }
       // Don't emit the same rule twice (e.g. two targets with the same
       // simple name)
-      if(t->second.GetName() &&
-         strlen(t->second.GetName()) &&
-         emitted.insert(t->second.GetName()).second &&
+      if(t->second->GetName() &&
+         strlen(t->second->GetName()) &&
+         emitted.insert(t->second->GetName()).second &&
          // Handle user targets here.  Global targets are handled in
          // the local generator on a per-directory basis.
-         ((t->second.GetType() == cmTarget::EXECUTABLE) ||
-          (t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
-          (t->second.GetType() == cmTarget::SHARED_LIBRARY) ||
-          (t->second.GetType() == cmTarget::MODULE_LIBRARY) ||
-          (t->second.GetType() == cmTarget::OBJECT_LIBRARY) ||
-          (t->second.GetType() == cmTarget::INTERFACE_LIBRARY) ||
-          (t->second.GetType() == cmTarget::UTILITY)))
+         ((t->second->GetType() == cmTarget::EXECUTABLE) ||
+          (t->second->GetType() == cmTarget::STATIC_LIBRARY) ||
+          (t->second->GetType() == cmTarget::SHARED_LIBRARY) ||
+          (t->second->GetType() == cmTarget::MODULE_LIBRARY) ||
+          (t->second->GetType() == cmTarget::OBJECT_LIBRARY) ||
+          (t->second->GetType() == cmTarget::INTERFACE_LIBRARY) ||
+          (t->second->GetType() == cmTarget::UTILITY)))
         {
         // Add a rule to build the target by name.
         lg->WriteDivider(ruleFileStream);
         ruleFileStream
           << "# Target rules for targets named "
-          << t->second.GetName() << "\n\n";
+          << t->second->GetName() << "\n\n";
 
         // Write the rule.
         commands.clear();
         std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
         tmp += "Makefile2";
         commands.push_back(lg->GetRecursiveMakeCall
-                            (tmp.c_str(),t->second.GetName()));
+                            (tmp.c_str(),t->second->GetName()));
         depends.clear();
         depends.push_back("cmake_check_build_system");
         lg->WriteMakeRule(ruleFileStream,
                           "Build rule for target.",
-                          t->second.GetName(), depends, commands,
+                          t->second->GetName(), depends, commands,
                           true);
 
-        if (t->second.GetType() == cmTarget::INTERFACE_LIBRARY)
+        if (t->second->GetType() == cmTarget::INTERFACE_LIBRARY)
           {
           continue;
           }
         // Add a fast rule to build the target
-        std::string localName = lg->GetRelativeTargetDirectory(t->second);
+        std::string localName =
+                          lg->GetRelativeTargetDirectory(*t->second->Target);
         std::string makefileName;
         makefileName = localName;
         makefileName += "/build.make";
@@ -682,7 +694,7 @@ cmGlobalUnixMakefileGenerator3
         commands.clear();
         std::string makeTargetName = localName;
         makeTargetName += "/build";
-        localName = t->second.GetName();
+        localName = t->second->GetName();
         localName += "/fast";
         commands.push_back(lg->GetRecursiveMakeCall
                             (makefileName.c_str(), makeTargetName.c_str()));
@@ -691,11 +703,12 @@ cmGlobalUnixMakefileGenerator3
 
         // Add a local name for the rule to relink the target before
         // installation.
-        if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
+        if(t->second->Target
+                    ->NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
           {
-          makeTargetName = lg->GetRelativeTargetDirectory(t->second);
+          makeTargetName = lg->GetRelativeTargetDirectory(*t->second->Target);
           makeTargetName += "/preinstall";
-          localName = t->second.GetName();
+          localName = t->second->GetName();
           localName += "/preinstall";
           depends.clear();
           commands.clear();
@@ -729,26 +742,31 @@ cmGlobalUnixMakefileGenerator3
   depends.push_back("cmake_check_build_system");
 
   // for each target Generate the rule files for each target.
-  cmTargets& targets = lg->GetMakefile()->GetTargets();
-  for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
+  cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
+  for(cmGeneratorTargetsType::iterator t = targets.begin();
+      t != targets.end(); ++t)
     {
-    if (t->second.GetName()
-     && strlen(t->second.GetName())
-     && ((t->second.GetType() == cmTarget::EXECUTABLE)
-        || (t->second.GetType() == cmTarget::STATIC_LIBRARY)
-        || (t->second.GetType() == cmTarget::SHARED_LIBRARY)
-        || (t->second.GetType() == cmTarget::MODULE_LIBRARY)
-        || (t->second.GetType() == cmTarget::OBJECT_LIBRARY)
-        || (t->second.GetType() == cmTarget::INTERFACE_LIBRARY)
-        || (t->second.GetType() == cmTarget::UTILITY)))
+    if(t->second->Target->IsImported())
+      {
+      continue;
+      }
+    if (t->second->GetName()
+     && strlen(t->second->GetName())
+     && ((t->second->GetType() == cmTarget::EXECUTABLE)
+        || (t->second->GetType() == cmTarget::STATIC_LIBRARY)
+        || (t->second->GetType() == cmTarget::SHARED_LIBRARY)
+        || (t->second->GetType() == cmTarget::MODULE_LIBRARY)
+        || (t->second->GetType() == cmTarget::OBJECT_LIBRARY)
+        || (t->second->GetType() == cmTarget::INTERFACE_LIBRARY)
+        || (t->second->GetType() == cmTarget::UTILITY)))
       {
       std::string makefileName;
       // Add a rule to build the target by name.
-      localName = lg->GetRelativeTargetDirectory(t->second);
+      localName = lg->GetRelativeTargetDirectory(*t->second->Target);
       makefileName = localName;
       makefileName += "/build.make";
 
-      bool needRequiresStep = this->NeedRequiresStep(t->second);
+      bool needRequiresStep = this->NeedRequiresStep(*t->second->Target);
 
       lg->WriteDivider(ruleFileStream);
       ruleFileStream
@@ -757,7 +775,7 @@ cmGlobalUnixMakefileGenerator3
 
       commands.clear();
 
-      if(t->second.GetType() != cmTarget::INTERFACE_LIBRARY)
+      if(t->second->GetType() != cmTarget::INTERFACE_LIBRARY)
         {
         makeTargetName = localName;
         makeTargetName += "/depend";
@@ -793,7 +811,7 @@ cmGlobalUnixMakefileGenerator3
                                   cmLocalGenerator::SHELL);
           progCmd << " ";
           std::vector<unsigned long>& progFiles =
-            this->ProgressMap[&t->second].Marks;
+            this->ProgressMap[t->second->Target].Marks;
           for (std::vector<unsigned long>::iterator i = progFiles.begin();
                 i != progFiles.end(); ++i)
             {
@@ -802,14 +820,14 @@ cmGlobalUnixMakefileGenerator3
           commands.push_back(progCmd.str());
           }
         progressDir = "Built target ";
-        progressDir += t->first;
+        progressDir += t->second->GetName();
         lg->AppendEcho(commands,progressDir.c_str());
         }
       else
         {
         depends.clear();
         }
-      this->AppendGlobalTargetDepends(depends,t->second);
+      this->AppendGlobalTargetDepends(depends,*t->second->Target);
       if(depends.empty() && this->EmptyRuleHackDepends != "")
         {
         depends.push_back(this->EmptyRuleHackDepends);
@@ -818,7 +836,7 @@ cmGlobalUnixMakefileGenerator3
                         localName.c_str(), depends, commands, true);
 
       // add the all/all dependency
-      if(!this->IsExcluded(this->LocalGenerators[0], t->second))
+      if(!this->IsExcluded(this->LocalGenerators[0], *t->second->Target))
         {
         depends.clear();
         depends.push_back(localName);
@@ -843,7 +861,7 @@ cmGlobalUnixMakefileGenerator3
       //
       std::set<cmTarget *> emitted;
       progCmd << " "
-              << this->CountProgressMarksInTarget(&t->second, emitted);
+              << this->CountProgressMarksInTarget(t->second->Target, emitted);
       commands.push_back(progCmd.str());
       }
       std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
@@ -861,7 +879,7 @@ cmGlobalUnixMakefileGenerator3
       }
       depends.clear();
       depends.push_back("cmake_check_build_system");
-      localName = lg->GetRelativeTargetDirectory(t->second);
+      localName = lg->GetRelativeTargetDirectory(*t->second->Target);
       localName += "/rule";
       lg->WriteMakeRule(ruleFileStream,
                         "Build rule for subdir invocation for target.",
@@ -872,12 +890,13 @@ cmGlobalUnixMakefileGenerator3
       depends.clear();
       depends.push_back(localName);
       lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
-                        t->second.GetName(), depends, commands, true);
+                        t->second->GetName(), depends, commands, true);
 
       // Add rules to prepare the target for installation.
-      if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
+      if(t->second->Target
+                  ->NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
         {
-        localName = lg->GetRelativeTargetDirectory(t->second);
+        localName = lg->GetRelativeTargetDirectory(*t->second->Target);
         localName += "/preinstall";
         depends.clear();
         commands.clear();
@@ -887,7 +906,7 @@ cmGlobalUnixMakefileGenerator3
                           "Pre-install relink rule for target.",
                           localName.c_str(), depends, commands, true);
 
-        if(!this->IsExcluded(this->LocalGenerators[0], t->second))
+        if(!this->IsExcluded(this->LocalGenerators[0], *t->second->Target))
           {
           depends.clear();
           depends.push_back(localName);
@@ -898,7 +917,7 @@ cmGlobalUnixMakefileGenerator3
         }
 
       // add the clean rule
-      localName = lg->GetRelativeTargetDirectory(t->second);
+      localName = lg->GetRelativeTargetDirectory(*t->second->Target);
       makeTargetName = localName;
       makeTargetName += "/clean";
       depends.clear();
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index f1d5e2cf10..158d714c41 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -64,18 +64,23 @@ void cmLocalNinjaGenerator::Generate()
       }
     }
 
-  cmTargets& targets = this->GetMakefile()->GetTargets();
-  for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
+  cmGeneratorTargetsType targets = this->GetMakefile()->GetGeneratorTargets();
+  for(cmGeneratorTargetsType::iterator t = targets.begin();
+      t != targets.end(); ++t)
     {
-    cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(&t->second);
+    if (t->second->Target->IsImported())
+      {
+      continue;
+      }
+    cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(t->second);
     if(tg)
       {
       tg->Generate();
       // Add the target to "all" if required.
       if (!this->GetGlobalNinjaGenerator()->IsExcluded(
             this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0],
-            t->second))
-        this->GetGlobalNinjaGenerator()->AddDependencyToAll(&t->second);
+            *t->second->Target))
+        this->GetGlobalNinjaGenerator()->AddDependencyToAll(t->second->Target);
       delete tg;
       }
     }
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 8ed8d0a28f..9af5c29b49 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -145,13 +145,18 @@ void cmLocalUnixMakefileGenerator3::Generate()
     this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES");
 
   // Generate the rule files for each target.
-  cmTargets& targets = this->Makefile->GetTargets();
+  cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
+  for(cmGeneratorTargetsType::iterator t = targets.begin();
+      t != targets.end(); ++t)
     {
+    if (t->second->Target->IsImported())
+      {
+      continue;
+      }
     cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
-      cmMakefileTargetGenerator::New(&(t->second)));
+      cmMakefileTargetGenerator::New(t->second));
     if (tg.get())
       {
       tg->WriteRuleFiles();
@@ -372,22 +377,23 @@ void cmLocalUnixMakefileGenerator3
 
   // for each target we just provide a rule to cd up to the top and do a make
   // on the target
-  cmTargets& targets = this->Makefile->GetTargets();
+  cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
   std::string localName;
-  for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
-    {
-    if((t->second.GetType() == cmTarget::EXECUTABLE) ||
-       (t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
-       (t->second.GetType() == cmTarget::SHARED_LIBRARY) ||
-       (t->second.GetType() == cmTarget::MODULE_LIBRARY) ||
-       (t->second.GetType() == cmTarget::OBJECT_LIBRARY) ||
-       (t->second.GetType() == cmTarget::INTERFACE_LIBRARY) ||
-       (t->second.GetType() == cmTarget::UTILITY))
+  for(cmGeneratorTargetsType::iterator t = targets.begin();
+      t != targets.end(); ++t)
+    {
+    if((t->second->GetType() == cmTarget::EXECUTABLE) ||
+       (t->second->GetType() == cmTarget::STATIC_LIBRARY) ||
+       (t->second->GetType() == cmTarget::SHARED_LIBRARY) ||
+       (t->second->GetType() == cmTarget::MODULE_LIBRARY) ||
+       (t->second->GetType() == cmTarget::OBJECT_LIBRARY) ||
+       (t->second->GetType() == cmTarget::INTERFACE_LIBRARY) ||
+       (t->second->GetType() == cmTarget::UTILITY))
       {
-      emitted.insert(t->second.GetName());
+      emitted.insert(t->second->GetName());
 
       // for subdirs add a rule to build this specific target by name.
-      localName = this->GetRelativeTargetDirectory(t->second);
+      localName = this->GetRelativeTargetDirectory(*t->second->Target);
       localName += "/rule";
       commands.clear();
       depends.clear();
@@ -404,22 +410,23 @@ void cmLocalUnixMakefileGenerator3
                           localName.c_str(), depends, commands, true);
 
       // Add a target with the canonical name (no prefix, suffix or path).
-      if(localName != t->second.GetName())
+      if(localName != t->second->GetName())
         {
         commands.clear();
         depends.push_back(localName);
         this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
-                            t->second.GetName(), depends, commands, true);
+                            t->second->GetName(), depends, commands, true);
         }
 
       // Add a fast rule to build the target
-      std::string makefileName = this->GetRelativeTargetDirectory(t->second);
+      std::string makefileName =
+                         this->GetRelativeTargetDirectory(*t->second->Target);
       makefileName += "/build.make";
       // make sure the makefile name is suitable for a makefile
       std::string makeTargetName =
-        this->GetRelativeTargetDirectory(t->second);
+        this->GetRelativeTargetDirectory(*t->second->Target);
       makeTargetName += "/build";
-      localName = t->second.GetName();
+      localName = t->second->GetName();
       localName += "/fast";
       depends.clear();
       commands.clear();
@@ -433,11 +440,12 @@ void cmLocalUnixMakefileGenerator3
 
       // Add a local name for the rule to relink the target before
       // installation.
-      if(t->second.NeedRelinkBeforeInstall(this->ConfigurationName.c_str()))
+      if(t->second->Target
+                  ->NeedRelinkBeforeInstall(this->ConfigurationName.c_str()))
         {
-        makeTargetName = this->GetRelativeTargetDirectory(t->second);
+        makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target);
         makeTargetName += "/preinstall";
-        localName = t->second.GetName();
+        localName = t->second->GetName();
         localName += "/preinstall";
         depends.clear();
         commands.clear();
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index e4219a9459..69fe444f82 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -21,15 +21,15 @@
 
 //----------------------------------------------------------------------------
 cmMakefileExecutableTargetGenerator
-::cmMakefileExecutableTargetGenerator(cmTarget* target):
-  cmMakefileTargetGenerator(target)
+::cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target):
+  cmMakefileTargetGenerator(target->Target)
 {
   this->CustomCommandDriver = OnDepends;
   this->Target->GetExecutableNames(
     this->TargetNameOut, this->TargetNameReal, this->TargetNameImport,
     this->TargetNamePDB, this->ConfigName);
 
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(this->Target,
+  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
                                                       this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
diff --git a/Source/cmMakefileExecutableTargetGenerator.h b/Source/cmMakefileExecutableTargetGenerator.h
index 3b18166ffd..940226b1a1 100644
--- a/Source/cmMakefileExecutableTargetGenerator.h
+++ b/Source/cmMakefileExecutableTargetGenerator.h
@@ -17,7 +17,7 @@
 class cmMakefileExecutableTargetGenerator: public cmMakefileTargetGenerator
 {
 public:
-  cmMakefileExecutableTargetGenerator(cmTarget* target);
+  cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target);
   virtual ~cmMakefileExecutableTargetGenerator();
 
   /* the main entry point for this class. Writes the Makefiles associated
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 29365a308e..7b8a53150c 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -21,15 +21,15 @@
 
 //----------------------------------------------------------------------------
 cmMakefileLibraryTargetGenerator
-::cmMakefileLibraryTargetGenerator(cmTarget* target):
-  cmMakefileTargetGenerator(target)
+::cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target):
+  cmMakefileTargetGenerator(target->Target)
 {
   this->CustomCommandDriver = OnDepends;
   this->Target->GetLibraryNames(
     this->TargetNameOut, this->TargetNameSO, this->TargetNameReal,
     this->TargetNameImport, this->TargetNamePDB, this->ConfigName);
 
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(this->Target,
+  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
                                                       this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
diff --git a/Source/cmMakefileLibraryTargetGenerator.h b/Source/cmMakefileLibraryTargetGenerator.h
index 07f828b7d9..1487b56b15 100644
--- a/Source/cmMakefileLibraryTargetGenerator.h
+++ b/Source/cmMakefileLibraryTargetGenerator.h
@@ -18,7 +18,7 @@ class cmMakefileLibraryTargetGenerator:
   public cmMakefileTargetGenerator
 {
 public:
-  cmMakefileLibraryTargetGenerator(cmTarget* target);
+  cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target);
   virtual ~cmMakefileLibraryTargetGenerator();
 
   /* the main entry point for this class. Writes the Makefiles associated
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 2fcad79748..2063a24030 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -63,7 +63,7 @@ cmMakefileTargetGenerator::~cmMakefileTargetGenerator()
 }
 
 cmMakefileTargetGenerator *
-cmMakefileTargetGenerator::New(cmTarget *tgt)
+cmMakefileTargetGenerator::New(cmGeneratorTarget *tgt)
 {
   cmMakefileTargetGenerator *result = 0;
 
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
index ec2af1cdb5..4f8fafacdc 100644
--- a/Source/cmMakefileTargetGenerator.h
+++ b/Source/cmMakefileTargetGenerator.h
@@ -38,7 +38,7 @@ public:
   virtual ~cmMakefileTargetGenerator();
 
   // construct using this factory call
-  static cmMakefileTargetGenerator *New(cmTarget *tgt);
+  static cmMakefileTargetGenerator *New(cmGeneratorTarget *tgt);
 
   /* the main entry point for this class. Writes the Makefiles associated
      with this target */
diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx
index 1fa4e95b6f..7751ad9b46 100644
--- a/Source/cmMakefileUtilityTargetGenerator.cxx
+++ b/Source/cmMakefileUtilityTargetGenerator.cxx
@@ -20,11 +20,11 @@
 
 //----------------------------------------------------------------------------
 cmMakefileUtilityTargetGenerator
-::cmMakefileUtilityTargetGenerator(cmTarget* target):
-  cmMakefileTargetGenerator(target)
+::cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target):
+  cmMakefileTargetGenerator(target->Target)
 {
   this->CustomCommandDriver = OnUtility;
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(this->Target,
+  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
                                                       this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
diff --git a/Source/cmMakefileUtilityTargetGenerator.h b/Source/cmMakefileUtilityTargetGenerator.h
index fc47b38914..8f99300521 100644
--- a/Source/cmMakefileUtilityTargetGenerator.h
+++ b/Source/cmMakefileUtilityTargetGenerator.h
@@ -18,7 +18,7 @@ class cmMakefileUtilityTargetGenerator:
   public cmMakefileTargetGenerator
 {
 public:
-  cmMakefileUtilityTargetGenerator(cmTarget* target);
+  cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target);
   virtual ~cmMakefileUtilityTargetGenerator();
 
   /* the main entry point for this class. Writes the Makefiles associated
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index d8e9b344d4..2c96ede4cb 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -17,6 +17,7 @@
 #include "cmGeneratedFileStream.h"
 #include "cmMakefile.h"
 #include "cmOSXBundleGenerator.h"
+#include "cmGeneratorTarget.h"
 
 #include <assert.h>
 #include <algorithm>
@@ -27,8 +28,8 @@
 
 
 cmNinjaNormalTargetGenerator::
-cmNinjaNormalTargetGenerator(cmTarget* target)
-  : cmNinjaTargetGenerator(target)
+cmNinjaNormalTargetGenerator(cmGeneratorTarget* target)
+  : cmNinjaTargetGenerator(target->Target)
   , TargetNameOut()
   , TargetNameSO()
   , TargetNameReal()
@@ -36,15 +37,16 @@ cmNinjaNormalTargetGenerator(cmTarget* target)
   , TargetNamePDB()
   , TargetLinkLanguage(0)
 {
-  this->TargetLinkLanguage = target->GetLinkerLanguage(this->GetConfigName());
+  this->TargetLinkLanguage = target->Target
+                                   ->GetLinkerLanguage(this->GetConfigName());
   if (target->GetType() == cmTarget::EXECUTABLE)
-    target->GetExecutableNames(this->TargetNameOut,
+    target->Target->GetExecutableNames(this->TargetNameOut,
                                this->TargetNameReal,
                                this->TargetNameImport,
                                this->TargetNamePDB,
                                GetLocalGenerator()->GetConfigName());
   else
-    target->GetLibraryNames(this->TargetNameOut,
+    target->Target->GetLibraryNames(this->TargetNameOut,
                             this->TargetNameSO,
                             this->TargetNameReal,
                             this->TargetNameImport,
@@ -55,7 +57,7 @@ cmNinjaNormalTargetGenerator(cmTarget* target)
     {
     // on Windows the output dir is already needed at compile time
     // ensure the directory exists (OutDir test)
-    EnsureDirectoryExists(target->GetDirectory(this->GetConfigName()));
+    EnsureDirectoryExists(target->Target->GetDirectory(this->GetConfigName()));
     }
 
   this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
diff --git a/Source/cmNinjaNormalTargetGenerator.h b/Source/cmNinjaNormalTargetGenerator.h
index 284804b08c..c7a089c6f1 100644
--- a/Source/cmNinjaNormalTargetGenerator.h
+++ b/Source/cmNinjaNormalTargetGenerator.h
@@ -21,11 +21,12 @@
 
 class cmSourceFile;
 class cmOSXBundleGenerator;
+class cmGeneratorTarget;
 
 class cmNinjaNormalTargetGenerator : public cmNinjaTargetGenerator
 {
 public:
-  cmNinjaNormalTargetGenerator(cmTarget* target);
+  cmNinjaNormalTargetGenerator(cmGeneratorTarget* target);
   ~cmNinjaNormalTargetGenerator();
 
   void Generate();
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 26eadbe526..b132db6c58 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -26,7 +26,7 @@
 #include <algorithm>
 
 cmNinjaTargetGenerator *
-cmNinjaTargetGenerator::New(cmTarget* target)
+cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
 {
   switch (target->GetType())
     {
@@ -44,7 +44,7 @@ cmNinjaTargetGenerator::New(cmTarget* target)
         // We only want to process global targets that live in the home
         // (i.e. top-level) directory.  CMake creates copies of these targets
         // in every directory, which we don't need.
-        cmMakefile *mf = target->GetMakefile();
+        cmMakefile *mf = target->Target->GetMakefile();
         if (strcmp(mf->GetStartDirectory(), mf->GetHomeDirectory()) == 0)
           return new cmNinjaUtilityTargetGenerator(target);
         // else fallthrough
diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h
index 1cf811a87a..e377a78df3 100644
--- a/Source/cmNinjaTargetGenerator.h
+++ b/Source/cmNinjaTargetGenerator.h
@@ -30,7 +30,7 @@ class cmNinjaTargetGenerator
 {
 public:
   /// Create a cmNinjaTargetGenerator according to the @a target's type.
-  static cmNinjaTargetGenerator* New(cmTarget* target);
+  static cmNinjaTargetGenerator* New(cmGeneratorTarget* target);
 
   /// Build a NinjaTargetGenerator.
   cmNinjaTargetGenerator(cmTarget* target);
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index 755ce6edc7..8556565494 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -18,8 +18,9 @@
 #include "cmSourceFile.h"
 #include "cmTarget.h"
 
-cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator(cmTarget *target)
-  : cmNinjaTargetGenerator(target) {}
+cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator(
+    cmGeneratorTarget *target)
+  : cmNinjaTargetGenerator(target->Target) {}
 
 cmNinjaUtilityTargetGenerator::~cmNinjaUtilityTargetGenerator() {}
 
diff --git a/Source/cmNinjaUtilityTargetGenerator.h b/Source/cmNinjaUtilityTargetGenerator.h
index 8b82ce49a5..add0291a53 100644
--- a/Source/cmNinjaUtilityTargetGenerator.h
+++ b/Source/cmNinjaUtilityTargetGenerator.h
@@ -21,7 +21,7 @@ class cmSourceFile;
 class cmNinjaUtilityTargetGenerator : public cmNinjaTargetGenerator
 {
 public:
-  cmNinjaUtilityTargetGenerator(cmTarget* target);
+  cmNinjaUtilityTargetGenerator(cmGeneratorTarget* target);
   ~cmNinjaUtilityTargetGenerator();
 
   void Generate();
diff --git a/Source/cmOSXBundleGenerator.cxx b/Source/cmOSXBundleGenerator.cxx
index a475c7cfa7..9a340dc527 100644
--- a/Source/cmOSXBundleGenerator.cxx
+++ b/Source/cmOSXBundleGenerator.cxx
@@ -18,10 +18,10 @@
 
 //----------------------------------------------------------------------------
 cmOSXBundleGenerator::
-cmOSXBundleGenerator(cmTarget* target,
+cmOSXBundleGenerator(cmGeneratorTarget* target,
                      const char* configName)
- : Target(target)
- , Makefile(target->GetMakefile())
+ : Target(target->Target)
+ , Makefile(target->Target->GetMakefile())
  , LocalGenerator(Makefile->GetLocalGenerator())
  , ConfigName(configName)
  , MacContentFolders(0)
diff --git a/Source/cmOSXBundleGenerator.h b/Source/cmOSXBundleGenerator.h
index ec82b9a159..29b7611d45 100644
--- a/Source/cmOSXBundleGenerator.h
+++ b/Source/cmOSXBundleGenerator.h
@@ -21,11 +21,12 @@
 class cmTarget;
 class cmMakefile;
 class cmLocalGenerator;
+class cmGeneratorTarget;
 
 class cmOSXBundleGenerator
 {
 public:
-  cmOSXBundleGenerator(cmTarget* target,
+  cmOSXBundleGenerator(cmGeneratorTarget* target,
                        const char* configName);
 
   // create an app bundle at a given root, and return