cmExportBuildFileGenerator.cxx 7.08 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 "cmExportBuildFileGenerator.h"

14
15
16
17
18
19
20
21
#include "cmExportCommand.h"

//----------------------------------------------------------------------------
cmExportBuildFileGenerator::cmExportBuildFileGenerator()
{
  this->ExportCommand = 0;
}

22
23
24
//----------------------------------------------------------------------------
bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
{
25
  std::vector<cmTarget*> allTargets;
26
27
28
29
30
31
32
33
34
  {
  std::string expectedTargets;
  std::string sep;
  for(std::vector<cmTarget*>::const_iterator
        tei = this->Exports->begin();
      tei != this->Exports->end(); ++tei)
    {
    expectedTargets += sep + this->Namespace + (*tei)->GetName();
    sep = " ";
35
    cmTarget* te = *tei;
36
37
    if(this->ExportedTargets.insert(te).second)
      {
38
      allTargets.push_back(te);
39
40
41
42
43
44
45
46
47
48
49
      }
    else
      {
      if(this->ExportCommand && this->ExportCommand->ErrorMessage.empty())
        {
        cmOStringStream e;
        e << "given target \"" << te->GetName() << "\" more than once.";
        this->ExportCommand->ErrorMessage = e.str();
        }
      return false;
      }
50
51
    }

52
53
54
  this->GenerateExpectedTargetsCode(os, expectedTargets);
  }

55
56
  std::vector<std::string> missingTargets;

57
58
59
60
61
62
63
  // 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);
64

65
66
    te->AppendBuildInterfaceIncludes();

67
68
69
70
71
72
73
74
    ImportPropertyMap properties;

    this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", te,
                                    cmGeneratorExpression::BuildInterface,
                                    properties, missingTargets);
    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", te,
                                    cmGeneratorExpression::BuildInterface,
                                    properties, missingTargets);
75
76
    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
                                  te, properties);
77
    this->PopulateCompatibleInterfaceProperties(te, properties);
78
79

    this->GenerateInterfaceProperties(te, os, properties);
80
81
    }

82
83
84
85
86
  // Generate import file content for each configuration.
  for(std::vector<std::string>::const_iterator
        ci = this->Configurations.begin();
      ci != this->Configurations.end(); ++ci)
    {
87
    this->GenerateImportConfig(os, ci->c_str(), missingTargets);
88
89
    }

90
91
  this->GenerateMissingTargetsCheckCode(os, missingTargets);

92
93
94
95
96
97
98
  return true;
}

//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator
::GenerateImportTargetsConfig(std::ostream& os,
99
100
                              const char* config, std::string const& suffix,
                            std::vector<std::string> &missingTargets)
101
102
103
104
105
106
107
108
109
110
111
112
113
{
  for(std::vector<cmTarget*>::const_iterator
        tei = this->Exports->begin();
      tei != this->Exports->end(); ++tei)
    {
    // Collect import properties for this target.
    cmTarget* target = *tei;
    ImportPropertyMap properties;
    this->SetImportLocationProperty(config, suffix, target, properties);
    if(!properties.empty())
      {
      // Get the rest of the target details.
      this->SetImportDetailProperties(config, suffix,
114
                                      target, properties, missingTargets);
115
116
117
118
      this->SetImportLinkInterface(config, suffix,
                                   cmGeneratorExpression::BuildInterface,
                                   target, properties, missingTargets);

119
120

      // TOOD: PUBLIC_HEADER_LOCATION
121
122
      // This should wait until the build feature propagation stuff
      // is done.  Then this can be a propagated include directory.
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
      // this->GenerateImportProperty(config, te->HeaderGenerator,
      //                              properties);

      // Generate code in the export file.
      this->GenerateImportPropertyCode(os, config, target, properties);
      }
    }
}

//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator
::SetImportLocationProperty(const char* config, std::string const& suffix,
                            cmTarget* target, ImportPropertyMap& properties)
{
  // Get the makefile in which to lookup target information.
  cmMakefile* mf = target->GetMakefile();

  // Add the main target file.
  {
  std::string prop = "IMPORTED_LOCATION";
  prop += suffix;
145
  std::string value;
146
  if(target->IsAppBundleOnApple())
147
    {
148
149
150
151
152
153
    value = target->GetFullPath(config, false);
    }
  else
    {
    value = target->GetFullPath(config, false, true);
    }
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
  properties[prop] = value;
  }

  // Check whether this is a DLL platform.
  bool dll_platform =
    (mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW"));

  // Add the import library for windows DLLs.
  if(dll_platform &&
     (target->GetType() == cmTarget::SHARED_LIBRARY ||
      target->IsExecutableWithExports()) &&
     mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))
    {
    std::string prop = "IMPORTED_IMPLIB";
    prop += suffix;
    std::string value = target->GetFullPath(config, true);
170
171
    target->GetImplibGNUtoMS(value, value,
                             "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
172
173
174
175
    properties[prop] = value;
    }
}

176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator::HandleMissingTarget(
  std::string& link_libs, std::vector<std::string>&,
  cmMakefile*, cmTarget* depender, cmTarget* dependee)
{
  // The target is not in the export.
  if(!this->AppendMode)
    {
    // We are not appending, so all exported targets should be
    // known here.  This is probably user-error.
    this->ComplainAboutMissingTarget(depender, dependee);
    }
  // Assume the target will be exported by another command.
  // Append it with the export namespace.
  link_libs += this->Namespace;
  link_libs += dependee->GetName();
}

195
196
197
//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator
198
::ComplainAboutMissingTarget(cmTarget* depender,
199
                             cmTarget* dependee)
200
{
201
202
203
204
205
  if(!this->ExportCommand || !this->ExportCommand->ErrorMessage.empty())
    {
    return;
    }

206
  cmOStringStream e;
207
208
209
210
211
  e << "called with target \"" << depender->GetName()
    << "\" which requires target \"" << dependee->GetName()
    << "\" that is not in the export list.\n"
    << "If the required target is not easy to reference in this call, "
    << "consider using the APPEND option with multiple separate calls.";
212
  this->ExportCommand->ErrorMessage = e.str();
213
}