Source/cmInstallTargetGenerator.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmInstallTargetGenerator.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-03-02 21:48:50 $
   7   Version:   $Revision: 1.62 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmInstallTargetGenerator.h"
  18
  19 #include "cmComputeLinkInformation.h"
  20 #include "cmGlobalGenerator.h"
  21 #include "cmLocalGenerator.h"
  22 #include "cmMakefile.h"
  23 #include "cmake.h"
  24
  25 #include <assert.h>
  26
  27 //----------------------------------------------------------------------------
  28 cmInstallTargetGenerator
  29 ::cmInstallTargetGenerator(cmTarget& t, const char* dest, bool implib,
  30                            const char* file_permissions,
  31                            std::vector<std::string> const& configurations,
  32                            const char* component, bool optional):
  33   cmInstallGenerator(dest, configurations, component), Target(&t),
  34   ImportLibrary(implib), FilePermissions(file_permissions), Optional(optional)
  35 {
  36   this->NamelinkMode = NamelinkModeNone;
  37   this->Target->SetHaveInstallRule(true);
  38 }
  39
  40 //----------------------------------------------------------------------------
  41 cmInstallTargetGenerator
  42 ::~cmInstallTargetGenerator()
  43 {
  44 }
  45
  46 //----------------------------------------------------------------------------
  47 void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
  48 {
  49   // Warn if installing an exclude-from-all target.
  50   if(this->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
  51     {
  52     cmOStringStream msg;
  53     msg << "WARNING: Target \"" << this->Target->GetName()
  54         << "\" has EXCLUDE_FROM_ALL set and will not be built by default "
  55         << "but an install rule has been provided for it.  CMake does "
  56         << "not define behavior for this case.";
  57     cmSystemTools::Message(msg.str().c_str(), "Warning");
  58     }
  59
  60   // Track indentation.
  61   Indent indent;
  62
  63   // Begin this block of installation.
  64   std::string component_test =
  65     this->CreateComponentTest(this->Component.c_str());
  66   os << indent << "IF(" << component_test << ")\n";
  67
  68   // Compute the build tree directory from which to copy the target.
  69   std::string fromDir;
  70   if(this->Target->NeedRelinkBeforeInstall())
  71     {
  72     fromDir = this->Target->GetMakefile()->GetStartOutputDirectory();
  73     fromDir += cmake::GetCMakeFilesDirectory();
  74     fromDir += "/CMakeRelink.dir/";
  75     }
  76   else
  77     {
  78     fromDir = this->Target->GetDirectory(0, this->ImportLibrary);
  79     fromDir += "/";
  80     }
  81
  82   // Generate a portion of the script for each configuration.
  83   if(this->ConfigurationTypes->empty())
  84     {
  85     this->GenerateScriptForConfig(os, fromDir.c_str(),
  86                                   this->ConfigurationName,
  87                                   indent.Next());
  88     }
  89   else
  90     {
  91     for(std::vector<std::string>::const_iterator i =
  92           this->ConfigurationTypes->begin();
  93         i != this->ConfigurationTypes->end(); ++i)
  94       {
  95       this->GenerateScriptForConfig(os, fromDir.c_str(), i->c_str(),
  96                                     indent.Next());
  97       }
  98     }
  99
 100   // End this block of installation.
 101   os << indent << "ENDIF(" << component_test << ")\n\n";
 102 }
 103
 104 //----------------------------------------------------------------------------
 105 void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
 106                                                        const char* fromDir,
 107                                                        const char* config,
 108                                                        Indent const& indent)
 109 {
 110   // Compute the per-configuration directory containing the files.
 111   std::string fromDirConfig = fromDir;
 112   this->Target->GetMakefile()->GetLocalGenerator()->GetGlobalGenerator()
 113     ->AppendDirectoryForConfig("", config, "/", fromDirConfig);
 114
 115   if(config && *config)
 116     {
 117     // Skip this configuration for config-specific installation that
 118     // does not match it.
 119     if(!this->InstallsForConfig(config))
 120       {
 121       return;
 122       }
 123
 124     // Generate a per-configuration block.
 125     std::string config_test = this->CreateConfigTest(config);
 126     os << indent << "IF(" << config_test << ")\n";
 127     this->GenerateScriptForConfigDir(os, fromDirConfig.c_str(), config,
 128                                      indent.Next());
 129     os << indent << "ENDIF(" << config_test << ")\n";
 130     }
 131   else
 132     {
 133     this->GenerateScriptForConfigDir(os, fromDirConfig.c_str(), config,
 134                                      indent);
 135     }
 136 }
 137
 138 //----------------------------------------------------------------------------
 139 void
 140 cmInstallTargetGenerator
 141 ::GenerateScriptForConfigDir(std::ostream& os,
 142                              const char* fromDirConfig,
 143                              const char* config,
 144                              Indent const& indent)
 145 {
 146   // Compute the full path to the main installed file for this target.
 147   NameType nameType = this->ImportLibrary? NameImplib : NameNormal;
 148   std::string toInstallPath = this->GetInstallDestination();
 149   toInstallPath += "/";
 150   toInstallPath += this->GetInstallFilename(this->Target, config, nameType);
 151
 152   // Track whether post-install operations should be added to the
 153   // script.
 154   bool tweakInstalledFile = true;
 155
 156   // Compute the list of files to install for this target.
 157   std::vector<std::string> files;
 158   std::string literal_args;
 159   cmTarget::TargetType type = this->Target->GetType();
 160   if(type == cmTarget::EXECUTABLE)
 161     {
 162     // There is a bug in cmInstallCommand if this fails.
 163     assert(this->NamelinkMode == NamelinkModeNone);
 164
 165     std::string targetName;
 166     std::string targetNameReal;
 167     std::string targetNameImport;
 168     std::string targetNamePDB;
 169     this->Target->GetExecutableNames(targetName, targetNameReal,
 170                                      targetNameImport, targetNamePDB,
 171                                      config);
 172     if(this->ImportLibrary)
 173       {
 174       std::string from1 = fromDirConfig;
 175       from1 += targetNameImport;
 176       files.push_back(from1);
 177
 178       // An import library looks like a static library.
 179       type = cmTarget::STATIC_LIBRARY;
 180       }
 181     else
 182       {
 183       std::string from1 = fromDirConfig;
 184       from1 += targetName;
 185
 186       // Handle OSX Bundles.
 187       if(this->Target->IsAppBundleOnApple())
 188         {
 189         // Compute the source locations of the bundle executable and
 190         // Info.plist file.
 191         from1 += ".app";
 192         files.push_back(from1);
 193         type = cmTarget::INSTALL_DIRECTORY;
 194         // Need to apply install_name_tool and stripping to binary
 195         // inside bundle.
 196         toInstallPath += ".app/Contents/MacOS/";
 197         toInstallPath +=
 198           this->GetInstallFilename(this->Target, config, nameType);
 199         literal_args += " USE_SOURCE_PERMISSIONS";
 200         }
 201       else
 202         {
 203         files.push_back(from1);
 204         if(targetNameReal != targetName)
 205           {
 206           std::string from2 = fromDirConfig;
 207           from2 += targetNameReal;
 208           files.push_back(from2);
 209           }
 210         }
 211       }
 212     }
 213   else
 214     {
 215     std::string targetName;
 216     std::string targetNameSO;
 217     std::string targetNameReal;
 218     std::string targetNameImport;
 219     std::string targetNamePDB;
 220     this->Target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
 221                                   targetNameImport, targetNamePDB,
 222                                   config);
 223     if(this->ImportLibrary)
 224       {
 225       // There is a bug in cmInstallCommand if this fails.
 226       assert(this->NamelinkMode == NamelinkModeNone);
 227
 228       std::string from1 = fromDirConfig;
 229       from1 += targetNameImport;
 230       files.push_back(from1);
 231
 232       // An import library looks like a static library.
 233       type = cmTarget::STATIC_LIBRARY;
 234       }
 235     else if(this->Target->IsFrameworkOnApple())
 236       {
 237       // There is a bug in cmInstallCommand if this fails.
 238       assert(this->NamelinkMode == NamelinkModeNone);
 239
 240       // Compute the build tree location of the framework directory
 241       std::string from1 = fromDirConfig;
 242       // Remove trailing slashes... so that from1 ends with ".framework":
 243       //
 244       cmSystemTools::ConvertToUnixSlashes(from1);
 245       files.push_back(from1);
 246
 247       type = cmTarget::INSTALL_DIRECTORY;
 248
 249       // Need to apply install_name_tool and stripping to binary
 250       // inside framework.
 251       toInstallPath += ".framework/";
 252       toInstallPath += this->GetInstallFilename(this->Target, config,
 253                                                 NameNormal);
 254
 255       literal_args += " USE_SOURCE_PERMISSIONS";
 256       }
 257     else
 258       {
 259       // Operations done at install time on the installed file should
 260       // be done on the real file and not any of the symlinks.
 261       toInstallPath = this->GetInstallDestination();
 262       toInstallPath += "/";
 263       toInstallPath += targetNameReal;
 264
 265       // Construct the list of file names to install for this library.
 266       bool haveNamelink = false;
 267       std::string fromName;
 268       std::string fromSOName;
 269       std::string fromRealName;
 270       fromName = fromDirConfig;
 271       fromName += targetName;
 272       if(targetNameSO != targetName)
 273         {
 274         haveNamelink = true;
 275         fromSOName = fromDirConfig;
 276         fromSOName += targetNameSO;
 277         }
 278       if(targetNameReal != targetName &&
 279          targetNameReal != targetNameSO)
 280         {
 281         haveNamelink = true;
 282         fromRealName = fromDirConfig;
 283         fromRealName += targetNameReal;
 284         }
 285
 286       // Add the names based on the current namelink mode.
 287       if(haveNamelink)
 288         {
 289         // With a namelink we need to check the mode.
 290         if(this->NamelinkMode == NamelinkModeOnly)
 291           {
 292           // Install the namelink only.
 293           files.push_back(fromName);
 294           tweakInstalledFile = false;
 295           }
 296         else
 297           {
 298           // Install the real file if it has its own name.
 299           if(!fromRealName.empty())
 300             {
 301             files.push_back(fromRealName);
 302             }
 303
 304           // Install the soname link if it has its own name.
 305           if(!fromSOName.empty())
 306             {
 307             files.push_back(fromSOName);
 308             }
 309
 310           // Install the namelink if it is not to be skipped.
 311           if(this->NamelinkMode != NamelinkModeSkip)
 312             {
 313             files.push_back(fromName);
 314             }
 315           }
 316         }
 317       else
 318         {
 319         // Without a namelink there will be only one file.  Install it
 320         // if this is not a namelink-only rule.
 321         if(this->NamelinkMode != NamelinkModeOnly)
 322           {
 323           files.push_back(fromName);
 324           }
 325         }
 326       }
 327     }
 328
 329   // Skip this rule if no files are to be installed for the target.
 330   if(files.empty())
 331     {
 332     return;
 333     }
 334
 335   // Write code to install the target file.
 336   const char* no_dir_permissions = 0;
 337   const char* no_rename = 0;
 338   const char* no_properties = 0;
 339   bool optional = this->Optional || this->ImportLibrary;
 340   this->AddInstallRule(os, type, files,
 341                        optional, no_properties,
 342                        this->FilePermissions.c_str(), no_dir_permissions,
 343                        no_rename, literal_args.c_str(),
 344                        indent);
 345
 346   // Construct the path of the file on disk after installation on
 347   // which tweaks may be performed.
 348   std::string toDestDirPath = "$ENV{DESTDIR}";
 349   if(toInstallPath[0] != '/' && toInstallPath[0] != '$')
 350     {
 351     toDestDirPath += "/";
 352     }
 353   toDestDirPath += toInstallPath;
 354
 355   // TODO:
 356   //   - Skip IF(EXISTS) checks if nothing is done with the installed file
 357   if(tweakInstalledFile)
 358     {
 359     os << indent << "IF(EXISTS \"" << toDestDirPath << "\")\n";
 360     this->AddInstallNamePatchRule(os, indent.Next(), config, toDestDirPath);
 361     this->AddChrpathPatchRule(os, indent.Next(), config, toDestDirPath);
 362     this->AddRanlibRule(os, indent.Next(), type, toDestDirPath);
 363     this->AddStripRule(os, indent.Next(), type, toDestDirPath);
 364     os << indent << "ENDIF(EXISTS \"" << toDestDirPath << "\")\n";
 365     }
 366 }
 367
 368 //----------------------------------------------------------------------------
 369 std::string
 370 cmInstallTargetGenerator::GetInstallFilename(const char* config) const
 371 {
 372   NameType nameType = this->ImportLibrary? NameImplib : NameNormal;
 373   return
 374     cmInstallTargetGenerator::GetInstallFilename(this->Target, config,
 375                                                  nameType);
 376 }
 377
 378 //----------------------------------------------------------------------------
 379 std::string cmInstallTargetGenerator::GetInstallFilename(cmTarget* target,
 380                                                          const char* config,
 381                                                          NameType nameType)
 382 {
 383   std::string fname;
 384   // Compute the name of the library.
 385   if(target->GetType() == cmTarget::EXECUTABLE)
 386     {
 387     std::string targetName;
 388     std::string targetNameReal;
 389     std::string targetNameImport;
 390     std::string targetNamePDB;
 391     target->GetExecutableNames(targetName, targetNameReal,
 392                                targetNameImport, targetNamePDB,
 393                                config);
 394     if(nameType == NameImplib)
 395       {
 396       // Use the import library name.
 397       fname = targetNameImport;
 398       }
 399     else if(nameType == NameReal)
 400       {
 401       // Use the canonical name.
 402       fname = targetNameReal;
 403       }
 404     else
 405       {
 406       // Use the canonical name.
 407       fname = targetName;
 408       }
 409     }
 410   else
 411     {
 412     std::string targetName;
 413     std::string targetNameSO;
 414     std::string targetNameReal;
 415     std::string targetNameImport;
 416     std::string targetNamePDB;
 417     target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
 418                             targetNameImport, targetNamePDB, config);
 419     if(nameType == NameImplib)
 420       {
 421       // Use the import library name.
 422       fname = targetNameImport;
 423       }
 424     else if(nameType == NameSO)
 425       {
 426       // Use the soname.
 427       fname = targetNameSO;
 428       }
 429     else if(nameType == NameReal)
 430       {
 431       // Use the real name.
 432       fname = targetNameReal;
 433       }
 434     else
 435       {
 436       // Use the canonical name.
 437       fname = targetName;
 438       }
 439     }
 440
 441   return fname;
 442 }
 443
 444 //----------------------------------------------------------------------------
 445 void
 446 cmInstallTargetGenerator
 447 ::AddInstallNamePatchRule(std::ostream& os, Indent const& indent,
 448                           const char* config, std::string const& toDestDirPath)
 449 {
 450   if(this->ImportLibrary ||
 451      !(this->Target->GetType() == cmTarget::SHARED_LIBRARY ||
 452        this->Target->GetType() == cmTarget::MODULE_LIBRARY ||
 453        this->Target->GetType() == cmTarget::EXECUTABLE))
 454     {
 455     return;
 456     }
 457
 458   // Fix the install_name settings in installed binaries.
 459   std::string installNameTool =
 460     this->Target->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_NAME_TOOL");
 461
 462   if(!installNameTool.size())
 463     {
 464     return;
 465     }
 466
 467   // Build a map of build-tree install_name to install-tree install_name for
 468   // shared libraries linked to this target.
 469   std::map<cmStdString, cmStdString> install_name_remap;
 470   if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config))
 471     {
 472     std::set<cmTarget*> const& sharedLibs = cli->GetSharedLibrariesLinked();
 473     for(std::set<cmTarget*>::const_iterator j = sharedLibs.begin();
 474         j != sharedLibs.end(); ++j)
 475       {
 476       // If the build tree and install tree use different path
 477       // components of the install_name field then we need to create a
 478       // mapping to be applied after installation.
 479       cmTarget* tgt = *j;
 480       std::string for_build = tgt->GetInstallNameDirForBuildTree(config);
 481       std::string for_install = tgt->GetInstallNameDirForInstallTree(config);
 482       if(for_build != for_install)
 483         {
 484         // The directory portions differ.  Append the filename to
 485         // create the mapping.
 486         std::string fname =
 487           this->GetInstallFilename(tgt, config, NameSO);
 488
 489         // Map from the build-tree install_name.
 490         for_build += fname;
 491
 492         // Map to the install-tree install_name.
 493         for_install += fname;
 494
 495         // Store the mapping entry.
 496         install_name_remap[for_build] = for_install;
 497         }
 498       }
 499     }
 500
 501   // Edit the install_name of the target itself if necessary.
 502   std::string new_id;
 503   if(this->Target->GetType() == cmTarget::SHARED_LIBRARY)
 504     {
 505     std::string for_build =
 506       this->Target->GetInstallNameDirForBuildTree(config);
 507     std::string for_install =
 508       this->Target->GetInstallNameDirForInstallTree(config);
 509
 510     if(this->Target->IsFrameworkOnApple() && for_install.empty())
 511       {
 512       // Frameworks seem to have an id corresponding to their own full
 513       // path.
 514       // ...
 515       // for_install = fullDestPath_without_DESTDIR_or_name;
 516       }
 517
 518     // If the install name will change on installation set the new id
 519     // on the installed file.
 520     if(for_build != for_install)
 521       {
 522       // Prepare to refer to the install-tree install_name.
 523       new_id = for_install;
 524       new_id += this->GetInstallFilename(this->Target, config, NameSO);
 525       }
 526     }
 527
 528   // Write a rule to run install_name_tool to set the install-tree
 529   // install_name value and references.
 530   if(!new_id.empty() || !install_name_remap.empty())
 531     {
 532     os << indent << "EXECUTE_PROCESS(COMMAND \"" << installNameTool;
 533     os << "\"";
 534     if(!new_id.empty())
 535       {
 536       os << "\n" << indent << "  -id \"" << new_id << "\"";
 537       }
 538     for(std::map<cmStdString, cmStdString>::const_iterator
 539           i = install_name_remap.begin();
 540         i != install_name_remap.end(); ++i)
 541       {
 542       os << "\n" << indent << "  -change \""
 543          << i->first << "\" \"" << i->second << "\"";
 544       }
 545     os << "\n" << indent << "  \"" << toDestDirPath << "\")\n";
 546     }
 547 }
 548
 549 //----------------------------------------------------------------------------
 550 void
 551 cmInstallTargetGenerator
 552 ::AddChrpathPatchRule(std::ostream& os, Indent const& indent,
 553                       const char* config, std::string const& toDestDirPath)
 554 {
 555   // Skip the chrpath if the target does not need it.
 556   if(this->ImportLibrary || !this->Target->IsChrpathUsed())
 557     {
 558     return;
 559     }
 560
 561   // Get the link information for this target.
 562   // It can provide the RPATH.
 563   cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
 564   if(!cli)
 565     {
 566     return;
 567     }
 568
 569   // Construct the original rpath string to be replaced.
 570   std::string oldRpath = cli->GetRPathString(false);
 571
 572   // Get the install RPATH from the link information.
 573   std::string newRpath = cli->GetChrpathString();
 574
 575   // Skip the rule if the paths are identical
 576   if(oldRpath == newRpath)
 577     {
 578     return;
 579     }
 580
 581   // Write a rule to run chrpath to set the install-tree RPATH
 582   os << indent << "FILE(CHRPATH FILE \"" << toDestDirPath << "\"\n"
 583      << indent << "     OLD_RPATH \"" << oldRpath << "\"\n"
 584      << indent << "     NEW_RPATH \"" << newRpath << "\")\n";
 585 }
 586
 587 //----------------------------------------------------------------------------
 588 void
 589 cmInstallTargetGenerator::AddStripRule(std::ostream& os,
 590                                        Indent const& indent,
 591                                        cmTarget::TargetType type,
 592                                        const std::string& toDestDirPath)
 593 {
 594
 595   // don't strip static libraries, because it removes the only symbol table
 596   // they have so you can't link to them anymore
 597   if(type == cmTarget::STATIC_LIBRARY)
 598     {
 599     return;
 600     }
 601
 602   // Don't handle OSX Bundles.
 603   if(this->Target->GetMakefile()->IsOn("APPLE") &&
 604      this->Target->GetPropertyAsBool("MACOSX_BUNDLE"))
 605     {
 606     return;
 607     }
 608
 609   if(! this->Target->GetMakefile()->IsSet("CMAKE_STRIP"))
 610     {
 611     return;
 612     }
 613
 614   os << indent << "IF(CMAKE_INSTALL_DO_STRIP)\n";
 615   os << indent << "  EXECUTE_PROCESS(COMMAND \""
 616      << this->Target->GetMakefile()->GetDefinition("CMAKE_STRIP")
 617      << "\" \"" << toDestDirPath << "\")\n";
 618   os << indent << "ENDIF(CMAKE_INSTALL_DO_STRIP)\n";
 619 }
 620
 621 //----------------------------------------------------------------------------
 622 void
 623 cmInstallTargetGenerator::AddRanlibRule(std::ostream& os,
 624                                         Indent const& indent,
 625                                         cmTarget::TargetType type,
 626                                         const std::string& toDestDirPath)
 627 {
 628   // Static libraries need ranlib on this platform.
 629   if(type != cmTarget::STATIC_LIBRARY)
 630     {
 631     return;
 632     }
 633
 634   // Perform post-installation processing on the file depending
 635   // on its type.
 636   if(!this->Target->GetMakefile()->IsOn("APPLE"))
 637     {
 638     return;
 639     }
 640
 641   std::string ranlib =
 642     this->Target->GetMakefile()->GetRequiredDefinition("CMAKE_RANLIB");
 643   if(ranlib.empty())
 644     {
 645     return;
 646     }
 647
 648   os << indent << "EXECUTE_PROCESS(COMMAND \""
 649      << ranlib << "\" \"" << toDestDirPath << "\")\n";
 650 }