cmExportInstallFileGenerator.cxx 16.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<cmTarget*> allTargets;
43
44
45
46
47
48
49
50
51
  {
  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)
    {
    expectedTargets += sep + this->Namespace + (*tei)->Target->GetName();
    sep = " ";
52
    cmTargetExport const* te = *tei;
53
54
    if(this->ExportedTargets.insert(te->Target).second)
      {
55
      allTargets.push_back(te->Target);
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
84
85
86
87
    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";
    if(strncmp(absDestS.c_str(), "/lib/", 5) == 0 ||
       strncmp(absDestS.c_str(), "/lib64/", 7) == 0 ||
       strncmp(absDestS.c_str(), "/usr/lib/", 9) == 0 ||
       strncmp(absDestS.c_str(), "/usr/lib64/", 11) == 0)
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
117
118
119
120
121
122
  // Create all the imported targets.
  for(std::vector<cmTarget*>::const_iterator
        tei = allTargets.begin();
      tei != allTargets.end(); ++tei)
    {
    cmTarget* te = *tei;
    this->GenerateImportTargetCode(os, te);
123
124
125

    ImportPropertyMap properties;

126
    this->PopulateIncludeDirectoriesInterface(te,
127
128
129
130
131
132
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
                                  te,
                                  cmGeneratorExpression::InstallInterface,
                                  properties, missingTargets);
133
134
    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
                                  te, properties);
135
    this->PopulateCompatibleInterfaceProperties(te, properties);
136
137

    this->GenerateInterfaceProperties(te, os, properties);
138
139
    }

140

141
142
  // Now load per-configuration properties for them.
  os << "# Load information for each installed configuration.\n"
143
144
     << "get_filename_component(_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n"
     << "file(GLOB CONFIG_FILES \"${_DIR}/"
145
     << this->GetConfigImportFileGlob() << "\")\n"
146
147
148
     << "foreach(f ${CONFIG_FILES})\n"
     << "  include(${f})\n"
     << "endforeach()\n"
149
150
     << "\n";

151
152
153
154
155
156
157
  // Cleanup the import prefix variable.
  if(!this->ImportPrefix.empty())
    {
    os << "# Cleanup temporary variables.\n"
       << "set(_IMPORT_PREFIX)\n"
       << "\n";
    }
158
159
  this->GenerateImportedFileCheckLoop(os);

160
161
162
163
164
165
  // Generate an import file for each configuration.
  bool result = true;
  for(std::vector<std::string>::const_iterator
        ci = this->Configurations.begin();
      ci != this->Configurations.end(); ++ci)
    {
166
    if(!this->GenerateImportFileConfig(ci->c_str(), missingTargets))
167
168
169
170
      {
      result = false;
      }
    }
171
172
173

  this->GenerateMissingTargetsCheckCode(os, missingTargets);

174
175
176
  return result;
}

Stephen Kelly's avatar
Stephen Kelly committed
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
//----------------------------------------------------------------------------
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;
    }
}

192
193
//----------------------------------------------------------------------------
bool
194
195
cmExportInstallFileGenerator::GenerateImportFileConfig(const char* config,
                                    std::vector<std::string> &missingTargets)
196
197
{
  // Skip configurations not enabled for this export.
198
  if(!this->IEGen->InstallsForConfig(config))
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
    {
    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.
235
  this->GenerateImportConfig(os, config, missingTargets);
236
237
238
239
240
241
242
243
244
245
246
247
248
249

  // 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,
250
251
                              const char* config, std::string const& suffix,
                              std::vector<std::string> &missingTargets)
252
253
{
  // Add each target in the set to the export.
254
  for(std::vector<cmTargetExport*>::const_iterator
255
256
        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
257
258
    {
    // Collect import properties for this target.
259
    cmTargetExport const* te = *tei;
260
    ImportPropertyMap properties;
261
262
263
264
265
    std::set<std::string> importedLocations;
    this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
                                    properties, importedLocations);
266
    this->SetImportLocationProperty(config, suffix,
267
268
269
270
271
272
                                    te->RuntimeGenerator, properties,
                                    importedLocations);
    this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
                                    properties, importedLocations);
    this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
                                    properties, importedLocations);
273
274
275
276
277
278
279

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

282
283
284
285
      this->SetImportLinkInterface(config, suffix,
                                   cmGeneratorExpression::InstallInterface,
                                   te->Target, properties, missingTargets);

286
      // TOOD: PUBLIC_HEADER_LOCATION
287
288
      // This should wait until the build feature propagation stuff
      // is done.  Then this can be a propagated include directory.
289
290
291
292
293
      // this->GenerateImportProperty(config, te->HeaderGenerator,
      //                              properties);

      // Generate code in the export file.
      this->GenerateImportPropertyCode(os, config, te->Target, properties);
294
295
      this->GenerateImportedFileChecksCode(os, te->Target, properties,
                                           importedLocations);
296
297
298
299
300
301
302
303
304
      }
    }
}

//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::SetImportLocationProperty(const char* config, std::string const& suffix,
                            cmInstallTargetGenerator* itgen,
305
306
307
                            ImportPropertyMap& properties,
                            std::set<std::string>& importedLocations
                           )
308
309
310
311
312
313
314
{
  // Skip rules that do not match this configuration.
  if(!(itgen && itgen->InstallsForConfig(config)))
    {
    return;
    }

315
316
  // Get the target to be installed.
  cmTarget* target = itgen->GetTarget();
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332

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

333
  if(itgen->IsImportLibrary())
334
    {
335
336
337
338
339
340
341
342
343
344
    // 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;
345
    importedLocations.insert(prop);
346
    }
347
  else
348
    {
349
350
351
    // Construct the property name.
    std::string prop = "IMPORTED_LOCATION";
    prop += suffix;
352

353
354
355
356
357
358
359
    // Append the installed file name.
    if(target->IsFrameworkOnApple())
      {
      value += itgen->GetInstallFilename(target, config);
      value += ".framework/";
      value += itgen->GetInstallFilename(target, config);
      }
360
361
362
363
364
365
366
367
368
369
370
371
372
373
    else if(target->IsCFBundleOnApple())
      {
      const char *ext = target->GetProperty("BUNDLE_EXTENSION");
      if (!ext)
        {
        ext = "bundle";
        }

      value += itgen->GetInstallFilename(target, config);
      value += ".";
      value += ext;
      value += "/";
      value += itgen->GetInstallFilename(target, config);
      }
374
375
376
377
378
379
380
381
382
383
384
385
386
387
    else if(target->IsAppBundleOnApple())
      {
      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;
388
    importedLocations.insert(prop);
389
    }
390
391
}

392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator::HandleMissingTarget(
  std::string& link_libs, std::vector<std::string>& missingTargets,
  cmMakefile* mf, cmTarget* depender, cmTarget* dependee)
{
  std::string name = dependee->GetName();
  std::vector<std::string> namespaces = this->FindNamespaces(mf, name);
  int targetOccurrences = (int)namespaces.size();
  if (targetOccurrences == 1)
    {
    std::string missingTarget = namespaces[0];
    missingTarget += name;
    link_libs += missingTarget;
    missingTargets.push_back(missingTarget);
    }
  else
    {
    // We are not appending, so all exported targets should be
    // known here.  This is probably user-error.
    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;
}


458
459
460
461
462
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::ComplainAboutImportPrefix(cmInstallTargetGenerator* itgen)
{
463
  const char* installDest = this->IEGen->GetDestination();
464
  cmOStringStream e;
465
  e << "install(EXPORT \""
466
467
    << this->IEGen->GetExportSet()->GetName()
    << "\") given absolute "
468
469
470
471
472
473
474
475
476
477
    << "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
478
479
480
::ComplainAboutMissingTarget(cmTarget* depender,
                             cmTarget* dependee,
                             int occurrences)
481
482
{
  cmOStringStream e;
483
  e << "install(EXPORT \""
484
485
    << this->IEGen->GetExportSet()->GetName()
    << "\" ...) "
486
    << "includes target \"" << depender->GetName()
487
488
489
490
491
492
493
494
495
496
    << "\" 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.";
    }
497
  cmSystemTools::Error(e.str().c_str());
498
}