cmExportInstallFileGenerator.cxx 18.1 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
179
180
181
    {
    this->GenerateRequiredCMakeVersion(os, "2.8.12.20131007");
    }
  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 char* config,
                                    std::vector<std::string> &missingTargets)
245
246
{
  // Skip configurations not enabled for this export.
247
  if(!this->IEGen->InstallsForConfig(config))
248
249
250
251
252
253
254
255
256
257
258
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
    {
    return true;
    }

  // Construct the name of the file to generate.
  std::string fileName = this->FileDir;
  fileName += "/";
  fileName += this->FileBase;
  fileName += "-";
  if(config && *config)
    {
    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.
284
  this->GenerateImportConfig(os, config, missingTargets);
285
286
287
288
289
290
291
292
293
294
295
296
297
298

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

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

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

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

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

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

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

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

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

  // 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 += "/";

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

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

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

    missingTarget += dependee->GetExportName();
441
442
443
444
445
    link_libs += missingTarget;
    missingTargets.push_back(missingTarget);
    }
  else
    {
446
447
    // All exported targets should be known here and should be unique.
    // This is probably user-error.
448
449
450
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
    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;
}


494
495
496
497
498
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::ComplainAboutImportPrefix(cmInstallTargetGenerator* itgen)
{
499
  const char* installDest = this->IEGen->GetDestination();
500
  cmOStringStream e;
501
  e << "install(EXPORT \""
502
503
    << this->IEGen->GetExportSet()->GetName()
    << "\") given absolute "
504
505
506
507
508
509
510
511
512
513
    << "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
514
515
516
::ComplainAboutMissingTarget(cmTarget* depender,
                             cmTarget* dependee,
                             int occurrences)
517
518
{
  cmOStringStream e;
519
  e << "install(EXPORT \""
520
521
    << this->IEGen->GetExportSet()->GetName()
    << "\" ...) "
522
    << "includes target \"" << depender->GetName()
523
524
525
526
527
528
529
530
531
532
    << "\" 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.";
    }
533
  cmSystemTools::Error(e.str().c_str());
534
}
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550

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