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
247
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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
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
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
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmDependsFortran.h"
#include <cassert>
#include <cstdlib>
#include <iostream>
#include <map>
#include <utility>
#include "cmsys/FStream.hxx"
#include "cmFortranParser.h" /* Interface to parser object. */
#include "cmGeneratedFileStream.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
// TODO: Test compiler for the case of the mod file. Some always
// use lower case and some always use upper case. I do not know if any
// use the case from the source code.
static void cmFortranModuleAppendUpperLower(std::string const& mod,
std::string& mod_upper,
std::string& mod_lower)
{
std::string::size_type ext_len = 0;
if (cmHasLiteralSuffix(mod, ".mod") || cmHasLiteralSuffix(mod, ".sub")) {
ext_len = 4;
} else if (cmHasLiteralSuffix(mod, ".smod")) {
ext_len = 5;
}
std::string const& name = mod.substr(0, mod.size() - ext_len);
std::string const& ext = mod.substr(mod.size() - ext_len);
mod_upper += cmSystemTools::UpperCase(name) + ext;
mod_lower += mod;
}
class cmDependsFortranInternals
{
public:
// The set of modules provided by this target.
std::set<std::string> TargetProvides;
// Map modules required by this target to locations.
using TargetRequiresMap = std::map<std::string, std::string>;
TargetRequiresMap TargetRequires;
// Information about each object file.
using ObjectInfoMap = std::map<std::string, cmFortranSourceInfo>;
ObjectInfoMap ObjectInfo;
cmFortranSourceInfo& CreateObjectInfo(const std::string& obj,
const std::string& src)
{
auto i = this->ObjectInfo.find(obj);
if (i == this->ObjectInfo.end()) {
std::map<std::string, cmFortranSourceInfo>::value_type entry(
obj, cmFortranSourceInfo());
i = this->ObjectInfo.insert(entry).first;
i->second.Source = src;
}
return i->second;
}
};
cmDependsFortran::cmDependsFortran() = default;
cmDependsFortran::cmDependsFortran(cmLocalUnixMakefileGenerator3* lg)
: cmDepends(lg)
, Internal(new cmDependsFortranInternals)
{
// Configure the include file search path.
this->SetIncludePathFromLanguage("Fortran");
// Get the list of definitions.
std::vector<std::string> definitions;
cmMakefile* mf = this->LocalGenerator->GetMakefile();
mf->GetDefExpandList("CMAKE_TARGET_DEFINITIONS_Fortran", definitions);
// translate i.e. FOO=BAR to FOO and add it to the list of defined
// preprocessor symbols
for (std::string def : definitions) {
std::string::size_type assignment = def.find('=');
if (assignment != std::string::npos) {
def = def.substr(0, assignment);
}
this->PPDefinitions.insert(def);
}
this->CompilerId = mf->GetSafeDefinition("CMAKE_Fortran_COMPILER_ID");
this->SModSep = mf->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_SEP");
this->SModExt = mf->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_EXT");
}
cmDependsFortran::~cmDependsFortran() = default;
bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
const std::string& obj,
std::ostream& /*makeDepends*/,
std::ostream& /*internalDepends*/)
{
// Make sure this is a scanning instance.
if (sources.empty() || sources.begin()->empty()) {
cmSystemTools::Error("Cannot scan dependencies without a source file.");
return false;
}
if (obj.empty()) {
cmSystemTools::Error("Cannot scan dependencies without an object file.");
return false;
}
cmFortranCompiler fc;
fc.Id = this->CompilerId;
fc.SModSep = this->SModSep;
fc.SModExt = this->SModExt;
bool okay = true;
for (std::string const& src : sources) {
// Get the information object for this source.
cmFortranSourceInfo& info = this->Internal->CreateObjectInfo(obj, src);
// Create the parser object. The constructor takes info by reference,
// so we may look into the resulting objects later.
cmFortranParser parser(fc, this->IncludePath, this->PPDefinitions, info);
// Push on the starting file.
cmFortranParser_FilePush(&parser, src.c_str());
// Parse the translation unit.
if (cmFortran_yyparse(parser.Scanner) != 0) {
// Failed to parse the file. Report failure to write dependencies.
okay = false;
/* clang-format off */
std::cerr <<
"warning: failed to parse dependencies from Fortran source "
"'" << src << "': " << parser.Error << std::endl
;
/* clang-format on */
}
}
return okay;
}
bool cmDependsFortran::Finalize(std::ostream& makeDepends,
std::ostream& internalDepends)
{
// Prepare the module search process.
this->LocateModules();
// Get the directory in which stamp files will be stored.
const std::string& stamp_dir = this->TargetDirectory;
// Get the directory in which module files will be created.
cmMakefile* mf = this->LocalGenerator->GetMakefile();
std::string mod_dir =
mf->GetSafeDefinition("CMAKE_Fortran_TARGET_MODULE_DIR");
if (mod_dir.empty()) {
mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory();
}
// Actually write dependencies to the streams.
using ObjectInfoMap = cmDependsFortranInternals::ObjectInfoMap;
ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
for (auto const& i : objInfo) {
if (!this->WriteDependenciesReal(i.first, i.second, mod_dir, stamp_dir,
makeDepends, internalDepends)) {
return false;
}
}
// Store the list of modules provided by this target.
std::string fiName = cmStrCat(this->TargetDirectory, "/fortran.internal");
cmGeneratedFileStream fiStream(fiName);
fiStream << "# The fortran modules provided by this target.\n";
fiStream << "provides\n";
std::set<std::string> const& provides = this->Internal->TargetProvides;
for (std::string const& i : provides) {
fiStream << ' ' << i << '\n';
}
// Create a script to clean the modules.
if (!provides.empty()) {
std::string fcName =
cmStrCat(this->TargetDirectory, "/cmake_clean_Fortran.cmake");
cmGeneratedFileStream fcStream(fcName);
fcStream << "# Remove fortran modules provided by this target.\n";
fcStream << "FILE(REMOVE";
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (std::string const& i : provides) {
std::string mod_upper = cmStrCat(mod_dir, '/');
std::string mod_lower = cmStrCat(mod_dir, '/');
cmFortranModuleAppendUpperLower(i, mod_upper, mod_lower);
std::string stamp = cmStrCat(stamp_dir, '/', i, ".stamp");
fcStream << "\n"
" \""
<< this->MaybeConvertToRelativePath(currentBinDir, mod_lower)
<< "\"\n"
" \""
<< this->MaybeConvertToRelativePath(currentBinDir, mod_upper)
<< "\"\n"
" \""
<< this->MaybeConvertToRelativePath(currentBinDir, stamp)
<< "\"\n";
}
fcStream << " )\n";
}
return true;
}
void cmDependsFortran::LocateModules()
{
// Collect the set of modules provided and required by all sources.
using ObjectInfoMap = cmDependsFortranInternals::ObjectInfoMap;
ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
for (auto const& infoI : objInfo) {
cmFortranSourceInfo const& info = infoI.second;
// Include this module in the set provided by this target.
this->Internal->TargetProvides.insert(info.Provides.begin(),
info.Provides.end());
for (std::string const& r : info.Requires) {
this->Internal->TargetRequires[r].clear();
}
}
// Short-circuit for simple targets.
if (this->Internal->TargetRequires.empty()) {
return;
}
// Match modules provided by this target to those it requires.
this->MatchLocalModules();
// Load information about other targets.
cmMakefile* mf = this->LocalGenerator->GetMakefile();
std::vector<std::string> infoFiles;
mf->GetDefExpandList("CMAKE_TARGET_LINKED_INFO_FILES", infoFiles);
for (std::string const& i : infoFiles) {
std::string targetDir = cmSystemTools::GetFilenamePath(i);
std::string fname = targetDir + "/fortran.internal";
cmsys::ifstream fin(fname.c_str());
if (fin) {
this->MatchRemoteModules(fin, targetDir);
}
}
}
void cmDependsFortran::MatchLocalModules()
{
std::string const& stampDir = this->TargetDirectory;
std::set<std::string> const& provides = this->Internal->TargetProvides;
for (std::string const& i : provides) {
this->ConsiderModule(i, stampDir);
}
}
void cmDependsFortran::MatchRemoteModules(std::istream& fin,
const std::string& stampDir)
{
std::string line;
bool doing_provides = false;
while (cmSystemTools::GetLineFromStream(fin, line)) {
// Ignore comments and empty lines.
if (line.empty() || line[0] == '#' || line[0] == '\r') {
continue;
}
if (line[0] == ' ') {
if (doing_provides) {
std::string mod = line;
if (!cmHasLiteralSuffix(mod, ".mod") &&
!cmHasLiteralSuffix(mod, ".smod") &&
!cmHasLiteralSuffix(mod, ".sub")) {
// Support fortran.internal files left by older versions of CMake.
// They do not include the ".mod" extension.
mod += ".mod";
}
this->ConsiderModule(mod.substr(1), stampDir);
}
} else if (line == "provides") {
doing_provides = true;
} else {
doing_provides = false;
}
}
}
void cmDependsFortran::ConsiderModule(const std::string& name,
const std::string& stampDir)
{
// Locate each required module.
auto required = this->Internal->TargetRequires.find(name);
if (required != this->Internal->TargetRequires.end() &&
required->second.empty()) {
// The module is provided by a CMake target. It will have a stamp file.
std::string stampFile = cmStrCat(stampDir, '/', name, ".stamp");
required->second = stampFile;
}
}
bool cmDependsFortran::WriteDependenciesReal(std::string const& obj,
cmFortranSourceInfo const& info,
std::string const& mod_dir,
std::string const& stamp_dir,
std::ostream& makeDepends,
std::ostream& internalDepends)
{
// Get the source file for this object.
std::string const& src = info.Source;
// Write the include dependencies to the output stream.
std::string binDir = this->LocalGenerator->GetBinaryDirectory();
std::string obj_i = this->MaybeConvertToRelativePath(binDir, obj);
std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i);
internalDepends << obj_i << "\n " << src << '\n';
for (std::string const& i : info.Includes) {
makeDepends << obj_m << ": "
<< cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, i))
<< '\n';
internalDepends << ' ' << i << '\n';
}
makeDepends << '\n';
// Write module requirements to the output stream.
for (std::string const& i : info.Requires) {
// Require only modules not provided in the same source.
if (info.Provides.find(i) != info.Provides.cend()) {
continue;
}
// The object file should depend on timestamped files for the
// modules it uses.
auto required = this->Internal->TargetRequires.find(i);
if (required == this->Internal->TargetRequires.end()) {
abort();
}
if (!required->second.empty()) {
// This module is known. Depend on its timestamp file.
std::string stampFile = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, required->second));
makeDepends << obj_m << ": " << stampFile << '\n';
} else {
// This module is not known to CMake. Try to locate it where
// the compiler will and depend on that.
std::string module;
if (this->FindModule(i, module)) {
module = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, module));
makeDepends << obj_m << ": " << module << '\n';
}
}
}
// If any modules are provided then they must be converted to stamp files.
if (!info.Provides.empty()) {
// Create a target to copy the module after the object file
// changes.
for (std::string const& i : info.Provides) {
// Include this module in the set provided by this target.
this->Internal->TargetProvides.insert(i);
// Always use lower case for the mod stamp file name. The
// cmake_copy_f90_mod will call back to this class, which will
// try various cases for the real mod file name.
std::string modFile = cmStrCat(mod_dir, '/', i);
modFile = this->LocalGenerator->ConvertToOutputFormat(
this->MaybeConvertToRelativePath(binDir, modFile),
cmOutputConverter::SHELL);
std::string stampFile = cmStrCat(stamp_dir, '/', i, ".stamp");
stampFile = this->MaybeConvertToRelativePath(binDir, stampFile);
std::string const stampFileForShell =
this->LocalGenerator->ConvertToOutputFormat(stampFile,
cmOutputConverter::SHELL);
std::string const stampFileForMake =
cmSystemTools::ConvertToOutputPath(stampFile);
makeDepends << obj_m << ".provides.build"
<< ": " << stampFileForMake << '\n';
// Note that when cmake_copy_f90_mod finds that a module file
// and the corresponding stamp file have no differences, the stamp
// file is not updated. In such case the stamp file will be always
// older than its prerequisite and trigger cmake_copy_f90_mod
// on each new build. This is expected behavior for incremental
// builds and can not be changed without preforming recursive make
// calls that would considerably slow down the building process.
makeDepends << stampFileForMake << ": " << obj_m << '\n';
makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
<< ' ' << stampFileForShell;
cmMakefile* mf = this->LocalGenerator->GetMakefile();
const char* cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID");
if (cid && *cid) {
makeDepends << ' ' << cid;
}
makeDepends << '\n';
}
makeDepends << obj_m << ".provides.build:\n";
// After copying the modules update the timestamp file.
makeDepends << "\t$(CMAKE_COMMAND) -E touch " << obj_m
<< ".provides.build\n";
// Make sure the module timestamp rule is evaluated by the time
// the target finishes building.
std::string driver = cmStrCat(this->TargetDirectory, "/build");
driver = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, driver));
makeDepends << driver << ": " << obj_m << ".provides.build\n";
}
return true;
}
bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
{
// Construct possible names for the module file.
std::string mod_upper;
std::string mod_lower;
cmFortranModuleAppendUpperLower(name, mod_upper, mod_lower);
// Search the include path for the module.
std::string fullName;
for (std::string const& ip : this->IncludePath) {
// Try the lower-case name.
fullName = cmStrCat(ip, '/', mod_lower);
if (cmSystemTools::FileExists(fullName, true)) {
module = fullName;
return true;
}
// Try the upper-case name.
fullName = cmStrCat(ip, '/', mod_upper);
if (cmSystemTools::FileExists(fullName, true)) {
module = fullName;
return true;
}
}
return false;
}
bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
{
// Implements
//
// $(CMAKE_COMMAND) -E cmake_copy_f90_mod input.mod output.mod.stamp
// [compiler-id]
//
// Note that the case of the .mod file depends on the compiler. In
// the future this copy could also account for the fact that some
// compilers include a timestamp in the .mod file so it changes even
// when the interface described in the module does not.
std::string mod = args[2];
std::string stamp = args[3];
std::string compilerId;
if (args.size() >= 5) {
compilerId = args[4];
}
if (!cmHasLiteralSuffix(mod, ".mod") && !cmHasLiteralSuffix(mod, ".smod") &&
!cmHasLiteralSuffix(mod, ".sub")) {
// Support depend.make files left by older versions of CMake.
// They do not include the ".mod" extension.
mod += ".mod";
}
std::string mod_dir = cmSystemTools::GetFilenamePath(mod);
if (!mod_dir.empty()) {
mod_dir += "/";
}
std::string mod_upper = mod_dir;
std::string mod_lower = mod_dir;
cmFortranModuleAppendUpperLower(cmSystemTools::GetFilenameName(mod),
mod_upper, mod_lower);
if (cmSystemTools::FileExists(mod_upper, true)) {
if (cmDependsFortran::ModulesDiffer(mod_upper, stamp, compilerId)) {
if (!cmSystemTools::CopyFileAlways(mod_upper, stamp)) {
std::cerr << "Error copying Fortran module from \"" << mod_upper
<< "\" to \"" << stamp << "\".\n";
return false;
}
}
return true;
}
if (cmSystemTools::FileExists(mod_lower, true)) {
if (cmDependsFortran::ModulesDiffer(mod_lower, stamp, compilerId)) {
if (!cmSystemTools::CopyFileAlways(mod_lower, stamp)) {
std::cerr << "Error copying Fortran module from \"" << mod_lower
<< "\" to \"" << stamp << "\".\n";
return false;
}
}
return true;
}
std::cerr << "Error copying Fortran module \"" << args[2] << "\". Tried \""
<< mod_upper << "\" and \"" << mod_lower << "\".\n";
return false;
}
// Helper function to look for a short sequence in a stream. If this
// is later used for longer sequences it should be re-written using an
// efficient string search algorithm such as Boyer-Moore.
static bool cmFortranStreamContainsSequence(std::istream& ifs, const char* seq,
int len)
{
assert(len > 0);
int cur = 0;
while (cur < len) {
// Get the next character.
int token = ifs.get();
if (!ifs) {
return false;
}
// Check the character.
if (token == static_cast<int>(seq[cur])) {
++cur;
} else {
// Assume the sequence has no repeating subsequence.
cur = 0;
}
}
// The entire sequence was matched.
return true;
}
// Helper function to compare the remaining content in two streams.
static bool cmFortranStreamsDiffer(std::istream& ifs1, std::istream& ifs2)
{
// Compare the remaining content.
for (;;) {
int ifs1_c = ifs1.get();
int ifs2_c = ifs2.get();
if (!ifs1 && !ifs2) {
// We have reached the end of both streams simultaneously.
// The streams are identical.
return false;
}
if (!ifs1 || !ifs2 || ifs1_c != ifs2_c) {
// We have reached the end of one stream before the other or
// found differing content. The streams are different.
break;
}
}
return true;
}
bool cmDependsFortran::ModulesDiffer(const std::string& modFile,
const std::string& stampFile,
const std::string& compilerId)
{
/*
gnu >= 4.9:
A mod file is an ascii file compressed with gzip.
Compiling twice produces identical modules.
gnu < 4.9:
A mod file is an ascii file.
<bar.mod>
FORTRAN module created from /path/to/foo.f90 on Sun Dec 30 22:47:58 2007
If you edit this, you'll get what you deserve.
...
</bar.mod>
As you can see the first line contains the date.
intel:
A mod file is a binary file.
However, looking into both generated bar.mod files with a hex editor
shows that they differ only before a sequence linefeed-zero (0x0A 0x00)
which is located some bytes in front of the absolute path to the source
file.
sun:
A mod file is a binary file. Compiling twice produces identical modules.
others:
TODO ...
*/
/* Compilers which do _not_ produce different mod content when the same
* source is compiled twice
* -SunPro
*/
if (compilerId == "SunPro") {
return cmSystemTools::FilesDiffer(modFile, stampFile);
}
#if defined(_WIN32) || defined(__CYGWIN__)
cmsys::ifstream finModFile(modFile.c_str(), std::ios::in | std::ios::binary);
cmsys::ifstream finStampFile(stampFile.c_str(),
std::ios::in | std::ios::binary);
#else
cmsys::ifstream finModFile(modFile.c_str());
cmsys::ifstream finStampFile(stampFile.c_str());
#endif
if (!finModFile || !finStampFile) {
// At least one of the files does not exist. The modules differ.
return true;
}
/* Compilers which _do_ produce different mod content when the same
* source is compiled twice
* -GNU
* -Intel
*
* Eat the stream content until all recompile only related changes
* are left behind.
*/
if (compilerId == "GNU") {
// GNU Fortran 4.9 and later compress .mod files with gzip
// but also do not include a date so we can fall through to
// compare them without skipping any prefix.
unsigned char hdr[2];
bool okay = !finModFile.read(reinterpret_cast<char*>(hdr), 2).fail();
finModFile.seekg(0);
if (!okay || hdr[0] != 0x1f || hdr[1] != 0x8b) {
const char seq[1] = { '\n' };
const int seqlen = 1;
if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
// The module is of unexpected format. Assume it is different.
std::cerr << compilerId << " fortran module " << modFile
<< " has unexpected format." << std::endl;
return true;
}
if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
// The stamp must differ if the sequence is not contained.
return true;
}
}
} else if (compilerId == "Intel") {
const char seq[2] = { '\n', '\0' };
const int seqlen = 2;
// Skip the leading byte which appears to be a version number.
// We do not need to check for an error because the sequence search
// below will fail in that case.
finModFile.get();
finStampFile.get();
if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
// The module is of unexpected format. Assume it is different.
std::cerr << compilerId << " fortran module " << modFile
<< " has unexpected format." << std::endl;
return true;
}
if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
// The stamp must differ if the sequence is not contained.
return true;
}
}
// Compare the remaining content. If no compiler id matched above,
// including the case none was given, this will compare the whole
// content.
return cmFortranStreamsDiffer(finModFile, finStampFile);
}
std::string cmDependsFortran::MaybeConvertToRelativePath(
std::string const& base, std::string const& path)
{
if (!this->LocalGenerator->GetStateSnapshot().GetDirectory().ContainsBoth(
base, path)) {
return path;
}
return cmSystemTools::ForceToRelativePath(base, path);
}
|