cmExportInstallFileGenerator.cxx 18.2 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 76
  // Add code to compute the installation prefix relative to the
  // import file location.
  const char* installDest = this->IEGen->GetDestination();
  if(!cmSystemTools::FileIsFullPath(installDest))
    {
77 78
    std::string installPrefix =
      this->IEGen->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
79 80 81 82 83
    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";
84 85 86 87
    if(cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/"))
88
      {
89 90 91 92 93 94 95 96 97 98 99
      // 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";
100
      }
101 102
    std::string dest = installDest;
    while(!dest.empty())
103
      {
104 105 106
      os <<
        "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" PATH)\n";
      dest = cmSystemTools::GetFilenamePath(dest);
107
      }
108
    os << "\n";
109 110 111 112 113

    // Import location properties may reference this variable.
    this->ImportPrefix = "${_IMPORT_PREFIX}/";
    }

114 115
  std::vector<std::string> missingTargets;

116
  bool require2_8_12 = false;
117
  bool require3_0_0 = false;
118
  bool requiresConfigFiles = false;
119
  // Create all the imported targets.
120
  for(std::vector<cmTargetExport*>::const_iterator
121 122 123
        tei = allTargets.begin();
      tei != allTargets.end(); ++tei)
    {
124
    cmTarget* te = (*tei)->Target;
125 126 127 128

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

129
    this->GenerateImportTargetCode(os, te);
130 131 132

    ImportPropertyMap properties;

133
    this->PopulateIncludeDirectoriesInterface(*tei,
134 135
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
136 137 138
    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
139 140 141 142 143
                                  properties, missingTargets);
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
144 145 146 147
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
148 149 150 151
    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
152 153 154 155 156 157 158 159 160 161 162 163 164 165

    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;
        }
      }
166 167
    if (te->GetType() == cmTarget::INTERFACE_LIBRARY)
      {
168
      require3_0_0 = true;
169
      }
170 171
    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
                                  te, properties);
172
    this->PopulateCompatibleInterfaceProperties(te, properties);
173 174

    this->GenerateInterfaceProperties(te, os, properties);
175 176
    }

177
  if (require3_0_0)
178
    {
Brad King's avatar
Brad King committed
179
    this->GenerateRequiredCMakeVersion(os, "3.0.0");
180 181
    }
  else if (require2_8_12)
182
    {
Brad King's avatar
Brad King committed
183
    this->GenerateRequiredCMakeVersion(os, "2.8.12");
184
    }
185

186 187
  // Now load per-configuration properties for them.
  os << "# Load information for each installed configuration.\n"
188 189
     << "get_filename_component(_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n"
     << "file(GLOB CONFIG_FILES \"${_DIR}/"
190
     << this->GetConfigImportFileGlob() << "\")\n"
191 192 193
     << "foreach(f ${CONFIG_FILES})\n"
     << "  include(${f})\n"
     << "endforeach()\n"
194 195
     << "\n";

196 197 198 199 200 201 202
  // Cleanup the import prefix variable.
  if(!this->ImportPrefix.empty())
    {
    os << "# Cleanup temporary variables.\n"
       << "set(_IMPORT_PREFIX)\n"
       << "\n";
    }
203 204
  this->GenerateImportedFileCheckLoop(os);

205
  bool result = true;
206 207 208
  // Generate an import file for each configuration.
  // Don't do this if we only export INTERFACE_LIBRARY targets.
  if (requiresConfigFiles)
209
    {
210 211 212
    for(std::vector<std::string>::const_iterator
          ci = this->Configurations.begin();
        ci != this->Configurations.end(); ++ci)
213
      {
214 215 216 217
      if(!this->GenerateImportFileConfig(ci->c_str(), missingTargets))
        {
        result = false;
        }
218 219
      }
    }
220 221 222

  this->GenerateMissingTargetsCheckCode(os, missingTargets);

223 224 225
  return result;
}

Stephen Kelly's avatar
Stephen Kelly committed
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
//----------------------------------------------------------------------------
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;
    }
}

241 242
//----------------------------------------------------------------------------
bool
243 244
cmExportInstallFileGenerator::GenerateImportFileConfig(
                                    const std::string& config,
245
                                    std::vector<std::string> &missingTargets)
246 247
{
  // Skip configurations not enabled for this export.
248
  if(!this->IEGen->InstallsForConfig(config))
249 250 251 252 253 254 255 256 257
    {
    return true;
    }

  // Construct the name of the file to generate.
  std::string fileName = this->FileDir;
  fileName += "/";
  fileName += this->FileBase;
  fileName += "-";
258
  if(!config.empty())
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
    {
    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;
    e << "cannot write to file \"" << fileName.c_str()
      << "\": " << 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.
285
  this->GenerateImportConfig(os, config, missingTargets);
286 287 288 289 290 291 292 293 294 295 296 297 298 299

  // 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,
300 301
                              const std::string& config,
                              std::string const& suffix,
302
                              std::vector<std::string> &missingTargets)
303 304
{
  // Add each target in the set to the export.
305
  for(std::vector<cmTargetExport*>::const_iterator
306 307
        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
308 309
    {
    // Collect import properties for this target.
310
    cmTargetExport const* te = *tei;
311
    if (te->Target->GetType() == cmTarget::INTERFACE_LIBRARY)
312 313 314
      {
      continue;
      }
315 316 317 318

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

319 320 321 322
    this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
                                    properties, importedLocations);
323
    this->SetImportLocationProperty(config, suffix,
324 325 326 327 328 329
                                    te->RuntimeGenerator, properties,
                                    importedLocations);
    this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
                                    properties, importedLocations);
330 331 332 333 334 335 336

    // 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,
337
                                      te->Target, properties, missingTargets);
338

339 340 341 342
      this->SetImportLinkInterface(config, suffix,
                                   cmGeneratorExpression::InstallInterface,
                                   te->Target, properties, missingTargets);

343
      // TOOD: PUBLIC_HEADER_LOCATION
344 345
      // This should wait until the build feature propagation stuff
      // is done.  Then this can be a propagated include directory.
346 347 348 349 350
      // this->GenerateImportProperty(config, te->HeaderGenerator,
      //                              properties);

      // Generate code in the export file.
      this->GenerateImportPropertyCode(os, config, te->Target, properties);
351 352
      this->GenerateImportedFileChecksCode(os, te->Target, properties,
                                           importedLocations);
353 354 355 356 357 358 359
      }
    }
}

//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
360 361
::SetImportLocationProperty(const std::string& config,
                            std::string const& suffix,
362
                            cmInstallTargetGenerator* itgen,
363 364 365
                            ImportPropertyMap& properties,
                            std::set<std::string>& importedLocations
                           )
366 367 368 369 370 371 372
{
  // Skip rules that do not match this configuration.
  if(!(itgen && itgen->InstallsForConfig(config)))
    {
    return;
    }

373 374
  // Get the target to be installed.
  cmTarget* target = itgen->GetTarget();
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390

  // 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.
    if(this->ImportPrefix.empty())
      {
      this->ComplainAboutImportPrefix(itgen);
      }
    value = this->ImportPrefix;
    }
  value += dest;
  value += "/";

391
  if(itgen->IsImportLibrary())
392
    {
393 394 395 396 397 398 399 400 401 402
    // 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;
403
    importedLocations.insert(prop);
404
    }
405
  else
406
    {
407 408 409
    // Construct the property name.
    std::string prop = "IMPORTED_LOCATION";
    prop += suffix;
410

411
    // Append the installed file name.
412
    if(target->IsAppBundleOnApple())
413 414 415 416 417 418 419 420 421 422 423 424 425
      {
      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;
426
    importedLocations.insert(prop);
427
    }
428 429
}

430 431 432 433 434 435
//----------------------------------------------------------------------------
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
436
  const std::string name = dependee->GetName();
437 438 439 440 441
  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
442 443

    missingTarget += dependee->GetExportName();
444 445 446 447 448
    link_libs += missingTarget;
    missingTargets.push_back(missingTarget);
    }
  else
    {
449 450
    // All exported targets should be known here and should be unique.
    // This is probably user-error.
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 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
    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;
}


497 498 499 500 501
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::ComplainAboutImportPrefix(cmInstallTargetGenerator* itgen)
{
502
  const char* installDest = this->IEGen->GetDestination();
503
  cmOStringStream e;
504
  e << "install(EXPORT \""
505 506
    << this->IEGen->GetExportSet()->GetName()
    << "\") given absolute "
507 508 509 510 511 512 513 514 515 516
    << "DESTINATION \"" << installDest << "\" but the export "
    << "references an installation of target \""
    << itgen->GetTarget()->GetName() << "\" which has relative "
    << "DESTINATION \"" << itgen->GetDestination() << "\".";
  cmSystemTools::Error(e.str().c_str());
}

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

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;
}