d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
35ca217bf0
freebsd-nq/contrib/gcc/f/sta.c
Alexander Kabaev 9a63ad9273 Gcc 3.4.2 20040728.
2004-07-28 03:11:36 +00:00

1723 lines
54 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* sta.c -- Implementation File (module.c template V1.0)
Copyright (C) 1995, 1996, 1997, 2003 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:
Analyzes the first two tokens, figures out what statements are
possible, tries parsing the possible statements by calling on
the ffestb functions.
Modifications:
*/
/* Include files. */
#include "proj.h"
#include "sta.h"
#include "bad.h"
#include "implic.h"
#include "lex.h"
#include "malloc.h"
#include "stb.h"
#include "stc.h"
#include "std.h"
#include "str.h"
#include "storag.h"
#include "symbol.h"
/* Externals defined here. */
ffelexToken ffesta_tokens[FFESTA_tokensMAX]; /* For use by a possible. */
ffestrFirst ffesta_first_kw; /* First NAME(S) looked up. */
ffestrSecond ffesta_second_kw; /* Second NAME(S) looked up. */
mallocPool ffesta_output_pool; /* Pool for results of stmt handling. */
mallocPool ffesta_scratch_pool; /* Pool for stmt scratch handling. */
ffelexToken ffesta_construct_name;
ffelexToken ffesta_label_token; /* Pending label stuff. */
bool ffesta_seen_first_exec;
bool ffesta_is_entry_valid = FALSE; /* TRUE only in SUBROUTINE/FUNCTION. */
bool ffesta_line_has_semicolons = FALSE;
/* Simple definitions and enumerations. */
#define FFESTA_ABORT_ON_CONFIRM_ 1 /* 0=slow, tested way; 1=faster way
that might not always work. Here's
the old description of what used
to not work with ==1: (try
"CONTINUE\10
FORMAT('hi',I11)\END"). Problem
is that the "topology" of the
confirmed stmt's tokens with
regard to CHARACTER, HOLLERITH,
NAME/NAMES/NUMBER tokens (like hex
numbers), isn't traced if we abort
early, then other stmts might get
their grubby hands on those
unprocessed tokens and commit them
improperly. Ideal fix is to rerun
the confirmed stmt and forget the
rest. */
#define FFESTA_maxPOSSIBLES_ 8/* Never more than this # of possibles. */
/* Internal typedefs. */
typedef struct _ffesta_possible_ *ffestaPossible_;
/* Private include files. */
/* Internal structure definitions. */
struct _ffesta_possible_
{
ffestaPossible_ next;
ffestaPossible_ previous;
ffelexHandler handler;
bool named;
};
struct _ffesta_possible_root_
{
ffestaPossible_ first;
ffestaPossible_ last;
ffelexHandler nil;
};
/* Static objects accessed by functions in this module. */
static bool ffesta_is_inhibited_ = FALSE;
static ffelexToken ffesta_token_0_; /* For use by ffest possibility
handling. */
static ffestaPossible_ ffesta_possibles_[FFESTA_maxPOSSIBLES_];
static int ffesta_num_possibles_ = 0; /* Number of possibilities. */
static struct _ffesta_possible_root_ ffesta_possible_nonexecs_;
static struct _ffesta_possible_root_ ffesta_possible_execs_;
static ffestaPossible_ ffesta_current_possible_;
static ffelexHandler ffesta_current_handler_;
static bool ffesta_confirmed_current_ = FALSE;
static bool ffesta_confirmed_other_ = FALSE;
static ffestaPossible_ ffesta_confirmed_possible_;
static bool ffesta_current_shutdown_ = FALSE;
#if !FFESTA_ABORT_ON_CONFIRM_
static bool ffesta_is_two_into_statement_ = FALSE; /* For IF, WHERE stmts. */
static ffelexToken ffesta_twotokens_1_; /* For IF, WHERE stmts. */
static ffelexToken ffesta_twotokens_2_; /* For IF, WHERE stmts. */
#endif
static ffestaPooldisp ffesta_outpooldisp_; /* After statement dealt
with. */
static bool ffesta_inhibit_confirmation_ = FALSE;
/* Static functions (internal). */
static void ffesta_add_possible_ (ffelexHandler fn, bool exec, bool named);
static bool ffesta_inhibited_exec_transition_ (void);
static void ffesta_reset_possibles_ (void);
static ffelexHandler ffesta_save_ (ffelexToken t);
static ffelexHandler ffesta_second_ (ffelexToken t);
#if !FFESTA_ABORT_ON_CONFIRM_
static ffelexHandler ffesta_send_two_ (ffelexToken t);
#endif
/* Internal macros. */
#define ffesta_add_possible_exec_(fn) (ffesta_add_possible_ (fn, TRUE, TRUE))
#define ffesta_add_possible_nonexec_(fn) (ffesta_add_possible_ (fn, FALSE, TRUE))
#define ffesta_add_possible_unnamed_exec_(fn) (ffesta_add_possible_ (fn, TRUE, FALSE))
#define ffesta_add_possible_unnamed_nonexec_(fn) (ffesta_add_possible_ (fn, FALSE, FALSE))
/* Add possible statement to appropriate list. */
static void
ffesta_add_possible_ (ffelexHandler fn, bool exec, bool named)
{
ffestaPossible_ p;
assert (ffesta_num_possibles_ < FFESTA_maxPOSSIBLES_);
p = ffesta_possibles_[ffesta_num_possibles_++];
if (exec)
{
p->next = (ffestaPossible_) &ffesta_possible_execs_.first;
p->previous = ffesta_possible_execs_.last;
}
else
{
p->next = (ffestaPossible_) &ffesta_possible_nonexecs_.first;
p->previous = ffesta_possible_nonexecs_.last;
}
p->next->previous = p;
p->previous->next = p;
p->handler = fn;
p->named = named;
}
/* ffesta_inhibited_exec_transition_ -- Do exec transition while inhibited
if (!ffesta_inhibited_exec_transition_()) // couldn't transition...
Invokes ffestc_exec_transition, but first enables ffebad and ffesta and
afterwards disables them again. Then returns the result of the
invocation of ffestc_exec_transition. */
static bool
ffesta_inhibited_exec_transition_ (void)
{
bool result;
assert (ffebad_inhibit ());
assert (ffesta_is_inhibited_);
ffebad_set_inhibit (FALSE);
ffesta_is_inhibited_ = FALSE;
result = ffestc_exec_transition ();
ffebad_set_inhibit (TRUE);
ffesta_is_inhibited_ = TRUE;
return result;
}
/* ffesta_reset_possibles_ -- Reset (clear) lists of possible statements
ffesta_reset_possibles_();
Clears the lists of executable and nonexecutable statements. */
static void
ffesta_reset_possibles_ (void)
{
ffesta_num_possibles_ = 0;
ffesta_possible_execs_.first = ffesta_possible_execs_.last
= (ffestaPossible_) &ffesta_possible_execs_.first;
ffesta_possible_nonexecs_.first = ffesta_possible_nonexecs_.last
= (ffestaPossible_) &ffesta_possible_nonexecs_.first;
}
/* ffesta_save_ -- Save token on list, pass thru to current handler
return ffesta_save_; // to lexer.
Receives a token from the lexer. Saves it in the list of tokens. Calls
the current handler with the token.
If no shutdown error occurred (via
ffest_ffebad_start), then if the token was EOS or SEMICOLON, mark the
current possible as successful and confirmed but try the next possible
anyway until ambiguities in the form handling are ironed out. */
static ffelexHandler
ffesta_save_ (ffelexToken t)
{
static ffelexToken *saved_tokens = NULL; /* A variable-sized array. */
static unsigned int num_saved_tokens = 0; /* Number currently saved. */
static unsigned int max_saved_tokens = 0; /* Maximum to be saved. */
unsigned int toknum; /* Index into saved_tokens array. */
ffelexToken eos; /* EOS created on-the-fly for shutdown
purposes. */
ffelexToken t2; /* Another temporary token (no intersect with
eos, btw). */
/* Save the current token. */
if (saved_tokens == NULL)
{
saved_tokens
= malloc_new_ksr (malloc_pool_image (), "FFEST Saved Tokens",
(max_saved_tokens = 8) * sizeof (ffelexToken));
/* Start off with 8. */
}
else if (num_saved_tokens >= max_saved_tokens)
{
toknum = max_saved_tokens;
max_saved_tokens <<= 1; /* Multiply by two. */
assert (max_saved_tokens > toknum);
saved_tokens
= malloc_resize_ksr (malloc_pool_image (), saved_tokens,
max_saved_tokens * sizeof (ffelexToken),
toknum * sizeof (ffelexToken));
}
*(saved_tokens + num_saved_tokens++) = ffelex_token_use (t);
/* Transmit the current token to the current handler. */
ffesta_current_handler_ = (ffelexHandler) (*ffesta_current_handler_) (t);
/* See if this possible has been shut down, or confirmed in which case we
might as well shut it down anyway to save time. */
if ((ffesta_current_shutdown_ || (FFESTA_ABORT_ON_CONFIRM_
&& ffesta_confirmed_current_))
&& !ffelex_expecting_character ())
{
switch (ffelex_token_type (t))
{
case FFELEX_typeEOS:
case FFELEX_typeSEMICOLON:
break;
default:
eos = ffelex_token_new_eos (ffelex_token_where_line (t),
ffelex_token_where_column (t));
ffesta_inhibit_confirmation_ = ffesta_current_shutdown_;
(*ffesta_current_handler_) (eos);
ffesta_inhibit_confirmation_ = FALSE;
ffelex_token_kill (eos);
break;
}
}
else
{
/* If this is an EOS or SEMICOLON token, switch to next handler, else
return self as next handler for lexer. */
switch (ffelex_token_type (t))
{
case FFELEX_typeEOS:
case FFELEX_typeSEMICOLON:
break;
default:
return (ffelexHandler) ffesta_save_;
}
}
next_handler: /* :::::::::::::::::::: */
/* Note that a shutdown also happens after seeing the first two tokens
after "IF (expr)" or "WHERE (expr)" where a statement follows, even
though there is no error. This causes the IF or WHERE form to be
implemented first before ffest_first is called for the first token in
the following statement. */
if (ffesta_current_shutdown_)
ffesta_current_shutdown_ = FALSE; /* Only after sending EOS! */
else
assert (ffesta_confirmed_current_);
if (ffesta_confirmed_current_)
{
ffesta_confirmed_current_ = FALSE;
ffesta_confirmed_other_ = TRUE;
}
/* Pick next handler. */
ffesta_current_possible_ = ffesta_current_possible_->next;
ffesta_current_handler_ = ffesta_current_possible_->handler;
if (ffesta_current_handler_ == NULL)
{ /* No handler in this list, try exec list if
not tried yet. */
if (ffesta_current_possible_
== (ffestaPossible_) &ffesta_possible_nonexecs_.first)
{
ffesta_current_possible_ = ffesta_possible_execs_.first;
ffesta_current_handler_ = ffesta_current_possible_->handler;
}
if ((ffesta_current_handler_ == NULL)
|| (!ffesta_seen_first_exec
&& ((ffesta_confirmed_possible_ != NULL)
|| !ffesta_inhibited_exec_transition_ ())))
/* Don't run execs if: (decoding the "if" ^^^ up here ^^^) - we
have no exec handler available, or - we haven't seen the first
executable statement yet, and - we've confirmed a nonexec
(otherwise even a nonexec would cause a transition), or - a
nonexec-to-exec transition can't be made at the statement context
level (as in an executable statement in the middle of a STRUCTURE
definition); if it can be made, ffestc_exec_transition makes the
corresponding transition at the statement state level so
specification statements are no longer accepted following an
unrecognized statement. (Note: it is valid for f_e_t_ to decide
to always return TRUE by "shrieking" away the statement state
stack until a transitionable state is reached. Or it can leave
the stack as is and return FALSE.)
If we decide not to run execs, enter this block to rerun the
confirmed statement, if any. */
{ /* At end of both lists! Pick confirmed or
first possible. */
ffebad_set_inhibit (FALSE);
ffesta_is_inhibited_ = FALSE;
ffesta_confirmed_other_ = FALSE;
ffesta_tokens[0] = ffesta_token_0_;
if (ffesta_confirmed_possible_ == NULL)
{ /* No confirmed success, just use first
named possible, or first possible if
no named possibles. */
ffestaPossible_ possible = ffesta_possible_nonexecs_.first;
ffestaPossible_ first = NULL;
ffestaPossible_ first_named = NULL;
ffestaPossible_ first_exec = NULL;
for (;;)
{
if (possible->handler == NULL)
{
if (possible == (ffestaPossible_) &ffesta_possible_nonexecs_.first)
{
possible = first_exec = ffesta_possible_execs_.first;
continue;
}
else
break;
}
if (first == NULL)
first = possible;
if (possible->named
&& (first_named == NULL))
first_named = possible;
possible = possible->next;
}
if (first_named != NULL)
ffesta_current_possible_ = first_named;
else if (ffesta_seen_first_exec
&& (first_exec != NULL))
ffesta_current_possible_ = first_exec;
else
ffesta_current_possible_ = first;
ffesta_current_handler_ = ffesta_current_possible_->handler;
assert (ffesta_current_handler_ != NULL);
}
else
{ /* Confirmed success, use it. */
ffesta_current_possible_ = ffesta_confirmed_possible_;
ffesta_current_handler_ = ffesta_confirmed_possible_->handler;
}
ffesta_reset_possibles_ ();
}
else
{ /* Switching from [empty?] list of nonexecs
to nonempty list of execs at this point. */
ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
ffesymbol_set_retractable (ffesta_scratch_pool);
}
}
else
{
ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
ffesymbol_set_retractable (ffesta_scratch_pool);
}
/* Send saved tokens to current handler until either shut down or all
tokens sent. */
for (toknum = 0; toknum < num_saved_tokens; ++toknum)
{
t = *(saved_tokens + toknum);
switch (ffelex_token_type (t))
{
case FFELEX_typeCHARACTER:
ffelex_set_expecting_hollerith (0, '\0',
ffewhere_line_unknown (),
ffewhere_column_unknown ());
ffesta_current_handler_
= (ffelexHandler) (*ffesta_current_handler_) (t);
break;
case FFELEX_typeNAMES:
if (ffelex_is_names_expected ())
ffesta_current_handler_
= (ffelexHandler) (*ffesta_current_handler_) (t);
else
{
t2 = ffelex_token_name_from_names (t, 0, 0);
ffesta_current_handler_
= (ffelexHandler) (*ffesta_current_handler_) (t2);
ffelex_token_kill (t2);
}
break;
default:
ffesta_current_handler_
= (ffelexHandler) (*ffesta_current_handler_) (t);
break;
}
if (!ffesta_is_inhibited_)
ffelex_token_kill (t); /* Won't need this any more. */
/* See if this possible has been shut down. */
else if ((ffesta_current_shutdown_ || (FFESTA_ABORT_ON_CONFIRM_
&& ffesta_confirmed_current_))
&& !ffelex_expecting_character ())
{
switch (ffelex_token_type (t))
{
case FFELEX_typeEOS:
case FFELEX_typeSEMICOLON:
break;
default:
eos = ffelex_token_new_eos (ffelex_token_where_line (t),
ffelex_token_where_column (t));
ffesta_inhibit_confirmation_ = ffesta_current_shutdown_;
(*ffesta_current_handler_) (eos);
ffesta_inhibit_confirmation_ = FALSE;
ffelex_token_kill (eos);
break;
}
goto next_handler; /* :::::::::::::::::::: */
}
}
/* Finished sending all the tokens so far. If still trying possibilities,
then if we've just sent an EOS or SEMICOLON token through, go to the
next handler. Otherwise, return self so we can gather and process more
tokens. */
if (ffesta_is_inhibited_)
{
switch (ffelex_token_type (t))
{
case FFELEX_typeEOS:
case FFELEX_typeSEMICOLON:
goto next_handler; /* :::::::::::::::::::: */
default:
#if FFESTA_ABORT_ON_CONFIRM_
assert (!ffesta_confirmed_other_); /* Catch ambiguities. */
#endif
return (ffelexHandler) ffesta_save_;
}
}
/* This was the one final possibility, uninhibited, so send the final
handler it sent. */
num_saved_tokens = 0;
#if !FFESTA_ABORT_ON_CONFIRM_
if (ffesta_is_two_into_statement_)
{ /* End of the line for the previous two
tokens, resurrect them. */
ffelexHandler next;
ffesta_is_two_into_statement_ = FALSE;
next = (ffelexHandler) ffesta_first (ffesta_twotokens_1_);
ffelex_token_kill (ffesta_twotokens_1_);
next = (ffelexHandler) (*next) (ffesta_twotokens_2_);
ffelex_token_kill (ffesta_twotokens_2_);
return (ffelexHandler) next;
}
#endif
assert (ffesta_current_handler_ != NULL);
return (ffelexHandler) ffesta_current_handler_;
}
/* ffesta_second_ -- Parse the token after a NAME/NAMES in a statement
return ffesta_second_; // to lexer.
The second token cannot be a NAMES, since the first token is a NAME or
NAMES. If the second token is a NAME, look up its name in the list of
second names for use by whoever needs it.
Then make a list of all the possible statements this could be, based on
looking at the first two tokens. Two lists of possible statements are
created, one consisting of nonexecutable statements, the other consisting
of executable statements.
If the total number of possibilities is one, just fire up that
possibility by calling its handler function, passing the first two
tokens through it and so on.
Otherwise, start up a process whereby tokens are passed to the first
possibility on the list until EOS or SEMICOLON is reached or an error
is detected. But inhibit any actual reporting of errors; just record
their existence in the list. If EOS or SEMICOLON is reached with no
errors (other than non-form errors happening downstream, such as an
overflowing value for an integer or a GOTO statement identifying a label
on a FORMAT statement), then that is the only possible statement. Rerun
the statement with error-reporting turned on if any non-form errors were
generated, otherwise just use its results, then erase the list of tokens
memorized during the search process. If a form error occurs, immediately
cancel that possibility by sending EOS as the next token, remember the
error code for that possibility, and try the next possibility on the list,
first sending it the list of tokens memorized while handling the first
possibility, then continuing on as before.
Ultimately, either the end of the list of possibilities will be reached
without any successful forms being detected, in which case we pick one
based on hueristics (usually the first possibility) and rerun it with
error reporting turned on using the list of memorized tokens so the user
sees the error, or one of the possibilities will effectively succeed. */
static ffelexHandler
ffesta_second_ (ffelexToken t)
{
ffelexHandler next;
ffesymbol s;
assert (ffelex_token_type (t) != FFELEX_typeNAMES);
if (ffelex_token_type (t) == FFELEX_typeNAME)
ffesta_second_kw = ffestr_second (t);
/* Here we use switch on the first keyword name and handle each possible
recognizable name by looking at the second token, and building the list
of possible names accordingly. For now, just put every possible
statement on the list for ambiguity checking. */
switch (ffesta_first_kw)
{
case FFESTR_firstASSIGN:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R838);
break;
case FFESTR_firstBACKSPACE:
ffestb_args.beru.len = FFESTR_firstlBACKSPACE;
ffestb_args.beru.badname = "BACKSPACE";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
break;
case FFESTR_firstBLOCK:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_block);
break;
case FFESTR_firstBLOCKDATA:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_blockdata);
break;
case FFESTR_firstBYTE:
ffestb_args.decl.len = FFESTR_firstlBYTE;
ffestb_args.decl.type = FFESTP_typeBYTE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstCALL:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1212);
break;
case FFESTR_firstCASE:
case FFESTR_firstCASEDEFAULT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R810);
break;
case FFESTR_firstCHRCTR:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_chartype);
break;
case FFESTR_firstCLOSE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R907);
break;
case FFESTR_firstCOMMON:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R547);
break;
case FFESTR_firstCMPLX:
ffestb_args.decl.len = FFESTR_firstlCMPLX;
ffestb_args.decl.type = FFESTP_typeCOMPLEX;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstCONTINUE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R841);
break;
case FFESTR_firstCYCLE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R834);
break;
case FFESTR_firstDATA:
if (ffe_is_pedantic_not_90 ())
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R528);
else
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R528);
break;
case FFESTR_firstDIMENSION:
ffestb_args.R524.len = FFESTR_firstlDIMENSION;
ffestb_args.R524.badname = "DIMENSION";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R524);
break;
case FFESTR_firstDO:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_do);
break;
case FFESTR_firstDBL:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_double);
break;
case FFESTR_firstDBLCMPLX:
ffestb_args.decl.len = FFESTR_firstlDBLCMPLX;
ffestb_args.decl.type = FFESTP_typeDBLCMPLX;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_dbltype);
break;
case FFESTR_firstDBLPRCSN:
ffestb_args.decl.len = FFESTR_firstlDBLPRCSN;
ffestb_args.decl.type = FFESTP_typeDBLPRCSN;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_dbltype);
break;
case FFESTR_firstDOWHILE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_dowhile);
break;
case FFESTR_firstELSE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_else);
break;
case FFESTR_firstELSEIF:
ffestb_args.elsexyz.second = FFESTR_secondIF;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_elsexyz);
break;
case FFESTR_firstEND:
if ((ffelex_token_type (ffesta_token_0_) == FFELEX_typeNAMES)
|| (ffelex_token_type (t) != FFELEX_typeNAME))
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_end);
else
{
switch (ffesta_second_kw)
{
case FFESTR_secondBLOCK:
case FFESTR_secondBLOCKDATA:
case FFESTR_secondDO:
case FFESTR_secondFILE:
case FFESTR_secondFUNCTION:
case FFESTR_secondIF:
case FFESTR_secondPROGRAM:
case FFESTR_secondSELECT:
case FFESTR_secondSUBROUTINE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_end);
break;
default:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_end);
break;
}
}
break;
case FFESTR_firstENDBLOCK:
ffestb_args.endxyz.len = FFESTR_firstlENDBLOCK;
ffestb_args.endxyz.second = FFESTR_secondBLOCK;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDBLOCKDATA:
ffestb_args.endxyz.len = FFESTR_firstlENDBLOCKDATA;
ffestb_args.endxyz.second = FFESTR_secondBLOCKDATA;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDDO:
ffestb_args.endxyz.len = FFESTR_firstlENDDO;
ffestb_args.endxyz.second = FFESTR_secondDO;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDFILE:
ffestb_args.beru.len = FFESTR_firstlENDFILE;
ffestb_args.beru.badname = "ENDFILE";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
break;
case FFESTR_firstENDFUNCTION:
ffestb_args.endxyz.len = FFESTR_firstlENDFUNCTION;
ffestb_args.endxyz.second = FFESTR_secondFUNCTION;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDIF:
ffestb_args.endxyz.len = FFESTR_firstlENDIF;
ffestb_args.endxyz.second = FFESTR_secondIF;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDPROGRAM:
ffestb_args.endxyz.len = FFESTR_firstlENDPROGRAM;
ffestb_args.endxyz.second = FFESTR_secondPROGRAM;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDSELECT:
ffestb_args.endxyz.len = FFESTR_firstlENDSELECT;
ffestb_args.endxyz.second = FFESTR_secondSELECT;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENDSUBROUTINE:
ffestb_args.endxyz.len = FFESTR_firstlENDSUBROUTINE;
ffestb_args.endxyz.second = FFESTR_secondSUBROUTINE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
case FFESTR_firstENTRY:
ffestb_args.dummy.len = FFESTR_firstlENTRY;
ffestb_args.dummy.badname = "ENTRY";
ffestb_args.dummy.is_subr = ffestc_is_entry_in_subr ();
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
break;
case FFESTR_firstEQUIVALENCE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R544);
break;
case FFESTR_firstEXIT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R835);
break;
case FFESTR_firstEXTERNAL:
ffestb_args.varlist.len = FFESTR_firstlEXTERNAL;
ffestb_args.varlist.badname = "EXTERNAL";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
/* WARNING: don't put anything that might cause an item to precede
FORMAT in the list of possible statements (it's added below) without
making sure FORMAT still is first. It has to run with
ffelex_set_names_pure(TRUE), to make sure the lexer delivers NAMES
tokens. */
case FFESTR_firstFORMAT:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1001);
break;
case FFESTR_firstFUNCTION:
ffestb_args.dummy.len = FFESTR_firstlFUNCTION;
ffestb_args.dummy.badname = "FUNCTION";
ffestb_args.dummy.is_subr = FALSE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
break;
case FFESTR_firstGO:
if ((ffelex_token_type (ffesta_token_0_) == FFELEX_typeNAMES)
|| (ffelex_token_type (t) != FFELEX_typeNAME))
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_goto);
else
switch (ffesta_second_kw)
{
case FFESTR_secondTO:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_goto);
break;
default:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_goto);
break;
}
break;
case FFESTR_firstGOTO:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_goto);
break;
case FFESTR_firstIF:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_if);
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R840);
break;
case FFESTR_firstIMPLICIT:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_R539);
break;
case FFESTR_firstINCLUDE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_S3P4);
switch (ffelex_token_type (t))
{
case FFELEX_typeNUMBER:
case FFELEX_typeNAME:
case FFELEX_typeAPOSTROPHE:
case FFELEX_typeQUOTE:
break;
default:
break;
}
break;
case FFESTR_firstINQUIRE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R923);
break;
case FFESTR_firstINTGR:
ffestb_args.decl.len = FFESTR_firstlINTGR;
ffestb_args.decl.type = FFESTP_typeINTEGER;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstINTRINSIC:
ffestb_args.varlist.len = FFESTR_firstlINTRINSIC;
ffestb_args.varlist.badname = "INTRINSIC";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
case FFESTR_firstLGCL:
ffestb_args.decl.len = FFESTR_firstlLGCL;
ffestb_args.decl.type = FFESTP_typeLOGICAL;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstNAMELIST:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R542);
break;
case FFESTR_firstOPEN:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R904);
break;
case FFESTR_firstPARAMETER:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R537);
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V027);
break;
case FFESTR_firstPAUSE:
ffestb_args.halt.len = FFESTR_firstlPAUSE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_halt);
break;
case FFESTR_firstPRINT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R911);
break;
case FFESTR_firstPROGRAM:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1102);
break;
case FFESTR_firstREAD:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R909);
break;
case FFESTR_firstREAL:
ffestb_args.decl.len = FFESTR_firstlREAL;
ffestb_args.decl.type = FFESTP_typeREAL;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstRETURN:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1227);
break;
case FFESTR_firstREWIND:
ffestb_args.beru.len = FFESTR_firstlREWIND;
ffestb_args.beru.badname = "REWIND";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
break;
case FFESTR_firstSAVE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R522);
break;
case FFESTR_firstSELECT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R809);
break;
case FFESTR_firstSELECTCASE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R809);
break;
case FFESTR_firstSTOP:
ffestb_args.halt.len = FFESTR_firstlSTOP;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_halt);
break;
case FFESTR_firstSUBROUTINE:
ffestb_args.dummy.len = FFESTR_firstlSUBROUTINE;
ffestb_args.dummy.badname = "SUBROUTINE";
ffestb_args.dummy.is_subr = TRUE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
break;
case FFESTR_firstTYPE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V020);
break;
case FFESTR_firstVIRTUAL:
ffestb_args.R524.len = FFESTR_firstlVIRTUAL;
ffestb_args.R524.badname = "VIRTUAL";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R524);
break;
case FFESTR_firstVOLATILE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V014);
break;
case FFESTR_firstWORD:
ffestb_args.decl.len = FFESTR_firstlWORD;
ffestb_args.decl.type = FFESTP_typeWORD;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
break;
case FFESTR_firstWRITE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R910);
break;
default:
break;
}
/* Now check the default cases, which are always "live" (meaning that no
other possibility can override them). These are where the second token
is OPEN_PAREN, PERCENT, EQUALS, POINTS, or COLON. */
switch (ffelex_token_type (t))
{
case FFELEX_typeOPEN_PAREN:
s = ffesymbol_lookup_local (ffesta_token_0_);
if (((s == NULL) || (ffesymbol_dims (s) == NULL))
&& !ffesta_seen_first_exec)
{ /* Not known as array; may be stmt function. */
ffesta_add_possible_unnamed_nonexec_ ((ffelexHandler) ffestb_R1229);
/* If the symbol is (or will be due to implicit typing) of
CHARACTER type, then the statement might be an assignment
statement. If so, since it can't be a function invocation nor
an array element reference, the open paren following the symbol
name must be followed by an expression and a colon. Without the
colon (which cannot appear in a stmt function definition), the
let stmt rejects. So CHARACTER_NAME(...)=expr, unlike any other
type, is not ambiguous alone. */
if (ffeimplic_peek_symbol_type (s,
ffelex_token_text (ffesta_token_0_))
== FFEINFO_basictypeCHARACTER)
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
}
else /* Not statement function if known as an
array. */
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
break;
case FFELEX_typeEQUALS:
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
break;
case FFELEX_typeCOLON:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_construct);
break;
default:
;
}
/* Now see how many possibilities are on the list. */
switch (ffesta_num_possibles_)
{
case 0: /* None, so invalid statement. */
no_stmts: /* :::::::::::::::::::: */
ffesta_tokens[0] = ffesta_token_0_;
ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_token_0_, t);
next = (ffelexHandler) ffelex_swallow_tokens (NULL,
(ffelexHandler) ffesta_zero);
break;
case 1: /* One, so just do it! */
ffesta_tokens[0] = ffesta_token_0_;
next = ffesta_possible_execs_.first->handler;
if (next == NULL)
{ /* Have a nonexec stmt. */
next = ffesta_possible_nonexecs_.first->handler;
assert (next != NULL);
}
else if (ffesta_seen_first_exec)
; /* Have an exec stmt after exec transition. */
else if (!ffestc_exec_transition ())
/* 1 exec stmt only, but not valid in context, so pretend as though
statement is unrecognized. */
goto no_stmts; /* :::::::::::::::::::: */
break;
default: /* More than one, so try them in order. */
ffesta_confirmed_possible_ = NULL;
ffesta_current_possible_ = ffesta_possible_nonexecs_.first;
ffesta_current_handler_ = ffesta_current_possible_->handler;
if (ffesta_current_handler_ == NULL)
{
ffesta_current_possible_ = ffesta_possible_execs_.first;
ffesta_current_handler_ = ffesta_current_possible_->handler;
assert (ffesta_current_handler_ != NULL);
if (!ffesta_seen_first_exec)
{ /* Need to do exec transition now. */
ffesta_tokens[0] = ffesta_token_0_;
if (!ffestc_exec_transition ())
goto no_stmts; /* :::::::::::::::::::: */
}
}
ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
next = (ffelexHandler) ffesta_save_;
ffebad_set_inhibit (TRUE);
ffesta_is_inhibited_ = TRUE;
break;
}
ffesta_output_pool
= malloc_pool_new ("Statement Output", ffe_pool_program_unit (), 1024);
ffesta_scratch_pool
= malloc_pool_new ("Statement Scratch", ffe_pool_program_unit (), 1024);
ffesta_outpooldisp_ = FFESTA_pooldispDISCARD;
if (ffesta_is_inhibited_)
ffesymbol_set_retractable (ffesta_scratch_pool);
ffelex_set_names (FALSE); /* Most handlers will want this. If not,
they have to set it TRUE again (its value
at the beginning of a statement). */
return (ffelexHandler) (*next) (t);
}
/* ffesta_send_two_ -- Send the two tokens saved by ffesta_two after all
return ffesta_send_two_; // to lexer.
Currently, if this function gets called, it means that the two tokens
saved by ffesta_two did not have their handlers derailed by
ffesta_save_, which probably means they weren't sent by ffesta_save_
but directly by the lexer, which probably means the original statement
(which should be IF (expr) or WHERE (expr)) somehow evaluated to only
one possibility in ffesta_second_ or somebody optimized FFEST to
immediately revert to one possibility upon confirmation but forgot to
change this function (and thus perhaps the entire resubmission
mechanism). */
#if !FFESTA_ABORT_ON_CONFIRM_
static ffelexHandler
ffesta_send_two_ (ffelexToken t)
{
assert ("what am I doing here?" == NULL);
return NULL;
}
#endif
/* ffesta_confirmed -- Confirm current possibility as only one
ffesta_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
ffesta_confirmed (void)
{
if (ffesta_inhibit_confirmation_)
return;
ffesta_confirmed_current_ = TRUE;
assert (!ffesta_confirmed_other_
|| (ffesta_confirmed_possible_ == ffesta_current_possible_));
ffesta_confirmed_possible_ = ffesta_current_possible_;
}
/* ffesta_eof -- End of (non-INCLUDEd) source file
ffesta_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
ffesta_eof (void)
{
ffesta_tokens[0] = ffelex_token_new_eof ();
ffesta_output_pool
= malloc_pool_new ("Statement Output", ffe_pool_program_unit (), 1024);
ffesta_scratch_pool
= malloc_pool_new ("Statement Scratch", ffe_pool_program_unit (), 1024);
ffesta_outpooldisp_ = FFESTA_pooldispDISCARD;
ffestc_eof ();
if (ffesta_tokens[0] != NULL)
ffelex_token_kill (ffesta_tokens[0]);
if (ffesta_output_pool != NULL)
{
if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
malloc_pool_kill (ffesta_output_pool);
ffesta_output_pool = NULL;
}
if (ffesta_scratch_pool != NULL)
{
malloc_pool_kill (ffesta_scratch_pool);
ffesta_scratch_pool = NULL;
}
if (ffesta_label_token != NULL)
{
ffelex_token_kill (ffesta_label_token);
ffesta_label_token = NULL;
}
if (ffe_is_ffedebug ())
{
ffestorag_report ();
}
}
/* ffesta_ffebad_here_current_stmt -- ffebad_here with ptr to current stmt
ffesta_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
ffesta_ffebad_here_current_stmt (ffebadIndex i)
{
assert (ffesta_tokens[0] != NULL);
ffebad_here (i, ffelex_token_where_line (ffesta_tokens[0]),
ffelex_token_where_column (ffesta_tokens[0]));
}
/* ffesta_ffebad_start -- Start a possibly inhibited error report
if (ffesta_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
ffesta_ffebad_start (ffebad errnum)
{
if (!ffesta_is_inhibited_)
{
ffebad_start (errnum);
return TRUE;
}
if (!ffesta_confirmed_current_)
ffesta_current_shutdown_ = TRUE;
return FALSE;
}
/* ffesta_first -- Parse the first token in a statement
return ffesta_first; // to lexer. */
ffelexHandler
ffesta_first (ffelexToken t)
{
switch (ffelex_token_type (t))
{
case FFELEX_typeSEMICOLON:
case FFELEX_typeEOS:
ffesta_tokens[0] = ffelex_token_use (t);
if (ffesta_label_token != NULL)
{
ffebad_start (FFEBAD_LABEL_WITHOUT_STMT);
ffebad_here (0, ffelex_token_where_line (ffesta_label_token),
ffelex_token_where_column (ffesta_label_token));
ffebad_string (ffelex_token_text (ffesta_label_token));
ffebad_here (1, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_finish ();
}
return (ffelexHandler) ffesta_zero (t);
case FFELEX_typeNAME:
case FFELEX_typeNAMES:
ffesta_token_0_ = ffelex_token_use (t);
ffesta_first_kw = ffestr_first (t);
return (ffelexHandler) ffesta_second_;
case FFELEX_typeNUMBER:
if (ffesta_line_has_semicolons
&& !ffe_is_free_form ()
&& ffe_is_pedantic ())
{
ffebad_start (FFEBAD_LABEL_WRONG_PLACE);
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_string (ffelex_token_text (t));
ffebad_finish ();
}
if (ffesta_label_token == NULL)
{
ffesta_label_token = ffelex_token_use (t);
return (ffelexHandler) ffesta_first;
}
else
{
ffebad_start (FFEBAD_EXTRA_LABEL_DEF);
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_string (ffelex_token_text (t));
ffebad_here (1, ffelex_token_where_line (ffesta_label_token),
ffelex_token_where_column (ffesta_label_token));
ffebad_string (ffelex_token_text (ffesta_label_token));
ffebad_finish ();
return (ffelexHandler) ffesta_first;
}
default: /* Invalid first token. */
ffesta_tokens[0] = ffelex_token_use (t);
ffebad_start (FFEBAD_STMT_BEGINS_BAD);
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_finish ();
return (ffelexHandler) ffelex_swallow_tokens (t,
(ffelexHandler) ffesta_zero);
}
}
/* ffesta_init_0 -- Initialize for entire image invocation
ffesta_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 (FFESTA_maxPOSSIBLES_)
and is not particularly large. Initializes the array of pointers to
this list. Initializes the executable and nonexecutable lists. */
void
ffesta_init_0 (void)
{
ffestaPossible_ ptr;
int i;
ptr = malloc_new_kp (malloc_pool_image (), "FFEST possibles",
FFESTA_maxPOSSIBLES_ * sizeof (*ptr));
for (i = 0; i < FFESTA_maxPOSSIBLES_; ++i)
ffesta_possibles_[i] = ptr++;
ffesta_possible_execs_.first = ffesta_possible_execs_.last
= (ffestaPossible_) &ffesta_possible_execs_.first;
ffesta_possible_nonexecs_.first = ffesta_possible_nonexecs_.last
= (ffestaPossible_) &ffesta_possible_nonexecs_.first;
ffesta_possible_execs_.nil = ffesta_possible_nonexecs_.nil = NULL;
}
/* ffesta_init_3 -- Initialize for any program unit
ffesta_init_3(); */
void
ffesta_init_3 (void)
{
ffesta_output_pool = NULL; /* May be doing this just before reaching */
ffesta_scratch_pool = NULL; /* ffesta_zero or ffesta_two. */
/* NOTE: we let the ffe_terminate_2 action of killing the program_unit pool
handle the killing of the output and scratch pools for us, which is why
we don't have a terminate_3 action to do so. */
ffesta_construct_name = NULL;
ffesta_label_token = NULL;
ffesta_seen_first_exec = FALSE;
}
/* ffesta_is_inhibited -- Test whether the current possibility is inhibited
if (!ffesta_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
ffesta_is_inhibited (void)
{
assert (ffesta_confirmed_current_ || ffesta_inhibit_confirmation_);
return ffesta_is_inhibited_;
}
/* ffesta_ffebad_1p -- Issue diagnostic with one source character
ffelexToken names_token;
ffeTokenLength index;
ffelexToken next_token;
ffesta_ffebad_1p(FFEBAD_SOME_ERROR,names_token,index,next_token);
Equivalent to "if (ffest_ffebad_start(FFEBAD_SOME_ERROR))" followed by
sending one argument, the location of index with names_token, if TRUE is
returned. If index is equal to the length of names_token, meaning it
points to the end of the token, then uses the location in next_token
(which should be the token sent by the lexer after it sent names_token)
instead. */
void
ffesta_ffebad_1p (ffebad errnum, ffelexToken names_token, ffeTokenLength index,
ffelexToken next_token)
{
ffewhereLine line;
ffewhereColumn col;
assert (index <= ffelex_token_length (names_token));
if (ffesta_ffebad_start (errnum))
{
if (index == ffelex_token_length (names_token))
{
assert (next_token != NULL);
line = ffelex_token_where_line (next_token);
col = ffelex_token_where_column (next_token);
ffebad_here (0, line, col);
}
else
{
ffewhere_set_from_track (&line, &col,
ffelex_token_where_line (names_token),
ffelex_token_where_column (names_token),
ffelex_token_wheretrack (names_token),
index);
ffebad_here (0, line, col);
ffewhere_line_kill (line);
ffewhere_column_kill (col);
}
ffebad_finish ();
}
}
void
ffesta_ffebad_1sp (ffebad errnum, const char *s, ffelexToken names_token,
ffeTokenLength index, ffelexToken next_token)
{
ffewhereLine line;
ffewhereColumn col;
assert (index <= ffelex_token_length (names_token));
if (ffesta_ffebad_start (errnum))
{
ffebad_string (s);
if (index == ffelex_token_length (names_token))
{
assert (next_token != NULL);
line = ffelex_token_where_line (next_token);
col = ffelex_token_where_column (next_token);
ffebad_here (0, line, col);
}
else
{
ffewhere_set_from_track (&line, &col,
ffelex_token_where_line (names_token),
ffelex_token_where_column (names_token),
ffelex_token_wheretrack (names_token),
index);
ffebad_here (0, line, col);
ffewhere_line_kill (line);
ffewhere_column_kill (col);
}
ffebad_finish ();
}
}
void
ffesta_ffebad_1st (ffebad errnum, const char *s, ffelexToken t)
{
if (ffesta_ffebad_start (errnum))
{
ffebad_string (s);
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_finish ();
}
}
/* ffesta_ffebad_1t -- Issue diagnostic with one source token
ffelexToken t;
ffesta_ffebad_1t(FFEBAD_SOME_ERROR,t);
Equivalent to "if (ffesta_ffebad_start(FFEBAD_SOME_ERROR))" followed by
sending one argument, the location of the token t, if TRUE is returned. */
void
ffesta_ffebad_1t (ffebad errnum, ffelexToken t)
{
if (ffesta_ffebad_start (errnum))
{
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_finish ();
}
}
void
ffesta_ffebad_2st (ffebad errnum, const char *s, ffelexToken t1, ffelexToken t2)
{
if (ffesta_ffebad_start (errnum))
{
ffebad_string (s);
ffebad_here (0, ffelex_token_where_line (t1), ffelex_token_where_column (t1));
ffebad_here (1, ffelex_token_where_line (t2), ffelex_token_where_column (t2));
ffebad_finish ();
}
}
/* ffesta_ffebad_2t -- Issue diagnostic with two source tokens
ffelexToken t1, t2;
ffesta_ffebad_2t(FFEBAD_SOME_ERROR,t1,t2);
Equivalent to "if (ffesta_ffebad_start(FFEBAD_SOME_ERROR))" followed by
sending two argument, the locations of the tokens t1 and t2, if TRUE is
returned. */
void
ffesta_ffebad_2t (ffebad errnum, ffelexToken t1, ffelexToken t2)
{
if (ffesta_ffebad_start (errnum))
{
ffebad_here (0, ffelex_token_where_line (t1), ffelex_token_where_column (t1));
ffebad_here (1, ffelex_token_where_line (t2), ffelex_token_where_column (t2));
ffebad_finish ();
}
}
ffestaPooldisp
ffesta_outpooldisp (void)
{
return ffesta_outpooldisp_;
}
void
ffesta_set_outpooldisp (ffestaPooldisp d)
{
ffesta_outpooldisp_ = d;
}
/* Shut down current parsing possibility, but without bothering the
user with a diagnostic if we're not inhibited. */
void
ffesta_shutdown (void)
{
if (ffesta_is_inhibited_)
ffesta_current_shutdown_ = TRUE;
}
/* ffesta_two -- Deal with the first two tokens after a swallowed statement
return ffesta_two(first_token,second_token); // to lexer.
Like ffesta_zero, except instead of expecting an EOS or SEMICOLON, it
expects the first two tokens of a statement that is part of another
statement: the first two tokens of statement in "IF (expr) statement" or
"WHERE (expr) statement", in particular. The first token must be a NAME
or NAMES, the second can be basically anything. The statement type MUST
be confirmed by now.
If we're not inhibited, just handle things as if we were ffesta_zero
and saw an EOS just before the two tokens.
If we're inhibited, set ffesta_current_shutdown_ to shut down the current
statement and continue with other possibilities, then (presumably) come
back to this one for real when not inhibited. */
ffelexHandler
ffesta_two (ffelexToken first, ffelexToken second)
{
#if FFESTA_ABORT_ON_CONFIRM_
ffelexHandler next;
#endif
assert ((ffelex_token_type (first) == FFELEX_typeNAME)
|| (ffelex_token_type (first) == FFELEX_typeNAMES));
assert (ffesta_tokens[0] != NULL);
if (ffesta_is_inhibited_) /* Oh, not really done with statement. */
{
ffesta_current_shutdown_ = TRUE;
/* To catch the EOS on shutdown. */
return (ffelexHandler) ffelex_swallow_tokens (second,
(ffelexHandler) ffesta_zero);
}
ffestw_display_state ();
ffelex_token_kill (ffesta_tokens[0]);
if (ffesta_output_pool != NULL)
{
if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
malloc_pool_kill (ffesta_output_pool);
ffesta_output_pool = NULL;
}
if (ffesta_scratch_pool != NULL)
{
malloc_pool_kill (ffesta_scratch_pool);
ffesta_scratch_pool = NULL;
}
ffesta_reset_possibles_ ();
ffesta_confirmed_current_ = FALSE;
/* What happens here is somewhat interesting. We effectively derail the
line of handlers for these two tokens, the first two in a statement, by
setting a flag to TRUE. This flag tells ffesta_save_ (or, conceivably,
the lexer via ffesta_second_'s case 1:, where it has only one possible
kind of statement -- someday this will be more likely, i.e. after
confirmation causes an immediate switch to only the one context rather
than just setting a flag and running through the remaining possibles to
look for ambiguities) that the last two tokens it sent did not reach the
truly desired targets (ffest_first and ffesta_second_) since that would
otherwise attempt to recursively invoke ffesta_save_ in most cases,
while the existing ffesta_save_ was still alive and making use of static
(nonrecursive) variables. Instead, ffesta_save_, upon seeing this flag
set TRUE, sets it to FALSE and resubmits the two tokens copied here to
ffest_first and, presumably, ffesta_second_, kills them, and returns the
handler returned by the handler for the second token. Thus, even though
ffesta_save_ is still (likely to be) recursively invoked, the former
invocation is past the use of any static variables possibly changed
during the first-two-token invocation of the latter invocation. */
#if FFESTA_ABORT_ON_CONFIRM_
/* Shouldn't be in ffesta_save_ at all here. */
next = (ffelexHandler) ffesta_first (first);
return (ffelexHandler) (*next) (second);
#else
ffesta_twotokens_1_ = ffelex_token_use (first);
ffesta_twotokens_2_ = ffelex_token_use (second);
ffesta_is_two_into_statement_ = TRUE;
return (ffelexHandler) ffesta_send_two_; /* Shouldn't get called. */
#endif
}
/* ffesta_zero -- Deal with the end of a swallowed statement
return ffesta_zero; // to lexer.
NOTICE that this code is COPIED, largely, into a
similar function named ffesta_two that gets invoked in place of
_zero_ when the end of the statement happens before EOS or SEMICOLON and
to tokens into the next statement have been read (as is the case with the
logical-IF and WHERE-stmt statements). So any changes made here should
probably be made in _two_ at the same time. */
ffelexHandler
ffesta_zero (ffelexToken t)
{
assert ((ffelex_token_type (t) == FFELEX_typeEOS)
|| (ffelex_token_type (t) == FFELEX_typeSEMICOLON));
assert (ffesta_tokens[0] != NULL);
if (ffesta_is_inhibited_)
ffesymbol_retract (TRUE);
else
ffestw_display_state ();
/* Do CONTINUE if nothing else. This is done specifically so that "IF
(...) BLAH" causes the same things to happen as if "IF (...) CONTINUE"
was done, so that tracking of labels and such works. (Try a small
program like "DO 10 ...", "IF (...) BLAH", "10 CONTINUE", "END".)
But it turns out that just testing "!ffesta_confirmed_current_"
isn't enough, because then typing "GOTO" instead of "BLAH" above
doesn't work -- the statement is confirmed (we know the user
attempted a GOTO) but ffestc hasn't seen it. So, instead, just
always tell ffestc to do "any" statement it needs to reset. */
if (!ffesta_is_inhibited_
&& ffesta_seen_first_exec)
{
ffestc_any ();
}
ffelex_token_kill (ffesta_tokens[0]);
if (ffesta_is_inhibited_) /* Oh, not really done with statement. */
return (ffelexHandler) ffesta_zero; /* Call me again when done! */
if (ffesta_output_pool != NULL)
{
if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
malloc_pool_kill (ffesta_output_pool);
ffesta_output_pool = NULL;
}
if (ffesta_scratch_pool != NULL)
{
malloc_pool_kill (ffesta_scratch_pool);
ffesta_scratch_pool = NULL;
}
ffesta_reset_possibles_ ();
ffesta_confirmed_current_ = FALSE;
if (ffelex_token_type (t) == FFELEX_typeSEMICOLON)
{
ffesta_line_has_semicolons = TRUE;
if (ffe_is_pedantic_not_90 ())
{
ffebad_start (FFEBAD_SEMICOLON);
ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
ffebad_finish ();
}
}
else
ffesta_line_has_semicolons = FALSE;
if (ffesta_label_token != NULL)
{
ffelex_token_kill (ffesta_label_token);
ffesta_label_token = NULL;
}
if (ffe_is_ffedebug ())
{
ffestorag_report ();
}
ffelex_set_names (TRUE);
return (ffelexHandler) ffesta_first;
}
Reference in New Issue View Git Blame Copy Permalink