path: root/gcc/f/st.c

/* 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 ();
}