kolan/CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'fortran-parser-updates'

Browse Source 
ecca8fd9 cmFortranParser: Port to bison 3
eebe732b cmFortranParser: Factor out of cmDependsFortran
fd194458 cmDependsFortran: Simplify storage of preprocessor definitions
295480b9 cmDependsFortran: Move FindIncludeFile method into parser class
98b9645b Rename Fortran parser infrastructure to drop "Depends" prefix
096dd3c9 cmDependsFortranLexer: Remove trailing blank line
This commit is contained in:
Brad King 2015-07-28 10:08:37 -04:00 committed by CMake Topic Stage
commit 24dd88d156
12 changed files with 1465 additions and 1638 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Source/CMakeLists.txt
View File

@ -88,7 +88,7 @@ option(CMAKE_REGENERATE_YACCLEX
"Regenerate YACC and LEXX files" OFF) "Regenerate YACC and LEXX files" OFF)
mark_as_advanced(CMAKE_REGENERATE_YACCLEX) mark_as_advanced(CMAKE_REGENERATE_YACCLEX)
if(CMAKE_REGENERATE_YACCLEX) if(CMAKE_REGENERATE_YACCLEX)
set(parsersLexers cmDependsFortran cmCommandArgument cmExpr) set(parsersLexers cmFortran cmCommandArgument cmExpr)
find_program(YACC_EXECUTABLE find_program(YACC_EXECUTABLE
NAMES yacc bison NAMES yacc bison
PATHS /usr/bin PATHS /usr/bin
@ -193,9 +193,6 @@ set(SRCS
cmDependsC.h cmDependsC.h
cmDependsFortran.cxx cmDependsFortran.cxx
cmDependsFortran.h cmDependsFortran.h
cmDependsFortranLexer.cxx
cmDependsFortranParser.cxx
cmDependsFortranParser.h
cmDependsJava.cxx cmDependsJava.cxx
cmDependsJava.h cmDependsJava.h
cmDependsJavaLexer.cxx cmDependsJavaLexer.cxx
@ -243,6 +240,11 @@ set(SRCS
cmFileLockResult.h cmFileLockResult.h
cmFileTimeComparison.cxx cmFileTimeComparison.cxx
cmFileTimeComparison.h cmFileTimeComparison.h
cmFortranLexer.cxx
cmFortranLexer.h
cmFortranParser.cxx
cmFortranParser.h
cmFortranParserImpl.cxx
cmGeneratedFileStream.cxx cmGeneratedFileStream.cxx
cmGeneratorExpressionContext.cxx cmGeneratorExpressionContext.cxx
cmGeneratorExpressionContext.h cmGeneratorExpressionContext.h

512
Source/cmDependsFortran.cxx
View File

@ -16,83 +16,14 @@
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmDependsFortranParser.h" /* Interface to parser object. */ #include "cmFortranParser.h" /* Interface to parser object. */
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <assert.h> #include <assert.h>
#include <stack>
// TODO: Test compiler for the case of the mod file. Some always // 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 lower case and some always use upper case. I do not know if any
// use the case from the source code. // 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<std::string> Provides;
std::set<std::string> Requires;
// Set of files included in the translation unit.
std::set<std::string> 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 class cmDependsFortranInternals
{ {
@ -105,18 +36,18 @@ public:
TargetRequiresMap TargetRequires; TargetRequiresMap TargetRequires;
// Information about each object file. // Information about each object file.
typedef std::map<std::string, cmDependsFortranSourceInfo> ObjectInfoMap; typedef std::map<std::string, cmFortranSourceInfo> ObjectInfoMap;
ObjectInfoMap ObjectInfo; ObjectInfoMap ObjectInfo;
cmDependsFortranSourceInfo& CreateObjectInfo(const char* obj, cmFortranSourceInfo& CreateObjectInfo(const char* obj,
const char* src) const char* src)
{ {
std::map<std::string, cmDependsFortranSourceInfo>::iterator i = std::map<std::string, cmFortranSourceInfo>::iterator i =
this->ObjectInfo.find(obj); this->ObjectInfo.find(obj);
if(i == this->ObjectInfo.end()) if(i == this->ObjectInfo.end())
{ {
std::map<std::string, cmDependsFortranSourceInfo>::value_type std::map<std::string, cmFortranSourceInfo>::value_type
entry(obj, cmDependsFortranSourceInfo()); entry(obj, cmFortranSourceInfo());
i = this->ObjectInfo.insert(entry).first; i = this->ObjectInfo.insert(entry).first;
i->second.Source = src; i->second.Source = src;
} }
@ -126,7 +57,7 @@ public:
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmDependsFortran::cmDependsFortran(): cmDependsFortran::cmDependsFortran():
PPDefinitions(0), Internal(0) Internal(0)
{ {
} }
@ -159,7 +90,7 @@ cmDependsFortran
{ {
def = it->substr(0, assignment); def = it->substr(0, assignment);
} }
this->PPDefinitions.push_back(def); this->PPDefinitions.insert(def);
} }
} }
@ -192,22 +123,18 @@ bool cmDependsFortran::WriteDependencies(
{ {
const std::string& src = *it; const std::string& src = *it;
// Get the information object for this source. // Get the information object for this source.
cmDependsFortranSourceInfo& info = cmFortranSourceInfo& info =
this->Internal->CreateObjectInfo(obj.c_str(), src.c_str()); this->Internal->CreateObjectInfo(obj.c_str(), src.c_str());
// Make a copy of the macros defined via ADD_DEFINITIONS // Create the parser object. The constructor takes info by reference,
std::set<std::string> ppDefines(this->PPDefinitions.begin(), // so we may look into the resulting objects later.
this->PPDefinitions.end()); cmFortranParser parser(this->IncludePath, this->PPDefinitions, info);
// 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. // Push on the starting file.
cmDependsFortranParser_FilePush(&parser, src.c_str()); cmFortranParser_FilePush(&parser, src.c_str());
// Parse the translation unit. // Parse the translation unit.
if(cmDependsFortran_yyparse(parser.Scanner) != 0) if(cmFortran_yyparse(parser.Scanner) != 0)
{ {
// Failed to parse the file. Report failure to write dependencies. // Failed to parse the file. Report failure to write dependencies.
okay = false; okay = false;
@ -318,7 +245,7 @@ void cmDependsFortran::LocateModules()
for(ObjectInfoMap::const_iterator infoI = objInfo.begin(); for(ObjectInfoMap::const_iterator infoI = objInfo.begin();
infoI != objInfo.end(); ++infoI) infoI != objInfo.end(); ++infoI)
{ {
cmDependsFortranSourceInfo const& info = infoI->second; cmFortranSourceInfo const& info = infoI->second;
// Include this module in the set provided by this target. // Include this module in the set provided by this target.
this->Internal->TargetProvides.insert(info.Provides.begin(), this->Internal->TargetProvides.insert(info.Provides.begin(),
info.Provides.end()); info.Provides.end());
@ -428,7 +355,7 @@ void cmDependsFortran::ConsiderModule(const char* name,
bool bool
cmDependsFortran cmDependsFortran
::WriteDependenciesReal(const char *obj, ::WriteDependenciesReal(const char *obj,
cmDependsFortranSourceInfo const& info, cmFortranSourceInfo const& info,
const char* mod_dir, const char* stamp_dir, const char* mod_dir, const char* stamp_dir,
std::ostream& makeDepends, std::ostream& makeDepends,
std::ostream& internalDepends) std::ostream& internalDepends)
@ -701,7 +628,7 @@ bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
// is later used for longer sequences it should be re-written using an // is later used for longer sequences it should be re-written using an
// efficient string search algorithm such as Boyer-Moore. // efficient string search algorithm such as Boyer-Moore.
static static
bool cmDependsFortranStreamContainsSequence(std::istream& ifs, bool cmFortranStreamContainsSequence(std::istream& ifs,
const char* seq, int len) const char* seq, int len)
{ {
assert(len > 0); assert(len > 0);
@ -734,7 +661,7 @@ bool cmDependsFortranStreamContainsSequence(std::istream& ifs,
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// Helper function to compare the remaining content in two streams. // Helper function to compare the remaining content in two streams.
static bool cmDependsFortranStreamsDiffer(std::istream& ifs1, static bool cmFortranStreamsDiffer(std::istream& ifs1,
std::istream& ifs2) std::istream& ifs2)
{ {
// Compare the remaining content. // Compare the remaining content.
@ -837,7 +764,7 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
const char seq[1] = {'\n'}; const char seq[1] = {'\n'};
const int seqlen = 1; const int seqlen = 1;
if(!cmDependsFortranStreamContainsSequence(finModFile, seq, seqlen)) if(!cmFortranStreamContainsSequence(finModFile, seq, seqlen))
{ {
// The module is of unexpected format. Assume it is different. // The module is of unexpected format. Assume it is different.
std::cerr << compilerId << " fortran module " << modFile std::cerr << compilerId << " fortran module " << modFile
@ -845,7 +772,7 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
return true; return true;
} }
if(!cmDependsFortranStreamContainsSequence(finStampFile, seq, seqlen)) if(!cmFortranStreamContainsSequence(finStampFile, seq, seqlen))
{ {
// The stamp must differ if the sequence is not contained. // The stamp must differ if the sequence is not contained.
return true; return true;
@ -857,7 +784,7 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
const char seq[2] = {'\n', '\0'}; const char seq[2] = {'\n', '\0'};
const int seqlen = 2; const int seqlen = 2;
if(!cmDependsFortranStreamContainsSequence(finModFile, seq, seqlen)) if(!cmFortranStreamContainsSequence(finModFile, seq, seqlen))
{ {
// The module is of unexpected format. Assume it is different. // The module is of unexpected format. Assume it is different.
std::cerr << compilerId << " fortran module " << modFile std::cerr << compilerId << " fortran module " << modFile
@ -865,7 +792,7 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
return true; return true;
} }
if(!cmDependsFortranStreamContainsSequence(finStampFile, seq, seqlen)) if(!cmFortranStreamContainsSequence(finStampFile, seq, seqlen))
{ {
// The stamp must differ if the sequence is not contained. // The stamp must differ if the sequence is not contained.
return true; return true;
@ -875,7 +802,7 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
// Compare the remaining content. If no compiler id matched above, // Compare the remaining content. If no compiler id matched above,
// including the case none was given, this will compare the whole // including the case none was given, this will compare the whole
// content. // content.
if(!cmDependsFortranStreamsDiffer(finModFile, finStampFile)) if(!cmFortranStreamsDiffer(finModFile, finStampFile))
{ {
return false; return false;
} }
@ -883,396 +810,3 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
// The modules are different. // The modules are different.
return true; 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 = cmsys::SystemTools::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--;
}
}

16
Source/cmDependsFortran.h
View File

@ -9,13 +9,13 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information. See the License for more information.
============================================================================*/ ============================================================================*/
#ifndef cmDependsFortran_h #ifndef cmFortran_h
#define cmDependsFortran_h #define cmFortran_h
#include "cmDepends.h" #include "cmDepends.h"
class cmDependsFortranInternals; class cmDependsFortranInternals;
class cmDependsFortranSourceInfo; class cmFortranSourceInfo;
/** \class cmDependsFortran /** \class cmDependsFortran
* \brief Dependency scanner for Fortran object files. * \brief Dependency scanner for Fortran object files.
@ -46,12 +46,6 @@ public:
static bool ModulesDiffer(const char* modFile, const char* stampFile, static bool ModulesDiffer(const char* modFile, const char* stampFile,
const char* compilerId); const char* compilerId);
/** Method to find an included file in the include path. Fortran
always searches the directory containing the including source
first. */
bool FindIncludeFile(const char* dir, const char* includeName,
std::string& fileName);
protected: protected:
// Finalize the dependency information for the target. // Finalize the dependency information for the target.
virtual bool Finalize(std::ostream& makeDepends, virtual bool Finalize(std::ostream& makeDepends,
@ -71,7 +65,7 @@ protected:
// Actually write the depenencies to the streams. // Actually write the depenencies to the streams.
bool WriteDependenciesReal(const char *obj, bool WriteDependenciesReal(const char *obj,
cmDependsFortranSourceInfo const& info, cmFortranSourceInfo const& info,
const char* mod_dir, const char* stamp_dir, const char* mod_dir, const char* stamp_dir,
std::ostream& makeDepends, std::ostream& makeDepends,
std::ostream& internalDepends); std::ostream& internalDepends);
@ -79,7 +73,7 @@ protected:
// The source file from which to start scanning. // The source file from which to start scanning.
std::string SourceFile; std::string SourceFile;
std::vector<std::string> PPDefinitions; std::set<std::string> PPDefinitions;
// Internal implementation details. // Internal implementation details.
cmDependsFortranInternals* Internal; cmDependsFortranInternals* Internal;

96
Source/cmDependsFortranParser.h
View File

@ -1,96 +0,0 @@
/*============================================================================
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.
============================================================================*/
#ifndef cmDependsFortranParser_h
#define cmDependsFortranParser_h
#include <stddef.h> /* size_t */
/* Forward declare parser object type. */
typedef struct cmDependsFortranParser_s cmDependsFortranParser;
/* Functions to enter/exit #include'd files in order. */
bool cmDependsFortranParser_FilePush(cmDependsFortranParser* parser,
const char* fname);
bool cmDependsFortranParser_FilePop(cmDependsFortranParser* parser);
/* Callbacks for lexer. */
int cmDependsFortranParser_Input(cmDependsFortranParser* parser,
char* buffer, size_t bufferSize);
void cmDependsFortranParser_StringStart(cmDependsFortranParser* parser);
const char* cmDependsFortranParser_StringEnd(cmDependsFortranParser* parser);
void cmDependsFortranParser_StringAppend(cmDependsFortranParser* parser,
char c);
void cmDependsFortranParser_SetInInterface(cmDependsFortranParser* parser,
bool is_in);
bool cmDependsFortranParser_GetInInterface(cmDependsFortranParser* parser);
void cmDependsFortranParser_SetInPPFalseBranch(cmDependsFortranParser* parser,
bool is_in);
bool cmDependsFortranParser_GetInPPFalseBranch(cmDependsFortranParser* parser);
void cmDependsFortranParser_SetOldStartcond(cmDependsFortranParser* parser,
int arg);
int cmDependsFortranParser_GetOldStartcond(cmDependsFortranParser* parser);
/* Callbacks for parser. */
void cmDependsFortranParser_Error(cmDependsFortranParser* parser,
const char* message);
void cmDependsFortranParser_RuleUse(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleInclude(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleModule(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleDefine(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleUndef(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleIfdef(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleIfndef(cmDependsFortranParser* parser,
const char* name);
void cmDependsFortranParser_RuleIf(cmDependsFortranParser* parser);
void cmDependsFortranParser_RuleElif(cmDependsFortranParser* parser);
void cmDependsFortranParser_RuleElse(cmDependsFortranParser* parser);
void cmDependsFortranParser_RuleEndif(cmDependsFortranParser* parser);
/* Define the parser stack element type. */
typedef union cmDependsFortran_yystype_u cmDependsFortran_yystype;
union cmDependsFortran_yystype_u
{
char* string;
};
/* Setup the proper yylex interface. */
#define YY_EXTRA_TYPE cmDependsFortranParser*
#define YY_DECL \
int cmDependsFortran_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
#define YYSTYPE cmDependsFortran_yystype
#define YYSTYPE_IS_DECLARED 1
#if !defined(cmDependsFortranLexer_cxx)
# include "cmDependsFortranLexer.h"
#endif
#if !defined(cmDependsFortranLexer_cxx)
#if !defined(cmDependsFortranParser_cxx)
# undef YY_EXTRA_TYPE
# undef YY_DECL
# undef YYSTYPE
# undef YYSTYPE_IS_DECLARED
#endif
#endif
#endif

451
Source/cmDependsFortranLexer.cxx → Source/cmFortranLexer.cxx
View File

File diff suppressed because it is too large Load Diff

76
Source/cmDependsFortranLexer.h → Source/cmFortranLexer.h
View File

@ -9,9 +9,9 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information. See the License for more information.
============================================================================*/ ============================================================================*/
#ifndef cmDependsFortran_yyHEADER_H #ifndef cmFortran_yyHEADER_H
#define cmDependsFortran_yyHEADER_H 1 #define cmFortran_yyHEADER_H 1
#define cmDependsFortran_yyIN_HEADER 1 #define cmFortran_yyIN_HEADER 1
#define YY_INT_ALIGNED short int #define YY_INT_ALIGNED short int
@ -211,25 +211,25 @@ struct yy_buffer_state
}; };
#endif /* !YY_STRUCT_YY_BUFFER_STATE */ #endif /* !YY_STRUCT_YY_BUFFER_STATE */
void cmDependsFortran_yyrestart (FILE *input_file ,yyscan_t yyscanner ); void cmFortran_yyrestart (FILE *input_file ,yyscan_t yyscanner );
void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); void cmFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); void cmFortran_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); void cmFortran_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); void cmFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner ); void cmFortran_yypop_buffer_state (yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *cmFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); void *cmFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
void cmDependsFortran_yyfree (void * ,yyscan_t yyscanner ); void cmFortran_yyfree (void * ,yyscan_t yyscanner );
/* Begin user sect3 */ /* Begin user sect3 */
#define cmDependsFortran_yywrap(n) 1 #define cmFortran_yywrap(n) 1
#define YY_SKIP_YYWRAP #define YY_SKIP_YYWRAP
#define yytext_ptr yytext_r #define yytext_ptr yytext_r
@ -247,38 +247,38 @@ void cmDependsFortran_yyfree (void * ,yyscan_t yyscanner );
#define YY_EXTRA_TYPE void * #define YY_EXTRA_TYPE void *
#endif #endif
int cmDependsFortran_yylex_init (yyscan_t* scanner); int cmFortran_yylex_init (yyscan_t* scanner);
int cmDependsFortran_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); int cmFortran_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
/* Accessor methods to globals. /* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */ These are made visible to non-reentrant scanners for convenience. */
int cmDependsFortran_yylex_destroy (yyscan_t yyscanner ); int cmFortran_yylex_destroy (yyscan_t yyscanner );
int cmDependsFortran_yyget_debug (yyscan_t yyscanner ); int cmFortran_yyget_debug (yyscan_t yyscanner );
void cmDependsFortran_yyset_debug (int debug_flag ,yyscan_t yyscanner ); void cmFortran_yyset_debug (int debug_flag ,yyscan_t yyscanner );
YY_EXTRA_TYPE cmDependsFortran_yyget_extra (yyscan_t yyscanner ); YY_EXTRA_TYPE cmFortran_yyget_extra (yyscan_t yyscanner );
void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); void cmFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
FILE *cmDependsFortran_yyget_in (yyscan_t yyscanner ); FILE *cmFortran_yyget_in (yyscan_t yyscanner );
void cmDependsFortran_yyset_in (FILE * in_str ,yyscan_t yyscanner ); void cmFortran_yyset_in (FILE * in_str ,yyscan_t yyscanner );
FILE *cmDependsFortran_yyget_out (yyscan_t yyscanner ); FILE *cmFortran_yyget_out (yyscan_t yyscanner );
void cmDependsFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner ); void cmFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner );
int cmDependsFortran_yyget_leng (yyscan_t yyscanner ); int cmFortran_yyget_leng (yyscan_t yyscanner );
char *cmDependsFortran_yyget_text (yyscan_t yyscanner ); char *cmFortran_yyget_text (yyscan_t yyscanner );
int cmDependsFortran_yyget_lineno (yyscan_t yyscanner ); int cmFortran_yyget_lineno (yyscan_t yyscanner );
void cmDependsFortran_yyset_lineno (int line_number ,yyscan_t yyscanner ); void cmFortran_yyset_lineno (int line_number ,yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in /* Macros after this point can all be overridden by user definitions in
* section 1. * section 1.
@ -286,9 +286,9 @@ void cmDependsFortran_yyset_lineno (int line_number ,yyscan_t yyscanner );
#ifndef YY_SKIP_YYWRAP #ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus #ifdef __cplusplus
extern "C" int cmDependsFortran_yywrap (yyscan_t yyscanner ); extern "C" int cmFortran_yywrap (yyscan_t yyscanner );
#else #else
extern int cmDependsFortran_yywrap (yyscan_t yyscanner ); extern int cmFortran_yywrap (yyscan_t yyscanner );
#endif #endif
#endif #endif
@ -325,9 +325,9 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
#ifndef YY_DECL #ifndef YY_DECL
#define YY_DECL_IS_OURS 1 #define YY_DECL_IS_OURS 1
extern int cmDependsFortran_yylex (yyscan_t yyscanner); extern int cmFortran_yylex (yyscan_t yyscanner);
#define YY_DECL int cmDependsFortran_yylex (yyscan_t yyscanner) #define YY_DECL int cmFortran_yylex (yyscan_t yyscanner)
#endif /* !YY_DECL */ #endif /* !YY_DECL */
/* yy_get_previous_state - get the state just before the EOB char was reached */ /* yy_get_previous_state - get the state just before the EOB char was reached */
@ -344,5 +344,5 @@ extern int cmDependsFortran_yylex (yyscan_t yyscanner);
#undef YY_DECL #undef YY_DECL
#endif #endif
#undef cmDependsFortran_yyIN_HEADER #undef cmFortran_yyIN_HEADER
#endif /* cmDependsFortran_yyHEADER_H */ #endif /* cmFortran_yyHEADER_H */

38
Source/cmDependsFortranLexer.in.l → Source/cmFortranLexer.in.l
View File

@ -26,18 +26,18 @@ This file must be translated to C and modified to build everywhere.
Run flex like this: Run flex like this:
flex -i --prefix=cmDependsFortran_yy --header-file=cmDependsFortranLexer.h -ocmDependsFortranLexer.cxx cmDependsFortranLexer.in.l flex -i --prefix=cmFortran_yy --header-file=cmFortranLexer.h -ocmFortranLexer.cxx cmFortranLexer.in.l
Modify cmDependsFortranLexer.cxx: Modify cmFortranLexer.cxx:
- remove TABs - remove TABs
- remove use of the 'register' storage class specifier - remove use of the 'register' storage class specifier
- remove "yyscanner" argument from these methods: - remove "yyscanner" argument from these methods:
yy_fatal_error, cmDependsFortran_yyalloc, cmDependsFortran_yyrealloc, cmDependsFortran_yyfree yy_fatal_error, cmFortran_yyalloc, cmFortran_yyrealloc, cmFortran_yyfree
- remove "yyscanner = NULL" from end of cmDependsFortran_yylex_destroy - remove "yyscanner = NULL" from end of cmFortran_yylex_destroy
- remove all YY_BREAK lines occurring right after return statements - remove all YY_BREAK lines occurring right after return statements
- change while ( 1 ) to for(;;) - change while ( 1 ) to for(;;)
Modify cmDependsFortranLexer.h: Modify cmFortranLexer.h:
- remove TABs - remove TABs
- remove the yy_init_globals function - remove the yy_init_globals function
- remove the block that includes unistd.h - remove the block that includes unistd.h
@ -47,16 +47,16 @@ Modify cmDependsFortranLexer.h:
#include "cmStandardLexer.h" #include "cmStandardLexer.h"
#define cmDependsFortranLexer_cxx #define cmFortranLexer_cxx
#include "cmDependsFortranParser.h" /* Interface to parser object. */ #include "cmFortranParser.h" /* Interface to parser object. */
/* Replace the lexer input function. */ /* Replace the lexer input function. */
#undef YY_INPUT #undef YY_INPUT
#define YY_INPUT(buf, result, max_size) \ #define YY_INPUT(buf, result, max_size) \
{ result = cmDependsFortranParser_Input(yyextra, buf, max_size); } { result = cmFortranParser_Input(yyextra, buf, max_size); }
/* Include the set of tokens from the parser. */ /* Include the set of tokens from the parser. */
#include "cmDependsFortranParserTokens.h" #include "cmFortranParserTokens.h"
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
%} %}
@ -72,21 +72,21 @@ Modify cmDependsFortranLexer.h:
%% %%
\" { \" {
cmDependsFortranParser_StringStart(yyextra); cmFortranParser_StringStart(yyextra);
cmDependsFortranParser_SetOldStartcond(yyextra, YY_START); cmFortranParser_SetOldStartcond(yyextra, YY_START);
BEGIN(str_dq); BEGIN(str_dq);
} }
' { ' {
cmDependsFortranParser_StringStart(yyextra); cmFortranParser_StringStart(yyextra);
cmDependsFortranParser_SetOldStartcond(yyextra, YY_START); cmFortranParser_SetOldStartcond(yyextra, YY_START);
BEGIN(str_sq); BEGIN(str_sq);
} }
<str_dq>\" | <str_dq>\" |
<str_sq>' { <str_sq>' {
BEGIN(cmDependsFortranParser_GetOldStartcond(yyextra) ); BEGIN(cmFortranParser_GetOldStartcond(yyextra) );
yylvalp->string = strdup(cmDependsFortranParser_StringEnd(yyextra)); yylvalp->string = strdup(cmFortranParser_StringEnd(yyextra));
return STRING; return STRING;
} }
@ -94,7 +94,7 @@ Modify cmDependsFortranLexer.h:
<str_dq,str_sq>&[ \t]*\n[ \t]*& /* Ignore (continued strings, free fmt) */ <str_dq,str_sq>&[ \t]*\n[ \t]*& /* Ignore (continued strings, free fmt) */
<fixed_fmt,str_dq,str_sq>\n[ ]{5}[^ \t\n] { <fixed_fmt,str_dq,str_sq>\n[ ]{5}[^ \t\n] {
if (cmDependsFortranParser_GetOldStartcond(yyextra) == fixed_fmt) if (cmFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
; /* Ignore (cont. strings, fixed fmt) */ ; /* Ignore (cont. strings, fixed fmt) */
else else
{ {
@ -110,7 +110,7 @@ Modify cmDependsFortranLexer.h:
} }
<str_sq,str_dq>. { <str_sq,str_dq>. {
cmDependsFortranParser_StringAppend(yyextra, yytext[0]); cmFortranParser_StringAppend(yyextra, yytext[0]);
} }
!.*\n { return EOSTMT; } /* Treat comments like */ !.*\n { return EOSTMT; } /* Treat comments like */
@ -173,7 +173,7 @@ $[ \t]*endif { return F90PPR_ENDIF; }
. { return *yytext; } . { return *yytext; }
<<EOF>> { <<EOF>> {
if(!cmDependsFortranParser_FilePop(yyextra) ) if(!cmFortranParser_FilePop(yyextra) )
{ {
return YY_NULL; return YY_NULL;
} }
@ -182,7 +182,7 @@ $[ \t]*endif { return F90PPR_ENDIF; }
%% %%
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
YY_BUFFER_STATE cmDependsFortranLexer_GetCurrentBuffer(yyscan_t yyscanner) YY_BUFFER_STATE cmFortranLexer_GetCurrentBuffer(yyscan_t yyscanner)
{ {
/* Hack into the internal flex-generated scanner to get the buffer. */ /* Hack into the internal flex-generated scanner to get the buffer. */
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

1059
Source/cmDependsFortranParser.cxx → Source/cmFortranParser.cxx
View File

File diff suppressed because it is too large Load Diff

175
Source/cmFortranParser.h Normal file
View File

@ -0,0 +1,175 @@
/*============================================================================
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.
============================================================================*/
#ifndef cmFortranParser_h
#define cmFortranParser_h
#if !defined(cmFortranLexer_cxx) && !defined(cmFortranParser_cxx)
# include "cmStandardIncludes.h"
#endif
#include <stddef.h> /* size_t */
/* Forward declare parser object type. */
typedef struct cmFortranParser_s cmFortranParser;
/* Functions to enter/exit #include'd files in order. */
bool cmFortranParser_FilePush(cmFortranParser* parser,
const char* fname);
bool cmFortranParser_FilePop(cmFortranParser* parser);
/* Callbacks for lexer. */
int cmFortranParser_Input(cmFortranParser* parser,
char* buffer, size_t bufferSize);
void cmFortranParser_StringStart(cmFortranParser* parser);
const char* cmFortranParser_StringEnd(cmFortranParser* parser);
void cmFortranParser_StringAppend(cmFortranParser* parser,
char c);
void cmFortranParser_SetInInterface(cmFortranParser* parser,
bool is_in);
bool cmFortranParser_GetInInterface(cmFortranParser* parser);
void cmFortranParser_SetInPPFalseBranch(cmFortranParser* parser,
bool is_in);
bool cmFortranParser_GetInPPFalseBranch(cmFortranParser* parser);
void cmFortranParser_SetOldStartcond(cmFortranParser* parser,
int arg);
int cmFortranParser_GetOldStartcond(cmFortranParser* parser);
/* Callbacks for parser. */
void cmFortranParser_Error(cmFortranParser* parser,
const char* message);
void cmFortranParser_RuleUse(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleInclude(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleModule(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleDefine(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleUndef(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleIfdef(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleIfndef(cmFortranParser* parser,
const char* name);
void cmFortranParser_RuleIf(cmFortranParser* parser);
void cmFortranParser_RuleElif(cmFortranParser* parser);
void cmFortranParser_RuleElse(cmFortranParser* parser);
void cmFortranParser_RuleEndif(cmFortranParser* parser);
/* Define the parser stack element type. */
typedef union cmFortran_yystype_u cmFortran_yystype;
union cmFortran_yystype_u
{
char* string;
};
/* Setup the proper yylex interface. */
#define YY_EXTRA_TYPE cmFortranParser*
#define YY_DECL \
int cmFortran_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
#define YYSTYPE cmFortran_yystype
#define YYSTYPE_IS_DECLARED 1
#if !defined(cmFortranLexer_cxx)
# include "cmFortranLexer.h"
#endif
#if !defined(cmFortranLexer_cxx)
#if !defined(cmFortranParser_cxx)
# undef YY_EXTRA_TYPE
# undef YY_DECL
# undef YYSTYPE
# undef YYSTYPE_IS_DECLARED
#endif
#endif
#if !defined(cmFortranLexer_cxx) && !defined(cmFortranParser_cxx)
#include <stack>
//----------------------------------------------------------------------------
// Information about a single source file.
class cmFortranSourceInfo
{
public:
// The name of the source file.
std::string Source;
// Set of provided and required modules.
std::set<std::string> Provides;
std::set<std::string> Requires;
// Set of files included in the translation unit.
std::set<std::string> Includes;
};
//----------------------------------------------------------------------------
// Parser methods not included in generated interface.
// Get the current buffer processed by the lexer.
YY_BUFFER_STATE cmFortranLexer_GetCurrentBuffer(yyscan_t yyscanner);
// The parser entry point.
int cmFortran_yyparse(yyscan_t);
//----------------------------------------------------------------------------
// Define parser object internal structure.
struct cmFortranFile
{
cmFortranFile(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 cmFortranParser_s
{
cmFortranParser_s(std::vector<std::string> const& includes,
std::set<std::string> const& defines,
cmFortranSourceInfo& info);
~cmFortranParser_s();
bool FindIncludeFile(const char* dir, const char* includeName,
std::string& fileName);
// The include file search path.
std::vector<std::string> IncludePath;
// Lexical scanner instance.
yyscan_t Scanner;
// Stack of open files in the translation unit.
std::stack<cmFortranFile> 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.
cmFortranSourceInfo& Info;
};
#endif
#endif

157
Source/cmDependsFortranParser.y → Source/cmFortranParser.y
View File

@ -26,42 +26,33 @@ This file must be translated to C and modified to build everywhere.
Run bison like this: Run bison like this:
bison --yacc --name-prefix=cmDependsFortran_yy bison --yacc --name-prefix=cmFortran_yy
--defines=cmDependsFortranParserTokens.h --defines=cmFortranParserTokens.h
-ocmDependsFortranParser.cxx -ocmFortranParser.cxx
cmDependsFortranParser.y cmFortranParser.y
Modify cmDependsFortranParser.cxx: Modify cmFortranParser.cxx:
- remove TABs - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
- remove use of the 'register' storage class specifier
- Remove the yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
*/ */
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
#define cmDependsFortranParser_cxx #define cmFortranParser_cxx
#include "cmDependsFortranParser.h" /* Interface to parser object. */ #include "cmFortranParser.h" /* Interface to parser object. */
#include "cmDependsFortranParserTokens.h" /* Need YYSTYPE for YY_DECL. */ #include "cmFortranParserTokens.h" /* Need YYSTYPE for YY_DECL. */
#include <cmsys/String.h> #include <cmsys/String.h>
/* Configure the parser to use a lexer object. */
#define YYPARSE_PARAM yyscanner
#define YYLEX_PARAM yyscanner
#define YYERROR_VERBOSE 1
#define cmDependsFortran_yyerror(x) \
cmDependsFortranError(yyscanner, x)
/* Forward declare the lexer entry point. */ /* Forward declare the lexer entry point. */
YY_DECL; YY_DECL;
/* Helper function to forward error callback. */ /* Helper function to forward error callback from parser. */
static void cmDependsFortranError(yyscan_t yyscanner, const char* message) static void cmFortran_yyerror(yyscan_t yyscanner, const char* message)
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_Error(parser, message); cmFortranParser_Error(parser, message);
} }
static bool cmDependsFortranParserIsKeyword(const char* word, static bool cmFortranParserIsKeyword(const char* word,
const char* keyword) const char* keyword)
{ {
return cmsysString_strcasecmp(word, keyword) == 0; return cmsysString_strcasecmp(word, keyword) == 0;
@ -79,7 +70,13 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
%} %}
/* Generate a reentrant parser object. */ /* Generate a reentrant parser object. */
%pure-parser %define api.pure
/* Configure the parser to use a lexer object. */
%lex-param {yyscan_t yyscanner}
%parse-param {yyscan_t yyscanner}
%define parse.error verbose
%union { %union {
char* string; char* string;
@ -115,63 +112,63 @@ assignment_stmt: WORD ASSIGNMENT_OP other EOSTMT /* Ignore */
keyword_stmt: keyword_stmt:
WORD EOSTMT WORD EOSTMT
{ {
if (cmDependsFortranParserIsKeyword($1, "interface")) if (cmFortranParserIsKeyword($1, "interface"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_SetInInterface(parser, true); cmFortranParser_SetInInterface(parser, true);
} }
free($1); free($1);
} }
| WORD WORD other EOSTMT | WORD WORD other EOSTMT
{ {
if (cmDependsFortranParserIsKeyword($1, "use")) if (cmFortranParserIsKeyword($1, "use"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleUse(parser, $2); cmFortranParser_RuleUse(parser, $2);
} }
else if (cmDependsFortranParserIsKeyword($1, "module")) else if (cmFortranParserIsKeyword($1, "module"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleModule(parser, $2); cmFortranParser_RuleModule(parser, $2);
} }
else if (cmDependsFortranParserIsKeyword($1, "interface")) else if (cmFortranParserIsKeyword($1, "interface"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_SetInInterface(parser, true); cmFortranParser_SetInInterface(parser, true);
} }
else if (cmDependsFortranParserIsKeyword($2, "interface") && else if (cmFortranParserIsKeyword($2, "interface") &&
cmDependsFortranParserIsKeyword($1, "end")) cmFortranParserIsKeyword($1, "end"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_SetInInterface(parser, false); cmFortranParser_SetInInterface(parser, false);
} }
free($1); free($1);
free($2); free($2);
} }
| WORD DCOLON WORD other EOSTMT | WORD DCOLON WORD other EOSTMT
{ {
if (cmDependsFortranParserIsKeyword($1, "use")) if (cmFortranParserIsKeyword($1, "use"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleUse(parser, $3); cmFortranParser_RuleUse(parser, $3);
} }
free($1); free($1);
free($3); free($3);
} }
| WORD COMMA WORD DCOLON WORD other EOSTMT | WORD COMMA WORD DCOLON WORD other EOSTMT
{ {
if (cmDependsFortranParserIsKeyword($1, "use") && if (cmFortranParserIsKeyword($1, "use") &&
cmDependsFortranParserIsKeyword($3, "non_intrinsic") ) cmFortranParserIsKeyword($3, "non_intrinsic") )
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleUse(parser, $5); cmFortranParser_RuleUse(parser, $5);
} }
free($1); free($1);
free($3); free($3);
@ -179,72 +176,72 @@ keyword_stmt:
} }
| WORD STRING other EOSTMT /* Ignore */ | WORD STRING other EOSTMT /* Ignore */
{ {
if (cmDependsFortranParserIsKeyword($1, "include")) if (cmFortranParserIsKeyword($1, "include"))
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleInclude(parser, $2); cmFortranParser_RuleInclude(parser, $2);
} }
free($1); free($1);
free($2); free($2);
} }
| CPP_INCLUDE_ANGLE other EOSTMT | CPP_INCLUDE_ANGLE other EOSTMT
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleInclude(parser, $1); cmFortranParser_RuleInclude(parser, $1);
free($1); free($1);
} }
| include STRING other EOSTMT | include STRING other EOSTMT
{ {
cmDependsFortranParser* parser = cmFortranParser* parser =
cmDependsFortran_yyget_extra(yyscanner); cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleInclude(parser, $2); cmFortranParser_RuleInclude(parser, $2);
free($2); free($2);
} }
| define WORD other EOSTMT | define WORD other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleDefine(parser, $2); cmFortranParser_RuleDefine(parser, $2);
free($2); free($2);
} }
| undef WORD other EOSTMT | undef WORD other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleUndef(parser, $2); cmFortranParser_RuleUndef(parser, $2);
free($2); free($2);
} }
| ifdef WORD other EOSTMT | ifdef WORD other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleIfdef(parser, $2); cmFortranParser_RuleIfdef(parser, $2);
free($2); free($2);
} }
| ifndef WORD other EOSTMT | ifndef WORD other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleIfndef(parser, $2); cmFortranParser_RuleIfndef(parser, $2);
free($2); free($2);
} }
| if other EOSTMT | if other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleIf(parser); cmFortranParser_RuleIf(parser);
} }
| elif other EOSTMT | elif other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleElif(parser); cmFortranParser_RuleElif(parser);
} }
| else other EOSTMT | else other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleElse(parser); cmFortranParser_RuleElse(parser);
} }
| endif other EOSTMT | endif other EOSTMT
{ {
cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner); cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmDependsFortranParser_RuleEndif(parser); cmFortranParser_RuleEndif(parser);
} }
| WORD GARBAGE other EOSTMT /* Ignore */ | WORD GARBAGE other EOSTMT /* Ignore */
{ {

408
Source/cmFortranParserImpl.cxx Normal file
View File

@ -0,0 +1,408 @@
/*============================================================================
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 "cmSystemTools.h"
#include <assert.h>
//----------------------------------------------------------------------------
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);
}
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;
}
//----------------------------------------------------------------------------
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(0, 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(0, 16384, parser->Scanner);
cmFortran_yy_switch_to_buffer(buffer, parser->Scanner);
parser->FileStack.push(f);
return 1;
}
else
{
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;
}
else
{
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*, 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 cmFortranParser_RuleUse(cmFortranParser* parser,
const char* name)
{
if(!parser->InPPFalseBranch)
{
parser->Info.Requires.insert(cmSystemTools::LowerCase(name) );
}
}
//----------------------------------------------------------------------------
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--;
}
}

105
Source/cmDependsFortranParserTokens.h → Source/cmFortranParserTokens.h
View File

@ -1,8 +1,8 @@
/* A Bison parser, made by GNU Bison 2.5. */ /* A Bison parser, made by GNU Bison 3.0.2. */
/* Bison interface for Yacc-like parsers in C /* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -30,43 +30,51 @@
This special exception was added by the Free Software Foundation in This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */ version 2.2 of Bison. */
#ifndef YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
# define YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int cmFortran_yydebug;
#endif
/* Tokens. */ /* Token type. */
#ifndef YYTOKENTYPE #ifndef YYTOKENTYPE
# define YYTOKENTYPE # define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers enum yytokentype
know about them. */ {
enum yytokentype { EOSTMT = 258,
EOSTMT = 258, ASSIGNMENT_OP = 259,
ASSIGNMENT_OP = 259, GARBAGE = 260,
GARBAGE = 260, CPP_INCLUDE = 261,
CPP_INCLUDE = 261, F90PPR_INCLUDE = 262,
F90PPR_INCLUDE = 262, COCO_INCLUDE = 263,
COCO_INCLUDE = 263, F90PPR_DEFINE = 264,
F90PPR_DEFINE = 264, CPP_DEFINE = 265,
CPP_DEFINE = 265, F90PPR_UNDEF = 266,
F90PPR_UNDEF = 266, CPP_UNDEF = 267,
CPP_UNDEF = 267, CPP_IFDEF = 268,
CPP_IFDEF = 268, CPP_IFNDEF = 269,
CPP_IFNDEF = 269, CPP_IF = 270,
CPP_IF = 270, CPP_ELSE = 271,
CPP_ELSE = 271, CPP_ELIF = 272,
CPP_ELIF = 272, CPP_ENDIF = 273,
CPP_ENDIF = 273, F90PPR_IFDEF = 274,
F90PPR_IFDEF = 274, F90PPR_IFNDEF = 275,
F90PPR_IFNDEF = 275, F90PPR_IF = 276,
F90PPR_IF = 276, F90PPR_ELSE = 277,
F90PPR_ELSE = 277, F90PPR_ELIF = 278,
F90PPR_ELIF = 278, F90PPR_ENDIF = 279,
F90PPR_ENDIF = 279, COMMA = 280,
COMMA = 280, DCOLON = 281,
DCOLON = 281, CPP_TOENDL = 282,
CPP_TOENDL = 282, UNTERMINATED_STRING = 283,
UNTERMINATED_STRING = 283, STRING = 284,
STRING = 284, WORD = 285,
WORD = 285, CPP_INCLUDE_ANGLE = 286
CPP_INCLUDE_ANGLE = 286 };
};
#endif #endif
/* Tokens. */ /* Tokens. */
#define EOSTMT 258 #define EOSTMT 258
@ -99,24 +107,23 @@
#define WORD 285 #define WORD 285
#define CPP_INCLUDE_ANGLE 286 #define CPP_INCLUDE_ANGLE 286
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE typedef union YYSTYPE YYSTYPE;
union YYSTYPE
{ {
#line 81 "cmFortranParser.y" /* yacc.c:1909 */
/* Line 2068 of yacc.c */
#line 89 "cmDependsFortranParser.y"
char* string; char* string;
#line 120 "cmFortranParserTokens.h" /* yacc.c:1909 */
};
/* Line 2068 of yacc.c */
#line 118 "cmDependsFortranParserTokens.h"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_DECLARED 1
#endif #endif
int cmFortran_yyparse (yyscan_t yyscanner);
#endif /* !YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED */