cmExportInstallFileGenerator.cxx 18.3 KB
Newer Older
1 2 3
/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
4

5 6
  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.
7

8 9 10 11
  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/
12 13
#include "cmExportInstallFileGenerator.h"

14 15
#include "cmExportSet.h"
#include "cmExportSetMap.h"
16
#include "cmGeneratedFileStream.h"
17 18
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
19 20
#include "cmInstallExportGenerator.h"
#include "cmInstallTargetGenerator.h"
21
#include "cmTargetExport.h"
22 23 24 25

//----------------------------------------------------------------------------
cmExportInstallFileGenerator
::cmExportInstallFileGenerator(cmInstallExportGenerator* iegen):
26
  IEGen(iegen)
27 28 29
{
}

30 31 32 33 34 35 36 37 38
//----------------------------------------------------------------------------
std::string cmExportInstallFileGenerator::GetConfigImportFileGlob()
{
  std::string glob = this->FileBase;
  glob += "-*";
  glob += this->FileExt;
  return glob;
}

39 40 41
//----------------------------------------------------------------------------
bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
{
42
  std::vector<cmTargetExport*> allTargets;
43 44 45 46 47 48 49
  {
  std::string expectedTargets;
  std::string sep;
  for(std::vector<cmTargetExport*>::const_iterator
        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
    {
Stephen Kelly's avatar
Stephen Kelly committed
50
    expectedTargets += sep + this->Namespace + (*tei)->Target->GetExportName();
51
    sep = " ";
52
    cmTargetExport * te = *tei;
53 54
    if(this->ExportedTargets.insert(te->Target).second)
      {
55
      allTargets.push_back(te);
56 57 58 59
      }
    else
      {
      cmOStringStream e;
60
      e << "install(EXPORT \""
61 62
        << this->IEGen->GetExportSet()->GetName()
        << "\" ...) " << "includes target \"" << te->Target->GetName()
63 64 65 66
        << "\" more than once in the export set.";
      cmSystemTools::Error(e.str().c_str());
      return false;
      }
67 68
    }

69 70 71
  this->GenerateExpectedTargetsCode(os, expectedTargets);
  }

72 73 74 75
  // Set an _IMPORT_PREFIX variable for import location properties
  // to reference if they are relative to the install prefix.
  std::string installPrefix =
    this->IEGen->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
76
  const char* installDest = this->IEGen->GetDestination();
77
  if(cmSystemTools::FileIsFullPath(installDest))
78
    {
79 80 81 82 83 84 85 86 87 88 89
    // The export file is being installed to an absolute path so the
    // package is not relocatable.  Use the configured install prefix.
    os <<
      "# The installation prefix configured by this project.\n"
      "set(_IMPORT_PREFIX \"" << installPrefix << "\")\n"
      "\n";
    }
  else
    {
    // Add code to compute the installation prefix relative to the
    // import file location.
90 91 92 93 94
    std::string absDest = installPrefix + "/" + installDest;
    std::string absDestS = absDest + "/";
    os << "# Compute the installation prefix relative to this file.\n"
       << "get_filename_component(_IMPORT_PREFIX"
       << " \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n";
95 96 97 98
    if(cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/"))
99
      {
100 101 102 103 104 105 106 107 108 109 110
      // Handle "/usr move" symlinks created by some Linux distros.
      os <<
        "# Use original install prefix when loaded through a\n"
        "# cross-prefix symbolic link such as /lib -> /usr/lib.\n"
        "get_filename_component(_realCurr \"${_IMPORT_PREFIX}\" REALPATH)\n"
        "get_filename_component(_realOrig \"" << absDest << "\" REALPATH)\n"
        "if(_realCurr STREQUAL _realOrig)\n"
        "  set(_IMPORT_PREFIX \"" << absDest << "\")\n"
        "endif()\n"
        "unset(_realOrig)\n"
        "unset(_realCurr)\n";
111
      }
112 113
    std::string dest = installDest;
    while(!dest.empty())
114
      {
115 116 117
      os <<
        "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" PATH)\n";
      dest = cmSystemTools::GetFilenamePath(dest);
118
      }
119
    os << "\n";
120 121
    }

122 123
  std::vector<std::string> missingTargets;

124
  bool require2_8_12 = false;
125
  bool require3_0_0 = false;
126
  bool requiresConfigFiles = false;
127
  // Create all the imported targets.
128
  for(std::vector<cmTargetExport*>::const_iterator
129 130 131
        tei = allTargets.begin();
      tei != allTargets.end(); ++tei)
    {
132
    cmTarget* te = (*tei)->Target;
133

134 135 136 137 138 139 140 141 142 143 144
    if (te->GetProperty("INTERFACE_SOURCES"))
      {
      cmOStringStream e;
      e << "Target \""
        << te->GetName()
        << "\" has a populated INTERFACE_SOURCES property.  This is not "
          "currently supported.";
      cmSystemTools::Error(e.str().c_str());
      return false;
      }

145 146 147
    requiresConfigFiles = requiresConfigFiles
                              || te->GetType() != cmTarget::INTERFACE_LIBRARY;

148
    this->GenerateImportTargetCode(os, te);
149 150 151

    ImportPropertyMap properties;

152
    this->PopulateIncludeDirectoriesInterface(*tei,
153 154
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
155 156 157
    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
158 159 160 161 162
                                  properties, missingTargets);
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
163 164 165 166
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
167 168 169 170
    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
171 172 173 174
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
175 176 177 178 179 180 181 182 183 184 185 186 187 188

    const bool newCMP0022Behavior =
                              te->GetPolicyStatusCMP0022() != cmPolicies::WARN
                           && te->GetPolicyStatusCMP0022() != cmPolicies::OLD;
    if (newCMP0022Behavior)
      {
      if (this->PopulateInterfaceLinkLibrariesProperty(te,
                                    cmGeneratorExpression::InstallInterface,
                                    properties, missingTargets)
          && !this->ExportOld)
        {
        require2_8_12 = true;
        }
      }
189 190
    if (te->GetType() == cmTarget::INTERFACE_LIBRARY)
      {
191
      require3_0_0 = true;
192
      }
193 194
    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
                                  te, properties);
195
    this->PopulateCompatibleInterfaceProperties(te, properties);
196 197

    this->GenerateInterfaceProperties(te, os, properties);
198 199
    }

200
  if (require3_0_0)
201
    {
Brad King's avatar
Brad King committed
202
    this->GenerateRequiredCMakeVersion(os, "3.0.0");
203 204
    }
  else if (require2_8_12)
205
    {
Brad King's avatar
Brad King committed
206
    this->GenerateRequiredCMakeVersion(os, "2.8.12");
207
    }
208

209 210
  // Now load per-configuration properties for them.
  os << "# Load information for each installed configuration.\n"
211 212
     << "get_filename_component(_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n"
     << "file(GLOB CONFIG_FILES \"${_DIR}/"
213
     << this->GetConfigImportFileGlob() << "\")\n"
214 215 216
     << "foreach(f ${CONFIG_FILES})\n"
     << "  include(${f})\n"
     << "endforeach()\n"
217 218
     << "\n";

219
  // Cleanup the import prefix variable.
220 221 222
  os << "# Cleanup temporary variables.\n"
     << "set(_IMPORT_PREFIX)\n"
     << "\n";
223 224
  this->GenerateImportedFileCheckLoop(os);

225
  bool result = true;
226 227 228
  // Generate an import file for each configuration.
  // Don't do this if we only export INTERFACE_LIBRARY targets.
  if (requiresConfigFiles)
229
    {
230 231 232
    for(std::vector<std::string>::const_iterator
          ci = this->Configurations.begin();
        ci != this->Configurations.end(); ++ci)
233
      {
Stephen Kelly's avatar
Stephen Kelly committed
234
      if(!this->GenerateImportFileConfig(*ci, missingTargets))
235 236 237
        {
        result = false;
        }
238 239
      }
    }
240 241 242

  this->GenerateMissingTargetsCheckCode(os, missingTargets);

243 244 245
  return result;
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string &input)
{
  std::string::size_type pos = 0;
  std::string::size_type lastPos = pos;

  while((pos = input.find("$<INSTALL_PREFIX>", lastPos)) != input.npos)
    {
    std::string::size_type endPos = pos + sizeof("$<INSTALL_PREFIX>") - 1;
    input.replace(pos, endPos - pos, "${_IMPORT_PREFIX}");
    lastPos = endPos;
    }
}

261 262
//----------------------------------------------------------------------------
bool
263 264
cmExportInstallFileGenerator::GenerateImportFileConfig(
                                    const std::string& config,
265
                                    std::vector<std::string> &missingTargets)
266 267
{
  // Skip configurations not enabled for this export.
268
  if(!this->IEGen->InstallsForConfig(config))
269 270 271 272 273 274 275 276 277
    {
    return true;
    }

  // Construct the name of the file to generate.
  std::string fileName = this->FileDir;
  fileName += "/";
  fileName += this->FileBase;
  fileName += "-";
278
  if(!config.empty())
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
    {
    fileName += cmSystemTools::LowerCase(config);
    }
  else
    {
    fileName += "noconfig";
    }
  fileName += this->FileExt;

  // Open the output file to generate it.
  cmGeneratedFileStream exportFileStream(fileName.c_str(), true);
  if(!exportFileStream)
    {
    std::string se = cmSystemTools::GetLastSystemError();
    cmOStringStream e;
294
    e << "cannot write to file \"" << fileName
295 296 297 298 299 300 301 302 303 304
      << "\": " << se;
    cmSystemTools::Error(e.str().c_str());
    return false;
    }
  std::ostream& os = exportFileStream;

  // Start with the import file header.
  this->GenerateImportHeaderCode(os, config);

  // Generate the per-config target information.
305
  this->GenerateImportConfig(os, config, missingTargets);
306 307 308 309 310 311 312 313 314 315 316 317 318 319

  // End with the import file footer.
  this->GenerateImportFooterCode(os);

  // Record this per-config import file.
  this->ConfigImportFiles[config] = fileName;

  return true;
}

//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::GenerateImportTargetsConfig(std::ostream& os,
320 321
                              const std::string& config,
                              std::string const& suffix,
322
                              std::vector<std::string> &missingTargets)
323 324
{
  // Add each target in the set to the export.
325
  for(std::vector<cmTargetExport*>::const_iterator
326 327
        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
328 329
    {
    // Collect import properties for this target.
330
    cmTargetExport const* te = *tei;
331
    if (te->Target->GetType() == cmTarget::INTERFACE_LIBRARY)
332 333 334
      {
      continue;
      }
335 336 337 338

    ImportPropertyMap properties;
    std::set<std::string> importedLocations;

339 340 341 342
    this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
                                    properties, importedLocations);
343
    this->SetImportLocationProperty(config, suffix,
344 345 346 347 348 349
                                    te->RuntimeGenerator, properties,
                                    importedLocations);
    this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
                                    properties, importedLocations);
350 351 352 353 354 355 356

    // If any file location was set for the target add it to the
    // import file.
    if(!properties.empty())
      {
      // Get the rest of the target details.
      this->SetImportDetailProperties(config, suffix,
357
                                      te->Target, properties, missingTargets);
358

359 360 361 362
      this->SetImportLinkInterface(config, suffix,
                                   cmGeneratorExpression::InstallInterface,
                                   te->Target, properties, missingTargets);

363
      // TOOD: PUBLIC_HEADER_LOCATION
364 365
      // This should wait until the build feature propagation stuff
      // is done.  Then this can be a propagated include directory.
366 367 368 369 370
      // this->GenerateImportProperty(config, te->HeaderGenerator,
      //                              properties);

      // Generate code in the export file.
      this->GenerateImportPropertyCode(os, config, te->Target, properties);
371 372
      this->GenerateImportedFileChecksCode(os, te->Target, properties,
                                           importedLocations);
373 374 375 376 377 378 379
      }
    }
}

//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
380 381
::SetImportLocationProperty(const std::string& config,
                            std::string const& suffix,
382
                            cmInstallTargetGenerator* itgen,
383 384 385
                            ImportPropertyMap& properties,
                            std::set<std::string>& importedLocations
                           )
386 387 388 389 390 391 392
{
  // Skip rules that do not match this configuration.
  if(!(itgen && itgen->InstallsForConfig(config)))
    {
    return;
    }

393 394
  // Get the target to be installed.
  cmTarget* target = itgen->GetTarget();
395 396 397 398 399 400 401

  // Construct the installed location of the target.
  std::string dest = itgen->GetDestination();
  std::string value;
  if(!cmSystemTools::FileIsFullPath(dest.c_str()))
    {
    // The target is installed relative to the installation prefix.
402
    value = "${_IMPORT_PREFIX}/";
403 404 405 406
    }
  value += dest;
  value += "/";

407
  if(itgen->IsImportLibrary())
408
    {
409 410 411 412 413 414 415 416 417 418
    // Construct the property name.
    std::string prop = "IMPORTED_IMPLIB";
    prop += suffix;

    // Append the installed file name.
    value += itgen->GetInstallFilename(target, config,
                                       cmInstallTargetGenerator::NameImplib);

    // Store the property.
    properties[prop] = value;
419
    importedLocations.insert(prop);
420
    }
421
  else
422
    {
423 424 425
    // Construct the property name.
    std::string prop = "IMPORTED_LOCATION";
    prop += suffix;
426

427
    // Append the installed file name.
428
    if(target->IsAppBundleOnApple())
429 430 431 432 433 434 435 436 437 438 439 440 441
      {
      value += itgen->GetInstallFilename(target, config);
      value += ".app/Contents/MacOS/";
      value += itgen->GetInstallFilename(target, config);
      }
    else
      {
      value += itgen->GetInstallFilename(target, config,
                                         cmInstallTargetGenerator::NameReal);
      }

    // Store the property.
    properties[prop] = value;
442
    importedLocations.insert(prop);
443
    }
444 445
}

446 447 448 449 450 451
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator::HandleMissingTarget(
  std::string& link_libs, std::vector<std::string>& missingTargets,
  cmMakefile* mf, cmTarget* depender, cmTarget* dependee)
{
Stephen Kelly's avatar
Stephen Kelly committed
452
  const std::string name = dependee->GetName();
453 454 455 456 457
  std::vector<std::string> namespaces = this->FindNamespaces(mf, name);
  int targetOccurrences = (int)namespaces.size();
  if (targetOccurrences == 1)
    {
    std::string missingTarget = namespaces[0];
Stephen Kelly's avatar
Stephen Kelly committed
458 459

    missingTarget += dependee->GetExportName();
460 461 462 463 464
    link_libs += missingTarget;
    missingTargets.push_back(missingTarget);
    }
  else
    {
465 466
    // All exported targets should be known here and should be unique.
    // This is probably user-error.
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
    this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
    }
}

//----------------------------------------------------------------------------
std::vector<std::string>
cmExportInstallFileGenerator
::FindNamespaces(cmMakefile* mf, const std::string& name)
{
  std::vector<std::string> namespaces;
  cmGlobalGenerator* gg = mf->GetLocalGenerator()->GetGlobalGenerator();
  const cmExportSetMap& exportSets = gg->GetExportSets();

  for(cmExportSetMap::const_iterator expIt = exportSets.begin();
      expIt != exportSets.end();
      ++expIt)
    {
    const cmExportSet* exportSet = expIt->second;
    std::vector<cmTargetExport*> const* targets =
                                                 exportSet->GetTargetExports();

    bool containsTarget = false;
    for(unsigned int i=0; i<targets->size(); i++)
      {
      if (name == (*targets)[i]->Target->GetName())
        {
        containsTarget = true;
        break;
        }
      }

    if (containsTarget)
      {
      std::vector<cmInstallExportGenerator const*> const* installs =
                                                 exportSet->GetInstallations();
      for(unsigned int i=0; i<installs->size(); i++)
        {
        namespaces.push_back((*installs)[i]->GetNamespace());
        }
      }
    }

  return namespaces;
}

512 513 514
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
515 516 517
::ComplainAboutMissingTarget(cmTarget* depender,
                             cmTarget* dependee,
                             int occurrences)
518 519
{
  cmOStringStream e;
520
  e << "install(EXPORT \""
521 522
    << this->IEGen->GetExportSet()->GetName()
    << "\" ...) "
523
    << "includes target \"" << depender->GetName()
524 525 526 527 528 529 530 531 532 533
    << "\" which requires target \"" << dependee->GetName() << "\" ";
  if (occurrences == 0)
    {
    e << "that is not in the export set.";
    }
  else
    {
    e << "that is not in this export set, but " << occurrences
    << " times in others.";
    }
534
  cmSystemTools::Error(e.str().c_str());
535
}
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551

std::string
cmExportInstallFileGenerator::InstallNameDir(cmTarget* target,
                                             const std::string&)
{
  std::string install_name_dir;

  cmMakefile* mf = target->GetMakefile();
  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
    {
    install_name_dir =
      target->GetInstallNameDirForInstallTree();
    }

  return install_name_dir;
}