e11cd31fa0
We expect to handle all relevant statements and ignore those that we do not understand. Warn if this process ever fails. Otherwise dependency information may be silently left out.
361 lines
10 KiB
C++
361 lines
10 KiB
C++
/*============================================================================
|
|
CMake - Cross Platform Makefile Generator
|
|
Copyright 2000-2015 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 "cmFortranParser.h"
|
|
#include "cmFortranLexer.h"
|
|
#include "cmSystemTools.h"
|
|
|
|
#include <assert.h>
|
|
#include <cmConfigure.h>
|
|
#include <set>
|
|
#include <stack>
|
|
#include <stdio.h>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
bool cmFortranParser_s::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);
|
|
}
|
|
// 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;
|
|
}
|
|
|
|
cmFortranParser_s::cmFortranParser_s(std::vector<std::string> const& includes,
|
|
std::set<std::string> const& defines,
|
|
cmFortranSourceInfo& info)
|
|
: IncludePath(includes)
|
|
, PPDefinitions(defines)
|
|
, Info(info)
|
|
{
|
|
this->InInterface = 0;
|
|
this->InPPFalseBranch = 0;
|
|
|
|
// Initialize the lexical scanner.
|
|
cmFortran_yylex_init(&this->Scanner);
|
|
cmFortran_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 =
|
|
cmFortran_yy_create_buffer(CM_NULLPTR, 4, this->Scanner);
|
|
cmFortran_yy_switch_to_buffer(buffer, this->Scanner);
|
|
}
|
|
|
|
cmFortranParser_s::~cmFortranParser_s()
|
|
{
|
|
cmFortran_yylex_destroy(this->Scanner);
|
|
}
|
|
|
|
bool cmFortranParser_FilePush(cmFortranParser* 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 = cmsys::SystemTools::Fopen(fname, "rb")) {
|
|
YY_BUFFER_STATE current = cmFortranLexer_GetCurrentBuffer(parser->Scanner);
|
|
std::string dir = cmSystemTools::GetParentDirectory(fname);
|
|
cmFortranFile f(file, current, dir);
|
|
YY_BUFFER_STATE buffer =
|
|
cmFortran_yy_create_buffer(CM_NULLPTR, 16384, parser->Scanner);
|
|
cmFortran_yy_switch_to_buffer(buffer, parser->Scanner);
|
|
parser->FileStack.push(f);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool cmFortranParser_FilePop(cmFortranParser* 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;
|
|
}
|
|
cmFortranFile f = parser->FileStack.top();
|
|
parser->FileStack.pop();
|
|
fclose(f.File);
|
|
YY_BUFFER_STATE current = cmFortranLexer_GetCurrentBuffer(parser->Scanner);
|
|
cmFortran_yy_delete_buffer(current, parser->Scanner);
|
|
cmFortran_yy_switch_to_buffer(f.Buffer, parser->Scanner);
|
|
return 1;
|
|
}
|
|
|
|
int cmFortranParser_Input(cmFortranParser* 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 cmFortranParser_StringStart(cmFortranParser* parser)
|
|
{
|
|
parser->TokenString = "";
|
|
}
|
|
|
|
const char* cmFortranParser_StringEnd(cmFortranParser* parser)
|
|
{
|
|
return parser->TokenString.c_str();
|
|
}
|
|
|
|
void cmFortranParser_StringAppend(cmFortranParser* parser, char c)
|
|
{
|
|
parser->TokenString += c;
|
|
}
|
|
|
|
void cmFortranParser_SetInInterface(cmFortranParser* parser, bool in)
|
|
{
|
|
if (parser->InPPFalseBranch) {
|
|
return;
|
|
}
|
|
|
|
parser->InInterface = in;
|
|
}
|
|
|
|
bool cmFortranParser_GetInInterface(cmFortranParser* parser)
|
|
{
|
|
return parser->InInterface;
|
|
}
|
|
|
|
void cmFortranParser_SetOldStartcond(cmFortranParser* parser, int arg)
|
|
{
|
|
parser->OldStartcond = arg;
|
|
}
|
|
|
|
int cmFortranParser_GetOldStartcond(cmFortranParser* parser)
|
|
{
|
|
return parser->OldStartcond;
|
|
}
|
|
|
|
void cmFortranParser_Error(cmFortranParser* parser, const char* msg)
|
|
{
|
|
parser->Error = msg ? msg : "unknown error";
|
|
}
|
|
|
|
void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name)
|
|
{
|
|
if (!parser->InPPFalseBranch) {
|
|
parser->Info.Requires.insert(cmSystemTools::LowerCase(name));
|
|
}
|
|
}
|
|
|
|
void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
|
|
const char* filename)
|
|
{
|
|
// This is a #line directive naming a file encountered during preprocessing.
|
|
std::string included = filename;
|
|
|
|
// Skip #line directives referencing non-files like
|
|
// "<built-in>" or "<command-line>".
|
|
if (included.empty() || included[0] == '<') {
|
|
return;
|
|
}
|
|
|
|
// Fix windows file path separators since our lexer does not
|
|
// process escape sequences in string literals.
|
|
cmSystemTools::ReplaceString(included, "\\\\", "\\");
|
|
cmSystemTools::ConvertToUnixSlashes(included);
|
|
|
|
// Save the named file as included in the source.
|
|
if (cmSystemTools::FileExists(included, true)) {
|
|
parser->Info.Includes.insert(included);
|
|
}
|
|
}
|
|
|
|
void cmFortranParser_RuleInclude(cmFortranParser* 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->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.
|
|
cmFortranParser_FilePush(parser, fullName.c_str());
|
|
}
|
|
}
|
|
|
|
void cmFortranParser_RuleModule(cmFortranParser* parser, const char* name)
|
|
{
|
|
if (!parser->InPPFalseBranch && !parser->InInterface) {
|
|
parser->Info.Provides.insert(cmSystemTools::LowerCase(name));
|
|
}
|
|
}
|
|
|
|
void cmFortranParser_RuleDefine(cmFortranParser* parser, const char* macro)
|
|
{
|
|
if (!parser->InPPFalseBranch) {
|
|
parser->PPDefinitions.insert(macro);
|
|
}
|
|
}
|
|
|
|
void cmFortranParser_RuleUndef(cmFortranParser* 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 cmFortranParser_RuleIfdef(cmFortranParser* 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 cmFortranParser_RuleIfndef(cmFortranParser* 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 cmFortranParser_RuleIf(cmFortranParser* 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 cmFortranParser_RuleElif(cmFortranParser* parser)
|
|
{
|
|
/* Note: There are parser limitations. See the note at
|
|
* cmFortranParser_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 cmFortranParser_RuleElse(cmFortranParser* 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 cmFortranParser_RuleEndif(cmFortranParser* 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--;
|
|
}
|
|
}
|