/* st.c -- Implementation File (module.c template V1.0) Copyright (C) 1995 Free Software Foundation, Inc. Contributed by James Craig Burley. 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 (); }