1 files changed, 114 insertions, 165 deletions

diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
index c1fa54b214..8ca7a1199c 100644
--- a/Source/cmExportBuildFileGenerator.cxx
+++ b/Source/cmExportBuildFileGenerator.cxx
@@ -25,56 +25,47 @@ cmExportBuildFileGenerator::cmExportBuildFileGenerator()
 void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
 {
   this->LG = lg;
-  if (this->ExportSet)
-    {
+  if (this->ExportSet) {
     this->ExportSet->Compute(lg);
-    }
+  }
 }
 
 bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
 {
   {
-  std::string expectedTargets;
-  std::string sep;
-  std::vector<std::string> targets;
-  this->GetTargets(targets);
-  for(std::vector<std::string>::const_iterator
-        tei = targets.begin();
-      tei != targets.end(); ++tei)
-    {
-    cmGeneratorTarget *te = this->LG
-                                ->FindGeneratorTargetToUse(*tei);
-    expectedTargets += sep + this->Namespace + te->GetExportName();
-    sep = " ";
-    if(this->ExportedTargets.insert(te).second)
-      {
-      this->Exports.push_back(te);
-      }
-    else
-      {
-      std::ostringstream e;
-      e << "given target \"" << te->GetName() << "\" more than once.";
-      this->LG->GetGlobalGenerator()->GetCMakeInstance()
-          ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                         this->LG->GetMakefile()->GetBacktrace());
-      return false;
+    std::string expectedTargets;
+    std::string sep;
+    std::vector<std::string> targets;
+    this->GetTargets(targets);
+    for (std::vector<std::string>::const_iterator tei = targets.begin();
+         tei != targets.end(); ++tei) {
+      cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(*tei);
+      expectedTargets += sep + this->Namespace + te->GetExportName();
+      sep = " ";
+      if (this->ExportedTargets.insert(te).second) {
+        this->Exports.push_back(te);
+      } else {
+        std::ostringstream e;
+        e << "given target \"" << te->GetName() << "\" more than once.";
+        this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+          cmake::FATAL_ERROR, e.str(),
+          this->LG->GetMakefile()->GetBacktrace());
+        return false;
       }
-    if (te->GetType() == cmState::INTERFACE_LIBRARY)
-      {
-      this->GenerateRequiredCMakeVersion(os, "3.0.0");
+      if (te->GetType() == cmState::INTERFACE_LIBRARY) {
+        this->GenerateRequiredCMakeVersion(os, "3.0.0");
       }
     }
 
-  this->GenerateExpectedTargetsCode(os, expectedTargets);
+    this->GenerateExpectedTargetsCode(os, expectedTargets);
   }
 
   std::vector<std::string> missingTargets;
 
   // Create all the imported targets.
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-        tei = this->Exports.begin();
-      tei != this->Exports.end(); ++tei)
-    {
+  for (std::vector<cmGeneratorTarget*>::const_iterator tei =
+         this->Exports.begin();
+       tei != this->Exports.end(); ++tei) {
     cmGeneratorTarget* gte = *tei;
     this->GenerateImportTargetCode(os, gte);
 
@@ -100,67 +91,56 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
     this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
                                     cmGeneratorExpression::BuildInterface,
                                     properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
-                                  gte, properties);
+    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
+                                    properties);
     const bool newCMP0022Behavior =
-        gte->GetPolicyStatusCMP0022() != cmPolicies::WARN
-        && gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
-    if (newCMP0022Behavior)
-      {
-      this->PopulateInterfaceLinkLibrariesProperty(gte,
-                                    cmGeneratorExpression::BuildInterface,
-                                    properties, missingTargets);
-      }
+      gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+      gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    if (newCMP0022Behavior) {
+      this->PopulateInterfaceLinkLibrariesProperty(
+        gte, cmGeneratorExpression::BuildInterface, properties,
+        missingTargets);
+    }
     this->PopulateCompatibleInterfaceProperties(gte, properties);
 
     this->GenerateInterfaceProperties(gte, os, properties);
-    }
+  }
 
   // Generate import file content for each configuration.
-  for(std::vector<std::string>::const_iterator
-        ci = this->Configurations.begin();
-      ci != this->Configurations.end(); ++ci)
-    {
+  for (std::vector<std::string>::const_iterator ci =
+         this->Configurations.begin();
+       ci != this->Configurations.end(); ++ci) {
     this->GenerateImportConfig(os, *ci, missingTargets);
-    }
+  }
 
   this->GenerateMissingTargetsCheckCode(os, missingTargets);
 
   return true;
 }
 
-void
-cmExportBuildFileGenerator
-::GenerateImportTargetsConfig(std::ostream& os,
-                              const std::string& config,
-                              std::string const& suffix,
-                              std::vector<std::string> &missingTargets)
+void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
+  std::ostream& os, const std::string& config, std::string const& suffix,
+  std::vector<std::string>& missingTargets)
 {
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-        tei = this->Exports.begin();
-      tei != this->Exports.end(); ++tei)
-    {
+  for (std::vector<cmGeneratorTarget*>::const_iterator tei =
+         this->Exports.begin();
+       tei != this->Exports.end(); ++tei) {
     // Collect import properties for this target.
     cmGeneratorTarget* target = *tei;
     ImportPropertyMap properties;
 
-    if (target->GetType() != cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() != cmState::INTERFACE_LIBRARY) {
       this->SetImportLocationProperty(config, suffix, target, properties);
-      }
-    if(!properties.empty())
-      {
+    }
+    if (!properties.empty()) {
       // Get the rest of the target details.
-      if (target->GetType() != cmState::INTERFACE_LIBRARY)
-        {
-        this->SetImportDetailProperties(config, suffix,
-                                        target,
-                                        properties, missingTargets);
+      if (target->GetType() != cmState::INTERFACE_LIBRARY) {
+        this->SetImportDetailProperties(config, suffix, target, properties,
+                                        missingTargets);
         this->SetImportLinkInterface(config, suffix,
                                      cmGeneratorExpression::BuildInterface,
-                                     target,
-                                     properties, missingTargets);
-        }
+                                     target, properties, missingTargets);
+      }
 
       // TOOD: PUBLIC_HEADER_LOCATION
       // This should wait until the build feature propagation stuff
@@ -169,179 +149,148 @@ cmExportBuildFileGenerator
       //                              properties);
 
       // Generate code in the export file.
-      this->GenerateImportPropertyCode(os, config, target,
-                                       properties);
-      }
+      this->GenerateImportPropertyCode(os, config, target, properties);
     }
+  }
 }
 
-void cmExportBuildFileGenerator::SetExportSet(cmExportSet *exportSet)
+void cmExportBuildFileGenerator::SetExportSet(cmExportSet* exportSet)
 {
   this->ExportSet = exportSet;
 }
 
-void
-cmExportBuildFileGenerator
-::SetImportLocationProperty(const std::string& config,
-                            std::string const& suffix,
-                            cmGeneratorTarget* target,
-                            ImportPropertyMap& properties)
+void cmExportBuildFileGenerator::SetImportLocationProperty(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorTarget* target, ImportPropertyMap& properties)
 {
   // Get the makefile in which to lookup target information.
   cmMakefile* mf = target->Makefile;
 
   // Add the main target file.
   {
-  std::string prop = "IMPORTED_LOCATION";
-  prop += suffix;
-  std::string value;
-  if(target->IsAppBundleOnApple())
-    {
-    value = target->GetFullPath(config, false);
-    }
-  else
-    {
-    value = target->GetFullPath(config, false, true);
+    std::string prop = "IMPORTED_LOCATION";
+    prop += suffix;
+    std::string value;
+    if (target->IsAppBundleOnApple()) {
+      value = target->GetFullPath(config, false);
+    } else {
+      value = target->GetFullPath(config, false, true);
     }
-  properties[prop] = value;
+    properties[prop] = value;
   }
 
   // Add the import library for windows DLLs.
-  if(target->IsDLLPlatform() &&
-     (target->GetType() == cmState::SHARED_LIBRARY ||
-      target->IsExecutableWithExports()) &&
-     mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))
-    {
+  if (target->IsDLLPlatform() &&
+      (target->GetType() == cmState::SHARED_LIBRARY ||
+       target->IsExecutableWithExports()) &&
+      mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
     std::string prop = "IMPORTED_IMPLIB";
     prop += suffix;
     std::string value = target->GetFullPath(config, true);
-    target->GetImplibGNUtoMS(value, value,
-                             "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+    target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
     properties[prop] = value;
-    }
+  }
 }
 
-void
-cmExportBuildFileGenerator::HandleMissingTarget(
-    std::string& link_libs,
-    std::vector<std::string>& missingTargets,
-    cmGeneratorTarget* depender,
-    cmGeneratorTarget* dependee)
+void cmExportBuildFileGenerator::HandleMissingTarget(
+  std::string& link_libs, std::vector<std::string>& missingTargets,
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
 {
   // The target is not in the export.
-  if(!this->AppendMode)
-    {
+  if (!this->AppendMode) {
     const std::string name = dependee->GetName();
     cmGlobalGenerator* gg =
-        dependee->GetLocalGenerator()->GetGlobalGenerator();
+      dependee->GetLocalGenerator()->GetGlobalGenerator();
     std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
 
     int targetOccurrences = (int)namespaces.size();
-    if (targetOccurrences == 1)
-      {
+    if (targetOccurrences == 1) {
       std::string missingTarget = namespaces[0];
 
       missingTarget += dependee->GetExportName();
       link_libs += missingTarget;
       missingTargets.push_back(missingTarget);
       return;
-      }
-    else
-      {
+    } else {
       // We are not appending, so all exported targets should be
       // known here.  This is probably user-error.
       this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
-      }
     }
+  }
   // Assume the target will be exported by another command.
   // Append it with the export namespace.
   link_libs += this->Namespace;
   link_libs += dependee->GetExportName();
 }
 
-void cmExportBuildFileGenerator
-::GetTargets(std::vector<std::string> &targets) const
+void cmExportBuildFileGenerator::GetTargets(
+  std::vector<std::string>& targets) const
 {
-  if (this->ExportSet)
-    {
-    for(std::vector<cmTargetExport*>::const_iterator
-          tei = this->ExportSet->GetTargetExports()->begin();
-          tei != this->ExportSet->GetTargetExports()->end(); ++tei)
-      {
+  if (this->ExportSet) {
+    for (std::vector<cmTargetExport*>::const_iterator tei =
+           this->ExportSet->GetTargetExports()->begin();
+         tei != this->ExportSet->GetTargetExports()->end(); ++tei) {
       targets.push_back((*tei)->TargetName);
-      }
-    return;
     }
+    return;
+  }
   targets = this->Targets;
 }
 
-std::vector<std::string>
-cmExportBuildFileGenerator
-::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
+std::vector<std::string> cmExportBuildFileGenerator::FindNamespaces(
+  cmGlobalGenerator* gg, const std::string& name)
 {
   std::vector<std::string> namespaces;
 
-  std::map<std::string, cmExportBuildFileGenerator*>& exportSets
-                                                  = gg->GetBuildExportSets();
+  std::map<std::string, cmExportBuildFileGenerator*>& exportSets =
+    gg->GetBuildExportSets();
 
-  for(std::map<std::string, cmExportBuildFileGenerator*>::const_iterator
-      expIt = exportSets.begin(); expIt != exportSets.end(); ++expIt)
-    {
+  for (std::map<std::string, cmExportBuildFileGenerator*>::const_iterator
+         expIt = exportSets.begin();
+       expIt != exportSets.end(); ++expIt) {
     const cmExportBuildFileGenerator* exportSet = expIt->second;
     std::vector<std::string> targets;
     exportSet->GetTargets(targets);
-    if (std::find(targets.begin(), targets.end(), name) != targets.end())
-      {
+    if (std::find(targets.begin(), targets.end(), name) != targets.end()) {
       namespaces.push_back(exportSet->GetNamespace());
-      }
     }
+  }
 
   return namespaces;
 }
 
-void
-cmExportBuildFileGenerator
-::ComplainAboutMissingTarget(cmGeneratorTarget* depender,
-                             cmGeneratorTarget* dependee,
-                             int occurrences)
+void cmExportBuildFileGenerator::ComplainAboutMissingTarget(
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee, int occurrences)
 {
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
-    }
+  }
 
   std::ostringstream e;
   e << "export called with target \"" << depender->GetName()
     << "\" which requires target \"" << dependee->GetName() << "\" ";
-  if (occurrences == 0)
-    {
+  if (occurrences == 0) {
     e << "that is not in the export set.\n";
-    }
-  else
-    {
+  } else {
     e << "that is not in this export set, but " << occurrences
-    << " times in others.\n";
-    }
+      << " times in others.\n";
+  }
   e << "If the required target is not easy to reference in this call, "
     << "consider using the APPEND option with multiple separate calls.";
 
-  this->LG->GetGlobalGenerator()->GetCMakeInstance()
-      ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                     this->LG->GetMakefile()->GetBacktrace());
+  this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+    cmake::FATAL_ERROR, e.str(), this->LG->GetMakefile()->GetBacktrace());
 }
 
-std::string
-cmExportBuildFileGenerator::InstallNameDir(cmGeneratorTarget* target,
-                                           const std::string& config)
+std::string cmExportBuildFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string& config)
 {
   std::string install_name_dir;
 
   cmMakefile* mf = target->Target->GetMakefile();
-  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    install_name_dir =
-      target->GetInstallNameDirForBuildTree(config);
-    }
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForBuildTree(config);
+  }
 
   return install_name_dir;
 }