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

ENH: change comment for fortran depend parsing

This commit is contained in:
Bill Hoffman 2006-08-15 10:56:00 -04:00
parent 006a8522ca
commit 7169980b59
3 changed files with 178 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

350
Source/cmDependsFortranLexer.cxx
View File

@ -1,6 +1,3 @@
#line 2 "cmDependsFortranLexer.cxx"
#line 4 "cmDependsFortranLexer.cxx"
#define YY_INT_ALIGNED short int #define YY_INT_ALIGNED short int
@ -165,8 +162,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
#define YY_LESS_LINENO(n) #define YY_LESS_LINENO(n)
/* Return all but the first "n" matched characters back to the input stream. /* Return all but the first "n" matched characters back to the input stream. */
*/
#define yyless(n) \ #define yyless(n) \
do \ do \
{ \ { \
@ -175,8 +171,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
YY_LESS_LINENO(yyless_macro_arg);\ YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = yyg->yy_hold_char; \ *yy_cp = yyg->yy_hold_char; \
YY_RESTORE_YY_MORE_OFFSET \ YY_RESTORE_YY_MORE_OFFSET \
yyg->yy_c_buf_p \ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
= yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \ } \
while ( 0 ) while ( 0 )
@ -250,8 +245,8 @@ struct yy_buffer_state
* possible backing-up. * possible backing-up.
* *
* When we actually see the EOF, we change the status to "new" * When we actually see the EOF, we change the status to "new"
* (via cmDependsFortran_yyrestart()), so that the user can continue * (via cmDependsFortran_yyrestart()), so that the user can continue scanning by
* scanning by just pointing yyin at a new input file. * just pointing yyin at a new input file.
*/ */
#define YY_BUFFER_EOF_PENDING 2 #define YY_BUFFER_EOF_PENDING 2
@ -291,9 +286,9 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,yysc
YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); YY_BUFFER_STATE cmDependsFortran_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 cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *cmDependsFortran_yyalloc (yy_size_t );
void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); void *cmDependsFortran_yyrealloc (void *, yy_size_t );
void cmDependsFortran_yyfree (void * ,yyscan_t yyscanner ); void cmDependsFortran_yyfree (void * );
#define yy_new_buffer cmDependsFortran_yy_create_buffer #define yy_new_buffer cmDependsFortran_yy_create_buffer
@ -333,7 +328,7 @@ typedef int yy_state_type;
static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); 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 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 int yy_get_next_buffer (yyscan_t yyscanner );
static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); static void yy_fatal_error (yyconst char msg[] );
/* Done after the current pattern has been matched and before the /* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext. * corresponding action - sets up yytext.
@ -358,10 +353,10 @@ static yyconst flex_int16_t yy_accept[270] =
{ 0, { 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
44, 39, 41, 40, 42, 1, 39, 39, 39, 2, 44, 39, 41, 40, 42, 1, 39, 39, 39, 2,
40, 39, 39, 39, 39, 39, 40, 39, 9, 8, 40, 39, 39, 39, 39, 39, 39, 40, 9, 8,
9, 4, 3, 39, 0, 10, 0, 39, 39, 39, 9, 4, 3, 39, 0, 10, 0, 39, 39, 39,
39, 0, 39, 39, 39, 39, 0, 37, 39, 39, 39, 0, 39, 39, 39, 39, 0, 37, 39, 39,
39, 39, 39, 0, 39, 0, 11, 0, 5, 0, 39, 39, 39, 39, 0, 11, 0, 0, 5, 0,
0, 0, 0, 39, 39, 39, 27, 39, 39, 0, 0, 0, 0, 39, 39, 39, 27, 39, 39, 0,
0, 0, 0, 39, 39, 39, 33, 39, 39, 0, 0, 0, 0, 39, 39, 39, 33, 39, 39, 0,
38, 0, 39, 39, 39, 39, 39, 16, 0, 0, 38, 0, 39, 39, 39, 39, 39, 16, 0, 0,
@ -428,46 +423,46 @@ static yyconst flex_int32_t yy_meta[29] =
static yyconst flex_int16_t yy_base[276] = static yyconst flex_int16_t yy_base[276] =
{ 0, { 0,
0, 0, 0, 0, 332, 26, 29, 34, 43, 44, 0, 17, 0, 18, 335, 28, 32, 35, 29, 44,
334, 0, 336, 336, 330, 336, 53, 80, 28, 336, 337, 0, 339, 339, 333, 339, 53, 80, 47, 339,
336, 318, 308, 307, 305, 302, 322, 107, 336, 321, 339, 321, 311, 310, 308, 305, 107, 325, 339, 324,
54, 336, 336, 0, 322, 336, 119, 306, 13, 29, 54, 339, 339, 0, 325, 339, 119, 309, 39, 18,
300, 146, 304, 39, 42, 298, 61, 67, 73, 303, 303, 146, 307, 40, 45, 301, 64, 70, 72, 306,
52, 302, 300, 312, 173, 313, 336, 81, 85, 297, 49, 305, 303, 173, 317, 339, 314, 81, 85, 300,
53, 69, 291, 294, 15, 295, 79, 295, 293, 291, 68, 80, 294, 297, 68, 298, 79, 298, 296, 294,
68, 80, 285, 288, 81, 289, 99, 289, 287, 121, 83, 82, 288, 291, 96, 292, 100, 292, 290, 123,
336, 123, 280, 110, 281, 283, 272, 0, 294, 136, 339, 124, 283, 110, 284, 286, 275, 0, 297, 133,
336, 279, 107, 280, 112, 280, 278, 274, 274, 274, 339, 282, 114, 283, 129, 283, 281, 277, 277, 277,
271, 272, 272, 267, 269, 267, 114, 268, 127, 268, 274, 275, 275, 270, 272, 270, 129, 271, 133, 271,
266, 262, 262, 262, 259, 260, 260, 255, 257, 251, 269, 265, 265, 265, 262, 263, 263, 258, 260, 254,
257, 137, 249, 247, 242, 244, 247, 262, 246, 246, 260, 137, 252, 250, 245, 247, 250, 265, 249, 249,
246, 243, 244, 244, 239, 241, 235, 0, 0, 238, 249, 246, 247, 247, 242, 244, 238, 0, 0, 241,
237, 237, 226, 234, 232, 232, 232, 229, 230, 230, 240, 240, 229, 237, 235, 235, 235, 232, 233, 233,
225, 227, 221, 0, 0, 224, 223, 223, 212, 220, 228, 230, 224, 0, 0, 227, 226, 226, 215, 223,
222, 216, 213, 211, 207, 216, 215, 212, 212, 224, 225, 219, 216, 214, 210, 219, 218, 215, 215, 227,
205, 336, 336, 208, 207, 207, 196, 204, 204, 0, 208, 339, 339, 211, 210, 210, 199, 207, 207, 0,
0, 202, 203, 0, 196, 336, 336, 199, 198, 198, 0, 205, 206, 0, 199, 339, 339, 202, 201, 201,
187, 195, 195, 0, 0, 193, 194, 0, 189, 181, 190, 198, 198, 0, 0, 196, 197, 0, 192, 184,
181, 190, 188, 177, 186, 188, 0, 0, 184, 336, 184, 193, 191, 180, 189, 191, 0, 0, 187, 339,
336, 181, 168, 336, 0, 0, 165, 164, 336, 336, 339, 185, 186, 339, 0, 0, 184, 182, 339, 339,
162, 156, 336, 0, 0, 154, 143, 153, 151, 140, 166, 166, 339, 0, 0, 164, 153, 156, 154, 143,
142, 144, 0, 146, 336, 336, 336, 143, 0, 336, 145, 148, 0, 152, 339, 339, 339, 149, 0, 339,
336, 142, 0, 141, 138, 130, 133, 134, 134, 131, 339, 147, 0, 145, 143, 135, 137, 135, 135, 127,
336, 336, 127, 0, 100, 99, 91, 0, 0, 336, 339, 339, 123, 0, 112, 109, 104, 0, 0, 339,
90, 336, 88, 78, 62, 49, 0, 336, 336, 186, 92, 339, 77, 63, 60, 35, 0, 339, 339, 186,
48, 189, 192, 195, 198 47, 189, 192, 195, 198
} ; } ;
static yyconst flex_int16_t yy_def[276] = static yyconst flex_int16_t yy_def[276] =
{ 0, { 0,
269, 1, 1, 1, 1, 1, 270, 270, 270, 270, 269, 1, 1, 1, 1, 1, 270, 270, 270, 270,
269, 271, 269, 269, 272, 269, 271, 271, 271, 269, 269, 271, 269, 269, 272, 269, 271, 271, 271, 269,
269, 271, 271, 271, 271, 271, 269, 273, 269, 269, 269, 271, 271, 271, 271, 271, 273, 269, 269, 269,
269, 269, 269, 271, 272, 269, 269, 271, 271, 271, 269, 269, 269, 271, 272, 269, 269, 271, 271, 271,
271, 269, 271, 271, 271, 271, 269, 269, 271, 271, 271, 269, 271, 271, 271, 271, 269, 269, 271, 271,
271, 271, 271, 269, 273, 274, 269, 269, 269, 269, 271, 271, 271, 273, 274, 269, 269, 269, 269, 269,
269, 269, 269, 271, 271, 271, 271, 271, 271, 269, 269, 269, 269, 271, 271, 271, 271, 271, 271, 269,
269, 269, 269, 271, 271, 271, 271, 271, 271, 269, 269, 269, 269, 271, 271, 271, 271, 271, 271, 269,
269, 269, 271, 271, 271, 271, 271, 271, 269, 269, 269, 269, 271, 271, 271, 271, 271, 271, 269, 269,
@ -494,92 +489,92 @@ static yyconst flex_int16_t yy_def[276] =
269, 269, 269, 269, 269 269, 269, 269, 269, 269
} ; } ;
static yyconst flex_int16_t yy_nxt[365] = static yyconst flex_int16_t yy_nxt[368] =
{ 0, { 0,
12, 13, 14, 13, 13, 15, 16, 17, 18, 19, 12, 13, 14, 13, 13, 15, 16, 17, 18, 19,
20, 12, 21, 22, 12, 12, 12, 23, 12, 24, 20, 12, 21, 22, 12, 12, 12, 23, 12, 24,
12, 25, 12, 12, 12, 12, 12, 26, 27, 47, 12, 25, 12, 12, 12, 12, 12, 26, 27, 27,
48, 30, 47, 65, 99, 66, 30, 28, 31, 32, 28, 30, 27, 27, 30, 33, 67, 30, 31, 27,
100, 28, 28, 31, 32, 30, 30, 67, 34, 33, 68, 31, 32, 27, 31, 32, 30, 34, 47, 48,
33, 68, 31, 31, 37, 58, 59, 37, 58, 75, 33, 47, 268, 31, 37, 58, 59, 37, 58, 65,
77, 76, 47, 48, 78, 47, 268, 85, 80, 38, 75, 66, 76, 77, 85, 47, 48, 78, 47, 38,
39, 80, 40, 93, 82, 94, 81, 82, 86, 267, 39, 80, 40, 82, 80, 86, 82, 267, 266, 81,
41, 42, 58, 59, 42, 58, 90, 95, 107, 90, 41, 42, 58, 59, 42, 58, 90, 99, 93, 90,
108, 96, 83, 266, 91, 102, 43, 44, 109, 45, 94, 83, 265, 100, 91, 102, 43, 44, 95, 45,
113, 103, 110, 265, 264, 263, 114, 46, 56, 57, 109, 103, 96, 107, 110, 108, 264, 46, 55, 56,
56, 56, 56, 56, 122, 116, 262, 56, 261, 56, 55, 55, 55, 55, 122, 113, 116, 55, 263, 55,
37, 117, 80, 37, 82, 80, 130, 82, 133, 123, 37, 114, 117, 37, 80, 82, 262, 80, 82, 123,
81, 124, 131, 146, 134, 60, 61, 90, 62, 147, 261, 124, 81, 130, 90, 60, 61, 90, 62, 131,
90, 122, 120, 149, 260, 91, 63, 42, 259, 150, 260, 122, 91, 120, 259, 133, 63, 42, 146, 149,
42, 258, 257, 256, 255, 254, 163, 253, 164, 252, 42, 134, 258, 257, 147, 150, 163, 256, 164, 255,
251, 250, 70, 71, 249, 72, 248, 247, 246, 245, 254, 253, 70, 71, 252, 72, 251, 250, 249, 248,
244, 243, 242, 73, 56, 57, 56, 56, 56, 56, 247, 246, 245, 73, 55, 56, 55, 55, 55, 55,
241, 240, 239, 56, 238, 56, 29, 29, 29, 35, 244, 243, 242, 55, 241, 55, 29, 29, 29, 35,
35, 35, 55, 55, 55, 56, 56, 56, 235, 237, 35, 35, 54, 54, 54, 55, 55, 55, 235, 240,
235, 236, 234, 233, 232, 231, 230, 229, 228, 227, 235, 239, 238, 237, 236, 234, 233, 232, 231, 230,
226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220,
216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210,
206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200,
196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190,
186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180,
176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170,
166, 165, 162, 161, 160, 159, 158, 157, 156, 155, 169, 168, 167, 166, 165, 162, 161, 160, 159, 158,
154, 153, 152, 151, 148, 145, 144, 143, 142, 141, 157, 156, 155, 154, 153, 152, 151, 148, 145, 144,
140, 139, 138, 137, 136, 135, 132, 129, 128, 127, 143, 142, 141, 140, 139, 138, 137, 136, 135, 132,
126, 125, 121, 119, 118, 115, 112, 111, 106, 105, 129, 128, 127, 126, 125, 121, 119, 118, 115, 112,
104, 101, 98, 97, 92, 57, 89, 88, 87, 84, 111, 106, 105, 104, 101, 98, 97, 92, 89, 56,
79, 74, 69, 64, 36, 54, 54, 53, 52, 51, 88, 87, 84, 79, 74, 69, 64, 36, 57, 57,
50, 49, 36, 269, 27, 11, 269, 269, 269, 269, 53, 52, 51, 50, 49, 36, 269, 28, 11, 269,
269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
269, 269, 269, 269 269, 269, 269, 269, 269, 269, 269
} ; } ;
static yyconst flex_int16_t yy_chk[365] = static yyconst flex_int16_t yy_chk[368] =
{ 0, { 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 6, 19, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4,
19, 7, 19, 39, 65, 39, 8, 6, 7, 7, 6, 9, 2, 4, 7, 9, 40, 8, 9, 6,
65, 6, 6, 8, 8, 9, 10, 40, 271, 9, 40, 7, 7, 6, 8, 8, 10, 271, 19, 19,
10, 40, 9, 10, 17, 31, 31, 17, 31, 44, 10, 19, 266, 10, 17, 31, 31, 17, 31, 39,
45, 44, 47, 47, 45, 47, 266, 51, 48, 17, 44, 39, 44, 45, 51, 47, 47, 45, 47, 17,
17, 48, 17, 61, 49, 61, 48, 49, 51, 265, 17, 48, 17, 49, 48, 51, 49, 265, 264, 48,
17, 18, 58, 58, 18, 58, 59, 62, 71, 59, 17, 18, 58, 58, 18, 58, 59, 65, 61, 59,
71, 62, 49, 264, 59, 67, 18, 18, 72, 18, 61, 49, 263, 65, 59, 67, 18, 18, 62, 18,
75, 67, 72, 263, 261, 257, 75, 18, 28, 28, 72, 67, 62, 71, 72, 71, 261, 18, 27, 27,
28, 28, 28, 28, 84, 77, 256, 28, 255, 28, 27, 27, 27, 27, 84, 75, 77, 27, 257, 27,
37, 77, 80, 37, 82, 80, 93, 82, 95, 84, 37, 75, 77, 37, 80, 82, 256, 80, 82, 84,
80, 84, 93, 107, 95, 37, 37, 90, 37, 107, 255, 84, 80, 93, 90, 37, 37, 90, 37, 93,
90, 122, 82, 109, 253, 90, 37, 42, 250, 109, 253, 122, 90, 82, 250, 95, 37, 42, 107, 109,
42, 249, 248, 247, 246, 245, 122, 244, 122, 242, 42, 95, 249, 248, 107, 109, 122, 247, 122, 246,
238, 234, 42, 42, 232, 42, 231, 230, 229, 228, 245, 244, 42, 42, 242, 42, 238, 234, 232, 231,
227, 226, 222, 42, 55, 55, 55, 55, 55, 55, 230, 229, 228, 42, 54, 54, 54, 54, 54, 54,
221, 218, 217, 55, 213, 55, 270, 270, 270, 272, 227, 226, 222, 54, 221, 54, 270, 270, 270, 272,
272, 272, 273, 273, 273, 274, 274, 274, 275, 212, 272, 272, 273, 273, 273, 274, 274, 274, 275, 218,
275, 209, 206, 205, 204, 203, 202, 201, 200, 199, 275, 217, 213, 212, 209, 206, 205, 204, 203, 202,
197, 196, 193, 192, 191, 190, 189, 188, 185, 183, 201, 200, 199, 197, 196, 193, 192, 191, 190, 189,
182, 179, 178, 177, 176, 175, 174, 171, 170, 169, 188, 185, 183, 182, 179, 178, 177, 176, 175, 174,
168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162,
158, 157, 156, 153, 152, 151, 150, 149, 148, 147, 161, 160, 159, 158, 157, 156, 153, 152, 151, 150,
146, 145, 144, 143, 142, 141, 140, 137, 136, 135, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140,
134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128,
124, 123, 121, 120, 119, 118, 117, 116, 115, 114, 127, 126, 125, 124, 123, 121, 120, 119, 118, 117,
113, 112, 111, 110, 108, 106, 105, 104, 103, 102, 116, 115, 114, 113, 112, 111, 110, 108, 106, 105,
101, 100, 99, 98, 97, 96, 94, 92, 89, 87, 104, 103, 102, 101, 100, 99, 98, 97, 96, 94,
86, 85, 83, 79, 78, 76, 74, 73, 70, 69, 92, 89, 87, 86, 85, 83, 79, 78, 76, 74,
68, 66, 64, 63, 60, 56, 54, 53, 52, 50, 73, 70, 69, 68, 66, 64, 63, 60, 57, 55,
46, 43, 41, 38, 35, 30, 27, 26, 25, 24, 53, 52, 50, 46, 43, 41, 38, 35, 30, 28,
23, 22, 15, 11, 5, 269, 269, 269, 269, 269, 26, 25, 24, 23, 22, 15, 11, 5, 269, 269,
269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
269, 269, 269, 269 269, 269, 269, 269, 269, 269, 269
} ; } ;
/* The intent behind this definition is that it'll catch /* The intent behind this definition is that it'll catch
@ -589,8 +584,6 @@ static yyconst flex_int16_t yy_chk[365] =
#define yymore() yymore_used_but_not_detected #define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0 #define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET #define YY_RESTORE_YY_MORE_OFFSET
#line 1 "cmDependsFortranLexer.in.l"
#line 2 "cmDependsFortranLexer.in.l"
/*========================================================================= /*=========================================================================
Program: CMake - Cross-Platform Makefile Generator Program: CMake - Cross-Platform Makefile Generator
@ -656,7 +649,6 @@ Modify cmDependsFortranLexer.h:
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
#line 682 "cmDependsFortranLexer.cxx"
#define INITIAL 0 #define INITIAL 0
#define free_fmt 1 #define free_fmt 1
@ -835,7 +827,7 @@ static int input (yyscan_t yyscanner );
/* Report a fatal error. */ /* Report a fatal error. */
#ifndef YY_FATAL_ERROR #ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif #endif
/* end tables serialization structures and prototypes */ /* end tables serialization structures and prototypes */
@ -878,10 +870,6 @@ YY_DECL
register int yy_act; register int yy_act;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
#line 98 "cmDependsFortranLexer.in.l"
#line 907 "cmDependsFortranLexer.cxx"
if ( yyg->yy_init ) if ( yyg->yy_init )
{ {
@ -909,7 +897,7 @@ YY_DECL
cmDependsFortran_yy_load_buffer_state(yyscanner ); cmDependsFortran_yy_load_buffer_state(yyscanner );
} }
for(;;) /* loops until end-of-file is reached */ for ( ;; ) /* loops until end-of-file is reached */
{ {
yy_cp = yyg->yy_c_buf_p; yy_cp = yyg->yy_c_buf_p;
@ -941,7 +929,7 @@ yy_match:
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp; ++yy_cp;
} }
while ( yy_base[yy_current_state] != 336 ); while ( yy_base[yy_current_state] != 339 );
yy_find_action: yy_find_action:
yy_act = yy_accept[yy_current_state]; yy_act = yy_accept[yy_current_state];
@ -967,7 +955,6 @@ do_action: /* This label is used only to access EOF actions. */
case 1: case 1:
YY_RULE_SETUP YY_RULE_SETUP
#line 100 "cmDependsFortranLexer.in.l"
{ {
cmDependsFortranParser_StringStart(yyextra); cmDependsFortranParser_StringStart(yyextra);
BEGIN(str_dq); BEGIN(str_dq);
@ -975,40 +962,33 @@ YY_RULE_SETUP
YY_BREAK YY_BREAK
case 2: case 2:
YY_RULE_SETUP YY_RULE_SETUP
#line 105 "cmDependsFortranLexer.in.l"
{ {
cmDependsFortranParser_StringStart(yyextra); cmDependsFortranParser_StringStart(yyextra);
BEGIN(str_sq); BEGIN(str_sq);
} }
YY_BREAK YY_BREAK
case 3: case 3:
#line 111 "cmDependsFortranLexer.in.l"
case 4: case 4:
YY_RULE_SETUP YY_RULE_SETUP
#line 111 "cmDependsFortranLexer.in.l"
{ {
yylvalp->string = strdup(cmDependsFortranParser_StringEnd(yyextra)); yylvalp->string = strdup(cmDependsFortranParser_StringEnd(yyextra));
return STRING; return STRING;
} }
case 5: case 5:
/* rule 5 can match eol */ /* rule 5 can match eol */
#line 117 "cmDependsFortranLexer.in.l"
case 6: case 6:
/* rule 6 can match eol */ /* rule 6 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 117 "cmDependsFortranLexer.in.l"
/* Ignore (continued strings, free fmt) */ /* Ignore (continued strings, free fmt) */
YY_BREAK YY_BREAK
case 7: case 7:
/* rule 7 can match eol */ /* rule 7 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 119 "cmDependsFortranLexer.in.l"
/*Ignore (cont. strings, fixed fmt) */ /*Ignore (cont. strings, fixed fmt) */
YY_BREAK YY_BREAK
case 8: case 8:
/* rule 8 can match eol */ /* rule 8 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 121 "cmDependsFortranLexer.in.l"
{ {
unput ('\n'); unput ('\n');
BEGIN(INITIAL); BEGIN(INITIAL);
@ -1016,7 +996,6 @@ YY_RULE_SETUP
} }
case 9: case 9:
YY_RULE_SETUP YY_RULE_SETUP
#line 127 "cmDependsFortranLexer.in.l"
{ {
cmDependsFortranParser_StringAppend(yyextra, yytext[0]); cmDependsFortranParser_StringAppend(yyextra, yytext[0]);
} }
@ -1024,55 +1003,44 @@ YY_RULE_SETUP
case 10: case 10:
/* rule 10 can match eol */ /* rule 10 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 131 "cmDependsFortranLexer.in.l"
{ return EOSTMT; } /* Treat comments like */ { return EOSTMT; } /* Treat comments like */
case 11: case 11:
/* rule 11 can match eol */ /* rule 11 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 132 "cmDependsFortranLexer.in.l"
{ return EOSTMT; } /* empty lines */ { return EOSTMT; } /* empty lines */
case 12: case 12:
YY_RULE_SETUP YY_RULE_SETUP
#line 134 "cmDependsFortranLexer.in.l"
{ return CPP_INCLUDE; } { return CPP_INCLUDE; }
case 13: case 13:
YY_RULE_SETUP YY_RULE_SETUP
#line 135 "cmDependsFortranLexer.in.l"
{ return F90PPR_INCLUDE; } { return F90PPR_INCLUDE; }
case 14: case 14:
YY_RULE_SETUP YY_RULE_SETUP
#line 136 "cmDependsFortranLexer.in.l"
{ return COCO_INCLUDE; } { return COCO_INCLUDE; }
case 15: case 15:
YY_RULE_SETUP YY_RULE_SETUP
#line 137 "cmDependsFortranLexer.in.l"
{ return F_INCLUDE; } { return F_INCLUDE; }
case 16: case 16:
YY_RULE_SETUP YY_RULE_SETUP
#line 138 "cmDependsFortranLexer.in.l"
{ return USE; } { return USE; }
case 17: case 17:
YY_RULE_SETUP YY_RULE_SETUP
#line 140 "cmDependsFortranLexer.in.l"
{ {
cmDependsFortranParser_SetInInterface(yyextra, 0); cmDependsFortranParser_SetInInterface(yyextra, 0);
} }
YY_BREAK YY_BREAK
case 18: case 18:
YY_RULE_SETUP YY_RULE_SETUP
#line 143 "cmDependsFortranLexer.in.l"
{ {
cmDependsFortranParser_SetInInterface(yyextra, 1); cmDependsFortranParser_SetInInterface(yyextra, 1);
} }
YY_BREAK YY_BREAK
case 19: case 19:
YY_RULE_SETUP YY_RULE_SETUP
#line 147 "cmDependsFortranLexer.in.l"
/* Ignore */ /* Ignore */
YY_BREAK YY_BREAK
case 20: case 20:
YY_RULE_SETUP YY_RULE_SETUP
#line 148 "cmDependsFortranLexer.in.l"
{ {
if(!cmDependsFortranParser_GetInInterface(yyextra)) if(!cmDependsFortranParser_GetInInterface(yyextra))
{ {
@ -1082,101 +1050,77 @@ YY_RULE_SETUP
YY_BREAK YY_BREAK
case 21: case 21:
YY_RULE_SETUP YY_RULE_SETUP
#line 155 "cmDependsFortranLexer.in.l"
{ return CPP_DEFINE; } { return CPP_DEFINE; }
case 22: case 22:
YY_RULE_SETUP YY_RULE_SETUP
#line 156 "cmDependsFortranLexer.in.l"
{ return F90PPR_DEFINE; } { return F90PPR_DEFINE; }
case 23: case 23:
YY_RULE_SETUP YY_RULE_SETUP
#line 158 "cmDependsFortranLexer.in.l"
{ return CPP_UNDEF; } { return CPP_UNDEF; }
case 24: case 24:
YY_RULE_SETUP YY_RULE_SETUP
#line 159 "cmDependsFortranLexer.in.l"
{ return F90PPR_UNDEF; } { return F90PPR_UNDEF; }
case 25: case 25:
YY_RULE_SETUP YY_RULE_SETUP
#line 161 "cmDependsFortranLexer.in.l"
{ return CPP_IFDEF; } { return CPP_IFDEF; }
case 26: case 26:
YY_RULE_SETUP YY_RULE_SETUP
#line 162 "cmDependsFortranLexer.in.l"
{ return CPP_IFNDEF; } { return CPP_IFNDEF; }
case 27: case 27:
YY_RULE_SETUP YY_RULE_SETUP
#line 163 "cmDependsFortranLexer.in.l"
{ return CPP_IF; } { return CPP_IF; }
case 28: case 28:
YY_RULE_SETUP YY_RULE_SETUP
#line 164 "cmDependsFortranLexer.in.l"
{ return CPP_ELIF; } { return CPP_ELIF; }
case 29: case 29:
YY_RULE_SETUP YY_RULE_SETUP
#line 165 "cmDependsFortranLexer.in.l"
{ return CPP_ELSE; } { return CPP_ELSE; }
case 30: case 30:
YY_RULE_SETUP YY_RULE_SETUP
#line 166 "cmDependsFortranLexer.in.l"
{ return CPP_ENDIF; } { return CPP_ENDIF; }
case 31: case 31:
YY_RULE_SETUP YY_RULE_SETUP
#line 168 "cmDependsFortranLexer.in.l"
{ return F90PPR_IFDEF; } { return F90PPR_IFDEF; }
case 32: case 32:
YY_RULE_SETUP YY_RULE_SETUP
#line 169 "cmDependsFortranLexer.in.l"
{ return F90PPR_IFNDEF; } { return F90PPR_IFNDEF; }
case 33: case 33:
YY_RULE_SETUP YY_RULE_SETUP
#line 170 "cmDependsFortranLexer.in.l"
{ return F90PPR_IF; } { return F90PPR_IF; }
case 34: case 34:
YY_RULE_SETUP YY_RULE_SETUP
#line 171 "cmDependsFortranLexer.in.l"
{ return F90PPR_ELIF; } { return F90PPR_ELIF; }
case 35: case 35:
YY_RULE_SETUP YY_RULE_SETUP
#line 172 "cmDependsFortranLexer.in.l"
{ return F90PPR_ELSE; } { return F90PPR_ELSE; }
case 36: case 36:
YY_RULE_SETUP YY_RULE_SETUP
#line 173 "cmDependsFortranLexer.in.l"
{ return F90PPR_ENDIF; } { return F90PPR_ENDIF; }
case 37: case 37:
/* rule 37 can match eol */ /* rule 37 can match eol */
#line 176 "cmDependsFortranLexer.in.l"
case 38: case 38:
/* rule 38 can match eol */ /* rule 38 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 176 "cmDependsFortranLexer.in.l"
/* Ignore */ /* Ignore */
YY_BREAK YY_BREAK
case 39: case 39:
YY_RULE_SETUP YY_RULE_SETUP
#line 179 "cmDependsFortranLexer.in.l"
{ yylvalp->string = strdup(yytext); return WORD; } { yylvalp->string = strdup(yytext); return WORD; }
case 40: case 40:
/* rule 40 can match eol */ /* rule 40 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 181 "cmDependsFortranLexer.in.l"
{ return EOSTMT; } { return EOSTMT; }
case 41: case 41:
YY_RULE_SETUP YY_RULE_SETUP
#line 183 "cmDependsFortranLexer.in.l"
/* Ignore */ /* Ignore */
YY_BREAK
case 42: case 42:
YY_RULE_SETUP YY_RULE_SETUP
#line 185 "cmDependsFortranLexer.in.l"
{ return *yytext; } { return *yytext; }
case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(free_fmt): case YY_STATE_EOF(free_fmt):
case YY_STATE_EOF(fixed_fmt): case YY_STATE_EOF(fixed_fmt):
case YY_STATE_EOF(str_sq): case YY_STATE_EOF(str_sq):
case YY_STATE_EOF(str_dq): case YY_STATE_EOF(str_dq):
#line 187 "cmDependsFortranLexer.in.l"
{ {
if(!cmDependsFortranParser_FilePop(yyextra)) if(!cmDependsFortranParser_FilePop(yyextra))
{ {
@ -1186,10 +1130,8 @@ case YY_STATE_EOF(str_dq):
YY_BREAK YY_BREAK
case 43: case 43:
YY_RULE_SETUP YY_RULE_SETUP
#line 194 "cmDependsFortranLexer.in.l"
ECHO; ECHO;
YY_BREAK YY_BREAK
#line 1243 "cmDependsFortranLexer.cxx"
case YY_END_OF_BUFFER: case YY_END_OF_BUFFER:
{ {
@ -1374,10 +1316,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
else else
{ {
size_t nuto_read = size_t num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( nuto_read <= 0 ) while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */ { /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */ /* just a shorter name for the current buffer */
@ -1397,7 +1339,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
b->yy_ch_buf = (char *) b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */ /* Include room in for 2 EOB chars. */
cmDependsFortran_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); cmDependsFortran_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
} }
else else
/* Can't grow it, we don't own it. */ /* Can't grow it, we don't own it. */
@ -1409,17 +1351,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
number_to_move - 1; number_to_move - 1;
} }
if ( nuto_read > YY_READ_BUF_SIZE ) if ( num_to_read > YY_READ_BUF_SIZE )
nuto_read = YY_READ_BUF_SIZE; num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */ /* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
yyg->yy_n_chars, nuto_read ); yyg->yy_n_chars, num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
} }
@ -1701,7 +1643,7 @@ static void cmDependsFortran_yy_load_buffer_state (yyscan_t yyscanner)
{ {
YY_BUFFER_STATE b; YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b ) if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" ); YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" );
@ -1710,7 +1652,7 @@ static void cmDependsFortran_yy_load_buffer_state (yyscan_t yyscanner)
/* yy_ch_buf has to be 2 characters longer than the size given because /* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters. * we need to put in 2 end-of-buffer characters.
*/ */
b->yy_ch_buf = (char *) cmDependsFortran_yyalloc(b->yy_buf_size + 2 ,yyscanner ); b->yy_ch_buf = (char *) cmDependsFortran_yyalloc(b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf ) if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" ); YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_create_buffer()" );
@ -1736,9 +1678,9 @@ static void cmDependsFortran_yy_load_buffer_state (yyscan_t yyscanner)
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer ) if ( b->yy_is_our_buffer )
cmDependsFortran_yyfree((void *) b->yy_ch_buf ,yyscanner ); cmDependsFortran_yyfree((void *) b->yy_ch_buf );
cmDependsFortran_yyfree((void *) b ,yyscanner ); cmDependsFortran_yyfree((void *) b );
} }
#ifndef __cplusplus #ifndef __cplusplus
@ -1861,7 +1803,7 @@ void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner)
*/ */
static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner) static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
{ {
int nuto_alloc; int num_to_alloc;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) { if (!yyg->yy_buffer_stack) {
@ -1870,15 +1812,14 @@ static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
* scanner will even need a stack. We use 2 instead of 1 to avoid an * scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call. * immediate realloc on the next call.
*/ */
nuto_alloc = 1; num_to_alloc = 1;
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyalloc yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyalloc
(nuto_alloc * sizeof(struct yy_buffer_state*) (num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner); );
memset(yyg->yy_buffer_stack, 0, memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
nuto_alloc * sizeof(struct yy_buffer_state*));
yyg->yy_buffer_stack_max = nuto_alloc; yyg->yy_buffer_stack_max = num_to_alloc;
yyg->yy_buffer_stack_top = 0; yyg->yy_buffer_stack_top = 0;
return; return;
} }
@ -1888,15 +1829,15 @@ static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
/* Increase the buffer to prepare for a possible push. */ /* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */; int grow_size = 8 /* arbitrary grow size */;
nuto_alloc = yyg->yy_buffer_stack_max + grow_size; num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyrealloc yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyrealloc
(yyg->yy_buffer_stack, (yyg->yy_buffer_stack,
nuto_alloc * sizeof(struct yy_buffer_state*) num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner); );
/* zero only the new slots.*/ /* zero only the new slots.*/
memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
yyg->yy_buffer_stack_max = nuto_alloc; yyg->yy_buffer_stack_max = num_to_alloc;
} }
} }
@ -1916,7 +1857,7 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char * base, yy_size_t size ,
/* They forgot to leave room for the EOB's. */ /* They forgot to leave room for the EOB's. */
return 0; return 0;
b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); b = (YY_BUFFER_STATE) cmDependsFortran_yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b ) if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_buffer()" ); YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_buffer()" );
@ -1938,6 +1879,7 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char * base, yy_size_t size ,
/** Setup the input buffer state to scan a string. The next call to cmDependsFortran_yylex() will /** Setup the input buffer state to scan a string. The next call to cmDependsFortran_yylex() will
* scan from a @e copy of @a str. * scan from a @e copy of @a str.
* @param str a NUL-terminated string to scan * @param str a NUL-terminated string to scan
* @param yy_str a NUL-terminated string to scan
* @param yyscanner The scanner object. * @param yyscanner The scanner object.
* @return the newly allocated buffer state object. * @return the newly allocated buffer state object.
* @note If you want to scan bytes that may contain NUL values, then use * @note If you want to scan bytes that may contain NUL values, then use
@ -1965,7 +1907,7 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char * bytes, int len
/* Get memory for full buffer, including space for trailing EOB's. */ /* Get memory for full buffer, including space for trailing EOB's. */
n = len + 2; n = len + 2;
buf = (char *) cmDependsFortran_yyalloc(n ,yyscanner ); buf = (char *) cmDependsFortran_yyalloc(n );
if ( ! buf ) if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_bytes()" ); YY_FATAL_ERROR( "out of dynamic memory in cmDependsFortran_yy_scan_bytes()" );
@ -1990,7 +1932,7 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char * bytes, int len
#define YY_EXIT_FAILURE 2 #define YY_EXIT_FAILURE 2
#endif #endif
static void yy_fatal_error (yyconst char* msg , yyscan_t) static void yy_fatal_error (yyconst char* msg )
{ {
(void) fprintf( stderr, "%s\n", msg ); (void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE ); exit( YY_EXIT_FAILURE );
@ -2107,7 +2049,7 @@ void cmDependsFortran_yyset_lineno (int line_number , yyscan_t yyscanner)
/* lineno is only valid if an input buffer exists. */ /* lineno is only valid if an input buffer exists. */
if (! YY_CURRENT_BUFFER ) if (! YY_CURRENT_BUFFER )
yy_fatal_error( "cmDependsFortran_yyset_lineno called with no buffer" , yyscanner); yy_fatal_error( "cmDependsFortran_yyset_lineno called with no buffer" );
yylineno = line_number; yylineno = line_number;
} }
@ -2122,7 +2064,7 @@ void cmDependsFortran_yyset_column (int column_no , yyscan_t yyscanner)
/* column is only valid if an input buffer exists. */ /* column is only valid if an input buffer exists. */
if (! YY_CURRENT_BUFFER ) if (! YY_CURRENT_BUFFER )
yy_fatal_error( "cmDependsFortran_yyset_column called with no buffer" , yyscanner); yy_fatal_error( "cmDependsFortran_yyset_column called with no buffer" );
yycolumn = column_no; yycolumn = column_no;
} }
@ -2205,7 +2147,7 @@ int cmDependsFortran_yylex_init(yyscan_t* ptr_yy_globals)
return 1; return 1;
} }
*ptr_yy_globals = (yyscan_t) cmDependsFortran_yyalloc ( sizeof( struct yyguts_t ), NULL ); *ptr_yy_globals = (yyscan_t) cmDependsFortran_yyalloc ( sizeof( struct yyguts_t ) );
if (*ptr_yy_globals == NULL){ if (*ptr_yy_globals == NULL){
errno = ENOMEM; errno = ENOMEM;
@ -2230,15 +2172,15 @@ int cmDependsFortran_yylex_destroy (yyscan_t yyscanner)
} }
/* Destroy the stack itself. */ /* Destroy the stack itself. */
cmDependsFortran_yyfree(yyg->yy_buffer_stack ,yyscanner); cmDependsFortran_yyfree(yyg->yy_buffer_stack );
yyg->yy_buffer_stack = NULL; yyg->yy_buffer_stack = NULL;
/* Destroy the start condition stack. */ /* Destroy the start condition stack. */
cmDependsFortran_yyfree(yyg->yy_start_stack ,yyscanner ); cmDependsFortran_yyfree(yyg->yy_start_stack );
yyg->yy_start_stack = NULL; yyg->yy_start_stack = NULL;
/* Destroy the main struct (reentrant only). */ /* Destroy the main struct (reentrant only). */
cmDependsFortran_yyfree ( yyscanner , yyscanner ); cmDependsFortran_yyfree ( yyscanner );
return 0; return 0;
} }
@ -2268,12 +2210,12 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
} }
#endif #endif
void *cmDependsFortran_yyalloc (yy_size_t size , yyscan_t) void *cmDependsFortran_yyalloc (yy_size_t size )
{ {
return (void *) malloc( size ); return (void *) malloc( size );
} }
void *cmDependsFortran_yyrealloc (void * ptr, yy_size_t size , yyscan_t) void *cmDependsFortran_yyrealloc (void * ptr, yy_size_t size )
{ {
/* The cast to (char *) in the following accommodates both /* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those * implementations that use char* generic pointers, and those
@ -2285,7 +2227,7 @@ void *cmDependsFortran_yyrealloc (void * ptr, yy_size_t size , yyscan_t)
return (void *) realloc( (char *) ptr, size ); return (void *) realloc( (char *) ptr, size );
} }
void cmDependsFortran_yyfree (void * ptr , yyscan_t) void cmDependsFortran_yyfree (void * ptr )
{ {
free( (char *) ptr ); /* see cmDependsFortran_yyrealloc() for (char *) cast */ free( (char *) ptr ); /* see cmDependsFortran_yyrealloc() for (char *) cast */
} }
@ -2304,7 +2246,6 @@ void cmDependsFortran_yyfree (void * ptr , yyscan_t)
#undef YY_DECL_IS_OURS #undef YY_DECL_IS_OURS
#undef YY_DECL #undef YY_DECL
#endif #endif
#line 194 "cmDependsFortranLexer.in.l"
@ -2315,3 +2256,4 @@ YY_BUFFER_STATE cmDependsFortranLexer_GetCurrentBuffer(yyscan_t yyscanner)
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
return YY_CURRENT_BUFFER; return YY_CURRENT_BUFFER;
} }

32
Source/cmDependsFortranLexer.h
View File

@ -185,24 +185,16 @@ 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 cmDependsFortran_yyrestart (FILE *input_file ,yyscan_t yyscanner );
void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
yyscan_t yyscanner ); YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size , void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
yyscan_t yyscanner ); void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b , void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
yyscan_t yyscanner );
void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,
yyscan_t yyscanner );
void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,
yyscan_t yyscanner );
void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner ); void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size , YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
yyscan_t yyscanner ); YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str , YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
yyscan_t yyscanner );
YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,
yyscan_t yyscanner );
void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@ -228,6 +220,7 @@ void cmDependsFortran_yyfree (void * ,yyscan_t yyscanner );
#define YY_EXTRA_TYPE void * #define YY_EXTRA_TYPE void *
#endif #endif
/* 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. */
@ -239,8 +232,7 @@ void cmDependsFortran_yyset_debug (int debug_flag ,yyscan_t yyscanner );
YY_EXTRA_TYPE cmDependsFortran_yyget_extra (yyscan_t yyscanner ); YY_EXTRA_TYPE cmDependsFortran_yyget_extra (yyscan_t yyscanner );
void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined , void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
yyscan_t yyscanner );
FILE *cmDependsFortran_yyget_in (yyscan_t yyscanner ); FILE *cmDependsFortran_yyget_in (yyscan_t yyscanner );
@ -303,8 +295,7 @@ extern int cmDependsFortran_yylex (yyscan_t yyscanner);
#define YY_DECL int cmDependsFortran_yylex (yyscan_t yyscanner) #define YY_DECL int cmDependsFortran_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 */
*/
#undef YY_NEW_FILE #undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER #undef YY_FLUSH_BUFFER
@ -319,5 +310,6 @@ extern int cmDependsFortran_yylex (yyscan_t yyscanner);
#undef YY_DECL #undef YY_DECL
#endif #endif
#undef cmDependsFortran_yyIN_HEADER #undef cmDependsFortran_yyIN_HEADER
#endif /* cmDependsFortran_yyHEADER_H */ #endif /* cmDependsFortran_yyHEADER_H */

2
Source/cmDependsFortranLexer.in.l
View File

@ -105,7 +105,7 @@ Modify cmDependsFortranLexer.h:
} }
!.*\n { return EOSTMT; } /* Treat comments like */ !.*\n { return EOSTMT; } /* Treat comments like */
<fixed_fmt>^[cC*dD].*\n { return EOSTMT; } /* empty lines */ ^[cC*].*\n { return EOSTMT; } /* empty lines */
#[ \t]*include { return CPP_INCLUDE; } #[ \t]*include { return CPP_INCLUDE; }
\$[ \t]*include { return F90PPR_INCLUDE; } \$[ \t]*include { return F90PPR_INCLUDE; }