#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"
ffelexToken ffesta_tokens[FFESTA_tokensMAX];
ffestrFirst ffesta_first_kw;
ffestrSecond ffesta_second_kw;
mallocPool ffesta_output_pool;
mallocPool ffesta_scratch_pool;
ffelexToken ffesta_construct_name;
ffelexToken ffesta_label_token;
bool ffesta_seen_first_exec;
bool ffesta_is_entry_valid = FALSE;
bool ffesta_line_has_semicolons = FALSE;
#define FFESTA_ABORT_ON_CONFIRM_ 1
#define FFESTA_maxPOSSIBLES_ 8
typedef struct _ffesta_possible_ *ffestaPossible_;
struct _ffesta_possible_
{
ffestaPossible_ next;
ffestaPossible_ previous;
ffelexHandler handler;
bool named;
};
struct _ffesta_possible_root_
{
ffestaPossible_ first;
ffestaPossible_ last;
ffelexHandler nil;
};
static bool ffesta_is_inhibited_ = FALSE;
static ffelexToken ffesta_token_0_;
static ffestaPossible_ ffesta_possibles_[FFESTA_maxPOSSIBLES_];
static int ffesta_num_possibles_ = 0;
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;
static ffelexToken ffesta_twotokens_1_;
static ffelexToken ffesta_twotokens_2_;
#endif
static ffestaPooldisp ffesta_outpooldisp_;
static bool ffesta_inhibit_confirmation_ = FALSE;
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
#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))
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;
}
static bool
ffesta_inhibited_exec_transition_ ()
{
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;
}
static void
ffesta_reset_possibles_ ()
{
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;
}
static ffelexHandler
ffesta_save_ (ffelexToken t)
{
static ffelexToken *saved_tokens = NULL;
static unsigned int num_saved_tokens = 0;
static unsigned int max_saved_tokens = 0;
unsigned int toknum;
ffelexToken eos;
ffelexToken t2;
if (saved_tokens == NULL)
{
saved_tokens
= (ffelexToken *) malloc_new_ksr (malloc_pool_image (),
"FFEST Saved Tokens",
(max_saved_tokens = 8) * sizeof (ffelexToken));
}
else if (num_saved_tokens >= max_saved_tokens)
{
toknum = max_saved_tokens;
max_saved_tokens <<= 1;
assert (max_saved_tokens > toknum);
saved_tokens
= (ffelexToken *) 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);
ffesta_current_handler_ = (ffelexHandler) (*ffesta_current_handler_) (t);
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
{
switch (ffelex_token_type (t))
{
case FFELEX_typeEOS:
case FFELEX_typeSEMICOLON:
break;
default:
return (ffelexHandler) ffesta_save_;
}
}
next_handler:
if (ffesta_current_shutdown_)
ffesta_current_shutdown_ = FALSE;
else
assert (ffesta_confirmed_current_);
if (ffesta_confirmed_current_)
{
ffesta_confirmed_current_ = FALSE;
ffesta_confirmed_other_ = TRUE;
}
ffesta_current_possible_ = ffesta_current_possible_->next;
ffesta_current_handler_ = ffesta_current_possible_->handler;
if (ffesta_current_handler_ == NULL)
{
if (ffesta_current_possible_
== (ffestaPossible_) &ffesta_possible_nonexecs_)
{
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_ ())))
{
ffebad_set_inhibit (FALSE);
ffesta_is_inhibited_ = FALSE;
ffesta_confirmed_other_ = FALSE;
ffesta_tokens[0] = ffesta_token_0_;
if (ffesta_confirmed_possible_ == NULL)
{
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_)
{
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
{
ffesta_current_possible_ = ffesta_confirmed_possible_;
ffesta_current_handler_ = ffesta_confirmed_possible_->handler;
}
ffesta_reset_possibles_ ();
}
else
{
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);
}
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);
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;
}
}
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_);
#endif
return (ffelexHandler) ffesta_save_;
}
}
num_saved_tokens = 0;
#if !FFESTA_ABORT_ON_CONFIRM_
if (ffesta_is_two_into_statement_)
{
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_;
}
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);
switch (ffesta_first_kw)
{
#if FFESTR_VXT
case FFESTR_firstACCEPT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V019);
break;
#endif
#if FFESTR_F90
case FFESTR_firstALLOCATABLE:
ffestb_args.dimlist.len = FFESTR_firstlALLOCATABLE;
ffestb_args.dimlist.badname = "ALLOCATABLE";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
break;
#endif
#if FFESTR_F90
case FFESTR_firstALLOCATE:
ffestb_args.heap.len = FFESTR_firstlALLOCATE;
ffestb_args.heap.badname = "ALLOCATE";
ffestb_args.heap.ctx = FFEEXPR_contextALLOCATE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_heap);
break;
#endif
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;
#if FFESTR_F90
case FFESTR_firstCONTAINS:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1228);
break;
#endif
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;
#if FFESTR_F90
case FFESTR_firstDEALLOCATE:
ffestb_args.heap.len = FFESTR_firstlDEALLOCATE;
ffestb_args.heap.badname = "DEALLOCATE";
ffestb_args.heap.ctx = FFEEXPR_contextDEALLOCATE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_heap);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstDECODE:
ffestb_args.vxtcode.len = FFESTR_firstlDECODE;
ffestb_args.vxtcode.badname = "DECODE";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_vxtcode);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstDEFINEFILE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V025);
break;
case FFESTR_firstDELETE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V021);
break;
#endif
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;
#if FFESTR_F90
case FFESTR_firstELSEWHERE:
ffestb_args.elsexyz.second = FFESTR_secondWHERE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_elsexyz);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstENCODE:
ffestb_args.vxtcode.len = FFESTR_firstlENCODE;
ffestb_args.vxtcode.badname = "ENCODE";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_vxtcode);
break;
#endif
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:
#if FFESTR_F90
case FFESTR_secondMODULE:
#endif
case FFESTR_secondPROGRAM:
case FFESTR_secondSELECT:
case FFESTR_secondSUBROUTINE:
#if FFESTR_F90
case FFESTR_secondWHERE:
#endif
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;
#if FFESTR_F90
case FFESTR_firstENDINTERFACE:
ffestb_args.endxyz.len = FFESTR_firstlENDINTERFACE;
ffestb_args.endxyz.second = FFESTR_secondINTERFACE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstENDMAP:
ffestb_args.endxyz.len = FFESTR_firstlENDMAP;
ffestb_args.endxyz.second = FFESTR_secondMAP;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
#if FFESTR_F90
case FFESTR_firstENDMODULE:
ffestb_args.endxyz.len = FFESTR_firstlENDMODULE;
ffestb_args.endxyz.second = FFESTR_secondMODULE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
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;
#if FFESTR_VXT
case FFESTR_firstENDSTRUCTURE:
ffestb_args.endxyz.len = FFESTR_firstlENDSTRUCTURE;
ffestb_args.endxyz.second = FFESTR_secondSTRUCTURE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
case FFESTR_firstENDSUBROUTINE:
ffestb_args.endxyz.len = FFESTR_firstlENDSUBROUTINE;
ffestb_args.endxyz.second = FFESTR_secondSUBROUTINE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
#if FFESTR_F90
case FFESTR_firstENDTYPE:
ffestb_args.endxyz.len = FFESTR_firstlENDTYPE;
ffestb_args.endxyz.second = FFESTR_secondTYPE;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstENDUNION:
ffestb_args.endxyz.len = FFESTR_firstlENDUNION;
ffestb_args.endxyz.second = FFESTR_secondUNION;
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
#if FFESTR_F90
case FFESTR_firstENDWHERE:
ffestb_args.endxyz.len = FFESTR_firstlENDWHERE;
ffestb_args.endxyz.second = FFESTR_secondWHERE;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
break;
#endif
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;
#if FFESTR_VXT
case FFESTR_firstFIND:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V026);
break;
#endif
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_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;
#if FFESTR_F90
case FFESTR_firstINTENT:
ffestb_args.varlist.len = FFESTR_firstlINTENT;
ffestb_args.varlist.badname = "INTENT";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
#endif
#if FFESTR_F90
case FFESTR_firstINTERFACE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1202);
break;
#endif
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;
#if FFESTR_VXT
case FFESTR_firstMAP:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V012);
break;
#endif
#if FFESTR_F90
case FFESTR_firstMODULE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_module);
break;
#endif
case FFESTR_firstNAMELIST:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R542);
break;
#if FFESTR_F90
case FFESTR_firstNULLIFY:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R624);
break;
#endif
case FFESTR_firstOPEN:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R904);
break;
#if FFESTR_F90
case FFESTR_firstOPTIONAL:
ffestb_args.varlist.len = FFESTR_firstlOPTIONAL;
ffestb_args.varlist.badname = "OPTIONAL";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
#endif
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;
#if FFESTR_F90
case FFESTR_firstPOINTER:
ffestb_args.dimlist.len = FFESTR_firstlPOINTER;
ffestb_args.dimlist.badname = "POINTER";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
break;
#endif
case FFESTR_firstPRINT:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R911);
break;
#if HARD_F90
case FFESTR_firstPRIVATE:
ffestb_args.varlist.len = FFESTR_firstlPRIVATE;
ffestb_args.varlist.badname = "ACCESS";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
#endif
case FFESTR_firstPROGRAM:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1102);
break;
#if HARD_F90
case FFESTR_firstPUBLIC:
ffestb_args.varlist.len = FFESTR_firstlPUBLIC;
ffestb_args.varlist.badname = "ACCESS";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
break;
#endif
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;
#if FFESTR_VXT
case FFESTR_firstRECORD:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V016);
break;
#endif
#if FFESTR_F90
case FFESTR_firstRECURSIVE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_recursive);
break;
#endif
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;
#if FFESTR_VXT
case FFESTR_firstREWRITE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V018);
break;
#endif
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;
#if HARD_F90
case FFESTR_firstSEQUENCE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R423B);
break;
#endif
case FFESTR_firstSTOP:
ffestb_args.halt.len = FFESTR_firstlSTOP;
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_halt);
break;
#if FFESTR_VXT
case FFESTR_firstSTRUCTURE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V003);
break;
#endif
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;
#if FFESTR_F90
case FFESTR_firstTARGET:
ffestb_args.dimlist.len = FFESTR_firstlTARGET;
ffestb_args.dimlist.badname = "TARGET";
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
break;
#endif
case FFESTR_firstTYPE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V020);
break;
#if FFESTR_F90
case FFESTR_firstTYPE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_type);
break;
#endif
#if HARD_F90
case FFESTR_firstTYPE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_typetype);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstUNLOCK:
ffestb_args.beru.len = FFESTR_firstlUNLOCK;
ffestb_args.beru.badname = "UNLOCK";
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
break;
#endif
#if FFESTR_VXT
case FFESTR_firstUNION:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V009);
break;
#endif
#if FFESTR_F90
case FFESTR_firstUSE:
ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1107);
break;
#endif
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;
#if HARD_F90
case FFESTR_firstWHERE:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_where);
break;
#endif
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;
}
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)
{
ffesta_add_possible_unnamed_nonexec_ ((ffelexHandler) ffestb_R1229);
if (ffeimplic_peek_symbol_type (s,
ffelex_token_text (ffesta_token_0_))
== FFEINFO_basictypeCHARACTER)
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
}
else
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
break;
#if FFESTR_F90
case FFELEX_typePERCENT:
#endif
case FFELEX_typeEQUALS:
#if FFESTR_F90
case FFELEX_typePOINTS:
#endif
ffesta_add_possible_unnamed_exec_ ((ffelexHandler) ffestb_let);
break;
case FFELEX_typeCOLON:
ffesta_add_possible_exec_ ((ffelexHandler) ffestb_construct);
break;
default:
;
}
switch (ffesta_num_possibles_)
{
case 0:
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:
ffesta_tokens[0] = ffesta_token_0_;
next = ffesta_possible_execs_.first->handler;
if (next == NULL)
{
next = ffesta_possible_nonexecs_.first->handler;
assert (next != NULL);
}
else if (ffesta_seen_first_exec)
;
else if (!ffestc_exec_transition ())
goto no_stmts;
break;
default:
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)
{
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);
return (ffelexHandler) (*next) (t);
}
#if !FFESTA_ABORT_ON_CONFIRM_
static ffelexHandler
ffesta_send_two_ (ffelexToken t)
{
assert ("what am I doing here?" == NULL);
return NULL;
}
#endif
void
ffesta_confirmed ()
{
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_;
}
void
ffesta_eof ()
{
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 ();
}
}
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]));
}
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;
}
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:
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);
}
}
void
ffesta_init_0 ()
{
ffestaPossible_ ptr;
int i;
ptr = (ffestaPossible_) 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;
}
void
ffesta_init_3 ()
{
ffesta_output_pool = NULL;
ffesta_scratch_pool = NULL;
ffesta_construct_name = NULL;
ffesta_label_token = NULL;
ffesta_seen_first_exec = FALSE;
}
bool
ffesta_is_inhibited ()
{
assert (ffesta_confirmed_current_ || ffesta_inhibit_confirmation_);
return ffesta_is_inhibited_;
}
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 ();
}
}
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 ();
}
}
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 ()
{
return ffesta_outpooldisp_;
}
void
ffesta_set_outpooldisp (ffestaPooldisp d)
{
ffesta_outpooldisp_ = d;
}
void
ffesta_shutdown ()
{
if (ffesta_is_inhibited_)
ffesta_current_shutdown_ = TRUE;
}
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_)
{
ffesta_current_shutdown_ = TRUE;
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;
#if FFESTA_ABORT_ON_CONFIRM_
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_;
#endif
}
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 ();
if (!ffesta_is_inhibited_
&& ffesta_seen_first_exec)
{
ffestc_any ();
}
ffelex_token_kill (ffesta_tokens[0]);
if (ffesta_is_inhibited_)
return (ffelexHandler) ffesta_zero;
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;
}