diff options
Diffstat (limited to 'Source/cmDependsFortran.cxx')
| -rw-r--r-- | Source/cmDependsFortran.cxx | 1258 |
1 files changed, 1258 insertions, 0 deletions
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx new file mode 100644 index 000000000..c1b60905d --- /dev/null +++ b/Source/cmDependsFortran.cxx @@ -0,0 +1,1258 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + 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. +============================================================================*/ +#include "cmDependsFortran.h" + +#include "cmSystemTools.h" +#include "cmLocalGenerator.h" +#include "cmMakefile.h" +#include "cmGeneratedFileStream.h" + +#include "cmDependsFortranParser.h" /* Interface to parser object. */ + +#include <assert.h> +#include <stack> + +// 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. + +//---------------------------------------------------------------------------- +// Information about a single source file. +class cmDependsFortranSourceInfo +{ +public: + // The name of the source file. + std::string Source; + + // Set of provided and required modules. + std::set<cmStdString> Provides; + std::set<cmStdString> Requires; + + // Set of files included in the translation unit. + std::set<cmStdString> Includes; +}; + +//---------------------------------------------------------------------------- +// Parser methods not included in generated interface. + +// Get the current buffer processed by the lexer. +YY_BUFFER_STATE cmDependsFortranLexer_GetCurrentBuffer(yyscan_t yyscanner); + +// The parser entry point. +int cmDependsFortran_yyparse(yyscan_t); + +//---------------------------------------------------------------------------- +// Define parser object internal structure. +struct cmDependsFortranFile +{ + cmDependsFortranFile(FILE* file, YY_BUFFER_STATE buffer, + const std::string& dir): + File(file), Buffer(buffer), Directory(dir) {} + FILE* File; + YY_BUFFER_STATE Buffer; + std::string Directory; +}; + +struct cmDependsFortranParser_s +{ + cmDependsFortranParser_s(cmDependsFortran* self, + std::set<std::string>& ppDefines, + cmDependsFortranSourceInfo& info); + ~cmDependsFortranParser_s(); + + // Pointer back to the main class. + cmDependsFortran* Self; + + // Lexical scanner instance. + yyscan_t Scanner; + + // Stack of open files in the translation unit. + std::stack<cmDependsFortranFile> FileStack; + + // Buffer for string literals. + std::string TokenString; + + // Flag for whether lexer is reading from inside an interface. + bool InInterface; + + int OldStartcond; + std::set<std::string> PPDefinitions; + size_t InPPFalseBranch; + std::stack<bool> SkipToEnd; + + // Information about the parsed source. + cmDependsFortranSourceInfo& Info; +}; + +//---------------------------------------------------------------------------- +class cmDependsFortranInternals +{ +public: + // The set of modules provided by this target. + std::set<cmStdString> TargetProvides; + + // Map modules required by this target to locations. + typedef std::map<cmStdString, cmStdString> TargetRequiresMap; + TargetRequiresMap TargetRequires; + + // Information about each object file. + typedef std::map<cmStdString, cmDependsFortranSourceInfo> ObjectInfoMap; + ObjectInfoMap ObjectInfo; + + cmDependsFortranSourceInfo& CreateObjectInfo(const char* obj, + const char* src) + { + std::map<cmStdString, cmDependsFortranSourceInfo>::iterator i = + this->ObjectInfo.find(obj); + if(i == this->ObjectInfo.end()) + { + std::map<cmStdString, cmDependsFortranSourceInfo>::value_type + entry(obj, cmDependsFortranSourceInfo()); + i = this->ObjectInfo.insert(entry).first; + i->second.Source = src; + } + return i->second; + } +}; + +//---------------------------------------------------------------------------- +cmDependsFortran::cmDependsFortran(): + PPDefinitions(0), Internal(0) +{ +} + +//---------------------------------------------------------------------------- +cmDependsFortran +::cmDependsFortran(cmLocalGenerator* 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(); + if(const char* c_defines = + mf->GetDefinition("CMAKE_TARGET_DEFINITIONS")) + { + cmSystemTools::ExpandListArgument(c_defines, definitions); + } + + // translate i.e. FOO=BAR to FOO and add it to the list of defined + // preprocessor symbols + for(std::vector<std::string>::const_iterator + it = definitions.begin(); it != definitions.end(); ++it) + { + std::string def = *it; + std::string::size_type assignment = def.find("="); + if(assignment != std::string::npos) + { + def = it->substr(0, assignment); + } + this->PPDefinitions.push_back(def); + } +} + +//---------------------------------------------------------------------------- +cmDependsFortran::~cmDependsFortran() +{ + delete this->Internal; +} + +//---------------------------------------------------------------------------- +bool cmDependsFortran::WriteDependencies(const char *src, const char *obj, + std::ostream&, std::ostream&) +{ + // Make sure this is a scanning instance. + if(!src || src[0] == '\0') + { + cmSystemTools::Error("Cannot scan dependencies without an source file."); + return false; + } + if(!obj || obj[0] == '\0') + { + cmSystemTools::Error("Cannot scan dependencies without an object file."); + return false; + } + + // Get the information object for this source. + cmDependsFortranSourceInfo& info = + this->Internal->CreateObjectInfo(obj, src); + + // Make a copy of the macros defined via ADD_DEFINITIONS + std::set<std::string> ppDefines(this->PPDefinitions.begin(), + this->PPDefinitions.end()); + + // Create the parser object. The constructor takes ppMacro and info per + // reference, so we may look into the resulting objects later. + cmDependsFortranParser parser(this, ppDefines, info); + + // Push on the starting file. + cmDependsFortranParser_FilePush(&parser, src); + + // Parse the translation unit. + if(cmDependsFortran_yyparse(parser.Scanner) != 0) + { + // Failed to parse the file. Report failure to write dependencies. + return false; + } + + return true; +} + +//---------------------------------------------------------------------------- +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 char* stamp_dir = this->TargetDirectory.c_str(); + + // Get the directory in which module files will be created. + const char* mod_dir; + cmMakefile* mf = this->LocalGenerator->GetMakefile(); + if(const char* target_mod_dir = + mf->GetDefinition("CMAKE_Fortran_TARGET_MODULE_DIR")) + { + mod_dir = target_mod_dir; + } + else + { + mod_dir = + this->LocalGenerator->GetMakefile()->GetCurrentOutputDirectory(); + } + + // Actually write dependencies to the streams. + typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap; + ObjectInfoMap const& objInfo = this->Internal->ObjectInfo; + for(ObjectInfoMap::const_iterator i = objInfo.begin(); + i != objInfo.end(); ++i) + { + if(!this->WriteDependenciesReal(i->first.c_str(), i->second, + mod_dir, stamp_dir, + makeDepends, internalDepends)) + { + return false; + } + } + + // Store the list of modules provided by this target. + std::string fiName = this->TargetDirectory; + fiName += "/fortran.internal"; + cmGeneratedFileStream fiStream(fiName.c_str()); + fiStream << "# The fortran modules provided by this target.\n"; + fiStream << "provides\n"; + std::set<cmStdString> const& provides = this->Internal->TargetProvides; + for(std::set<cmStdString>::const_iterator i = provides.begin(); + i != provides.end(); ++i) + { + fiStream << " " << *i << "\n"; + } + + // Create a script to clean the modules. + if(!provides.empty()) + { + std::string fcName = this->TargetDirectory; + fcName += "/cmake_clean_Fortran.cmake"; + cmGeneratedFileStream fcStream(fcName.c_str()); + fcStream << "# Remove fortran modules provided by this target.\n"; + fcStream << "FILE(REMOVE"; + for(std::set<cmStdString>::const_iterator i = provides.begin(); + i != provides.end(); ++i) + { + std::string mod_upper = mod_dir; + mod_upper += "/"; + mod_upper += cmSystemTools::UpperCase(*i); + mod_upper += ".mod"; + std::string mod_lower = mod_dir; + mod_lower += "/"; + mod_lower += *i; + mod_lower += ".mod"; + std::string stamp = stamp_dir; + stamp += "/"; + stamp += *i; + stamp += ".mod.stamp"; + fcStream << "\n"; + fcStream << " \"" << + this->LocalGenerator->Convert(mod_lower.c_str(), + cmLocalGenerator::START_OUTPUT) + << "\"\n"; + fcStream << " \"" << + this->LocalGenerator->Convert(mod_upper.c_str(), + cmLocalGenerator::START_OUTPUT) + << "\"\n"; + fcStream << " \"" << + this->LocalGenerator->Convert(stamp.c_str(), + cmLocalGenerator::START_OUTPUT) + << "\"\n"; + } + fcStream << " )\n"; + } + return true; +} + +//---------------------------------------------------------------------------- +void cmDependsFortran::LocateModules() +{ + // Collect the set of modules provided and required by all sources. + typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap; + ObjectInfoMap const& objInfo = this->Internal->ObjectInfo; + for(ObjectInfoMap::const_iterator infoI = objInfo.begin(); + infoI != objInfo.end(); ++infoI) + { + cmDependsFortranSourceInfo const& info = infoI->second; + for(std::set<cmStdString>::const_iterator i = info.Provides.begin(); + i != info.Provides.end(); ++i) + { + // Include this module in the set provided by this target. + this->Internal->TargetProvides.insert(*i); + } + + for(std::set<cmStdString>::const_iterator i = info.Requires.begin(); + i != info.Requires.end(); ++i) + { + // Include this module in the set required by this target. + this->Internal->TargetRequires[*i] = ""; + } + } + + // 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; + if(const char* infoFilesValue = + mf->GetDefinition("CMAKE_TARGET_LINKED_INFO_FILES")) + { + cmSystemTools::ExpandListArgument(infoFilesValue, infoFiles); + } + for(std::vector<std::string>::const_iterator i = infoFiles.begin(); + i != infoFiles.end(); ++i) + { + std::string targetDir = cmSystemTools::GetFilenamePath(*i); + std::string fname = targetDir + "/fortran.internal"; + std::ifstream fin(fname.c_str()); + if(fin) + { + this->MatchRemoteModules(fin, targetDir.c_str()); + } + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortran::MatchLocalModules() +{ + const char* stampDir = this->TargetDirectory.c_str(); + std::set<cmStdString> const& provides = this->Internal->TargetProvides; + for(std::set<cmStdString>::const_iterator i = provides.begin(); + i != provides.end(); ++i) + { + this->ConsiderModule(i->c_str(), stampDir); + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortran::MatchRemoteModules(std::istream& fin, + const char* 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) + { + this->ConsiderModule(line.c_str()+1, stampDir); + } + } + else if(line == "provides") + { + doing_provides = true; + } + else + { + doing_provides = false; + } + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortran::ConsiderModule(const char* name, + const char* stampDir) +{ + // Locate each required module. + typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap; + TargetRequiresMap::iterator 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 = stampDir; + stampFile += "/"; + stampFile += name; + stampFile += ".mod.stamp"; + required->second = stampFile; + } +} + +//---------------------------------------------------------------------------- +bool +cmDependsFortran +::WriteDependenciesReal(const char *obj, + cmDependsFortranSourceInfo const& info, + const char* mod_dir, const char* stamp_dir, + std::ostream& makeDepends, + std::ostream& internalDepends) +{ + typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap; + + // Get the source file for this object. + const char* src = info.Source.c_str(); + + // Write the include dependencies to the output stream. + internalDepends << obj << std::endl; + internalDepends << " " << src << std::endl; + for(std::set<cmStdString>::const_iterator i = info.Includes.begin(); + i != info.Includes.end(); ++i) + { + makeDepends << obj << ": " << + this->LocalGenerator->Convert(i->c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE) + << std::endl; + internalDepends << " " << i->c_str() << std::endl; + } + makeDepends << std::endl; + + // Write module requirements to the output stream. + for(std::set<cmStdString>::const_iterator i = info.Requires.begin(); + i != info.Requires.end(); ++i) + { + // Require only modules not provided in the same source. + if(std::set<cmStdString>::const_iterator(info.Provides.find(*i)) != + info.Provides.end()) + { + continue; + } + + // If the module is provided in this target special handling is + // needed. + if(this->Internal->TargetProvides.find(*i) != + this->Internal->TargetProvides.end()) + { + // The module is provided by a different source in the same + // target. Add the proxy dependency to make sure the other + // source builds first. + std::string proxy = stamp_dir; + proxy += "/"; + proxy += *i; + proxy += ".mod.proxy"; + proxy = this->LocalGenerator->Convert(proxy.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + + // since we require some things add them to our list of requirements + makeDepends << obj << ".requires: " << proxy << std::endl; + } + + // The object file should depend on timestamped files for the + // modules it uses. + TargetRequiresMap::const_iterator 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 = + this->LocalGenerator->Convert(required->second.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + makeDepends << obj << ": " << 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 = + this->LocalGenerator->Convert(module.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + makeDepends << obj << ": " << module << "\n"; + } + } + } + + // Write provided modules to the output stream. + for(std::set<cmStdString>::const_iterator i = info.Provides.begin(); + i != info.Provides.end(); ++i) + { + std::string proxy = stamp_dir; + proxy += "/"; + proxy += *i; + proxy += ".mod.proxy"; + proxy = this->LocalGenerator->Convert(proxy.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + makeDepends << proxy << ": " << obj << ".provides" << std::endl; + } + + // 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. + makeDepends << obj << ".provides.build:\n"; + for(std::set<cmStdString>::const_iterator i = info.Provides.begin(); + i != info.Provides.end(); ++i) + { + // 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 m = cmSystemTools::LowerCase(*i); + std::string modFile = mod_dir; + modFile += "/"; + modFile += *i; + modFile = + this->LocalGenerator->Convert(modFile.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::SHELL); + std::string stampFile = stamp_dir; + stampFile += "/"; + stampFile += m; + stampFile += ".mod.stamp"; + stampFile = + this->LocalGenerator->Convert(stampFile.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::SHELL); + makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " + << modFile << " " << stampFile; + cmMakefile* mf = this->LocalGenerator->GetMakefile(); + const char* cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID"); + if(cid && *cid) + { + makeDepends << " " << cid; + } + makeDepends << "\n"; + } + // After copying the modules update the timestamp file so that + // copying will not be done again until the source rebuilds. + makeDepends << "\t$(CMAKE_COMMAND) -E touch " << obj + << ".provides.build\n"; + + // Make sure the module timestamp rule is evaluated by the time + // the target finishes building. + std::string driver = this->TargetDirectory; + driver += "/build"; + driver = this->LocalGenerator->Convert(driver.c_str(), + cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + makeDepends << driver << ": " << obj << ".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 = cmSystemTools::UpperCase(name); + std::string mod_lower = name; + mod_upper += ".mod"; + mod_lower += ".mod"; + + // Search the include path for the module. + std::string fullName; + for(std::vector<std::string>::const_iterator i = + this->IncludePath.begin(); i != this->IncludePath.end(); ++i) + { + // Try the lower-case name. + fullName = *i; + fullName += "/"; + fullName += mod_lower; + if(cmSystemTools::FileExists(fullName.c_str(), true)) + { + module = fullName; + return true; + } + + // Try the upper-case name. + fullName = *i; + fullName += "/"; + fullName += mod_upper; + if(cmSystemTools::FileExists(fullName.c_str(), 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]; + } + std::string mod_dir = cmSystemTools::GetFilenamePath(mod); + if(!mod_dir.empty()) { mod_dir += "/"; } + std::string mod_upper = mod_dir; + mod_upper += cmSystemTools::UpperCase(cmSystemTools::GetFilenameName(mod)); + std::string mod_lower = mod_dir; + mod_lower += cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(mod)); + mod += ".mod"; + mod_upper += ".mod"; + mod_lower += ".mod"; + if(cmSystemTools::FileExists(mod_upper.c_str(), true)) + { + if(cmDependsFortran::ModulesDiffer(mod_upper.c_str(), stamp.c_str(), + compilerId.c_str())) + { + if(!cmSystemTools::CopyFileAlways(mod_upper.c_str(), stamp.c_str())) + { + std::cerr << "Error copying Fortran module from \"" + << mod_upper.c_str() << "\" to \"" << stamp.c_str() + << "\".\n"; + return false; + } + } + return true; + } + else if(cmSystemTools::FileExists(mod_lower.c_str(), true)) + { + if(cmDependsFortran::ModulesDiffer(mod_lower.c_str(), stamp.c_str(), + compilerId.c_str())) + { + if(!cmSystemTools::CopyFileAlways(mod_lower.c_str(), stamp.c_str())) + { + std::cerr << "Error copying Fortran module from \"" + << mod_lower.c_str() << "\" to \"" << stamp.c_str() + << "\".\n"; + return false; + } + } + return true; + } + + std::cerr << "Error copying Fortran module \"" << args[2].c_str() + << "\". Tried \"" << mod_upper.c_str() + << "\" and \"" << mod_lower.c_str() << "\".\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 cmDependsFortranStreamContainsSequence(std::ifstream& 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 cmDependsFortranStreamsDiffer(std::ifstream& ifs1, + std::ifstream& 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 char* modFile, + const char* stampFile, + const char* compilerId) +{ + /* + gnu: + 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 absoulte 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(strcmp(compilerId, "SunPro") == 0) + { + return cmSystemTools::FilesDiffer(modFile, stampFile); + } + +#if defined(_WIN32) || defined(__CYGWIN__) + std::ifstream finModFile(modFile, std::ios::in | std::ios::binary); + std::ifstream finStampFile(stampFile, std::ios::in | std::ios::binary); +#else + std::ifstream finModFile(modFile, std::ios::in); + std::ifstream finStampFile(stampFile, std::ios::in); +#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 (strcmp(compilerId, "GNU") == 0 ) + { + const char seq[1] = {'\n'}; + const int seqlen = 1; + + if(!cmDependsFortranStreamContainsSequence(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(!cmDependsFortranStreamContainsSequence(finStampFile, seq, seqlen)) + { + // The stamp must differ if the sequence is not contained. + return true; + } + } + else if(strcmp(compilerId, "Intel") == 0) + { + const char seq[2] = {'\n', '\0'}; + const int seqlen = 2; + + if(!cmDependsFortranStreamContainsSequence(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(!cmDependsFortranStreamContainsSequence(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. + if(!cmDependsFortranStreamsDiffer(finModFile, finStampFile)) + { + return false; + } + + // The modules are different. + return true; +} + +//---------------------------------------------------------------------------- +bool cmDependsFortran::FindIncludeFile(const char* dir, + const char* includeName, + std::string& fileName) +{ + // If the file is a full path, include it directly. + if(cmSystemTools::FileIsFullPath(includeName)) + { + fileName = includeName; + return cmSystemTools::FileExists(fileName.c_str(), true); + } + else + { + // Check for the file in the directory containing the including + // file. + std::string fullName = dir; + fullName += "/"; + fullName += includeName; + if(cmSystemTools::FileExists(fullName.c_str(), true)) + { + fileName = fullName; + return true; + } + + // Search the include path for the file. + for(std::vector<std::string>::const_iterator i = + this->IncludePath.begin(); i != this->IncludePath.end(); ++i) + { + fullName = *i; + fullName += "/"; + fullName += includeName; + if(cmSystemTools::FileExists(fullName.c_str(), true)) + { + fileName = fullName; + return true; + } + } + } + return false; +} + +//---------------------------------------------------------------------------- +cmDependsFortranParser_s +::cmDependsFortranParser_s(cmDependsFortran* self, + std::set<std::string>& ppDefines, + cmDependsFortranSourceInfo& info): + Self(self), PPDefinitions(ppDefines), Info(info) +{ + this->InInterface = 0; + this->InPPFalseBranch = 0; + + // Initialize the lexical scanner. + cmDependsFortran_yylex_init(&this->Scanner); + cmDependsFortran_yyset_extra(this, this->Scanner); + + // Create a dummy buffer that is never read but is the fallback + // buffer when the last file is popped off the stack. + YY_BUFFER_STATE buffer = + cmDependsFortran_yy_create_buffer(0, 4, this->Scanner); + cmDependsFortran_yy_switch_to_buffer(buffer, this->Scanner); +} + +//---------------------------------------------------------------------------- +cmDependsFortranParser_s::~cmDependsFortranParser_s() +{ + cmDependsFortran_yylex_destroy(this->Scanner); +} + +//---------------------------------------------------------------------------- +bool cmDependsFortranParser_FilePush(cmDependsFortranParser* parser, + const char* fname) +{ + // Open the new file and push it onto the stack. Save the old + // buffer with it on the stack. + if(FILE* file = fopen(fname, "rb")) + { + YY_BUFFER_STATE current = + cmDependsFortranLexer_GetCurrentBuffer(parser->Scanner); + std::string dir = cmSystemTools::GetParentDirectory(fname); + cmDependsFortranFile f(file, current, dir); + YY_BUFFER_STATE buffer = + cmDependsFortran_yy_create_buffer(0, 16384, parser->Scanner); + cmDependsFortran_yy_switch_to_buffer(buffer, parser->Scanner); + parser->FileStack.push(f); + return 1; + } + else + { + return 0; + } +} + +//---------------------------------------------------------------------------- +bool cmDependsFortranParser_FilePop(cmDependsFortranParser* parser) +{ + // Pop one file off the stack and close it. Switch the lexer back + // to the next one on the stack. + if(parser->FileStack.empty()) + { + return 0; + } + else + { + cmDependsFortranFile f = parser->FileStack.top(); parser->FileStack.pop(); + fclose(f.File); + YY_BUFFER_STATE current = + cmDependsFortranLexer_GetCurrentBuffer(parser->Scanner); + cmDependsFortran_yy_delete_buffer(current, parser->Scanner); + cmDependsFortran_yy_switch_to_buffer(f.Buffer, parser->Scanner); + return 1; + } +} + +//---------------------------------------------------------------------------- +int cmDependsFortranParser_Input(cmDependsFortranParser* parser, + char* buffer, size_t bufferSize) +{ + // Read from the file on top of the stack. If the stack is empty, + // the end of the translation unit has been reached. + if(!parser->FileStack.empty()) + { + FILE* file = parser->FileStack.top().File; + return (int)fread(buffer, 1, bufferSize, file); + } + return 0; +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_StringStart(cmDependsFortranParser* parser) +{ + parser->TokenString = ""; +} + +//---------------------------------------------------------------------------- +const char* cmDependsFortranParser_StringEnd(cmDependsFortranParser* parser) +{ + return parser->TokenString.c_str(); +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_StringAppend(cmDependsFortranParser* parser, + char c) +{ + parser->TokenString += c; +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_SetInInterface(cmDependsFortranParser* parser, + bool in) +{ + if(parser->InPPFalseBranch) + { + return; + } + + parser->InInterface = in; +} + +//---------------------------------------------------------------------------- +bool cmDependsFortranParser_GetInInterface(cmDependsFortranParser* parser) +{ + return parser->InInterface; +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_SetOldStartcond(cmDependsFortranParser* parser, + int arg) +{ + parser->OldStartcond = arg; +} + +//---------------------------------------------------------------------------- +int cmDependsFortranParser_GetOldStartcond(cmDependsFortranParser* parser) +{ + return parser->OldStartcond; +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_Error(cmDependsFortranParser*, const char*) +{ + // If there is a parser error just ignore it. The source will not + // compile and the user will edit it. Then dependencies will have + // to be regenerated anyway. +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleUse(cmDependsFortranParser* parser, + const char* name) +{ + if(!parser->InPPFalseBranch) + { + parser->Info.Requires.insert(cmSystemTools::LowerCase(name) ); + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleInclude(cmDependsFortranParser* parser, + const char* name) +{ + if(parser->InPPFalseBranch) + { + return; + } + + // If processing an include statement there must be an open file. + assert(!parser->FileStack.empty()); + + // Get the directory containing the source in which the include + // statement appears. This is always the first search location for + // Fortran include files. + std::string dir = parser->FileStack.top().Directory; + + // Find the included file. If it cannot be found just ignore the + // problem because either the source will not compile or the user + // does not care about depending on this included source. + std::string fullName; + if(parser->Self->FindIncludeFile(dir.c_str(), name, fullName)) + { + // Found the included file. Save it in the set of included files. + parser->Info.Includes.insert(fullName); + + // Parse it immediately to translate the source inline. + cmDependsFortranParser_FilePush(parser, fullName.c_str()); + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleModule(cmDependsFortranParser* parser, + const char* name) +{ + if(!parser->InPPFalseBranch && !parser->InInterface) + { + parser->Info.Provides.insert(cmSystemTools::LowerCase(name)); + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleDefine(cmDependsFortranParser* parser, + const char* macro) +{ + if(!parser->InPPFalseBranch) + { + parser->PPDefinitions.insert(macro); + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleUndef(cmDependsFortranParser* parser, + const char* macro) +{ + if(!parser->InPPFalseBranch) + { + std::set<std::string>::iterator match; + match = parser->PPDefinitions.find(macro); + if(match != parser->PPDefinitions.end()) + { + parser->PPDefinitions.erase(match); + } + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleIfdef(cmDependsFortranParser* parser, + const char* macro) +{ + // A new PP branch has been opened + parser->SkipToEnd.push(false); + + if (parser->InPPFalseBranch) + { + parser->InPPFalseBranch++; + } + else if(parser->PPDefinitions.find(macro) == parser->PPDefinitions.end()) + { + parser->InPPFalseBranch=1; + } + else + { + parser->SkipToEnd.top() = true; + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleIfndef(cmDependsFortranParser* parser, + const char* macro) +{ + // A new PP branch has been opened + parser->SkipToEnd.push(false); + + if (parser->InPPFalseBranch) + { + parser->InPPFalseBranch++; + } + else if(parser->PPDefinitions.find(macro) != parser->PPDefinitions.end()) + { + parser->InPPFalseBranch = 1; + } + else + { + // ignore other branches + parser->SkipToEnd.top() = true; + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleIf(cmDependsFortranParser* parser) +{ + /* Note: The current parser is _not_ able to get statements like + * #if 0 + * #if 1 + * #if MYSMBOL + * #if defined(MYSYMBOL) + * #if defined(MYSYMBOL) && ... + * right. The same for #elif. Thus in + * #if SYMBOL_1 + * .. + * #elif SYMBOL_2 + * ... + * ... + * #elif SYMBOL_N + * .. + * #else + * .. + * #endif + * _all_ N+1 branches are considered. If you got something like this + * #if defined(MYSYMBOL) + * #if !defined(MYSYMBOL) + * use + * #ifdef MYSYMBOL + * #ifndef MYSYMBOL + * instead. + */ + + // A new PP branch has been opened + // Never skip! See note above. + parser->SkipToEnd.push(false); +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleElif(cmDependsFortranParser* parser) +{ + /* Note: There are parser limitations. See the note at + * cmDependsFortranParser_RuleIf(..) + */ + + // Always taken unless an #ifdef or #ifndef-branch has been taken + // already. If the second condition isn't meet already + // (parser->InPPFalseBranch == 0) correct it. + if(!parser->SkipToEnd.empty() && + parser->SkipToEnd.top() && !parser->InPPFalseBranch) + { + parser->InPPFalseBranch = 1; + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleElse(cmDependsFortranParser* parser) +{ + // if the parent branch is false do nothing! + if(parser->InPPFalseBranch > 1) + { + return; + } + + // parser->InPPFalseBranch is either 0 or 1. We change it depending on + // parser->SkipToEnd.top() + if(!parser->SkipToEnd.empty() && + parser->SkipToEnd.top()) + { + parser->InPPFalseBranch = 1; + } + else + { + parser->InPPFalseBranch = 0; + } +} + +//---------------------------------------------------------------------------- +void cmDependsFortranParser_RuleEndif(cmDependsFortranParser* parser) +{ + if(!parser->SkipToEnd.empty()) + { + parser->SkipToEnd.pop(); + } + + // #endif doesn't know if there was a "#else" in before, so it + // always decreases InPPFalseBranch + if(parser->InPPFalseBranch) + { + parser->InPPFalseBranch--; + } +} |