cmTargetLinkLibrariesCommand.cxx 16.9 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 "cmTargetLinkLibrariesCommand.h"

14
15
#include "cmGeneratorExpression.h"

16
17
18
19
20
21
22
const char* cmTargetLinkLibrariesCommand::LinkLibraryTypeNames[3] =
{
  "general",
  "debug",
  "optimized"
};

23
// cmTargetLinkLibrariesCommand
24
25
bool cmTargetLinkLibrariesCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
26
{
Ken Martin's avatar
Ken Martin committed
27
  // must have one argument
28
  if(args.size() < 1)
29
30
31
32
    {
    this->SetError("called with incorrect number of arguments");
    return false;
    }
33

34
  if (this->Makefile->IsAlias(args[0]))
35
36
37
38
    {
    this->SetError("can not be used on an ALIAS target.");
    return false;
    }
39
40
41
  // Lookup the target for which libraries are specified.
  this->Target =
    this->Makefile->GetCMakeInstance()
Stephen Kelly's avatar
Stephen Kelly committed
42
    ->GetGlobalGenerator()->FindTarget(args[0]);
43
44
  if(!this->Target)
    {
45
    cmake::MessageType t = cmake::FATAL_ERROR;  // fail by default
46
    std::ostringstream e;
47
48
    e << "Cannot specify link libraries for target \"" << args[0] << "\" "
      << "which is not built by this project.";
49
50
    // The bad target is the only argument. Check how policy CMP0016 is set,
    // and accept, warn or fail respectively:
51
52
    if (args.size() < 2)
      {
53
54
55
56
57
58
59
60
      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0016))
        {
        case cmPolicies::WARN:
          t = cmake::AUTHOR_WARNING;
          // Print the warning.
          e << "\n"
            << "CMake does not support this but it used to work accidentally "
            << "and is being allowed for compatibility."
Stephen Kelly's avatar
Stephen Kelly committed
61
            << "\n" << cmPolicies::GetPolicyWarning(cmPolicies::CMP0016);
62
63
64
65
66
67
           break;
        case cmPolicies::OLD:          // OLD behavior does not warn.
          t = cmake::MESSAGE;
          break;
        case cmPolicies::REQUIRED_IF_USED:
        case cmPolicies::REQUIRED_ALWAYS:
Stephen Kelly's avatar
Stephen Kelly committed
68
          e << "\n" << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0016);
69
70
71
72
          break;
        case cmPolicies::NEW:  // NEW behavior prints the error.
          break;
        }
73
      }
74
75
76

    // now actually print the message
    switch(t)
77
      {
78
79
80
81
82
83
84
85
86
      case cmake::AUTHOR_WARNING:
        this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
        break;
      case cmake::FATAL_ERROR:
        this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
        cmSystemTools::SetFatalErrorOccured();
        break;
      default:
        break;
87
      }
88
89
90
    return true;
    }

Brad King's avatar
Brad King committed
91
92
  if(this->Target->GetType() == cmTarget::OBJECT_LIBRARY)
    {
93
    std::ostringstream e;
Brad King's avatar
Brad King committed
94
95
96
97
98
99
100
    e << "Object library target \"" << args[0] << "\" "
      << "may not link to anything.";
    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
    cmSystemTools::SetFatalErrorOccured();
    return true;
    }

101
102
  if (this->Target->GetType() == cmTarget::UTILITY)
    {
103
    std::ostringstream e;
104
105
106
107
108
    const char *modal = 0;
    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0039))
      {
      case cmPolicies::WARN:
Stephen Kelly's avatar
Stephen Kelly committed
109
        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0039) << "\n";
110
111
112
113
114
115
116
117
118
119
120
        modal = "should";
      case cmPolicies::OLD:
        break;
      case cmPolicies::REQUIRED_ALWAYS:
      case cmPolicies::REQUIRED_IF_USED:
      case cmPolicies::NEW:
        modal = "must";
        messageType = cmake::FATAL_ERROR;
      }
    if (modal)
      {
121
      e <<
122
123
        "Utility target \"" << this->Target->GetName() << "\" " << modal
        << " not be used as the target of a target_link_libraries call.";
Stephen Kelly's avatar
Stephen Kelly committed
124
      this->Makefile->IssueMessage(messageType, e.str());
125
126
127
128
129
130
131
      if(messageType == cmake::FATAL_ERROR)
        {
        return false;
        }
      }
    }

132
133
134
135
136
137
  // but we might not have any libs after variable expansion
  if(args.size() < 2)
    {
    return true;
    }

138
139
140
141
  // Keep track of link configuration specifiers.
  cmTarget::LinkLibraryType llt = cmTarget::GENERAL;
  bool haveLLT = false;

142
  // Start with primary linking and switch to link interface
143
144
  // specification if the keyword is encountered as the first argument.
  this->CurrentProcessingState = ProcessingLinkLibraries;
145

Stephen Kelly's avatar
Stephen Kelly committed
146
147
  // add libraries, note that there is an optional prefix
  // of debug and optimized that can be used
148
  for(unsigned int i=1; i < args.size(); ++i)
149
    {
150
    if(args[i] == "LINK_INTERFACE_LIBRARIES")
151
      {
152
      this->CurrentProcessingState = ProcessingPlainLinkInterface;
153
154
155
156
157
158
159
160
161
      if(i != 1)
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The LINK_INTERFACE_LIBRARIES option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
162
      }
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
    else if(args[i] == "INTERFACE")
      {
      if(i != 1
          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The INTERFACE option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
      this->CurrentProcessingState = ProcessingKeywordLinkInterface;
      }
179
180
    else if(args[i] == "LINK_PUBLIC")
      {
181
      if(i != 1
182
183
          && this->CurrentProcessingState != ProcessingPlainPrivateInterface
          && this->CurrentProcessingState != ProcessingPlainPublicInterface)
184
185
186
187
188
189
190
191
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The LINK_PUBLIC or LINK_PRIVATE option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
      this->CurrentProcessingState = ProcessingPlainPublicInterface;
      }
    else if(args[i] == "PUBLIC")
      {
      if(i != 1
          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The PUBLIC or PRIVATE option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
      this->CurrentProcessingState = ProcessingKeywordPublicInterface;
209
210
211
      }
    else if(args[i] == "LINK_PRIVATE")
      {
212
      if(i != 1
213
214
          && this->CurrentProcessingState != ProcessingPlainPublicInterface
          && this->CurrentProcessingState != ProcessingPlainPrivateInterface)
215
216
217
218
219
220
221
222
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The LINK_PUBLIC or LINK_PRIVATE option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
      this->CurrentProcessingState = ProcessingPlainPrivateInterface;
      }
    else if(args[i] == "PRIVATE")
      {
      if(i != 1
          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
        {
        this->Makefile->IssueMessage(
          cmake::FATAL_ERROR,
          "The PUBLIC or PRIVATE option must appear as the second "
          "argument, just after the target name."
          );
        return true;
        }
      this->CurrentProcessingState = ProcessingKeywordPrivateInterface;
240
      }
241
    else if(args[i] == "debug")
242
      {
243
      if(haveLLT)
244
        {
245
        this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::DEBUG);
246
        }
247
248
      llt = cmTarget::DEBUG;
      haveLLT = true;
249
      }
250
    else if(args[i] == "optimized")
251
      {
252
      if(haveLLT)
253
        {
254
        this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::OPTIMIZED);
255
        }
256
257
      llt = cmTarget::OPTIMIZED;
      haveLLT = true;
258
      }
259
    else if(args[i] == "general")
260
      {
261
      if(haveLLT)
262
        {
263
        this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::GENERAL);
264
        }
265
266
267
268
269
270
271
      llt = cmTarget::GENERAL;
      haveLLT = true;
      }
    else if(haveLLT)
      {
      // The link type was specified by the previous argument.
      haveLLT = false;
272
      if (!this->HandleLibrary(args[i], llt))
273
274
275
        {
        return false;
        }
276
277
278
      }
    else
      {
279
      // Lookup old-style cache entry if type is unspecified.  So if you
280
281
282
283
284
      // do a target_link_libraries(foo optimized bar) it will stay optimized
      // and not use the lookup.  As there maybe the case where someone has
      // specifed that a library is both debug and optimized.  (this check is
      // only there for backwards compatibility when mixing projects built
      // with old versions of CMake and new)
285
      llt = cmTarget::GENERAL;
286
287
      std::string linkType = args[0];
      linkType += "_LINK_TYPE";
288
      const char* linkTypeString =
Stephen Kelly's avatar
Stephen Kelly committed
289
        this->Makefile->GetDefinition( linkType );
290
291
292
293
294
295
296
297
298
299
300
      if(linkTypeString)
        {
        if(strcmp(linkTypeString, "debug") == 0)
          {
          llt = cmTarget::DEBUG;
          }
        if(strcmp(linkTypeString, "optimized") == 0)
          {
          llt = cmTarget::OPTIMIZED;
          }
        }
301
      if (!this->HandleLibrary(args[i], llt))
302
303
304
        {
        return false;
        }
305
      }
306
    }
307
308
309
310

  // Make sure the last argument was not a library type specifier.
  if(haveLLT)
    {
311
    std::ostringstream e;
312
313
314
315
316
317
    e << "The \"" << this->LinkLibraryTypeNames[llt]
      << "\" argument must be followed by a library.";
    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
    cmSystemTools::SetFatalErrorOccured();
    }

318
319
320
  const cmPolicies::PolicyStatus policy22Status
                      = this->Target->GetPolicyStatusCMP0022();

321
322
323
324
325
  // If any of the LINK_ options were given, make sure the
  // LINK_INTERFACE_LIBRARIES target property exists.
  // Use of any of the new keywords implies awareness of
  // this property. And if no libraries are named, it should
  // result in an empty link interface.
326
327
328
  if((policy22Status == cmPolicies::OLD ||
      policy22Status == cmPolicies::WARN) &&
      this->CurrentProcessingState != ProcessingLinkLibraries &&
329
     !this->Target->GetProperty("LINK_INTERFACE_LIBRARIES"))
330
331
332
333
    {
    this->Target->SetProperty("LINK_INTERFACE_LIBRARIES", "");
    }

334
335
  return true;
}
336
337
338
339
340
341

//----------------------------------------------------------------------------
void
cmTargetLinkLibrariesCommand
::LinkLibraryTypeSpecifierWarning(int left, int right)
{
342
  std::ostringstream w;
343
344
345
346
347
348
  w << "Link library type specifier \""
    << this->LinkLibraryTypeNames[left] << "\" is followed by specifier \""
    << this->LinkLibraryTypeNames[right] << "\" instead of a library name.  "
    << "The first specifier will be ignored.";
  this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
349
350

//----------------------------------------------------------------------------
351
bool
352
cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
353
354
                                            cmTarget::LinkLibraryType llt)
{
355
356
357
358
359
360
361
362
363
  if(this->Target->GetType() == cmTarget::INTERFACE_LIBRARY
      && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
    {
    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
      "INTERFACE library can only be used with the INTERFACE keyword of "
      "target_link_libraries");
    return false;
    }

364
365
366
367
368
369
370
  cmTarget::TLLSignature sig =
        (this->CurrentProcessingState == ProcessingPlainPrivateInterface
      || this->CurrentProcessingState == ProcessingPlainPublicInterface
      || this->CurrentProcessingState == ProcessingKeywordPrivateInterface
      || this->CurrentProcessingState == ProcessingKeywordPublicInterface
      || this->CurrentProcessingState == ProcessingKeywordLinkInterface)
        ? cmTarget::KeywordTLLSignature : cmTarget::PlainTLLSignature;
371
372
  if (!this->Target->PushTLLCommandTrace(
        sig, this->Makefile->GetExecutionContext()))
373
    {
374
    std::ostringstream e;
375
376
377
378
379
    const char *modal = 0;
    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0023))
      {
      case cmPolicies::WARN:
Stephen Kelly's avatar
Stephen Kelly committed
380
        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0023) << "\n";
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
        modal = "should";
      case cmPolicies::OLD:
        break;
      case cmPolicies::REQUIRED_ALWAYS:
      case cmPolicies::REQUIRED_IF_USED:
      case cmPolicies::NEW:
        modal = "must";
        messageType = cmake::FATAL_ERROR;
      }

      if(modal)
        {
        // If the sig is a keyword form and there is a conflict, the existing
        // form must be the plain form.
        const char *existingSig
                    = (sig == cmTarget::KeywordTLLSignature ? "plain"
                                                            : "keyword");
398
          e <<
399
400
401
402
403
404
405
406
407
            "The " << existingSig << " signature for target_link_libraries "
            "has already been used with the target \""
          << this->Target->GetName() << "\".  All uses of "
             "target_link_libraries with a target " << modal << " be either "
             "all-keyword or all-plain.\n";
        this->Target->GetTllSignatureTraces(e,
                                          sig == cmTarget::KeywordTLLSignature
                                            ? cmTarget::PlainTLLSignature
                                            : cmTarget::KeywordTLLSignature);
Stephen Kelly's avatar
Stephen Kelly committed
408
        this->Makefile->IssueMessage(messageType, e.str());
409
410
411
412
413
414
415
        if(messageType == cmake::FATAL_ERROR)
          {
          return false;
          }
        }
    }

416
417
  // Handle normal case first.
  if(this->CurrentProcessingState != ProcessingKeywordLinkInterface
418
      && this->CurrentProcessingState != ProcessingPlainLinkInterface)
419
420
421
    {
    this->Makefile
      ->AddLinkLibraryForTarget(this->Target->GetName(), lib, llt);
422
423
424
425
426
427
428
429
    if(this->CurrentProcessingState == ProcessingLinkLibraries)
      {
      this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
        this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
      return true;
      }
    else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface
            && this->CurrentProcessingState != ProcessingPlainPublicInterface)
430
      {
431
432
      if (this->Target->GetType() == cmTarget::STATIC_LIBRARY)
        {
433
434
435
436
437
438
439
        std::string configLib = this->Target
                                     ->GetDebugGeneratorExpressions(lib, llt);
        if (cmGeneratorExpression::IsValidTargetName(lib)
            || cmGeneratorExpression::Find(lib) != std::string::npos)
          {
          configLib = "$<LINK_ONLY:" + configLib + ">";
          }
440
        this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
441
                                     configLib.c_str());
442
        }
443
444
445
      // Not a 'public' or 'interface' library. Do not add to interface
      // property.
      return true;
446
      }
447
448
    }

449
450
451
452
453
454
455
456
457
  this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
              this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());

  const cmPolicies::PolicyStatus policy22Status
                      = this->Target->GetPolicyStatusCMP0022();

  if (policy22Status != cmPolicies::OLD
      && policy22Status != cmPolicies::WARN)
    {
458
    return true;
459
460
    }

461
462
463
464
465
  if (this->Target->GetType() == cmTarget::INTERFACE_LIBRARY)
    {
    return true;
    }

466
  // Get the list of configurations considered to be DEBUG.
467
  std::vector<std::string> debugConfigs =
468
469
470
    this->Makefile->GetCMakeInstance()->GetDebugConfigs();
  std::string prop;

471
  // Include this library in the link interface for the target.
472
  if(llt == cmTarget::DEBUG || llt == cmTarget::GENERAL)
473
    {
474
475
476
477
478
479
    // Put in the DEBUG configuration interfaces.
    for(std::vector<std::string>::const_iterator i = debugConfigs.begin();
        i != debugConfigs.end(); ++i)
      {
      prop = "LINK_INTERFACE_LIBRARIES_";
      prop += *i;
Stephen Kelly's avatar
Stephen Kelly committed
480
      this->Target->AppendProperty(prop, lib.c_str());
481
      }
482
    }
483
  if(llt == cmTarget::OPTIMIZED || llt == cmTarget::GENERAL)
484
    {
485
    // Put in the non-DEBUG configuration interfaces.
486
    this->Target->AppendProperty("LINK_INTERFACE_LIBRARIES", lib.c_str());
487

488
489
490
491
    // Make sure the DEBUG configuration interfaces exist so that the
    // general one will not be used as a fall-back.
    for(std::vector<std::string>::const_iterator i = debugConfigs.begin();
        i != debugConfigs.end(); ++i)
492
      {
493
494
      prop = "LINK_INTERFACE_LIBRARIES_";
      prop += *i;
Stephen Kelly's avatar
Stephen Kelly committed
495
      if(!this->Target->GetProperty(prop))
496
        {
Stephen Kelly's avatar
Stephen Kelly committed
497
        this->Target->SetProperty(prop, "");
498
        }
499
500
      }
    }
501
  return true;
502
}