cmExportInstallFileGenerator.cxx 18.6 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
#include "cmAlgorithms.h"
23 24 25 26

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

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

40 41 42
//----------------------------------------------------------------------------
bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
{
43
  std::vector<cmTargetExport*> allTargets;
44 45 46 47 48 49 50
  {
  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)
    {
51 52
    expectedTargets +=
        sep + this->Namespace + (*tei)->Target->Target->GetExportName();
53
    sep = " ";
54
    cmTargetExport * te = *tei;
55
    if(this->ExportedTargets.insert(te->Target->Target).second)
56
      {
57
      allTargets.push_back(te);
58 59 60
      }
    else
      {
61
      std::ostringstream e;
62
      e << "install(EXPORT \""
63 64
        << this->IEGen->GetExportSet()->GetName()
        << "\" ...) " << "includes target \"" << te->Target->GetName()
65 66 67 68
        << "\" more than once in the export set.";
      cmSystemTools::Error(e.str().c_str());
      return false;
      }
69 70
    }

71 72 73
  this->GenerateExpectedTargetsCode(os, expectedTargets);
  }

74 75
  // Set an _IMPORT_PREFIX variable for import location properties
  // to reference if they are relative to the install prefix.
76 77
  std::string installPrefix = this->IEGen->GetLocalGenerator()
      ->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
78 79
  std::string const& expDest = this->IEGen->GetDestination();
  if(cmSystemTools::FileIsFullPath(expDest))
80
    {
81 82 83 84 85 86 87 88 89 90 91
    // 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.
92
    std::string absDest = installPrefix + "/" + expDest;
93 94 95 96
    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";
97 98 99 100
    if(cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/"))
101
      {
102 103 104 105 106 107 108 109 110 111 112
      // 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";
113
      }
114
    std::string dest = expDest;
115
    while(!dest.empty())
116
      {
117 118 119
      os <<
        "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" PATH)\n";
      dest = cmSystemTools::GetFilenamePath(dest);
120
      }
121
    os << "\n";
122 123
    }

124 125
  std::vector<std::string> missingTargets;

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

    requiresConfigFiles = requiresConfigFiles
139
                              || te->GetType() != cmState::INTERFACE_LIBRARY;
140

141
    this->GenerateImportTargetCode(os, te);
142 143 144

    ImportPropertyMap properties;

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

    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;
        }
      }
185
    if (te->GetType() == cmState::INTERFACE_LIBRARY)
186
      {
187
      require3_0_0 = true;
188
      }
189 190 191 192 193 194 195
    if(te->GetProperty("INTERFACE_SOURCES"))
      {
      // We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1
      // can consume them.
      require3_1_0 = true;
      }

196 197
    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
                                  te, properties);
198

199
    this->PopulateCompatibleInterfaceProperties(gt, properties);
200

201
    this->GenerateInterfaceProperties(gt->Target, os, properties);
202 203
    }

204 205 206 207 208
  if (require3_1_0)
    {
    this->GenerateRequiredCMakeVersion(os, "3.1.0");
    }
  else if (require3_0_0)
209
    {
Brad King's avatar
Brad King committed
210
    this->GenerateRequiredCMakeVersion(os, "3.0.0");
211 212
    }
  else if (require2_8_12)
213
    {
Brad King's avatar
Brad King committed
214
    this->GenerateRequiredCMakeVersion(os, "2.8.12");
215
    }
216

217 218
  // Now load per-configuration properties for them.
  os << "# Load information for each installed configuration.\n"
219 220
     << "get_filename_component(_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n"
     << "file(GLOB CONFIG_FILES \"${_DIR}/"
221
     << this->GetConfigImportFileGlob() << "\")\n"
222 223 224
     << "foreach(f ${CONFIG_FILES})\n"
     << "  include(${f})\n"
     << "endforeach()\n"
225 226
     << "\n";

227
  // Cleanup the import prefix variable.
228 229 230
  os << "# Cleanup temporary variables.\n"
     << "set(_IMPORT_PREFIX)\n"
     << "\n";
231 232
  this->GenerateImportedFileCheckLoop(os);

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

  this->GenerateMissingTargetsCheckCode(os, missingTargets);

251 252 253
  return result;
}

Stephen Kelly's avatar
Stephen Kelly committed
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
//----------------------------------------------------------------------------
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;
    }
}

269 270
//----------------------------------------------------------------------------
bool
271 272
cmExportInstallFileGenerator::GenerateImportFileConfig(
                                    const std::string& config,
273
                                    std::vector<std::string> &missingTargets)
274 275
{
  // Skip configurations not enabled for this export.
276
  if(!this->IEGen->InstallsForConfig(config))
277 278 279 280 281 282 283 284 285
    {
    return true;
    }

  // Construct the name of the file to generate.
  std::string fileName = this->FileDir;
  fileName += "/";
  fileName += this->FileBase;
  fileName += "-";
286
  if(!config.empty())
287 288 289 290 291 292 293 294 295 296 297 298 299 300
    {
    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();
301
    std::ostringstream e;
302
    e << "cannot write to file \"" << fileName
303 304 305 306 307 308 309 310 311 312
      << "\": " << 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.
313
  this->GenerateImportConfig(os, config, missingTargets);
314 315 316 317 318 319 320 321 322 323 324 325 326 327

  // 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,
328 329
                              const std::string& config,
                              std::string const& suffix,
330
                              std::vector<std::string> &missingTargets)
331 332
{
  // Add each target in the set to the export.
333
  for(std::vector<cmTargetExport*>::const_iterator
334 335
        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
336 337
    {
    // Collect import properties for this target.
338
    cmTargetExport const* te = *tei;
339
    if (te->Target->GetType() == cmState::INTERFACE_LIBRARY)
340 341 342
      {
      continue;
      }
343 344 345 346

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

347 348 349 350
    this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
                                    properties, importedLocations);
351
    this->SetImportLocationProperty(config, suffix,
352 353 354 355 356 357
                                    te->RuntimeGenerator, properties,
                                    importedLocations);
    this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
                                    properties, importedLocations);
358 359 360 361 362 363

    // 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.
364
      cmGeneratorTarget *gtgt = te->Target;
365
      this->SetImportDetailProperties(config, suffix,
366
                                      gtgt, properties, missingTargets);
367

368 369
      this->SetImportLinkInterface(config, suffix,
                                   cmGeneratorExpression::InstallInterface,
370
                                   gtgt, properties, missingTargets);
371

372
      // TOOD: PUBLIC_HEADER_LOCATION
373 374
      // This should wait until the build feature propagation stuff
      // is done.  Then this can be a propagated include directory.
375 376 377 378
      // this->GenerateImportProperty(config, te->HeaderGenerator,
      //                              properties);

      // Generate code in the export file.
379 380
      this->GenerateImportPropertyCode(os, config, gtgt->Target, properties);
      this->GenerateImportedFileChecksCode(os, gtgt->Target, properties,
381
                                           importedLocations);
382 383 384 385 386 387 388
      }
    }
}

//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
389 390
::SetImportLocationProperty(const std::string& config,
                            std::string const& suffix,
391
                            cmInstallTargetGenerator* itgen,
392 393 394
                            ImportPropertyMap& properties,
                            std::set<std::string>& importedLocations
                           )
395 396 397 398 399 400 401
{
  // Skip rules that do not match this configuration.
  if(!(itgen && itgen->InstallsForConfig(config)))
    {
    return;
    }

402
  // Get the target to be installed.
403
  cmTarget* target = itgen->GetTarget()->Target;
404 405

  // Construct the installed location of the target.
406
  std::string dest = itgen->GetDestination(config);
407 408 409 410
  std::string value;
  if(!cmSystemTools::FileIsFullPath(dest.c_str()))
    {
    // The target is installed relative to the installation prefix.
411
    value = "${_IMPORT_PREFIX}/";
412 413 414 415
    }
  value += dest;
  value += "/";

416
  if(itgen->IsImportLibrary())
417
    {
418 419 420 421 422 423 424 425 426 427
    // 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;
428
    importedLocations.insert(prop);
429
    }
430
  else
431
    {
432 433 434
    // Construct the property name.
    std::string prop = "IMPORTED_LOCATION";
    prop += suffix;
435

436
    // Append the installed file name.
437
    if(target->IsAppBundleOnApple())
438 439 440 441 442 443 444 445 446 447 448 449 450
      {
      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;
451
    importedLocations.insert(prop);
452
    }
453 454
}

455 456 457 458 459 460
//----------------------------------------------------------------------------
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
461
  const std::string name = dependee->GetName();
462 463 464 465 466
  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
467 468

    missingTarget += dependee->GetExportName();
469 470 471 472 473
    link_libs += missingTarget;
    missingTargets.push_back(missingTarget);
    }
  else
    {
474 475
    // All exported targets should be known here and should be unique.
    // This is probably user-error.
476 477 478 479 480 481 482 483 484 485
    this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
    }
}

//----------------------------------------------------------------------------
std::vector<std::string>
cmExportInstallFileGenerator
::FindNamespaces(cmMakefile* mf, const std::string& name)
{
  std::vector<std::string> namespaces;
486
  cmGlobalGenerator* gg = mf->GetGlobalGenerator();
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 512 513 514 515 516 517 518 519 520
  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;
}

521 522 523
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
524 525 526
::ComplainAboutMissingTarget(cmTarget* depender,
                             cmTarget* dependee,
                             int occurrences)
527
{
528
  std::ostringstream e;
529
  e << "install(EXPORT \""
530 531
    << this->IEGen->GetExportSet()->GetName()
    << "\" ...) "
532
    << "includes target \"" << depender->GetName()
533 534 535 536 537 538 539 540 541 542
    << "\" 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.";
    }
543
  cmSystemTools::Error(e.str().c_str());
544
}
545 546

std::string
547
cmExportInstallFileGenerator::InstallNameDir(cmGeneratorTarget* target,
548 549 550 551
                                             const std::string&)
{
  std::string install_name_dir;

552
  cmMakefile* mf = target->Target->GetMakefile();
553 554 555 556 557 558 559 560
  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
    {
    install_name_dir =
      target->GetInstallNameDirForInstallTree();
    }

  return install_name_dir;
}