diff options
Diffstat (limited to 'gcc/f/st.c')
| -rw-r--r-- | gcc/f/st.c | 554 |
1 files changed, 554 insertions, 0 deletions
diff --git a/gcc/f/st.c b/gcc/f/st.c new file mode 100644 index 00000000000..5406acdb5a7 --- /dev/null +++ b/gcc/f/st.c @@ -0,0 +1,554 @@ +/* st.c -- Implementation File (module.c template V1.0) + Copyright (C) 1995 Free Software Foundation, Inc. + Contributed by James Craig Burley (burley@gnu.ai.mit.edu). + +This file is part of GNU Fortran. + +GNU Fortran is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Fortran is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Fortran; see the file COPYING. If not, write to +the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. + + Related Modules: + None + + Description: + The high-level input level to statement handling for the rest of the + FFE. ffest_first is the first state for the lexer to invoke to start + a statement. A statement normally starts with a NUMBER token (to indicate + a label def) followed by a NAME token (to indicate what kind of statement + it is), though of course the NUMBER token may be omitted. ffest_first + gathers the first NAME token and returns a state of ffest_second_, + where the trailing underscore means "internal to ffest" and thus outside + users should not depend on this. ffest_second_ then looks at the second + token in conjunction with the first, decides what possible statements are + meant, and tries each possible statement in turn, from most likely to + least likely. A successful attempt currently is recorded, and further + successful attempts by other possibilities raise an assertion error in + ffest_confirmed (this is to detect ambiguities). A failure in an + attempt is signaled by calling ffest_ffebad_start; this results in the + next token sent by ffest_save_ (the intermediary when more than one + possible statement exists) being EOS to shut down processing and the next + possibility tried. + + When all possibilities have been tried, the successful one is retried with + inhibition turned off (FALSE) as reported by ffest_is_inhibited(). If + there is no successful one, the first one is retried so the user gets to + see the error messages. + + In the future, after syntactic bugs have been reasonably shaken out and + ambiguities thus detected, the first successful possibility will be + enabled (inhibited goes FALSE) as soon as it confirms success by calling + ffest_confirmed, thus retrying the possibility will not be necessary. + + The only complication in all this is that expression handling is + happening while possibilities are inhibited. It is up to the expression + handler, conceptually, to not make any changes to its knowledge base for + variable names and so on when inhibited that cannot be undone if + the current possibility fails (shuts down via ffest_ffebad_start). In + fact, this business is handled not be ffeexpr, but by lower levels. + + ffesta functions serve only to provide information used in syntactic + processing of possible statements, and thus may not make changes to the + knowledge base for variables and such. + + ffestb functions perform the syntactic analysis for possible statements, + and thus again may not make changes to the knowledge base except under the + auspices of ffeexpr and its subordinates, changes which can be undone when + necessary. + + ffestc functions perform the semantic analysis for the chosen statement, + and thus may change the knowledge base as necessary since they are invoked + by ffestb functions only after a given statement is confirmed and + enabled. Note, however, that a few ffestc functions (identified by + their statement names rather than grammar numbers) indicate valid forms + that are, outside of any context, ambiguous, such as ELSE WHERE and + PRIVATE; these functions should make a quick decision as to what is + intended and dispatch to the appropriate specific ffestc function. + + ffestd functions actually implement statements. When called, the + statement is considered valid and is either an executable statement or + a nonexecutable statement with direct-output results. For example, CALL, + GOTO, and assignment statements pass through ffestd because they are + executable; DATA statements pass through because they map directly to the + output file (or at least might so map); ENTRY statements also pass through + because they essentially affect code generation in an immediate way; + whereas INTEGER, SAVE, and SUBROUTINE statements do not go through + ffestd functions because they merely update the knowledge base. + + Modifications: +*/ + +/* Include files. */ + +#include "proj.h" +#include "st.h" +#include "bad.h" +#include "lex.h" +#include "sta.h" +#include "stb.h" +#include "stc.h" +#include "std.h" +#include "ste.h" +#include "stp.h" +#include "str.h" +#include "sts.h" +#include "stt.h" +#include "stu.h" +#include "stv.h" +#include "stw.h" + +/* Externals defined here. */ + + +/* Simple definitions and enumerations. */ + + +/* Internal typedefs. */ + + +/* Private include files. */ + + +/* Internal structure definitions. */ + + +/* Static objects accessed by functions in this module. */ + + +/* Static functions (internal). */ + + +/* Internal macros. */ + + +/* ffest_confirmed -- Confirm current possibility as only one + + ffest_confirmed(); + + Sets the confirmation flag. During debugging for ambiguous constructs, + asserts that the confirmation flag for a previous possibility has not + yet been set. */ + +void +ffest_confirmed () +{ + ffesta_confirmed (); +} + +/* ffest_eof -- End of (non-INCLUDEd) source file + + ffest_eof(); + + Call after piping tokens through ffest_first, where the most recent + token sent through must be EOS. + + 20-Feb-91 JCB 1.1 + Put new EOF token in ffesta_tokens[0], not NULL, because too much + code expects something there for error reporting and the like. Also, + do basically the same things ffest_second and ffesta_zero do for + processing a statement (make and destroy pools, et cetera). */ + +void +ffest_eof () +{ + ffesta_eof (); +} + +/* ffest_ffebad_here_current_stmt -- ffebad_here with ptr to current stmt + + ffest_ffebad_here_current_stmt(0); + + Outsiders can call this fn if they have no more convenient place to + point to (via a token or pair of ffewhere objects) and they know a + current, useful statement is being evaluted by ffest (i.e. they are + being called from ffestb, ffestc, ffestd, ... functions). */ + +void +ffest_ffebad_here_current_stmt (ffebadIndex i) +{ + ffesta_ffebad_here_current_stmt (i); +} + +/* ffest_ffebad_here_doiter -- Calls ffebad_here with ptr to DO iter var + + ffesymbol s; + // call ffebad_start first, of course. + ffest_ffebad_here_doiter(0,s); + // call ffebad_finish afterwards, naturally. + + Searches the stack of blocks backwards for a DO loop that has s + as its iteration variable, then calls ffebad_here with pointers to + that particular reference to the variable. Crashes if the DO loop + can't be found. */ + +void +ffest_ffebad_here_doiter (ffebadIndex i, ffesymbol s) +{ + ffestc_ffebad_here_doiter (i, s); +} + +/* ffest_ffebad_start -- Start a possibly inhibited error report + + if (ffest_ffebad_start(FFEBAD_SOME_ERROR)) + { + ffebad_here, ffebad_string ...; + ffebad_finish(); + } + + Call if the error might indicate that ffest is evaluating the wrong + statement form, instead of calling ffebad_start directly. If ffest + is choosing between forms, it will return FALSE, send an EOS/SEMICOLON + token through as the next token (if the current one isn't already one + of those), and try another possible form. Otherwise, ffebad_start is + called with the argument and TRUE returned. */ + +bool +ffest_ffebad_start (ffebad errnum) +{ + return ffesta_ffebad_start (errnum); +} + +/* ffest_first -- Parse the first token in a statement + + return ffest_first; // to lexer. */ + +ffelexHandler +ffest_first (ffelexToken t) +{ + return ffesta_first (t); +} + +/* ffest_init_0 -- Initialize for entire image invocation + + ffest_init_0(); + + Call just once per invocation of the compiler (not once per invocation + of the front end). + + Gets memory for the list of possibles once and for all, since this + list never gets larger than a certain size (FFEST_maxPOSSIBLES_) + and is not particularly large. Initializes the array of pointers to + this list. Initializes the executable and nonexecutable lists. */ + +void +ffest_init_0 () +{ + ffesta_init_0 (); + ffestb_init_0 (); + ffestc_init_0 (); + ffestd_init_0 (); + ffeste_init_0 (); + ffestp_init_0 (); + ffestr_init_0 (); + ffests_init_0 (); + ffestt_init_0 (); + ffestu_init_0 (); + ffestv_init_0 (); + ffestw_init_0 (); +} + +/* ffest_init_1 -- Initialize for entire image invocation + + ffest_init_1(); + + Call just once per invocation of the compiler (not once per invocation + of the front end). + + Gets memory for the list of possibles once and for all, since this + list never gets larger than a certain size (FFEST_maxPOSSIBLES_) + and is not particularly large. Initializes the array of pointers to + this list. Initializes the executable and nonexecutable lists. */ + +void +ffest_init_1 () +{ + ffesta_init_1 (); + ffestb_init_1 (); + ffestc_init_1 (); + ffestd_init_1 (); + ffeste_init_1 (); + ffestp_init_1 (); + ffestr_init_1 (); + ffests_init_1 (); + ffestt_init_1 (); + ffestu_init_1 (); + ffestv_init_1 (); + ffestw_init_1 (); +} + +/* ffest_init_2 -- Initialize for entire image invocation + + ffest_init_2(); + + Call just once per invocation of the compiler (not once per invocation + of the front end). + + Gets memory for the list of possibles once and for all, since this + list never gets larger than a certain size (FFEST_maxPOSSIBLES_) + and is not particularly large. Initializes the array of pointers to + this list. Initializes the executable and nonexecutable lists. */ + +void +ffest_init_2 () +{ + ffesta_init_2 (); + ffestb_init_2 (); + ffestc_init_2 (); + ffestd_init_2 (); + ffeste_init_2 (); + ffestp_init_2 (); + ffestr_init_2 (); + ffests_init_2 (); + ffestt_init_2 (); + ffestu_init_2 (); + ffestv_init_2 (); + ffestw_init_2 (); +} + +/* ffest_init_3 -- Initialize for any program unit + + ffest_init_3(); */ + +void +ffest_init_3 () +{ + ffesta_init_3 (); + ffestb_init_3 (); + ffestc_init_3 (); + ffestd_init_3 (); + ffeste_init_3 (); + ffestp_init_3 (); + ffestr_init_3 (); + ffests_init_3 (); + ffestt_init_3 (); + ffestu_init_3 (); + ffestv_init_3 (); + ffestw_init_3 (); + + ffestw_display_state (); +} + +/* ffest_init_4 -- Initialize for statement functions + + ffest_init_4(); */ + +void +ffest_init_4 () +{ + ffesta_init_4 (); + ffestb_init_4 (); + ffestc_init_4 (); + ffestd_init_4 (); + ffeste_init_4 (); + ffestp_init_4 (); + ffestr_init_4 (); + ffests_init_4 (); + ffestt_init_4 (); + ffestu_init_4 (); + ffestv_init_4 (); + ffestw_init_4 (); +} + +/* Test whether ENTRY statement is valid. + + Returns TRUE if current program unit is known to be FUNCTION or SUBROUTINE. + Else returns FALSE. */ + +bool +ffest_is_entry_valid () +{ + return ffesta_is_entry_valid; +} + +/* ffest_is_inhibited -- Test whether the current possibility is inhibited + + if (!ffest_is_inhibited()) + // implement the statement. + + Just make sure the current possibility has been confirmed. If anyone + really needs to test whether the current possibility is inhibited prior + to confirming it, that indicates a need to begin statement processing + before it is certain that the given possibility is indeed the statement + to be processed. As of this writing, there does not appear to be such + a need. If there is, then when confirming a statement would normally + immediately disable the inhibition (whereas currently we leave the + confirmed statement disabled until we've tried the other possibilities, + to check for ambiguities), we must check to see if the possibility has + already tested for inhibition prior to confirmation and, if so, maintain + inhibition until the end of the statement (which may be forced right + away) and then rerun the entire statement from the beginning. Otherwise, + initial calls to ffestb functions won't have been made, but subsequent + calls (after confirmation) will, which is wrong. Of course, this all + applies only to those statements implemented via multiple calls to + ffestb, although if a statement requiring only a single ffestb call + tested for inhibition prior to confirmation, it would likely mean that + the ffestb call would be completely dropped without this mechanism. */ + +bool +ffest_is_inhibited () +{ + return ffesta_is_inhibited (); +} + +/* ffest_seen_first_exec -- Test whether first executable stmt has been seen + + if (ffest_seen_first_exec()) + // No more spec stmts can be seen. + + In a case where, say, the first statement is PARAMETER(A)=B, FALSE + will be returned while the PARAMETER statement is being run, and TRUE + will be returned if it doesn't confirm and the assignment statement + is being run. */ + +bool +ffest_seen_first_exec () +{ + return ffesta_seen_first_exec; +} + +/* Shut down current parsing possibility, but without bothering the + user with a diagnostic if we're not inhibited. */ + +void +ffest_shutdown () +{ + ffesta_shutdown (); +} + +/* ffest_sym_end_transition -- Update symbol info just before end of unit + + ffesymbol s; + ffest_sym_end_transition(s); */ + +ffesymbol +ffest_sym_end_transition (ffesymbol s) +{ + return ffestu_sym_end_transition (s); +} + +/* ffest_sym_exec_transition -- Update symbol just before first exec stmt + + ffesymbol s; + ffest_sym_exec_transition(s); */ + +ffesymbol +ffest_sym_exec_transition (ffesymbol s) +{ + return ffestu_sym_exec_transition (s); +} + +/* ffest_terminate_0 -- Terminate for entire image invocation + + ffest_terminate_0(); */ + +void +ffest_terminate_0 () +{ + ffesta_terminate_0 (); + ffestb_terminate_0 (); + ffestc_terminate_0 (); + ffestd_terminate_0 (); + ffeste_terminate_0 (); + ffestp_terminate_0 (); + ffestr_terminate_0 (); + ffests_terminate_0 (); + ffestt_terminate_0 (); + ffestu_terminate_0 (); + ffestv_terminate_0 (); + ffestw_terminate_0 (); +} + +/* ffest_terminate_1 -- Terminate for source file + + ffest_terminate_1(); */ + +void +ffest_terminate_1 () +{ + ffesta_terminate_1 (); + ffestb_terminate_1 (); + ffestc_terminate_1 (); + ffestd_terminate_1 (); + ffeste_terminate_1 (); + ffestp_terminate_1 (); + ffestr_terminate_1 (); + ffests_terminate_1 (); + ffestt_terminate_1 (); + ffestu_terminate_1 (); + ffestv_terminate_1 (); + ffestw_terminate_1 (); +} + +/* ffest_terminate_2 -- Terminate for outer program unit + + ffest_terminate_2(); */ + +void +ffest_terminate_2 () +{ + ffesta_terminate_2 (); + ffestb_terminate_2 (); + ffestc_terminate_2 (); + ffestd_terminate_2 (); + ffeste_terminate_2 (); + ffestp_terminate_2 (); + ffestr_terminate_2 (); + ffests_terminate_2 (); + ffestt_terminate_2 (); + ffestu_terminate_2 (); + ffestv_terminate_2 (); + ffestw_terminate_2 (); +} + +/* ffest_terminate_3 -- Terminate for any program unit + + ffest_terminate_3(); */ + +void +ffest_terminate_3 () +{ + ffesta_terminate_3 (); + ffestb_terminate_3 (); + ffestc_terminate_3 (); + ffestd_terminate_3 (); + ffeste_terminate_3 (); + ffestp_terminate_3 (); + ffestr_terminate_3 (); + ffests_terminate_3 (); + ffestt_terminate_3 (); + ffestu_terminate_3 (); + ffestv_terminate_3 (); + ffestw_terminate_3 (); +} + +/* ffest_terminate_4 -- Terminate for statement functions + + ffest_terminate_4(); */ + +void +ffest_terminate_4 () +{ + ffesta_terminate_4 (); + ffestb_terminate_4 (); + ffestc_terminate_4 (); + ffestd_terminate_4 (); + ffeste_terminate_4 (); + ffestp_terminate_4 (); + ffestr_terminate_4 (); + ffests_terminate_4 (); + ffestt_terminate_4 (); + ffestu_terminate_4 (); + ffestv_terminate_4 (); + ffestw_terminate_4 (); +} |