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

Merge topic 'fortran-depend-cleanup'

Browse Source 
d28da906 cmFortranParser: Inject a newline at end-of-file when missing
8c65a501 cmFortranParser: Revise indentation style to match rest of CMake
f70c71c5 cmFortranLexer: Update to flex 2.6
e11cd31f Fortran: Warn when dependency scanning fails to parse a source file
This commit is contained in:
Brad King 2016-09-08 09:36:57 -04:00 committed by CMake Topic Stage
commit f506489d1e
10 changed files with 1196 additions and 1270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/.gitattributes vendored
View File

@ -3,3 +3,5 @@ cm_sha2.* whitespace=indent-with-non-tab
# Preserve indentation style in generated code.
cmListFileLexer.c whitespace=-tab-in-indent,-indent-with-non-tab
cmFortranLexer.cxx whitespace=-tab-in-indent,-indent-with-non-tab
cmFortranLexer.h whitespace=-tab-in-indent,-indent-with-non-tab

6
Source/cmDependsFortran.cxx
View File

@ -130,6 +130,12 @@ bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
if (cmFortran_yyparse(parser.Scanner) != 0) {
// Failed to parse the file. Report failure to write dependencies.
okay = false;
/* clang-format off */
std::cerr <<
"warning: failed to parse dependencies from Fortran source "
"'" << src << "': " << parser.Error << std::endl
;
/* clang-format on */
}
}
return okay;

316
Source/cmFortranLexer.cxx
View File

@ -1,14 +1,3 @@
/*============================================================================
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.
============================================================================*/
#line 2 "cmFortranLexer.cxx"
#line 4 "cmFortranLexer.cxx"
@ -19,8 +8,8 @@
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 39
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 1
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
@ -99,25 +88,13 @@ typedef unsigned int flex_uint32_t;
#endif /* ! FLEXINT_H */
#ifdef __cplusplus
/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
/* C99 requires __STDC__ to be defined as 1. */
#if defined (__STDC__)
#define YY_USE_CONST
#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */
#ifdef YY_USE_CONST
/* TODO: this is always defined, so inline it */
#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yyconst
#define yynoreturn
#endif
/* Returned upon end-of-file. */
@ -230,12 +207,12 @@ struct yy_buffer_state
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
yy_size_t yy_n_chars;
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
@ -314,7 +291,7 @@ static void cmFortran_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yys
YY_BUFFER_STATE cmFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
void *cmFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
void *cmFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@ -346,7 +323,7 @@ void cmFortran_yyfree (void * ,yyscan_t yyscanner );
/* Begin user sect3 */
#define cmFortran_yywrap(yyscanner) 1
#define cmFortran_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef unsigned char YY_CHAR;
@ -358,14 +335,14 @@ typedef int yy_state_type;
static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
static int yy_get_next_buffer (yyscan_t yyscanner );
static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
static void yynoreturn yy_fatal_error (yyconst char* msg ,yyscan_t yyscanner );
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
yyg->yytext_ptr = yy_bp; \
yyleng = (size_t) (yy_cp - yy_bp); \
yyleng = (int) (yy_cp - yy_bp); \
yyg->yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yyg->yy_c_buf_p = yy_cp;
@ -402,7 +379,7 @@ static yyconst flex_int16_t yy_accept[173] =
13, 0
} ;
static yyconst flex_int32_t yy_ec[256] =
static yyconst YY_CHAR yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
@ -434,7 +411,7 @@ static yyconst flex_int32_t yy_ec[256] =
1, 1, 1, 1, 1
} ;
static yyconst flex_int32_t yy_meta[42] =
static yyconst YY_CHAR yy_meta[42] =
{ 0,
1, 2, 2, 3, 4, 3, 3, 1, 1, 3,
3, 1, 3, 5, 1, 3, 1, 3, 6, 1,
@ -443,7 +420,7 @@ static yyconst flex_int32_t yy_meta[42] =
7
} ;
static yyconst flex_int16_t yy_base[182] =
static yyconst flex_uint16_t yy_base[182] =
{ 0,
0, 40, 0, 41, 220, 48, 44, 54, 56, 65,
220, 0, 535, 535, 216, 535, 81, 74, 535, 535,
@ -491,7 +468,7 @@ static yyconst flex_int16_t yy_def[182] =
172
} ;
static yyconst flex_int16_t yy_nxt[577] =
static yyconst flex_uint16_t yy_nxt[577] =
{ 0,
12, 13, 14, 13, 13, 15, 16, 12, 17, 18,
19, 12, 20, 12, 21, 22, 12, 23, 12, 24,
@ -636,7 +613,7 @@ static yyconst flex_int16_t yy_chk[577] =
#line 2 "cmFortranLexer.in.l"
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
@ -659,28 +636,21 @@ static yyconst flex_int16_t yy_chk[577] =
This file must be translated to C and modified to build everywhere.
Run flex like this:
Run flex >= 2.6 like this:
flex -i --prefix=cmFortran_yy --header-file=cmFortranLexer.h -ocmFortranLexer.cxx cmFortranLexer.in.l
Modify cmFortranLexer.cxx:
- remove TABs
- remove use of the 'register' storage class specifier
- remove "yyscanner" argument from these methods:
yy_fatal_error, cmFortran_yyalloc, cmFortran_yyrealloc, cmFortran_yyfree
- remove trailing whitespace: sed -i 's/\s*$//' cmFortranLexer.h cmFortranLexer.cxx
- remove blank lines at end of file
- remove "yyscanner = NULL" from end of cmFortran_yylex_destroy
- remove all YY_BREAK lines occurring right after return statements
- change while ( 1 ) to for(;;)
Modify cmFortranLexer.h:
- remove TABs
- remove the yy_init_globals function
- remove the block that includes unistd.h
- remove #line directives (avoids bogus warning on old Sun)
- add cast in cmFortran_yy_scan_bytes for loop condition of _yybytes_len to size_t
*/
#include "cmStandardLexer.h"
#undef YY_NO_UNPUT
#define cmFortranLexer_cxx
#include "cmFortranParser.h" /* Interface to parser object. */
@ -696,7 +666,7 @@ Modify cmFortranLexer.h:
/*--------------------------------------------------------------------------*/
#line 689 "cmFortranLexer.cxx"
#line 670 "cmFortranLexer.cxx"
#define INITIAL 0
#define free_fmt 1
@ -729,8 +699,8 @@ struct yyguts_t
size_t yy_buffer_stack_max; /**< capacity of stack. */
YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
char yy_hold_char;
yy_size_t yy_n_chars;
yy_size_t yyleng_r;
int yy_n_chars;
int yyleng_r;
char *yy_c_buf_p;
int yy_init;
int yy_start;
@ -771,23 +741,23 @@ void cmFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
FILE *cmFortran_yyget_in (yyscan_t yyscanner );
void cmFortran_yyset_in (FILE * in_str ,yyscan_t yyscanner );
void cmFortran_yyset_in (FILE * _in_str ,yyscan_t yyscanner );
FILE *cmFortran_yyget_out (yyscan_t yyscanner );
void cmFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner );
void cmFortran_yyset_out (FILE * _out_str ,yyscan_t yyscanner );
yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner );
int cmFortran_yyget_leng (yyscan_t yyscanner );
char *cmFortran_yyget_text (yyscan_t yyscanner );
int cmFortran_yyget_lineno (yyscan_t yyscanner );
void cmFortran_yyset_lineno (int line_number ,yyscan_t yyscanner );
void cmFortran_yyset_lineno (int _line_number ,yyscan_t yyscanner );
int cmFortran_yyget_column (yyscan_t yyscanner );
void cmFortran_yyset_column (int column_no ,yyscan_t yyscanner );
void cmFortran_yyset_column (int _column_no ,yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
@ -801,8 +771,12 @@ extern int cmFortran_yywrap (yyscan_t yyscanner );
#endif
#endif
#ifndef YY_NO_UNPUT
static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
#endif
@ -836,7 +810,7 @@ static int input (yyscan_t yyscanner );
/* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite().
*/
#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@ -860,7 +834,7 @@ static int input (yyscan_t yyscanner );
else \
{ \
errno=0; \
while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
{ \
if( errno != EINTR) \
{ \
@ -915,7 +889,7 @@ extern int cmFortran_yylex (yyscan_t yyscanner);
/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#define YY_BREAK /*LINTED*/break;
#endif
#define YY_RULE_SETUP \
@ -960,12 +934,12 @@ YY_DECL
}
{
#line 72 "cmFortranLexer.in.l"
#line 65 "cmFortranLexer.in.l"
#line 956 "cmFortranLexer.cxx"
#line 941 "cmFortranLexer.cxx"
for(;;) /* loops until end-of-file is reached */
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
{
yy_cp = yyg->yy_c_buf_p;
@ -994,7 +968,7 @@ yy_match:
if ( yy_current_state >= 173 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 535 );
@ -1023,7 +997,7 @@ do_action: /* This label is used only to access EOF actions. */
case 1:
YY_RULE_SETUP
#line 74 "cmFortranLexer.in.l"
#line 67 "cmFortranLexer.in.l"
{
cmFortranParser_StringStart(yyextra);
cmFortranParser_SetOldStartcond(yyextra, YY_START);
@ -1032,7 +1006,7 @@ YY_RULE_SETUP
YY_BREAK
case 2:
YY_RULE_SETUP
#line 80 "cmFortranLexer.in.l"
#line 73 "cmFortranLexer.in.l"
{
cmFortranParser_StringStart(yyextra);
cmFortranParser_SetOldStartcond(yyextra, YY_START);
@ -1040,10 +1014,10 @@ YY_RULE_SETUP
}
YY_BREAK
case 3:
#line 87 "cmFortranLexer.in.l"
#line 80 "cmFortranLexer.in.l"
case 4:
YY_RULE_SETUP
#line 87 "cmFortranLexer.in.l"
#line 80 "cmFortranLexer.in.l"
{
BEGIN(cmFortranParser_GetOldStartcond(yyextra) );
yylvalp->string = strdup(cmFortranParser_StringEnd(yyextra));
@ -1051,17 +1025,17 @@ YY_RULE_SETUP
}
case 5:
/* rule 5 can match eol */
#line 94 "cmFortranLexer.in.l"
#line 87 "cmFortranLexer.in.l"
case 6:
/* rule 6 can match eol */
YY_RULE_SETUP
#line 94 "cmFortranLexer.in.l"
#line 87 "cmFortranLexer.in.l"
/* Ignore (continued strings, free fmt) */
YY_BREAK
case 7:
/* rule 7 can match eol */
YY_RULE_SETUP
#line 96 "cmFortranLexer.in.l"
#line 89 "cmFortranLexer.in.l"
{
if (cmFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
; /* Ignore (cont. strings, fixed fmt) */
@ -1074,7 +1048,7 @@ YY_RULE_SETUP
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
#line 106 "cmFortranLexer.in.l"
#line 99 "cmFortranLexer.in.l"
{
unput ('\n');
BEGIN(INITIAL);
@ -1082,7 +1056,7 @@ YY_RULE_SETUP
}
case 9:
YY_RULE_SETUP
#line 112 "cmFortranLexer.in.l"
#line 105 "cmFortranLexer.in.l"
{
cmFortranParser_StringAppend(yyextra, yytext[0]);
}
@ -1090,21 +1064,21 @@ YY_RULE_SETUP
case 10:
/* rule 10 can match eol */
YY_RULE_SETUP
#line 116 "cmFortranLexer.in.l"
#line 109 "cmFortranLexer.in.l"
{ return EOSTMT; } /* Treat comments like */
case 11:
/* rule 11 can match eol */
YY_RULE_SETUP
#line 117 "cmFortranLexer.in.l"
#line 110 "cmFortranLexer.in.l"
{ return EOSTMT; } /* empty lines */
case 12:
YY_RULE_SETUP
#line 119 "cmFortranLexer.in.l"
#line 112 "cmFortranLexer.in.l"
{ return CPP_LINE_DIRECTIVE; }
case 13:
/* rule 13 can match eol */
YY_RULE_SETUP
#line 120 "cmFortranLexer.in.l"
#line 113 "cmFortranLexer.in.l"
{
yytext[yyleng-1] = 0;
yylvalp->string = strdup(strchr(yytext, '<')+1);
@ -1112,147 +1086,147 @@ YY_RULE_SETUP
}
case 14:
YY_RULE_SETUP
#line 125 "cmFortranLexer.in.l"
#line 118 "cmFortranLexer.in.l"
{ return CPP_INCLUDE; }
case 15:
YY_RULE_SETUP
#line 126 "cmFortranLexer.in.l"
#line 119 "cmFortranLexer.in.l"
{ return F90PPR_INCLUDE; }
case 16:
YY_RULE_SETUP
#line 127 "cmFortranLexer.in.l"
#line 120 "cmFortranLexer.in.l"
{ return COCO_INCLUDE; }
case 17:
YY_RULE_SETUP
#line 129 "cmFortranLexer.in.l"
#line 122 "cmFortranLexer.in.l"
{ return CPP_DEFINE; }
case 18:
YY_RULE_SETUP
#line 130 "cmFortranLexer.in.l"
#line 123 "cmFortranLexer.in.l"
{ return F90PPR_DEFINE; }
case 19:
YY_RULE_SETUP
#line 132 "cmFortranLexer.in.l"
#line 125 "cmFortranLexer.in.l"
{ return CPP_UNDEF; }
case 20:
YY_RULE_SETUP
#line 133 "cmFortranLexer.in.l"
#line 126 "cmFortranLexer.in.l"
{ return F90PPR_UNDEF; }
case 21:
YY_RULE_SETUP
#line 135 "cmFortranLexer.in.l"
#line 128 "cmFortranLexer.in.l"
{ return CPP_IFDEF; }
case 22:
YY_RULE_SETUP
#line 136 "cmFortranLexer.in.l"
#line 129 "cmFortranLexer.in.l"
{ return CPP_IFNDEF; }
case 23:
YY_RULE_SETUP
#line 137 "cmFortranLexer.in.l"
#line 130 "cmFortranLexer.in.l"
{ return CPP_IF; }
case 24:
YY_RULE_SETUP
#line 138 "cmFortranLexer.in.l"
#line 131 "cmFortranLexer.in.l"
{ return CPP_ELIF; }
case 25:
YY_RULE_SETUP
#line 139 "cmFortranLexer.in.l"
#line 132 "cmFortranLexer.in.l"
{ return CPP_ELSE; }
case 26:
YY_RULE_SETUP
#line 140 "cmFortranLexer.in.l"
#line 133 "cmFortranLexer.in.l"
{ return CPP_ENDIF; }
case 27:
YY_RULE_SETUP
#line 142 "cmFortranLexer.in.l"
#line 135 "cmFortranLexer.in.l"
{ return F90PPR_IFDEF; }
case 28:
YY_RULE_SETUP
#line 143 "cmFortranLexer.in.l"
#line 136 "cmFortranLexer.in.l"
{ return F90PPR_IFNDEF; }
case 29:
YY_RULE_SETUP
#line 144 "cmFortranLexer.in.l"
#line 137 "cmFortranLexer.in.l"
{ return F90PPR_IF; }
case 30:
YY_RULE_SETUP
#line 145 "cmFortranLexer.in.l"
#line 138 "cmFortranLexer.in.l"
{ return F90PPR_ELIF; }
case 31:
YY_RULE_SETUP
#line 146 "cmFortranLexer.in.l"
#line 139 "cmFortranLexer.in.l"
{ return F90PPR_ELSE; }
case 32:
YY_RULE_SETUP
#line 147 "cmFortranLexer.in.l"
#line 140 "cmFortranLexer.in.l"
{ return F90PPR_ENDIF; }
/* Line continuations, possible involving comments. */
case 33:
/* rule 33 can match eol */
YY_RULE_SETUP
#line 150 "cmFortranLexer.in.l"
#line 143 "cmFortranLexer.in.l"
YY_BREAK
case 34:
/* rule 34 can match eol */
YY_RULE_SETUP
#line 151 "cmFortranLexer.in.l"
#line 144 "cmFortranLexer.in.l"
YY_BREAK
case 35:
YY_RULE_SETUP
#line 153 "cmFortranLexer.in.l"
#line 146 "cmFortranLexer.in.l"
{ return COMMA; }
case 36:
YY_RULE_SETUP
#line 155 "cmFortranLexer.in.l"
#line 148 "cmFortranLexer.in.l"
{ return DCOLON; }
case 37:
/* rule 37 can match eol */
YY_RULE_SETUP
#line 157 "cmFortranLexer.in.l"
#line 150 "cmFortranLexer.in.l"
{ return GARBAGE; }
case 38:
YY_RULE_SETUP
#line 159 "cmFortranLexer.in.l"
#line 152 "cmFortranLexer.in.l"
{ return ASSIGNMENT_OP; }
case 39:
YY_RULE_SETUP
#line 161 "cmFortranLexer.in.l"
#line 154 "cmFortranLexer.in.l"
{
yylvalp->string = strdup(yytext);
return WORD;
}
case 40:
YY_RULE_SETUP
#line 166 "cmFortranLexer.in.l"
#line 159 "cmFortranLexer.in.l"
{ return GARBAGE; }
case 41:
/* rule 41 can match eol */
YY_RULE_SETUP
#line 168 "cmFortranLexer.in.l"
#line 161 "cmFortranLexer.in.l"
{ return EOSTMT; }
case 42:
YY_RULE_SETUP
#line 171 "cmFortranLexer.in.l"
#line 164 "cmFortranLexer.in.l"
/* Ignore */
YY_BREAK
case 43:
/* rule 43 can match eol */
YY_RULE_SETUP
#line 172 "cmFortranLexer.in.l"
#line 165 "cmFortranLexer.in.l"
/* Ignore line-endings preceded by \ */
YY_BREAK
case 44:
YY_RULE_SETUP
#line 174 "cmFortranLexer.in.l"
#line 167 "cmFortranLexer.in.l"
{ return *yytext; }
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(free_fmt):
case YY_STATE_EOF(fixed_fmt):
case YY_STATE_EOF(str_sq):
case YY_STATE_EOF(str_dq):
#line 176 "cmFortranLexer.in.l"
#line 169 "cmFortranLexer.in.l"
{
if(!cmFortranParser_FilePop(yyextra) )
{
@ -1262,10 +1236,10 @@ case YY_STATE_EOF(str_dq):
YY_BREAK
case 45:
YY_RULE_SETUP
#line 183 "cmFortranLexer.in.l"
#line 176 "cmFortranLexer.in.l"
ECHO;
YY_BREAK
#line 1291 "cmFortranLexer.cxx"
#line 1276 "cmFortranLexer.cxx"
case YY_END_OF_BUFFER:
{
@ -1409,7 +1383,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = yyg->yytext_ptr;
int number_to_move, i;
yy_size_t number_to_move, i;
int ret_val;
if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
@ -1438,7 +1412,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
@ -1451,7 +1425,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
else
{
yy_size_t num_to_read =
int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
@ -1465,7 +1439,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
if ( b->yy_is_our_buffer )
{
yy_size_t new_size = b->yy_buf_size * 2;
int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
@ -1478,7 +1452,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
b->yy_ch_buf = NULL;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
@ -1520,9 +1494,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
else
ret_val = EOB_ACT_CONTINUE_SCAN;
if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */
yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cmFortran_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
@ -1562,7 +1536,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
if ( yy_current_state >= 173 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
}
return yy_current_state;
@ -1591,13 +1565,15 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
if ( yy_current_state >= 173 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
yy_is_jam = (yy_current_state == 172);
(void)yyg;
return yy_is_jam ? 0 : yy_current_state;
}
#ifndef YY_NO_UNPUT
static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
{
char *yy_cp;
@ -1611,7 +1587,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
yy_size_t number_to_move = yyg->yy_n_chars + 2;
int number_to_move = yyg->yy_n_chars + 2;
char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
char *source =
@ -1623,7 +1599,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
@ -1636,6 +1612,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
yyg->yy_c_buf_p = yy_cp;
}
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput (yyscan_t yyscanner)
@ -1661,7 +1639,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
else
{ /* need more input */
yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
++yyg->yy_c_buf_p;
switch ( yy_get_next_buffer( yyscanner ) )
@ -1685,7 +1663,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
case EOB_ACT_END_OF_FILE:
{
if ( cmFortran_yywrap(yyscanner ) )
return EOF;
return 0;
if ( ! yyg->yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
@ -1791,7 +1769,7 @@ static void cmFortran_yy_load_buffer_state (yyscan_t yyscanner)
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in cmFortran_yy_create_buffer()" );
b->yy_buf_size = size;
b->yy_buf_size = (yy_size_t)size;
/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.
@ -1943,7 +1921,7 @@ void cmFortran_yypop_buffer_state (yyscan_t yyscanner)
*/
static void cmFortran_yyensure_buffer_stack (yyscan_t yyscanner)
{
yy_size_t num_to_alloc;
int num_to_alloc;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) {
@ -1952,7 +1930,7 @@ static void cmFortran_yyensure_buffer_stack (yyscan_t yyscanner)
* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.
*/
num_to_alloc = 1;
num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmFortran_yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner);
@ -1969,7 +1947,7 @@ static void cmFortran_yyensure_buffer_stack (yyscan_t yyscanner)
if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
/* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */;
yy_size_t grow_size = 8 /* arbitrary grow size */;
num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmFortran_yyrealloc
@ -1999,7 +1977,7 @@ YY_BUFFER_STATE cmFortran_yy_scan_buffer (char * base, yy_size_t size , yyscan
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
return 0;
return NULL;
b = (YY_BUFFER_STATE) cmFortran_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
if ( ! b )
@ -2008,7 +1986,7 @@ YY_BUFFER_STATE cmFortran_yy_scan_buffer (char * base, yy_size_t size , yyscan
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;
b->yy_input_file = 0;
b->yy_input_file = NULL;
b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
@ -2031,7 +2009,7 @@ YY_BUFFER_STATE cmFortran_yy_scan_buffer (char * base, yy_size_t size , yyscan
YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
{
return cmFortran_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
return cmFortran_yy_scan_bytes(yystr,(int) strlen(yystr) ,yyscanner);
}
/** Setup the input buffer state to scan the given bytes. The next call to cmFortran_yylex() will
@ -2041,7 +2019,7 @@ YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char * yystr , yyscan_t yyscan
* @param yyscanner The scanner object.
* @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
char *buf;
@ -2049,12 +2027,12 @@ YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yy
yy_size_t i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;
n = (yy_size_t) _yybytes_len + 2;
buf = (char *) cmFortran_yyalloc(n ,yyscanner );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in cmFortran_yy_scan_bytes()" );
for ( i = 0; i < _yybytes_len; ++i )
for ( i = 0; i < (size_t)_yybytes_len; ++i )
buf[i] = yybytes[i];
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
@ -2075,8 +2053,10 @@ YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yy
#define YY_EXIT_FAILURE 2
#endif
static void yy_fatal_error (yyconst char* msg , yyscan_t)
static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
@ -2156,7 +2136,7 @@ FILE *cmFortran_yyget_out (yyscan_t yyscanner)
/** Get the length of the current token.
* @param yyscanner The scanner object.
*/
yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner)
int cmFortran_yyget_leng (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
return yyleng;
@ -2183,10 +2163,10 @@ void cmFortran_yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
}
/** Set the current line number.
* @param line_number The line number to set.
* @param _line_number line number
* @param yyscanner The scanner object.
*/
void cmFortran_yyset_lineno (int line_number , yyscan_t yyscanner)
void cmFortran_yyset_lineno (int _line_number , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
@ -2194,14 +2174,14 @@ void cmFortran_yyset_lineno (int line_number , yyscan_t yyscanner)
if (! YY_CURRENT_BUFFER )
YY_FATAL_ERROR( "cmFortran_yyset_lineno called with no buffer" );
yylineno = line_number;
yylineno = _line_number;
}
/** Set the current column.
* @param column_no The column number to set.
* @param _column_no column number
* @param yyscanner The scanner object.
*/
void cmFortran_yyset_column (int column_no , yyscan_t yyscanner)
void cmFortran_yyset_column (int _column_no , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
@ -2209,25 +2189,25 @@ void cmFortran_yyset_column (int column_no , yyscan_t yyscanner)
if (! YY_CURRENT_BUFFER )
YY_FATAL_ERROR( "cmFortran_yyset_column called with no buffer" );
yycolumn = column_no;
yycolumn = _column_no;
}
/** Set the input stream. This does not discard the current
* input buffer.
* @param in_str A readable stream.
* @param _in_str A readable stream.
* @param yyscanner The scanner object.
* @see cmFortran_yy_switch_to_buffer
*/
void cmFortran_yyset_in (FILE * in_str , yyscan_t yyscanner)
void cmFortran_yyset_in (FILE * _in_str , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
yyin = in_str ;
yyin = _in_str ;
}
void cmFortran_yyset_out (FILE * out_str , yyscan_t yyscanner)
void cmFortran_yyset_out (FILE * _out_str , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
yyout = out_str ;
yyout = _out_str ;
}
int cmFortran_yyget_debug (yyscan_t yyscanner)
@ -2236,10 +2216,10 @@ int cmFortran_yyget_debug (yyscan_t yyscanner)
return yy_flex_debug;
}
void cmFortran_yyset_debug (int bdebug , yyscan_t yyscanner)
void cmFortran_yyset_debug (int _bdebug , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
yy_flex_debug = bdebug ;
yy_flex_debug = _bdebug ;
}
/* Accessor methods for yylval and yylloc */
@ -2315,10 +2295,10 @@ static int yy_init_globals (yyscan_t yyscanner)
* This function is called from cmFortran_yylex_destroy(), so don't allocate here.
*/
yyg->yy_buffer_stack = 0;
yyg->yy_buffer_stack = NULL;
yyg->yy_buffer_stack_top = 0;
yyg->yy_buffer_stack_max = 0;
yyg->yy_c_buf_p = (char *) 0;
yyg->yy_c_buf_p = NULL;
yyg->yy_init = 0;
yyg->yy_start = 0;
@ -2331,8 +2311,8 @@ static int yy_init_globals (yyscan_t yyscanner)
yyin = stdin;
yyout = stdout;
#else
yyin = (FILE *) 0;
yyout = (FILE *) 0;
yyin = NULL;
yyout = NULL;
#endif
/* For future reference: Set errno on error, since we are called by
@ -2377,6 +2357,9 @@ int cmFortran_yylex_destroy (yyscan_t yyscanner)
#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
@ -2394,13 +2377,18 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
}
#endif
void *cmFortran_yyalloc (yy_size_t size , yyscan_t)
void *cmFortran_yyalloc (yy_size_t size , yyscan_t yyscanner)
{
return (void *) malloc( size );
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
return malloc(size);
}
void *cmFortran_yyrealloc (void * ptr, yy_size_t size , yyscan_t)
void *cmFortran_yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter
@ -2408,17 +2396,19 @@ void *cmFortran_yyrealloc (void * ptr, yy_size_t size , yyscan_t)
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
return (void *) realloc( (char *) ptr, size );
return realloc(ptr, size);
}
void cmFortran_yyfree (void * ptr , yyscan_t)
void cmFortran_yyfree (void * ptr , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
free( (char *) ptr ); /* see cmFortran_yyrealloc() for (char *) cast */
}
#define YYTABLES_NAME "yytables"
#line 182 "cmFortranLexer.in.l"
#line 176 "cmFortranLexer.in.l"

71
Source/cmFortranLexer.h
View File

@ -1,26 +1,19 @@
/*============================================================================
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.
============================================================================*/
#ifndef cmFortran_yyHEADER_H
#define cmFortran_yyHEADER_H 1
#define cmFortran_yyIN_HEADER 1
#line 6 "cmFortranLexer.h"
#line 8 "cmFortranLexer.h"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 39
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 1
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
@ -99,25 +92,13 @@ typedef unsigned int flex_uint32_t;
#endif /* ! FLEXINT_H */
#ifdef __cplusplus
/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
/* C99 requires __STDC__ to be defined as 1. */
#if defined (__STDC__)
#define YY_USE_CONST
#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */
#ifdef YY_USE_CONST
/* TODO: this is always defined, so inline it */
#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yyconst
#define yynoreturn
#endif
/* An opaque pointer. */
@ -172,12 +153,12 @@ struct yy_buffer_state
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
yy_size_t yy_n_chars;
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
@ -221,7 +202,7 @@ void cmFortran_yypop_buffer_state (yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
void *cmFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
void *cmFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@ -229,7 +210,7 @@ void cmFortran_yyfree (void * ,yyscan_t yyscanner );
/* Begin user sect3 */
#define cmFortran_yywrap(yyscanner) 1
#define cmFortran_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
#define yytext_ptr yytext_r
@ -243,6 +224,14 @@ void cmFortran_yyfree (void * ,yyscan_t yyscanner );
#endif
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include <unistd.h>
#endif
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
@ -266,23 +255,23 @@ void cmFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
FILE *cmFortran_yyget_in (yyscan_t yyscanner );
void cmFortran_yyset_in (FILE * in_str ,yyscan_t yyscanner );
void cmFortran_yyset_in (FILE * _in_str ,yyscan_t yyscanner );
FILE *cmFortran_yyget_out (yyscan_t yyscanner );
void cmFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner );
void cmFortran_yyset_out (FILE * _out_str ,yyscan_t yyscanner );
yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner );
int cmFortran_yyget_leng (yyscan_t yyscanner );
char *cmFortran_yyget_text (yyscan_t yyscanner );
int cmFortran_yyget_lineno (yyscan_t yyscanner );
void cmFortran_yyset_lineno (int line_number ,yyscan_t yyscanner );
void cmFortran_yyset_lineno (int _line_number ,yyscan_t yyscanner );
int cmFortran_yyget_column (yyscan_t yyscanner );
void cmFortran_yyset_column (int column_no ,yyscan_t yyscanner );
void cmFortran_yyset_column (int _column_no ,yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
@ -348,5 +337,9 @@ extern int cmFortran_yylex (yyscan_t yyscanner);
#undef YY_DECL
#endif
#line 176 "cmFortranLexer.in.l"
#line 344 "cmFortranLexer.h"
#undef cmFortran_yyIN_HEADER
#endif /* cmFortran_yyHEADER_H */

17
Source/cmFortranLexer.in.l
View File

@ -24,28 +24,21 @@
This file must be translated to C and modified to build everywhere.
Run flex like this:
Run flex >= 2.6 like this:
flex -i --prefix=cmFortran_yy --header-file=cmFortranLexer.h -ocmFortranLexer.cxx cmFortranLexer.in.l
Modify cmFortranLexer.cxx:
- remove TABs
- remove use of the 'register' storage class specifier
- remove "yyscanner" argument from these methods:
yy_fatal_error, cmFortran_yyalloc, cmFortran_yyrealloc, cmFortran_yyfree
- remove trailing whitespace: sed -i 's/\s*$//' cmFortranLexer.h cmFortranLexer.cxx
- remove blank lines at end of file
- remove "yyscanner = NULL" from end of cmFortran_yylex_destroy
- remove all YY_BREAK lines occurring right after return statements
- change while ( 1 ) to for(;;)
Modify cmFortranLexer.h:
- remove TABs
- remove the yy_init_globals function
- remove the block that includes unistd.h
- remove #line directives (avoids bogus warning on old Sun)
- add cast in yy_scan_bytes for loop condition of _yybytes_len to size_t
*/
#include "cmStandardLexer.h"
#undef YY_NO_UNPUT
#define cmFortranLexer_cxx
#include "cmFortranParser.h" /* Interface to parser object. */

399
Source/cmFortranParser.cxx
View File

@ -1,8 +1,8 @@
/* A Bison parser, made by GNU Bison 3.0.2. */
/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
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
@ -44,7 +44,7 @@
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "3.0.2"
#define YYBISON_VERSION "3.0.4"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
@ -199,11 +199,10 @@ extern int cmFortran_yydebug;
F90PPR_ENDIF = 280,
COMMA = 281,
DCOLON = 282,
CPP_TOENDL = 283,
UNTERMINATED_STRING = 284,
STRING = 285,
WORD = 286,
CPP_INCLUDE_ANGLE = 287
UNTERMINATED_STRING = 283,
STRING = 284,
WORD = 285,
CPP_INCLUDE_ANGLE = 286
};
#endif
/* Tokens. */
@ -232,23 +231,24 @@ extern int cmFortran_yydebug;
#define F90PPR_ENDIF 280
#define COMMA 281
#define DCOLON 282
#define CPP_TOENDL 283
#define UNTERMINATED_STRING 284
#define STRING 285
#define WORD 286
#define CPP_INCLUDE_ANGLE 287
#define UNTERMINATED_STRING 283
#define STRING 284
#define WORD 285
#define CPP_INCLUDE_ANGLE 286
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE YYSTYPE;
union YYSTYPE
{
#line 81 "cmFortranParser.y" /* yacc.c:355 */
char* string;
#line 251 "cmFortranParser.cxx" /* yacc.c:355 */
#line 249 "cmFortranParser.cxx" /* yacc.c:355 */
};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
@ -503,10 +503,10 @@ union yyalloc
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 2
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 290
#define YYLAST 249
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 33
#define YYNTOKENS 32
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 16
/* YYNRULES -- Number of rules. */
@ -517,7 +517,7 @@ union yyalloc
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 287
#define YYMAXUTOK 286
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@ -554,19 +554,19 @@ static const yytype_uint8 yytranslate[] =
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32
25, 26, 27, 28, 29, 30, 31
};
#if YYDEBUG
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
static const yytype_uint8 yyrline[] =
{
0, 104, 104, 104, 106, 106, 108, 114, 124, 154,
165, 178, 189, 196, 203, 210, 216, 222, 228, 234,
239, 244, 249, 254, 258, 259, 260, 265, 265, 265,
266, 266, 267, 267, 268, 268, 269, 269, 270, 270,
271, 271, 272, 272, 273, 273, 274, 274, 277, 278,
279, 280, 281, 282, 283
0, 103, 103, 103, 105, 105, 108, 113, 120, 138,
146, 156, 164, 169, 174, 179, 184, 189, 194, 199,
203, 207, 211, 215, 218, 219, 220, 225, 225, 225,
226, 226, 227, 227, 228, 228, 229, 229, 230, 230,
231, 231, 232, 232, 233, 233, 234, 234, 237, 238,
239, 240, 241, 242, 243
};
#endif
@ -580,11 +580,10 @@ static const char *const yytname[] =
"F90PPR_DEFINE", "CPP_DEFINE", "F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF",
"CPP_IFNDEF", "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF",
"F90PPR_IFDEF", "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE",
"F90PPR_ELIF", "F90PPR_ENDIF", "COMMA", "DCOLON", "CPP_TOENDL",
"UNTERMINATED_STRING", "STRING", "WORD", "CPP_INCLUDE_ANGLE", "$accept",
"code", "stmt", "assignment_stmt", "keyword_stmt", "include", "define",
"undef", "ifdef", "ifndef", "if", "elif", "else", "endif", "other",
"misc_code", YY_NULLPTR
"F90PPR_ELIF", "F90PPR_ENDIF", "COMMA", "DCOLON", "UNTERMINATED_STRING",
"STRING", "WORD", "CPP_INCLUDE_ANGLE", "$accept", "code", "stmt",
"assignment_stmt", "keyword_stmt", "include", "define", "undef", "ifdef",
"ifndef", "if", "elif", "else", "endif", "other", "misc_code", YY_NULLPTR
};
#endif
@ -596,14 +595,14 @@ static const yytype_uint16 yytoknum[] =
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287
285, 286
};
# endif
#define YYPACT_NINF -30
#define YYPACT_NINF -29
#define yypact_value_is_default(Yystate) \
(!!((Yystate) == (-30)))
(!!((Yystate) == (-29)))
#define YYTABLE_NINF -1
@ -614,17 +613,17 @@ static const yytype_uint16 yytoknum[] =
STATE-NUM. */
static const yytype_int16 yypact[] =
{
-30, 41, -30, -30, -30, -30, -29, -30, -30, -30,
-30, -30, -30, -30, -30, -30, -30, -30, -30, -30,
-30, -30, -30, -30, -30, -30, 259, -30, -30, -30,
-30, -28, -23, -18, -16, -13, -30, -30, -30, -30,
2, -30, -30, -30, -30, -12, -9, -30, -30, 64,
-30, -30, -30, -30, -30, 71, 77, 83, 112, -30,
-30, -30, -30, -30, -30, -30, -30, -30, 118, 124,
130, -24, -30, 159, 165, -30, 171, 177, 206, 212,
218, -30, -30, -30, -30, -30, -30, -30, -1, 224,
-30, -30, -30, -30, -30, -30, -30, -30, -30, 253,
-30
-29, 41, -29, -29, -29, -29, -28, -29, -29, -29,
-29, -29, -29, -29, -29, -29, -29, -29, -29, -29,
-29, -29, -29, -29, -29, -29, 219, -29, -29, -29,
-29, -26, -22, -17, -15, -12, -29, -29, -29, -29,
2, -29, -29, -29, -29, -11, -8, -29, -29, 64,
-29, -29, -29, -29, -29, 70, 75, 80, 108, -29,
-29, -29, -29, -29, -29, -29, -29, -29, 113, 118,
123, -25, -29, 128, 156, -29, 161, 166, 171, 176,
204, -29, -29, -29, -29, -29, -29, -29, 3, 209,
-29, -29, -29, -29, -29, -29, -29, -29, -29, 214,
-29
};
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@ -648,8 +647,8 @@ static const yytype_uint8 yydefact[] =
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int8 yypgoto[] =
{
-30, -30, -30, -30, -30, -30, -30, -30, -30, -30,
-30, -30, -30, -30, -27, -30
-29, -29, -29, -29, -29, -29, -29, -29, -29, -29,
-29, -29, -29, -29, -27, -29
};
/* YYDEFGOTO[NTERM-NUM]. */
@ -664,98 +663,88 @@ static const yytype_int8 yydefgoto[] =
number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_uint8 yytable[] =
{
49, 41, 50, 88, 0, 59, 60, 61, 51, 55,
49, 41, 88, 50, 0, 59, 60, 61, 51, 55,
56, 57, 58, 52, 68, 53, 69, 70, 54, 71,
73, 74, 72, 76, 77, 78, 79, 80, 62, 63,
97, 64, 65, 66, 0, 0, 0, 0, 0, 0,
64, 65, 66, 97, 0, 0, 0, 0, 0, 0,
0, 2, 3, 0, 4, 89, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 75, 60, 61,
99, 0, 26, 27, 81, 60, 61, 0, 0, 0,
82, 60, 61, 0, 0, 0, 83, 60, 61, 0,
62, 63, 0, 64, 65, 66, 0, 62, 63, 0,
64, 65, 66, 62, 63, 0, 64, 65, 66, 62,
63, 0, 64, 65, 66, 84, 60, 61, 0, 0,
0, 85, 60, 61, 0, 0, 0, 86, 60, 61,
0, 0, 0, 87, 60, 61, 0, 0, 62, 63,
0, 64, 65, 66, 62, 63, 0, 64, 65, 66,
62, 63, 0, 64, 65, 66, 62, 63, 0, 64,
65, 66, 90, 60, 61, 0, 0, 0, 91, 60,
61, 0, 0, 0, 92, 60, 61, 0, 0, 0,
93, 60, 61, 0, 0, 62, 63, 0, 64, 65,
66, 62, 63, 0, 64, 65, 66, 62, 63, 0,
64, 65, 66, 62, 63, 0, 64, 65, 66, 94,
60, 61, 0, 0, 0, 95, 60, 61, 0, 0,
0, 96, 60, 61, 0, 0, 0, 98, 60, 61,
0, 0, 62, 63, 0, 64, 65, 66, 62, 63,
0, 64, 65, 66, 62, 63, 0, 64, 65, 66,
62, 63, 0, 64, 65, 66, 100, 60, 61, 0,
99, 26, 27, 81, 60, 61, 0, 0, 82, 60,
61, 0, 0, 83, 60, 61, 0, 0, 0, 0,
62, 63, 64, 65, 66, 0, 62, 63, 64, 65,
66, 62, 63, 64, 65, 66, 62, 63, 64, 65,
66, 84, 60, 61, 0, 0, 85, 60, 61, 0,
0, 86, 60, 61, 0, 0, 87, 60, 61, 0,
0, 90, 60, 61, 62, 63, 64, 65, 66, 62,
63, 64, 65, 66, 62, 63, 64, 65, 66, 62,
63, 64, 65, 66, 62, 63, 64, 65, 66, 91,
60, 61, 0, 0, 92, 60, 61, 0, 0, 93,
60, 61, 0, 0, 94, 60, 61, 0, 0, 95,
60, 61, 62, 63, 64, 65, 66, 62, 63, 64,
65, 66, 62, 63, 64, 65, 66, 62, 63, 64,
65, 66, 62, 63, 64, 65, 66, 96, 60, 61,
0, 0, 98, 60, 61, 0, 0, 100, 60, 61,
0, 0, 42, 43, 44, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 62,
63, 0, 64, 65, 66, 45, 46, 0, 0, 47,
48
62, 63, 64, 65, 66, 62, 63, 64, 65, 66,
62, 63, 64, 65, 66, 45, 46, 0, 47, 48
};
static const yytype_int8 yycheck[] =
{
27, 30, 30, 27, -1, 3, 4, 5, 31, 36,
37, 38, 39, 31, 41, 31, 43, 44, 31, 31,
47, 48, 31, 50, 51, 52, 53, 54, 26, 27,
31, 29, 30, 31, -1, -1, -1, -1, -1, -1,
27, 29, 27, 29, -1, 3, 4, 5, 30, 36,
37, 38, 39, 30, 41, 30, 43, 44, 30, 30,
47, 48, 30, 50, 51, 52, 53, 54, 26, 27,
28, 29, 30, 30, -1, -1, -1, -1, -1, -1,
-1, 0, 1, -1, 3, 72, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 3, 4, 5,
97, -1, 31, 32, 3, 4, 5, -1, -1, -1,
3, 4, 5, -1, -1, -1, 3, 4, 5, -1,
26, 27, -1, 29, 30, 31, -1, 26, 27, -1,
29, 30, 31, 26, 27, -1, 29, 30, 31, 26,
27, -1, 29, 30, 31, 3, 4, 5, -1, -1,
-1, 3, 4, 5, -1, -1, -1, 3, 4, 5,
-1, -1, -1, 3, 4, 5, -1, -1, 26, 27,
-1, 29, 30, 31, 26, 27, -1, 29, 30, 31,
26, 27, -1, 29, 30, 31, 26, 27, -1, 29,
30, 31, 3, 4, 5, -1, -1, -1, 3, 4,
5, -1, -1, -1, 3, 4, 5, -1, -1, -1,
3, 4, 5, -1, -1, 26, 27, -1, 29, 30,
31, 26, 27, -1, 29, 30, 31, 26, 27, -1,
29, 30, 31, 26, 27, -1, 29, 30, 31, 3,
4, 5, -1, -1, -1, 3, 4, 5, -1, -1,
-1, 3, 4, 5, -1, -1, -1, 3, 4, 5,
-1, -1, 26, 27, -1, 29, 30, 31, 26, 27,
-1, 29, 30, 31, 26, 27, -1, 29, 30, 31,
26, 27, -1, 29, 30, 31, 3, 4, 5, -1,
97, 30, 31, 3, 4, 5, -1, -1, 3, 4,
5, -1, -1, 3, 4, 5, -1, -1, -1, -1,
26, 27, 28, 29, 30, -1, 26, 27, 28, 29,
30, 26, 27, 28, 29, 30, 26, 27, 28, 29,
30, 3, 4, 5, -1, -1, 3, 4, 5, -1,
-1, 3, 4, 5, -1, -1, 3, 4, 5, -1,
-1, 3, 4, 5, 26, 27, 28, 29, 30, 26,
27, 28, 29, 30, 26, 27, 28, 29, 30, 26,
27, 28, 29, 30, 26, 27, 28, 29, 30, 3,
4, 5, -1, -1, 3, 4, 5, -1, -1, 3,
4, 5, -1, -1, 3, 4, 5, -1, -1, 3,
4, 5, 26, 27, 28, 29, 30, 26, 27, 28,
29, 30, 26, 27, 28, 29, 30, 26, 27, 28,
29, 30, 26, 27, 28, 29, 30, 3, 4, 5,
-1, -1, 3, 4, 5, -1, -1, 3, 4, 5,
-1, -1, 3, 4, 5, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 26,
27, -1, 29, 30, 31, 26, 27, -1, -1, 30,
31
26, 27, 28, 29, 30, 26, 27, 28, 29, 30,
26, 27, 28, 29, 30, 26, 27, -1, 29, 30
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =
{
0, 34, 0, 1, 3, 5, 6, 7, 8, 9,
0, 33, 0, 1, 3, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 31, 32, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 30, 3, 4, 5, 26, 27, 30, 31, 47,
30, 31, 31, 31, 31, 47, 47, 47, 47, 3,
4, 5, 26, 27, 29, 30, 31, 48, 47, 47,
47, 31, 31, 47, 47, 3, 47, 47, 47, 47,
47, 3, 3, 3, 3, 3, 3, 3, 27, 47,
3, 3, 3, 3, 3, 3, 3, 31, 3, 47,
20, 21, 22, 23, 24, 25, 30, 31, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 29, 3, 4, 5, 26, 27, 29, 30, 46,
29, 30, 30, 30, 30, 46, 46, 46, 46, 3,
4, 5, 26, 27, 28, 29, 30, 47, 46, 46,
46, 30, 30, 46, 46, 3, 46, 46, 46, 46,
46, 3, 3, 3, 3, 3, 3, 3, 27, 46,
3, 3, 3, 3, 3, 3, 3, 30, 3, 46,
3
};
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1[] =
{
0, 33, 34, 34, 35, 35, 36, 37, 37, 37,
37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
37, 37, 37, 37, 37, 37, 37, 38, 38, 38,
39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
48, 48, 48, 48, 48
0, 32, 33, 33, 34, 34, 35, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 37, 37, 37,
38, 38, 39, 39, 40, 40, 41, 41, 42, 42,
43, 43, 44, 44, 45, 45, 46, 46, 47, 47,
47, 47, 47, 47, 47
};
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
@ -1449,239 +1438,217 @@ yyreduce:
switch (yyn)
{
case 6:
#line 109 "cmFortranParser.y" /* yacc.c:1646 */
#line 108 "cmFortranParser.y" /* yacc.c:1646 */
{
free((yyvsp[-3].string));
}
#line 1457 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1446 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 7:
#line 115 "cmFortranParser.y" /* yacc.c:1646 */
#line 113 "cmFortranParser.y" /* yacc.c:1646 */
{
if (cmFortranParserIsKeyword((yyvsp[-1].string), "interface"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
if (cmFortranParserIsKeyword((yyvsp[-1].string), "interface")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, true);
}
free((yyvsp[-1].string));
}
#line 1471 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1458 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 8:
#line 125 "cmFortranParser.y" /* yacc.c:1646 */
#line 120 "cmFortranParser.y" /* yacc.c:1646 */
{
if (cmFortranParserIsKeyword((yyvsp[-3].string), "use"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
if (cmFortranParserIsKeyword((yyvsp[-3].string), "use")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
}
else if (cmFortranParserIsKeyword((yyvsp[-3].string), "module"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword((yyvsp[-3].string), "module")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleModule(parser, (yyvsp[-2].string));
}
else if (cmFortranParserIsKeyword((yyvsp[-3].string), "interface"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword((yyvsp[-3].string), "interface")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, true);
}
else if (cmFortranParserIsKeyword((yyvsp[-2].string), "interface") &&
cmFortranParserIsKeyword((yyvsp[-3].string), "end"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword((yyvsp[-2].string), "interface") &&
cmFortranParserIsKeyword((yyvsp[-3].string), "end")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, false);
}
free((yyvsp[-3].string));
free((yyvsp[-2].string));
}
#line 1505 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1481 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 9:
#line 155 "cmFortranParser.y" /* yacc.c:1646 */
#line 138 "cmFortranParser.y" /* yacc.c:1646 */
{
if (cmFortranParserIsKeyword((yyvsp[-4].string), "use"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
if (cmFortranParserIsKeyword((yyvsp[-4].string), "use")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
}
free((yyvsp[-4].string));
free((yyvsp[-2].string));
}
#line 1520 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1494 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 10:
#line 166 "cmFortranParser.y" /* yacc.c:1646 */
#line 146 "cmFortranParser.y" /* yacc.c:1646 */
{
if (cmFortranParserIsKeyword((yyvsp[-6].string), "use") &&
cmFortranParserIsKeyword((yyvsp[-4].string), "non_intrinsic") )
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
cmFortranParserIsKeyword((yyvsp[-4].string), "non_intrinsic") ) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
}
free((yyvsp[-6].string));
free((yyvsp[-4].string));
free((yyvsp[-2].string));
}
#line 1537 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1509 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 11:
#line 179 "cmFortranParser.y" /* yacc.c:1646 */
#line 156 "cmFortranParser.y" /* yacc.c:1646 */
{
if (cmFortranParserIsKeyword((yyvsp[-3].string), "include"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
if (cmFortranParserIsKeyword((yyvsp[-3].string), "include")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
}
free((yyvsp[-3].string));
free((yyvsp[-2].string));
}
#line 1522 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 12:
#line 164 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1532 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 13:
#line 169 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1542 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 14:
#line 174 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1552 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 12:
#line 190 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1563 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 13:
#line 197 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1574 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 14:
#line 204 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1585 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 15:
#line 211 "cmFortranParser.y" /* yacc.c:1646 */
#line 179 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleDefine(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1595 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1562 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 16:
#line 217 "cmFortranParser.y" /* yacc.c:1646 */
#line 184 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUndef(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1605 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1572 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 17:
#line 223 "cmFortranParser.y" /* yacc.c:1646 */
#line 189 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIfdef(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1615 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1582 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 18:
#line 229 "cmFortranParser.y" /* yacc.c:1646 */
#line 194 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIfndef(parser, (yyvsp[-2].string));
free((yyvsp[-2].string));
}
#line 1625 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1592 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 19:
#line 235 "cmFortranParser.y" /* yacc.c:1646 */
#line 199 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIf(parser);
}
#line 1634 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1601 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 20:
#line 240 "cmFortranParser.y" /* yacc.c:1646 */
#line 203 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleElif(parser);
}
#line 1643 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1610 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 21:
#line 245 "cmFortranParser.y" /* yacc.c:1646 */
#line 207 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleElse(parser);
}
#line 1652 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1619 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 22:
#line 250 "cmFortranParser.y" /* yacc.c:1646 */
#line 211 "cmFortranParser.y" /* yacc.c:1646 */
{
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleEndif(parser);
}
#line 1661 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1628 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 23:
#line 255 "cmFortranParser.y" /* yacc.c:1646 */
#line 215 "cmFortranParser.y" /* yacc.c:1646 */
{
free((yyvsp[-3].string));
}
#line 1669 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1636 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 48:
#line 277 "cmFortranParser.y" /* yacc.c:1646 */
#line 237 "cmFortranParser.y" /* yacc.c:1646 */
{ free ((yyvsp[0].string)); }
#line 1675 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1642 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
case 49:
#line 278 "cmFortranParser.y" /* yacc.c:1646 */
#line 238 "cmFortranParser.y" /* yacc.c:1646 */
{ free ((yyvsp[0].string)); }
#line 1681 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1648 "cmFortranParser.cxx" /* yacc.c:1646 */
break;
#line 1685 "cmFortranParser.cxx" /* yacc.c:1646 */
#line 1652 "cmFortranParser.cxx" /* yacc.c:1646 */
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
@ -1911,6 +1878,6 @@ yyreturn:
#endif
return yyresult;
}
#line 286 "cmFortranParser.y" /* yacc.c:1906 */
#line 246 "cmFortranParser.y" /* yacc.c:1906 */
/* End of grammar */

6
Source/cmFortranParser.h
View File

@ -73,6 +73,7 @@ union cmFortran_yystype_u
#define YYSTYPE cmFortran_yystype
#define YYSTYPE_IS_DECLARED 1
#if !defined(cmFortranLexer_cxx)
#define YY_NO_UNISTD_H
#include "cmFortranLexer.h"
#endif
#if !defined(cmFortranLexer_cxx)
@ -117,11 +118,13 @@ struct cmFortranFile
: File(file)
, Buffer(buffer)
, Directory(dir)
, LastCharWasNewline(false)
{
}
FILE* File;
YY_BUFFER_STATE Buffer;
std::string Directory;
bool LastCharWasNewline;
};
struct cmFortranParser_s
@ -146,6 +149,9 @@ struct cmFortranParser_s
// Buffer for string literals.
std::string TokenString;
// Error message text if a parser error occurs.
std::string Error;
// Flag for whether lexer is reading from inside an interface.
bool InInterface;

118
Source/cmFortranParser.y
View File

@ -92,7 +92,6 @@ static bool cmFortranParserIsKeyword(const char* word,
%token F90PPR_IFDEF F90PPR_IFNDEF F90PPR_IF
%token F90PPR_ELSE F90PPR_ELIF F90PPR_ENDIF
%token COMMA DCOLON
%token <string> CPP_TOENDL
%token <number> UNTERMINATED_STRING
%token <string> STRING WORD
%token <string> CPP_INCLUDE_ANGLE
@ -105,154 +104,115 @@ code: /* empty */ | code stmt;
stmt: keyword_stmt | assignment_stmt;
assignment_stmt: WORD ASSIGNMENT_OP other EOSTMT /* Ignore */
{
assignment_stmt:
WORD ASSIGNMENT_OP other EOSTMT {
free($1);
}
keyword_stmt:
WORD EOSTMT
{
if (cmFortranParserIsKeyword($1, "interface"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
WORD EOSTMT {
if (cmFortranParserIsKeyword($1, "interface")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, true);
}
free($1);
}
| WORD WORD other EOSTMT
{
if (cmFortranParserIsKeyword($1, "use"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| WORD WORD other EOSTMT {
if (cmFortranParserIsKeyword($1, "use")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, $2);
}
else if (cmFortranParserIsKeyword($1, "module"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword($1, "module")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleModule(parser, $2);
}
else if (cmFortranParserIsKeyword($1, "interface"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword($1, "interface")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, true);
}
else if (cmFortranParserIsKeyword($2, "interface") &&
cmFortranParserIsKeyword($1, "end"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
} else if (cmFortranParserIsKeyword($2, "interface") &&
cmFortranParserIsKeyword($1, "end")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_SetInInterface(parser, false);
}
free($1);
free($2);
}
| WORD DCOLON WORD other EOSTMT
{
if (cmFortranParserIsKeyword($1, "use"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| WORD DCOLON WORD other EOSTMT {
if (cmFortranParserIsKeyword($1, "use")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, $3);
}
free($1);
free($3);
}
| WORD COMMA WORD DCOLON WORD other EOSTMT
{
| WORD COMMA WORD DCOLON WORD other EOSTMT {
if (cmFortranParserIsKeyword($1, "use") &&
cmFortranParserIsKeyword($3, "non_intrinsic") )
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
cmFortranParserIsKeyword($3, "non_intrinsic") ) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUse(parser, $5);
}
free($1);
free($3);
free($5);
}
| WORD STRING other EOSTMT /* Ignore */
{
if (cmFortranParserIsKeyword($1, "include"))
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| WORD STRING other EOSTMT {
if (cmFortranParserIsKeyword($1, "include")) {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, $2);
}
free($1);
free($2);
}
| CPP_LINE_DIRECTIVE STRING other EOSTMT
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| CPP_LINE_DIRECTIVE STRING other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleLineDirective(parser, $2);
free($2);
}
| CPP_INCLUDE_ANGLE other EOSTMT
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| CPP_INCLUDE_ANGLE other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, $1);
free($1);
}
| include STRING other EOSTMT
{
cmFortranParser* parser =
cmFortran_yyget_extra(yyscanner);
| include STRING other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleInclude(parser, $2);
free($2);
}
| define WORD other EOSTMT
{
| define WORD other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleDefine(parser, $2);
free($2);
}
| undef WORD other EOSTMT
{
| undef WORD other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleUndef(parser, $2);
free($2);
}
| ifdef WORD other EOSTMT
{
| ifdef WORD other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIfdef(parser, $2);
free($2);
}
| ifndef WORD other EOSTMT
{
| ifndef WORD other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIfndef(parser, $2);
free($2);
}
| if other EOSTMT
{
| if other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleIf(parser);
}
| elif other EOSTMT
{
| elif other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleElif(parser);
}
| else other EOSTMT
{
| else other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleElse(parser);
}
| endif other EOSTMT
{
| endif other EOSTMT {
cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
cmFortranParser_RuleEndif(parser);
}
| WORD GARBAGE other EOSTMT /* Ignore */
{
| WORD GARBAGE other EOSTMT {
free($1);
}
| GARBAGE other EOSTMT

21
Source/cmFortranParserImpl.cxx
View File

@ -119,8 +119,19 @@ int cmFortranParser_Input(cmFortranParser* parser, char* buffer,
// 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);
cmFortranFile& ff = parser->FileStack.top();
FILE* file = ff.File;
size_t n = fread(buffer, 1, bufferSize, file);
if (n > 0) {
ff.LastCharWasNewline = buffer[n - 1] == '\n';
} else if (!ff.LastCharWasNewline) {
// The file ended without a newline. Inject one so
// that the file always ends in an end-of-statement.
buffer[0] = '\n';
n = 1;
ff.LastCharWasNewline = true;
}
return (int)n;
}
return 0;
}
@ -164,11 +175,9 @@ int cmFortranParser_GetOldStartcond(cmFortranParser* parser)
return parser->OldStartcond;
}
void cmFortranParser_Error(cmFortranParser* /*unused*/, const char* /*unused*/)
void cmFortranParser_Error(cmFortranParser* parser, const char* msg)
{
// 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.
parser->Error = msg ? msg : "unknown error";
}
void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name)

28
Source/cmFortranParserTokens.h
View File

@ -1,8 +1,8 @@
/* A Bison parser, made by GNU Bison 3.0.2. */
/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
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
@ -70,11 +70,10 @@ extern int cmFortran_yydebug;
F90PPR_ENDIF = 280,
COMMA = 281,
DCOLON = 282,
CPP_TOENDL = 283,
UNTERMINATED_STRING = 284,
STRING = 285,
WORD = 286,
CPP_INCLUDE_ANGLE = 287
UNTERMINATED_STRING = 283,
STRING = 284,
WORD = 285,
CPP_INCLUDE_ANGLE = 286
};
#endif
/* Tokens. */
@ -103,23 +102,24 @@ extern int cmFortran_yydebug;
#define F90PPR_ENDIF 280
#define COMMA 281
#define DCOLON 282
#define CPP_TOENDL 283
#define UNTERMINATED_STRING 284
#define STRING 285
#define WORD 286
#define CPP_INCLUDE_ANGLE 287
#define UNTERMINATED_STRING 283
#define STRING 284
#define WORD 285
#define CPP_INCLUDE_ANGLE 286
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE YYSTYPE;
union YYSTYPE
{
#line 81 "cmFortranParser.y" /* yacc.c:1909 */
char* string;
#line 122 "cmFortranParserTokens.h" /* yacc.c:1909 */
#line 120 "cmFortranParserTokens.h" /* yacc.c:1909 */
};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif