summaryrefslogtreecommitdiffstats
path: root/Source/cmDepends.cxx
blob: eca1abdaae5e18cdbdb301aff2a5dcdb1d0c3a1f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
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
235
236
237
238
239
240
241
242
243
244
245
246
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include "cmDepends.h"

#include <utility>

#include "cmsys/FStream.hxx"

#include "cmFileTime.h"
#include "cmFileTimeCache.h"
#include "cmGeneratedFileStream.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmValue.h"

cmDepends::cmDepends(cmLocalUnixMakefileGenerator3* lg, std::string targetDir)
  : LocalGenerator(lg)
  , TargetDirectory(std::move(targetDir))
{
}

cmDepends::~cmDepends() = default;

bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
{
  std::map<std::string, std::set<std::string>> dependencies;
  {
    // Lookup the set of sources to scan.
    std::vector<std::string> pairs;
    {
      std::string const srcLang = "CMAKE_DEPENDS_CHECK_" + this->Language;
      cmMakefile* mf = this->LocalGenerator->GetMakefile();
      cmExpandList(mf->GetSafeDefinition(srcLang), pairs);
    }
    for (auto si = pairs.begin(); si != pairs.end();) {
      // Get the source and object file.
      std::string const& src = *si++;
      if (si == pairs.end()) {
        break;
      }
      std::string const& obj = *si++;
      dependencies[obj].insert(src);
    }
  }
  for (auto const& d : dependencies) {
    // Write the dependencies for this pair.
    if (!this->WriteDependencies(d.second, d.first, makeDepends,
                                 internalDepends)) {
      return false;
    }
  }

  return this->Finalize(makeDepends, internalDepends);
}

bool cmDepends::Finalize(std::ostream& /*unused*/, std::ostream& /*unused*/)
{
  return true;
}

bool cmDepends::Check(const std::string& makeFile,
                      const std::string& internalFile,
                      DependencyMap& validDeps)
{
  // Check whether dependencies must be regenerated.
  bool okay = true;
  cmsys::ifstream fin(internalFile.c_str());
  if (!(fin && this->CheckDependencies(fin, internalFile, validDeps))) {
    // Clear all dependencies so they will be regenerated.
    this->Clear(makeFile);
    cmSystemTools::RemoveFile(internalFile);
    this->FileTimeCache->Remove(internalFile);
    okay = false;
  }
  return okay;
}

void cmDepends::Clear(const std::string& file) const
{
  // Print verbose output.
  if (this->Verbose) {
    cmSystemTools::Stdout(
      cmStrCat("Clearing dependencies in \"", file, "\".\n"));
  }

  // Write an empty dependency file.
  cmGeneratedFileStream depFileStream(file);
  depFileStream << "# Empty dependencies file\n"
                   "# This may be replaced when dependencies are built.\n";
}

bool cmDepends::WriteDependencies(const std::set<std::string>& /*unused*/,
                                  const std::string& /*unused*/,
                                  std::ostream& /*unused*/,
                                  std::ostream& /*unused*/)
{
  // This should be implemented by the subclass.
  return false;
}

bool cmDepends::CheckDependencies(std::istream& internalDepends,
                                  const std::string& internalDependsFileName,
                                  DependencyMap& validDeps)
{
  // Read internal depends file time
  cmFileTime internalDependsTime;
  if (!this->FileTimeCache->Load(internalDependsFileName,
                                 internalDependsTime)) {
    return false;
  }

  // Parse dependencies from the stream.  If any dependee is missing
  // or newer than the depender then dependencies should be
  // regenerated.
  bool okay = true;
  bool dependerExists = false;

  std::string line;
  line.reserve(1024);
  std::string depender;
  std::string dependee;
  cmFileTime dependerTime;
  cmFileTime dependeeTime;
  std::vector<std::string>* currentDependencies = nullptr;

  while (std::getline(internalDepends, line)) {
    // Check if this an empty or a comment line
    if (line.empty() || line.front() == '#') {
      continue;
    }
    // Drop carriage return character at the end
    if (line.back() == '\r') {
      line.pop_back();
      if (line.empty()) {
        continue;
      }
    }
    // Check if this a depender line
    if (line.front() != ' ') {
      depender = line;
      dependerExists = this->FileTimeCache->Load(depender, dependerTime);
      // If we erase validDeps[this->Depender] by overwriting it with an empty
      // vector, we lose dependencies for dependers that have multiple
      // entries. No need to initialize the entry, std::map will do so on first
      // access.
      currentDependencies = &validDeps[depender];
      continue;
    }

    // This is a dependee line
    dependee = line.substr(1);

    // Add dependee to depender's list
    if (currentDependencies != nullptr) {
      currentDependencies->push_back(dependee);
    }

    // Dependencies must be regenerated
    // * if the dependee does not exist
    // * if the depender exists and is older than the dependee.
    // * if the depender does not exist, but the dependee is newer than the
    //   depends file
    bool regenerate = false;
    bool dependeeExists = this->FileTimeCache->Load(dependee, dependeeTime);
    if (!dependeeExists) {
      // The dependee does not exist.
      regenerate = true;

      // Print verbose output.
      if (this->Verbose) {
        cmSystemTools::Stdout(cmStrCat("Dependee \"", dependee,
                                       "\" does not exist for depender \"",
                                       depender, "\".\n"));
      }
    } else if (dependerExists) {
      // The dependee and depender both exist.  Compare file times.
      if (dependerTime.Older(dependeeTime)) {
        // The depender is older than the dependee.
        regenerate = true;

        // Print verbose output.
        if (this->Verbose) {
          cmSystemTools::Stdout(cmStrCat("Dependee \"", dependee,
                                         "\" is newer than depender \"",
                                         depender, "\".\n"));
        }
      }
    } else {
      // The dependee exists, but the depender doesn't. Regenerate if the
      // internalDepends file is older than the dependee.
      if (internalDependsTime.Older(dependeeTime)) {
        // The depends-file is older than the dependee.
        regenerate = true;

        // Print verbose output.
        if (this->Verbose) {
          cmSystemTools::Stdout(cmStrCat("Dependee \"", dependee,
                                         "\" is newer than depends file \"",
                                         internalDependsFileName, "\".\n"));
        }
      }
    }

    if (regenerate) {
      // Dependencies must be regenerated.
      okay = false;

      // Remove the information of this depender from the map, it needs
      // to be rescanned
      if (currentDependencies != nullptr) {
        validDeps.erase(depender);
        currentDependencies = nullptr;
      }

      // Remove the depender to be sure it is rebuilt.
      if (dependerExists) {
        cmSystemTools::RemoveFile(depender);
        this->FileTimeCache->Remove(depender);
        dependerExists = false;
      }
    }
  }

  return okay;
}

void cmDepends::SetIncludePathFromLanguage(const std::string& lang)
{
  // Look for the new per "TARGET_" variant first:
  std::string includePathVar =
    cmStrCat("CMAKE_", lang, "_TARGET_INCLUDE_PATH");
  cmMakefile* mf = this->LocalGenerator->GetMakefile();
  cmValue includePath = mf->GetDefinition(includePathVar);
  if (includePath) {
    cmExpandList(*includePath, this->IncludePath);
  } else {
    // Fallback to the old directory level variable if no per-target var:
    includePathVar = cmStrCat("CMAKE_", lang, "_INCLUDE_PATH");
    includePath = mf->GetDefinition(includePathVar);
    if (includePath) {
      cmExpandList(*includePath, this->IncludePath);
    }
  }
}