2 Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Andy Vaught
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
31 /* Current statement label. Zero means no statement label. Because
32 new_st can get wiped during statement matching, we have to keep it
35 gfc_st_label
*gfc_statement_label
;
37 static locus label_locus
;
40 gfc_state_data
*gfc_state_stack
;
42 /* TODO: Re-order functions to kill these forward decls. */
43 static void check_statement_label (gfc_statement
);
44 static void undo_new_statement (void);
45 static void reject_statement (void);
47 /* A sort of half-matching function. We try to match the word on the
48 input with the passed string. If this succeeds, we call the
49 keyword-dependent matching function that will match the rest of the
50 statement. For single keywords, the matching subroutine is
54 match_word (const char *str
, match (*subr
) (void), locus
* old_locus
)
69 gfc_set_locus (old_locus
);
77 /* Figure out what the next statement is, (mostly) regardless of
80 #define match(keyword, subr, st) \
81 if (match_word(keyword, subr, &old_locus) == MATCH_YES) \
84 undo_new_statement ();
87 decode_statement (void)
98 gfc_clear_error (); /* Clear any pending errors. */
99 gfc_clear_warning (); /* Clear any pending warnings. */
101 if (gfc_match_eos () == MATCH_YES
)
104 old_locus
= *gfc_current_locus ();
106 /* Try matching a data declaration or function declaration. The
107 input "REALFUNCTIONA(N)" can mean several things in different
108 contexts, so it (and its relatives) get special treatment. */
110 if (gfc_current_state () == COMP_NONE
111 || gfc_current_state () == COMP_INTERFACE
112 || gfc_current_state () == COMP_CONTAINS
)
114 m
= gfc_match_function_decl ();
117 else if (m
== MATCH_ERROR
)
121 gfc_set_locus (&old_locus
);
124 /* Match statements whose error messages are meant to be overwritten
125 by something better. */
127 match (NULL
, gfc_match_assignment
, ST_ASSIGNMENT
);
128 match (NULL
, gfc_match_pointer_assignment
, ST_POINTER_ASSIGNMENT
);
129 match (NULL
, gfc_match_st_function
, ST_STATEMENT_FUNCTION
);
131 match (NULL
, gfc_match_data_decl
, ST_DATA_DECL
);
133 /* Try to match a subroutine statement, which has the same optional
134 prefixes that functions can have. */
136 if (gfc_match_subroutine () == MATCH_YES
)
137 return ST_SUBROUTINE
;
139 gfc_set_locus (&old_locus
);
141 /* Check for the IF, DO, SELECT, WHERE and FORALL statements, which
142 might begin with a block label. The match functions for these
143 statements are unusual in that their keyword is not seen before
144 the matcher is called. */
146 if (gfc_match_if (&st
) == MATCH_YES
)
149 gfc_set_locus (&old_locus
);
151 if (gfc_match_where (&st
) == MATCH_YES
)
154 gfc_set_locus (&old_locus
);
156 if (gfc_match_forall (&st
) == MATCH_YES
)
159 gfc_set_locus (&old_locus
);
161 match (NULL
, gfc_match_do
, ST_DO
);
162 match (NULL
, gfc_match_select
, ST_SELECT_CASE
);
164 /* General statement matching: Instead of testing every possible
165 statement, we eliminate most possibilities by peeking at the
168 c
= gfc_peek_char ();
173 match ("allocate", gfc_match_allocate
, ST_ALLOCATE
);
174 match ("allocatable", gfc_match_allocatable
, ST_ATTR_DECL
);
175 match ("assign", gfc_match_assign
, ST_LABEL_ASSIGNMENT
);
179 match ("backspace", gfc_match_backspace
, ST_BACKSPACE
);
180 match ("block data", gfc_match_block_data
, ST_BLOCK_DATA
);
184 match ("call", gfc_match_call
, ST_CALL
);
185 match ("close", gfc_match_close
, ST_CLOSE
);
186 match ("continue", gfc_match_continue
, ST_CONTINUE
);
187 match ("cycle", gfc_match_cycle
, ST_CYCLE
);
188 match ("case", gfc_match_case
, ST_CASE
);
189 match ("common", gfc_match_common
, ST_COMMON
);
190 match ("contains", gfc_match_eos
, ST_CONTAINS
);
194 match ("deallocate", gfc_match_deallocate
, ST_DEALLOCATE
);
195 match ("data", gfc_match_data
, ST_DATA
);
196 match ("dimension", gfc_match_dimension
, ST_ATTR_DECL
);
200 match ("end file", gfc_match_endfile
, ST_END_FILE
);
201 match ("exit", gfc_match_exit
, ST_EXIT
);
202 match ("else", gfc_match_else
, ST_ELSE
);
203 match ("else where", gfc_match_elsewhere
, ST_ELSEWHERE
);
204 match ("else if", gfc_match_elseif
, ST_ELSEIF
);
206 if (gfc_match_end (&st
) == MATCH_YES
)
209 match ("entry", gfc_match_entry
, ST_ENTRY
);
210 match ("equivalence", gfc_match_equivalence
, ST_EQUIVALENCE
);
211 match ("external", gfc_match_external
, ST_ATTR_DECL
);
215 match ("format", gfc_match_format
, ST_FORMAT
);
219 match ("go to", gfc_match_goto
, ST_GOTO
);
223 match ("inquire", gfc_match_inquire
, ST_INQUIRE
);
224 match ("implicit", gfc_match_implicit
, ST_IMPLICIT
);
225 match ("implicit% none", gfc_match_implicit_none
, ST_IMPLICIT_NONE
);
226 match ("interface", gfc_match_interface
, ST_INTERFACE
);
227 match ("intent", gfc_match_intent
, ST_ATTR_DECL
);
228 match ("intrinsic", gfc_match_intrinsic
, ST_ATTR_DECL
);
232 match ("module% procedure", gfc_match_modproc
, ST_MODULE_PROC
);
233 match ("module", gfc_match_module
, ST_MODULE
);
237 match ("nullify", gfc_match_nullify
, ST_NULLIFY
);
238 match ("namelist", gfc_match_namelist
, ST_NAMELIST
);
242 match ("open", gfc_match_open
, ST_OPEN
);
243 match ("optional", gfc_match_optional
, ST_ATTR_DECL
);
247 match ("print", gfc_match_print
, ST_WRITE
);
248 match ("parameter", gfc_match_parameter
, ST_PARAMETER
);
249 match ("pause", gfc_match_pause
, ST_PAUSE
);
250 match ("pointer", gfc_match_pointer
, ST_ATTR_DECL
);
251 if (gfc_match_private (&st
) == MATCH_YES
)
253 match ("program", gfc_match_program
, ST_PROGRAM
);
254 if (gfc_match_public (&st
) == MATCH_YES
)
259 match ("read", gfc_match_read
, ST_READ
);
260 match ("return", gfc_match_return
, ST_RETURN
);
261 match ("rewind", gfc_match_rewind
, ST_REWIND
);
265 match ("sequence", gfc_match_eos
, ST_SEQUENCE
);
266 match ("stop", gfc_match_stop
, ST_STOP
);
267 match ("save", gfc_match_save
, ST_ATTR_DECL
);
271 match ("target", gfc_match_target
, ST_ATTR_DECL
);
272 match ("type", gfc_match_derived_decl
, ST_DERIVED_DECL
);
276 match ("use", gfc_match_use
, ST_USE
);
280 match ("write", gfc_match_write
, ST_WRITE
);
284 /* All else has failed, so give up. See if any of the matchers has
285 stored an error message of some sort. */
287 if (gfc_error_check () == 0)
288 gfc_error_now ("Unclassifiable statement at %C");
292 gfc_error_recovery ();
300 /* Get the next statement in free form source. */
308 gfc_gobble_whitespace ();
310 c
= gfc_peek_char ();
314 /* Found a statement label? */
315 m
= gfc_match_st_label (&gfc_statement_label
, 0);
317 d
= gfc_peek_char ();
318 if (m
!= MATCH_YES
|| !gfc_is_whitespace (d
))
322 /* Skip the bad statement label. */
323 gfc_warning_now ("Ignoring bad statement label at %C");
324 c
= gfc_next_char ();
330 label_locus
= *gfc_current_locus ();
332 if (gfc_statement_label
->value
== 0)
334 gfc_warning_now ("Ignoring statement label of zero at %C");
335 gfc_free_st_label (gfc_statement_label
);
336 gfc_statement_label
= NULL
;
339 gfc_gobble_whitespace ();
341 if (gfc_match_eos () == MATCH_YES
)
344 ("Ignoring statement label in empty statement at %C");
345 gfc_free_st_label (gfc_statement_label
);
346 gfc_statement_label
= NULL
;
352 return decode_statement ();
356 /* Get the next statement in fixed-form source. */
361 int label
, digit_flag
, i
;
366 return decode_statement ();
368 /* Skip past the current label field, parsing a statement label if
369 one is there. This is a weird number parser, since the number is
370 contained within five columns and can have any kind of embedded
371 spaces. We also check for characters that make the rest of the
377 for (i
= 0; i
< 5; i
++)
379 c
= gfc_next_char_literal (0);
396 label
= label
* 10 + c
- '0';
397 label_locus
= *gfc_current_locus ();
401 /* Comments have already been skipped by the time we get
402 here so don't bother checking for them. */
405 gfc_buffer_error (0);
406 gfc_error ("Non-numeric character in statement label at %C");
414 gfc_warning_now ("Zero is not a valid statement label at %C");
417 /* We've found a valid statement label. */
418 gfc_statement_label
= gfc_get_st_label (label
);
422 /* Since this line starts a statement, it cannot be a continuation
423 of a previous statement. Hence we mostly ignore column 6. */
425 if (gfc_next_char_literal (0) == '\n')
428 /* Now that we've taken care of the statement label columns, we have
429 to make sure that the first nonblank character is not a '!'. If
430 it is, the rest of the line is a comment. */
434 loc
= *gfc_current_locus ();
435 c
= gfc_next_char_literal (0);
437 while (gfc_is_whitespace (c
));
441 gfc_set_locus (&loc
);
443 if (gfc_match_eos () == MATCH_YES
)
446 /* At this point, we've got a nonblank statement to parse. */
447 return decode_statement ();
451 gfc_warning ("Statement label in blank line will be " "ignored at %C");
457 /* Return the next non-ST_NONE statement to the caller. We also worry
458 about including files and the ends of include files at this stage. */
461 next_statement (void)
465 gfc_new_block
= NULL
;
469 gfc_statement_label
= NULL
;
470 gfc_buffer_error (1);
475 gfc_skip_comments ();
477 if (gfc_at_bol () && gfc_check_include ())
480 if (gfc_at_eof () && gfc_current_file
->included_by
!= NULL
)
482 gfc_current_file
= gfc_current_file
->included_by
;
494 (gfc_current_file
->form
== FORM_FIXED
) ? next_fixed () : next_free ();
499 gfc_buffer_error (0);
502 check_statement_label (st
);
508 /****************************** Parser ***********************************/
510 /* The parser subroutines are of type 'try' that fail if the file ends
513 /* Macros that expand to case-labels for various classes of
514 statements. Start with executable statements that directly do
517 #define case_executable case ST_ALLOCATE: case ST_BACKSPACE: case ST_CALL: \
518 case ST_CLOSE: case ST_CONTINUE: case ST_DEALLOCATE: case ST_END_FILE: \
519 case ST_GOTO: case ST_INQUIRE: case ST_NULLIFY: case ST_OPEN: \
520 case ST_READ: case ST_RETURN: case ST_REWIND: case ST_SIMPLE_IF: \
521 case ST_PAUSE: case ST_STOP: case ST_WRITE: case ST_ASSIGNMENT: \
522 case ST_POINTER_ASSIGNMENT: case ST_EXIT: case ST_CYCLE: \
523 case ST_ARITHMETIC_IF: case ST_WHERE: case ST_FORALL: case ST_LABEL_ASSIGNMENT
525 /* Statements that mark other executable statements. */
527 #define case_exec_markers case ST_DO: case ST_FORALL_BLOCK: case ST_IF_BLOCK: \
528 case ST_WHERE_BLOCK: case ST_SELECT_CASE
530 /* Declaration statements */
532 #define case_decl case ST_ATTR_DECL: case ST_COMMON: case ST_DATA_DECL: \
533 case ST_EQUIVALENCE: case ST_NAMELIST: case ST_STATEMENT_FUNCTION: \
534 case ST_TYPE: case ST_INTERFACE
536 /* Block end statements. Errors associated with interchanging these
537 are detected in gfc_match_end(). */
539 #define case_end case ST_END_BLOCK_DATA: case ST_END_FUNCTION: \
540 case ST_END_PROGRAM: case ST_END_SUBROUTINE
543 /* Push a new state onto the stack. */
546 push_state (gfc_state_data
* p
, gfc_compile_state new_state
, gfc_symbol
* sym
)
549 p
->state
= new_state
;
550 p
->previous
= gfc_state_stack
;
552 p
->head
= p
->tail
= NULL
;
558 /* Pop the current state. */
564 gfc_state_stack
= gfc_state_stack
->previous
;
568 /* Try to find the given state in the state stack. */
571 gfc_find_state (gfc_compile_state state
)
575 for (p
= gfc_state_stack
; p
; p
= p
->previous
)
576 if (p
->state
== state
)
579 return (p
== NULL
) ? FAILURE
: SUCCESS
;
583 /* Starts a new level in the statement list. */
586 new_level (gfc_code
* q
)
590 p
= q
->block
= gfc_get_code ();
592 gfc_state_stack
->head
= gfc_state_stack
->tail
= p
;
598 /* Add the current new_st code structure and adds it to the current
599 program unit. As a side-effect, it zeroes the new_st. */
609 p
->loc
= *gfc_current_locus ();
611 if (gfc_state_stack
->head
== NULL
)
612 gfc_state_stack
->head
= p
;
614 gfc_state_stack
->tail
->next
= p
;
616 while (p
->next
!= NULL
)
619 gfc_state_stack
->tail
= p
;
627 /* Frees everything associated with the current statement. */
630 undo_new_statement (void)
632 gfc_free_statements (new_st
.block
);
633 gfc_free_statements (new_st
.next
);
634 gfc_free_statement (&new_st
);
639 /* If the current statement has a statement label, make sure that it
640 is allowed to, or should have one. */
643 check_statement_label (gfc_statement st
)
647 if (gfc_statement_label
== NULL
)
650 gfc_error ("FORMAT statement at %L does not have a statement label",
658 case ST_END_FUNCTION
:
659 case ST_END_SUBROUTINE
:
665 type
= ST_LABEL_TARGET
;
669 type
= ST_LABEL_FORMAT
;
672 /* Statement labels are not restricted from appearing on a
673 particular line. However, there are plenty of situations
674 where the resulting label can't be referenced. */
677 type
= ST_LABEL_BAD_TARGET
;
681 gfc_define_st_label (gfc_statement_label
, type
, &label_locus
);
683 new_st
.here
= gfc_statement_label
;
687 /* Figures out what the enclosing program unit is. This will be a
688 function, subroutine, program, block data or module. */
691 gfc_enclosing_unit (gfc_compile_state
* result
)
695 for (p
= gfc_state_stack
; p
; p
= p
->previous
)
696 if (p
->state
== COMP_FUNCTION
|| p
->state
== COMP_SUBROUTINE
697 || p
->state
== COMP_MODULE
|| p
->state
== COMP_BLOCK_DATA
698 || p
->state
== COMP_PROGRAM
)
707 *result
= COMP_PROGRAM
;
712 /* Translate a statement enum to a string. */
715 gfc_ascii_statement (gfc_statement st
)
721 case ST_ARITHMETIC_IF
:
728 p
= "attribute declaration";
758 p
= "data declaration";
766 case ST_DERIVED_DECL
:
767 p
= "Derived type declaration";
781 case ST_END_BLOCK_DATA
:
782 p
= "END BLOCK DATA";
793 case ST_END_FUNCTION
:
799 case ST_END_INTERFACE
:
811 case ST_END_SUBROUTINE
:
812 p
= "END SUBROUTINE";
829 case ST_FORALL_BLOCK
: /* Fall through */
848 case ST_IMPLICIT_NONE
:
851 case ST_IMPLIED_ENDDO
:
852 p
= "implied END DO";
876 p
= "MODULE PROCEDURE";
911 case ST_WHERE_BLOCK
: /* Fall through */
921 case ST_POINTER_ASSIGNMENT
:
922 p
= "pointer assignment";
933 case ST_STATEMENT_FUNCTION
:
934 p
= "STATEMENT FUNCTION";
936 case ST_LABEL_ASSIGNMENT
:
937 p
= "LABEL ASSIGNMENT";
940 gfc_internal_error ("gfc_ascii_statement(): Bad statement code");
947 /* Return the name of a compile state. */
950 gfc_state_name (gfc_compile_state state
)
962 case COMP_SUBROUTINE
:
968 case COMP_BLOCK_DATA
:
975 p
= "a DERIVED TYPE block";
978 p
= "an IF-THEN block";
984 p
= "a SELECT block";
987 p
= "a FORALL block";
993 p
= "a contained subprogram";
997 gfc_internal_error ("gfc_state_name(): Bad state");
1004 /* Do whatever is necessary to accept the last statement. */
1007 accept_statement (gfc_statement st
)
1016 case ST_IMPLICIT_NONE
:
1017 gfc_set_implicit_none ();
1021 gfc_set_implicit ();
1027 gfc_current_ns
->proc_name
= gfc_new_block
;
1030 /* If the statement is the end of a block, lay down a special code
1031 that allows a branch to the end of the block from within the
1037 if (gfc_statement_label
!= NULL
)
1039 new_st
.op
= EXEC_NOP
;
1045 /* The end-of-program unit statements do not get the special
1046 marker and require a statement of some sort if they are a
1049 case ST_END_PROGRAM
:
1050 case ST_END_FUNCTION
:
1051 case ST_END_SUBROUTINE
:
1052 if (gfc_statement_label
!= NULL
)
1054 new_st
.op
= EXEC_RETURN
;
1062 gfc_symbol
*block_data
= NULL
;
1063 symbol_attribute attr
;
1065 gfc_get_symbol ("_BLOCK_DATA__", gfc_current_ns
, &block_data
);
1066 gfc_clear_attr (&attr
);
1067 attr
.flavor
= FL_PROCEDURE
;
1068 attr
.proc
= PROC_UNKNOWN
;
1069 attr
.subroutine
= 1;
1070 attr
.access
= ACCESS_PUBLIC
;
1071 block_data
->attr
= attr
;
1072 gfc_current_ns
->proc_name
= block_data
;
1073 gfc_commit_symbols ();
1087 gfc_commit_symbols ();
1088 gfc_warning_check ();
1089 gfc_clear_new_st ();
1093 /* Undo anything tentative that has been built for the current
1097 reject_statement (void)
1100 gfc_undo_symbols ();
1101 gfc_clear_warning ();
1102 undo_new_statement ();
1106 /* Generic complaint about an out of order statement. We also do
1107 whatever is necessary to clean up. */
1110 unexpected_statement (gfc_statement st
)
1113 gfc_error ("Unexpected %s statement at %C", gfc_ascii_statement (st
));
1115 reject_statement ();
1119 /* Given the next statement seen by the matcher, make sure that it is
1120 in proper order with the last. This subroutine is initialized by
1121 calling it with an argument of ST_NONE. If there is a problem, we
1122 issue an error and return FAILURE. Otherwise we return SUCCESS.
1124 Individual parsers need to verify that the statements seen are
1125 valid before calling here, ie ENTRY statements are not allowed in
1126 INTERFACE blocks. The following diagram is taken from the standard:
1128 +---------------------------------------+
1129 | program subroutine function module |
1130 +---------------------------------------+
1132 |---------------------------------------+
1134 | +-----------+------------------+
1135 | | parameter | implicit |
1136 | +-----------+------------------+
1137 | format | | derived type |
1138 | entry | parameter | interface |
1139 | | data | specification |
1140 | | | statement func |
1141 | +-----------+------------------+
1142 | | data | executable |
1143 +--------+-----------+------------------+
1145 +---------------------------------------+
1146 | internal module/subprogram |
1147 +---------------------------------------+
1149 +---------------------------------------+
1156 { ORDER_START
, ORDER_USE
, ORDER_IMPLICIT_NONE
, ORDER_IMPLICIT
,
1157 ORDER_SPEC
, ORDER_EXEC
1160 gfc_statement last_statement
;
1166 verify_st_order (st_state
* p
, gfc_statement st
)
1172 p
->state
= ORDER_START
;
1176 if (p
->state
> ORDER_USE
)
1178 p
->state
= ORDER_USE
;
1181 case ST_IMPLICIT_NONE
:
1182 if (p
->state
> ORDER_IMPLICIT_NONE
)
1185 /* The '>' sign cannot be a '>=', because a FORMAT or ENTRY
1186 statement disqualifies a USE but not an IMPLICIT NONE.
1187 Duplicate IMPLICIT NONEs are caught when the implicit types
1190 p
->state
= ORDER_IMPLICIT_NONE
;
1194 if (p
->state
> ORDER_IMPLICIT
)
1196 p
->state
= ORDER_IMPLICIT
;
1201 if (p
->state
< ORDER_IMPLICIT_NONE
)
1202 p
->state
= ORDER_IMPLICIT_NONE
;
1206 if (p
->state
>= ORDER_EXEC
)
1208 if (p
->state
< ORDER_IMPLICIT
)
1209 p
->state
= ORDER_IMPLICIT
;
1213 if (p
->state
< ORDER_SPEC
)
1214 p
->state
= ORDER_SPEC
;
1219 case ST_DERIVED_DECL
:
1221 if (p
->state
>= ORDER_EXEC
)
1223 if (p
->state
< ORDER_SPEC
)
1224 p
->state
= ORDER_SPEC
;
1229 if (p
->state
< ORDER_EXEC
)
1230 p
->state
= ORDER_EXEC
;
1235 ("Unexpected %s statement in verify_st_order() at %C",
1236 gfc_ascii_statement (st
));
1239 /* All is well, record the statement in case we need it next time. */
1240 p
->where
= *gfc_current_locus ();
1241 p
->last_statement
= st
;
1245 gfc_error ("%s statement at %C cannot follow %s statement at %L",
1246 gfc_ascii_statement (st
),
1247 gfc_ascii_statement (p
->last_statement
), &p
->where
);
1253 /* Handle an unexpected end of file. This is a show-stopper... */
1255 static void unexpected_eof (void) ATTRIBUTE_NORETURN
;
1258 unexpected_eof (void)
1262 gfc_error ("Unexpected end of file in '%s'", gfc_current_file
->filename
);
1264 /* Memory cleanup. Move to "second to last". */
1265 for (p
= gfc_state_stack
; p
&& p
->previous
&& p
->previous
->previous
;
1268 gfc_current_ns
->code
= (p
&& p
->previous
) ? p
->head
: NULL
;
1275 /* Parse a derived type. */
1278 parse_derived (void)
1280 int compiling_type
, seen_private
, seen_sequence
, seen_component
, error_flag
;
1287 accept_statement (ST_DERIVED_DECL
);
1288 push_state (&s
, COMP_DERIVED
, gfc_new_block
);
1290 gfc_new_block
->component_access
= ACCESS_PUBLIC
;
1297 while (compiling_type
)
1299 st
= next_statement ();
1306 accept_statement (st
);
1313 if (!seen_component
)
1315 gfc_error ("Derived type definition at %C has no components");
1319 accept_statement (ST_END_TYPE
);
1323 if (gfc_find_state (COMP_MODULE
) == FAILURE
)
1326 ("PRIVATE statement in TYPE at %C must be inside a MODULE");
1333 gfc_error ("PRIVATE statement at %C must precede "
1334 "structure components");
1341 gfc_error ("Duplicate PRIVATE statement at %C");
1345 s
.sym
->component_access
= ACCESS_PRIVATE
;
1346 accept_statement (ST_PRIVATE
);
1353 gfc_error ("SEQUENCE statement at %C must precede "
1354 "structure components");
1359 if (gfc_current_block ()->attr
.sequence
)
1360 gfc_warning ("SEQUENCE attribute at %C already specified in "
1365 gfc_error ("Duplicate SEQUENCE statement at %C");
1370 gfc_add_sequence (&gfc_current_block ()->attr
, NULL
);
1374 unexpected_statement (st
);
1379 /* Sanity checks on the structure. If the structure has the
1380 SEQUENCE attribute, then all component structures must also have
1382 if (error_flag
== 0 && gfc_current_block ()->attr
.sequence
)
1383 for (c
= gfc_current_block ()->components
; c
; c
= c
->next
)
1385 if (c
->ts
.type
== BT_DERIVED
&& c
->ts
.derived
->attr
.sequence
== 0)
1388 ("Component %s of SEQUENCE type declared at %C does not "
1389 "have the SEQUENCE attribute", c
->ts
.derived
->name
);
1398 /* Parse an interface. We must be able to deal with the possibility
1399 of recursive interfaces. The parse_spec() subroutine is mutually
1400 recursive with parse_interface(). */
1402 static gfc_statement
parse_spec (gfc_statement
);
1405 parse_interface (void)
1407 gfc_compile_state new_state
, current_state
;
1408 gfc_symbol
*prog_unit
, *sym
;
1409 gfc_interface_info save
;
1410 gfc_state_data s1
, s2
;
1414 accept_statement (ST_INTERFACE
);
1416 current_interface
.ns
= gfc_current_ns
;
1417 save
= current_interface
;
1419 sym
= (current_interface
.type
== INTERFACE_GENERIC
1420 || current_interface
.type
== INTERFACE_USER_OP
) ? gfc_new_block
: NULL
;
1422 push_state (&s1
, COMP_INTERFACE
, sym
);
1424 current_state
= COMP_NONE
;
1427 gfc_current_ns
= gfc_get_namespace (current_interface
.ns
);
1429 st
= next_statement ();
1436 new_state
= COMP_SUBROUTINE
;
1437 gfc_add_explicit_interface (gfc_new_block
, IFSRC_IFBODY
,
1438 gfc_new_block
->formal
, NULL
);
1442 new_state
= COMP_FUNCTION
;
1443 gfc_add_explicit_interface (gfc_new_block
, IFSRC_IFBODY
,
1444 gfc_new_block
->formal
, NULL
);
1447 case ST_MODULE_PROC
: /* The module procedure matcher makes
1448 sure the context is correct. */
1450 accept_statement (st
);
1451 gfc_free_namespace (gfc_current_ns
);
1454 case ST_END_INTERFACE
:
1455 gfc_free_namespace (gfc_current_ns
);
1456 gfc_current_ns
= current_interface
.ns
;
1460 gfc_error ("Unexpected %s statement in INTERFACE block at %C",
1461 gfc_ascii_statement (st
));
1462 reject_statement ();
1463 gfc_free_namespace (gfc_current_ns
);
1468 /* Make sure that a generic interface has only subroutines or
1469 functions and that the generic name has the right attribute. */
1470 if (current_interface
.type
== INTERFACE_GENERIC
)
1472 if (current_state
== COMP_NONE
)
1474 if (new_state
== COMP_FUNCTION
)
1475 gfc_add_function (&sym
->attr
, NULL
);
1476 if (new_state
== COMP_SUBROUTINE
)
1477 gfc_add_subroutine (&sym
->attr
, NULL
);
1479 current_state
= new_state
;
1483 if (new_state
!= current_state
)
1485 if (new_state
== COMP_SUBROUTINE
)
1487 ("SUBROUTINE at %C does not belong in a generic function "
1490 if (new_state
== COMP_FUNCTION
)
1492 ("FUNCTION at %C does not belong in a generic subroutine "
1498 push_state (&s2
, new_state
, gfc_new_block
);
1499 accept_statement (st
);
1500 prog_unit
= gfc_new_block
;
1501 prog_unit
->formal_ns
= gfc_current_ns
;
1504 /* Read data declaration statements. */
1505 st
= parse_spec (ST_NONE
);
1507 if (st
!= ST_END_SUBROUTINE
&& st
!= ST_END_FUNCTION
)
1509 gfc_error ("Unexpected %s statement at %C in INTERFACE body",
1510 gfc_ascii_statement (st
));
1511 reject_statement ();
1517 current_interface
= save
;
1518 gfc_add_interface (prog_unit
);
1525 gfc_error ("INTERFACE block at %C is empty");
1531 /* Parse a set of specification statements. Returns the statement
1532 that doesn't fit. */
1534 static gfc_statement
1535 parse_spec (gfc_statement st
)
1539 verify_st_order (&ss
, ST_NONE
);
1541 st
= next_statement ();
1551 case ST_DATA
: /* Not allowed in interfaces */
1552 if (gfc_current_state () == COMP_INTERFACE
)
1558 case ST_IMPLICIT_NONE
:
1563 case ST_DERIVED_DECL
:
1565 if (verify_st_order (&ss
, st
) == FAILURE
)
1567 reject_statement ();
1568 st
= next_statement ();
1578 case ST_DERIVED_DECL
:
1584 if (gfc_current_state () != COMP_MODULE
)
1586 gfc_error ("%s statement must appear in a MODULE",
1587 gfc_ascii_statement (st
));
1591 if (gfc_current_ns
->default_access
!= ACCESS_UNKNOWN
)
1593 gfc_error ("%s statement at %C follows another accessibility "
1594 "specification", gfc_ascii_statement (st
));
1598 gfc_current_ns
->default_access
= (st
== ST_PUBLIC
)
1599 ? ACCESS_PUBLIC
: ACCESS_PRIVATE
;
1607 accept_statement (st
);
1608 st
= next_statement ();
1619 /* Parse a WHERE block, (not a simple WHERE statement). */
1622 parse_where_block (void)
1624 int seen_empty_else
;
1629 accept_statement (ST_WHERE_BLOCK
);
1630 top
= gfc_state_stack
->tail
;
1632 push_state (&s
, COMP_WHERE
, gfc_new_block
);
1634 d
= add_statement ();
1635 d
->expr
= top
->expr
;
1641 seen_empty_else
= 0;
1645 st
= next_statement ();
1651 case ST_WHERE_BLOCK
:
1652 parse_where_block ();
1657 accept_statement (st
);
1661 if (seen_empty_else
)
1664 ("ELSEWHERE statement at %C follows previous unmasked "
1669 if (new_st
.expr
== NULL
)
1670 seen_empty_else
= 1;
1672 d
= new_level (gfc_state_stack
->head
);
1674 d
->expr
= new_st
.expr
;
1676 accept_statement (st
);
1681 accept_statement (st
);
1685 gfc_error ("Unexpected %s statement in WHERE block at %C",
1686 gfc_ascii_statement (st
));
1687 reject_statement ();
1692 while (st
!= ST_END_WHERE
);
1698 /* Parse a FORALL block (not a simple FORALL statement). */
1701 parse_forall_block (void)
1707 accept_statement (ST_FORALL_BLOCK
);
1708 top
= gfc_state_stack
->tail
;
1710 push_state (&s
, COMP_FORALL
, gfc_new_block
);
1712 d
= add_statement ();
1713 d
->op
= EXEC_FORALL
;
1718 st
= next_statement ();
1723 case ST_POINTER_ASSIGNMENT
:
1726 accept_statement (st
);
1729 case ST_WHERE_BLOCK
:
1730 parse_where_block ();
1733 case ST_FORALL_BLOCK
:
1734 parse_forall_block ();
1738 accept_statement (st
);
1745 gfc_error ("Unexpected %s statement in FORALL block at %C",
1746 gfc_ascii_statement (st
));
1748 reject_statement ();
1752 while (st
!= ST_END_FORALL
);
1758 static gfc_statement
parse_executable (gfc_statement
);
1760 /* parse the statements of an IF-THEN-ELSEIF-ELSE-ENDIF block. */
1763 parse_if_block (void)
1772 accept_statement (ST_IF_BLOCK
);
1774 top
= gfc_state_stack
->tail
;
1775 push_state (&s
, COMP_IF
, gfc_new_block
);
1777 new_st
.op
= EXEC_IF
;
1778 d
= add_statement ();
1780 d
->expr
= top
->expr
;
1786 st
= parse_executable (ST_NONE
);
1797 ("ELSE IF statement at %C cannot follow ELSE statement at %L",
1800 reject_statement ();
1804 d
= new_level (gfc_state_stack
->head
);
1806 d
->expr
= new_st
.expr
;
1808 accept_statement (st
);
1815 gfc_error ("Duplicate ELSE statements at %L and %C",
1817 reject_statement ();
1822 else_locus
= *gfc_current_locus ();
1824 d
= new_level (gfc_state_stack
->head
);
1827 accept_statement (st
);
1835 unexpected_statement (st
);
1839 while (st
!= ST_ENDIF
);
1842 accept_statement (st
);
1846 /* Parse a SELECT block. */
1849 parse_select_block (void)
1855 accept_statement (ST_SELECT_CASE
);
1857 cp
= gfc_state_stack
->tail
;
1858 push_state (&s
, COMP_SELECT
, gfc_new_block
);
1860 /* Make sure that the next statement is a CASE or END SELECT. */
1863 st
= next_statement ();
1866 if (st
== ST_END_SELECT
)
1868 /* Empty SELECT CASE is OK. */
1869 accept_statement (st
);
1877 ("Expected a CASE or END SELECT statement following SELECT CASE "
1880 reject_statement ();
1883 /* At this point, we're got a nonempty select block. */
1884 cp
= new_level (cp
);
1887 accept_statement (st
);
1891 st
= parse_executable (ST_NONE
);
1898 cp
= new_level (gfc_state_stack
->head
);
1900 gfc_clear_new_st ();
1902 accept_statement (st
);
1908 /* Can't have an executable statement because of
1909 parse_executable(). */
1911 unexpected_statement (st
);
1915 while (st
!= ST_END_SELECT
);
1918 accept_statement (st
);
1922 /* Checks to see if the current statement label closes an enddo.
1923 Returns 0 if not, 1 if closes an ENDDO correctly, or 2 (and issues
1924 an error) if it incorrectly closes an ENDDO. */
1927 check_do_closure (void)
1931 if (gfc_statement_label
== NULL
)
1934 for (p
= gfc_state_stack
; p
; p
= p
->previous
)
1935 if (p
->state
== COMP_DO
)
1939 return 0; /* No loops to close */
1941 if (p
->ext
.end_do_label
== gfc_statement_label
)
1944 if (p
== gfc_state_stack
)
1948 ("End of nonblock DO statement at %C is within another block");
1952 /* At this point, the label doesn't terminate the innermost loop.
1953 Make sure it doesn't terminate another one. */
1954 for (; p
; p
= p
->previous
)
1955 if (p
->state
== COMP_DO
&& p
->ext
.end_do_label
== gfc_statement_label
)
1957 gfc_error ("End of nonblock DO statement at %C is interwoven "
1958 "with another DO loop");
1966 /* Parse a DO loop. Note that the ST_CYCLE and ST_EXIT statements are
1967 handled inside of parse_executable(), because they aren't really
1971 parse_do_block (void)
1977 s
.ext
.end_do_label
= new_st
.label
;
1979 accept_statement (ST_DO
);
1981 top
= gfc_state_stack
->tail
;
1982 push_state (&s
, COMP_DO
, gfc_new_block
);
1984 top
->block
= new_level (top
);
1985 top
->block
->op
= EXEC_DO
;
1988 st
= parse_executable (ST_NONE
);
1996 if (s
.ext
.end_do_label
!= NULL
1997 && s
.ext
.end_do_label
!= gfc_statement_label
)
1999 ("Statement label in ENDDO at %C doesn't match DO label");
2002 case ST_IMPLIED_ENDDO
:
2006 unexpected_statement (st
);
2011 accept_statement (st
);
2015 /* Accept a series of executable statements. We return the first
2016 statement that doesn't fit to the caller. Any block statements are
2017 passed on to the correct handler, which usually passes the buck
2020 static gfc_statement
2021 parse_executable (gfc_statement st
)
2026 st
= next_statement ();
2028 for (;; st
= next_statement ())
2031 close_flag
= check_do_closure ();
2036 case ST_END_PROGRAM
:
2039 case ST_END_FUNCTION
:
2043 case ST_END_SUBROUTINE
:
2048 case ST_SELECT_CASE
:
2050 ("%s statement at %C cannot terminate a non-block DO loop",
2051 gfc_ascii_statement (st
));
2067 accept_statement (st
);
2068 if (close_flag
== 1)
2069 return ST_IMPLIED_ENDDO
;
2076 case ST_SELECT_CASE
:
2077 parse_select_block ();
2082 if (check_do_closure () == 1)
2083 return ST_IMPLIED_ENDDO
;
2086 case ST_WHERE_BLOCK
:
2087 parse_where_block ();
2090 case ST_FORALL_BLOCK
:
2091 parse_forall_block ();
2105 /* Parse a series of contained program units. */
2107 static void parse_progunit (gfc_statement
);
2110 /* Fix the symbols for sibling functions. These are incorrectly added to
2111 the child namespace as the parser didn't know about this procedure. */
2114 gfc_fixup_sibling_symbols (gfc_symbol
* sym
, gfc_namespace
* siblings
)
2118 gfc_symbol
*old_sym
;
2120 for (ns
= siblings
; ns
; ns
= ns
->sibling
)
2122 gfc_find_sym_tree (sym
->name
, ns
, 0, &st
);
2126 old_sym
= st
->n
.sym
;
2127 if (old_sym
->attr
.flavor
== FL_PROCEDURE
&& old_sym
->ns
== ns
2128 && ! old_sym
->attr
.contained
)
2130 /* Replace it with the symbol from the parent namespace. */
2134 /* Free the old (local) symbol. */
2136 if (old_sym
->refs
== 0)
2137 gfc_free_symbol (old_sym
);
2140 /* Do the same for any contined procedures. */
2141 gfc_fixup_sibling_symbols (sym
, ns
->contained
);
2146 parse_contained (int module
)
2148 gfc_namespace
*ns
, *parent_ns
;
2149 gfc_state_data s1
, s2
;
2153 push_state (&s1
, COMP_CONTAINS
, NULL
);
2154 parent_ns
= gfc_current_ns
;
2158 gfc_current_ns
= gfc_get_namespace (parent_ns
);
2160 gfc_current_ns
->sibling
= parent_ns
->contained
;
2161 parent_ns
->contained
= gfc_current_ns
;
2163 st
= next_statement ();
2172 accept_statement (st
);
2175 (st
== ST_FUNCTION
) ? COMP_FUNCTION
: COMP_SUBROUTINE
,
2178 /* For internal procedures, create/update the symbol in the
2179 * parent namespace */
2183 if (gfc_get_symbol (gfc_new_block
->name
, parent_ns
, &sym
))
2185 ("Contained procedure '%s' at %C is already ambiguous",
2186 gfc_new_block
->name
);
2189 if (gfc_add_procedure (&sym
->attr
, PROC_INTERNAL
,
2190 &gfc_new_block
->declared_at
) ==
2193 if (st
== ST_FUNCTION
)
2194 gfc_add_function (&sym
->attr
,
2195 &gfc_new_block
->declared_at
);
2197 gfc_add_subroutine (&sym
->attr
,
2198 &gfc_new_block
->declared_at
);
2202 gfc_commit_symbols ();
2205 sym
= gfc_new_block
;
2207 /* Mark this as a contained function, so it isn't replaced
2208 by other module functions. */
2209 sym
->attr
.contained
= 1;
2211 /* Fix up any sibling functions that refer to this one. */
2212 gfc_fixup_sibling_symbols (sym
, gfc_current_ns
);
2214 parse_progunit (ST_NONE
);
2216 gfc_current_ns
->code
= s2
.head
;
2217 gfc_current_ns
= parent_ns
;
2222 /* These statements are associated with the end of the host
2224 case ST_END_FUNCTION
:
2226 case ST_END_PROGRAM
:
2227 case ST_END_SUBROUTINE
:
2228 accept_statement (st
);
2232 gfc_error ("Unexpected %s statement in CONTAINS section at %C",
2233 gfc_ascii_statement (st
));
2234 reject_statement ();
2238 while (st
!= ST_END_FUNCTION
&& st
!= ST_END_SUBROUTINE
2239 && st
!= ST_END_MODULE
&& st
!= ST_END_PROGRAM
);
2241 /* The first namespace in the list is guaranteed to not have
2242 anything (worthwhile) in it. */
2244 gfc_current_ns
= parent_ns
;
2246 ns
= gfc_current_ns
->contained
;
2247 gfc_current_ns
->contained
= ns
->sibling
;
2248 gfc_free_namespace (ns
);
2254 /* Parse a PROGRAM, SUBROUTINE or FUNCTION unit. */
2257 parse_progunit (gfc_statement st
)
2262 st
= parse_spec (st
);
2272 accept_statement (st
);
2282 st
= parse_executable (st
);
2293 accept_statement (st
);
2300 unexpected_statement (st
);
2301 reject_statement ();
2302 st
= next_statement ();
2308 for (p
= gfc_state_stack
; p
; p
= p
->previous
)
2309 if (p
->state
== COMP_CONTAINS
)
2312 if (gfc_find_state (COMP_MODULE
) == SUCCESS
)
2317 gfc_error ("CONTAINS statement at %C is already in a contained "
2319 st
= next_statement ();
2323 parse_contained (0);
2326 gfc_current_ns
->code
= gfc_state_stack
->head
;
2330 /* Parse a block data program unit. */
2333 parse_block_data (void)
2337 st
= parse_spec (ST_NONE
);
2339 while (st
!= ST_END_BLOCK_DATA
)
2341 gfc_error ("Unexpected %s statement in BLOCK DATA at %C",
2342 gfc_ascii_statement (st
));
2343 reject_statement ();
2344 st
= next_statement ();
2349 /* Parse a module subprogram. */
2356 st
= parse_spec (ST_NONE
);
2365 parse_contained (1);
2369 accept_statement (st
);
2373 gfc_error ("Unexpected %s statement in MODULE at %C",
2374 gfc_ascii_statement (st
));
2376 reject_statement ();
2377 st
= next_statement ();
2383 /* Top level parser. */
2386 gfc_parse_file (void)
2388 int seen_program
, errors_before
, errors
;
2389 gfc_state_data top
, s
;
2393 top
.state
= COMP_NONE
;
2395 top
.previous
= NULL
;
2396 top
.head
= top
.tail
= NULL
;
2398 gfc_state_stack
= &top
;
2400 gfc_clear_new_st ();
2402 gfc_statement_label
= NULL
;
2405 return FAILURE
; /* Come here on unexpected EOF */
2411 st
= next_statement ();
2420 goto duplicate_main
;
2422 prog_locus
= *gfc_current_locus ();
2424 push_state (&s
, COMP_PROGRAM
, gfc_new_block
);
2425 accept_statement (st
);
2426 parse_progunit (ST_NONE
);
2430 push_state (&s
, COMP_SUBROUTINE
, gfc_new_block
);
2431 accept_statement (st
);
2432 parse_progunit (ST_NONE
);
2436 push_state (&s
, COMP_FUNCTION
, gfc_new_block
);
2437 accept_statement (st
);
2438 parse_progunit (ST_NONE
);
2442 push_state (&s
, COMP_BLOCK_DATA
, gfc_new_block
);
2443 accept_statement (st
);
2444 parse_block_data ();
2448 push_state (&s
, COMP_MODULE
, gfc_new_block
);
2449 accept_statement (st
);
2451 gfc_get_errors (NULL
, &errors_before
);
2455 /* Anything else starts a nameless main program block. */
2458 goto duplicate_main
;
2460 prog_locus
= *gfc_current_locus ();
2462 push_state (&s
, COMP_PROGRAM
, gfc_new_block
);
2463 parse_progunit (st
);
2467 gfc_current_ns
->code
= s
.head
;
2469 gfc_resolve (gfc_current_ns
);
2471 /* Dump the parse tree if requested. */
2472 if (gfc_option
.verbose
)
2473 gfc_show_namespace (gfc_current_ns
);
2475 gfc_get_errors (NULL
, &errors
);
2476 if (s
.state
== COMP_MODULE
)
2478 gfc_dump_module (s
.sym
->name
, errors_before
== errors
);
2479 if (errors
== 0 && ! gfc_option
.flag_no_backend
)
2480 gfc_generate_module_code (gfc_current_ns
);
2484 if (errors
== 0 && ! gfc_option
.flag_no_backend
)
2485 gfc_generate_code (gfc_current_ns
);
2496 /* If we see a duplicate main program, shut down. If the second
2497 instance is an implied main program, ie data decls or executable
2498 statements, we're in for lots of errors. */
2499 gfc_error ("Two main PROGRAMs at %L and %C", &prog_locus
);
2500 reject_statement ();