#include "proj.h"
#include "symbol.h"
#include "bad.h"
#include "bld.h"
#include "com.h"
#include "equiv.h"
#include "global.h"
#include "info.h"
#include "intrin.h"
#include "lex.h"
#include "malloc.h"
#include "src.h"
#include "st.h"
#include "storag.h"
#include "target.h"
#include "where.h"
#define FFESYMBOL_globalPROGUNIT_ 1
#define FFESYMBOL_globalFILE_ 2
#define FFESYMBOL_globalCURRENT_ FFESYMBOL_globalPROGUNIT_
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalPROGUNIT_
#define FFESYMBOL_SPACE_POOL_ ffe_pool_program_unit()
#elif FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalFILE_
#define FFESYMBOL_SPACE_POOL_ ffe_pool_file()
#else
#error
#endif
enum _ffesymbol_retractcommand_
{
FFESYMBOL_retractcommandDELETE_,
FFESYMBOL_retractcommandRETRACT_,
FFESYMBOL_retractcommand_
};
typedef enum _ffesymbol_retractcommand_ ffesymbolRetractCommand_;
typedef struct _ffesymbol_retract_ *ffesymbolRetract_;
struct _ffesymbol_retract_
{
ffesymbolRetract_ next;
ffesymbolRetractCommand_ command;
ffesymbol live;
ffesymbol symbol;
};
static ffebad ffesymbol_check_token_ (ffelexToken t, char *c);
static void ffesymbol_kill_manifest_ (void);
static ffesymbol ffesymbol_new_ (ffename n);
static ffesymbol ffesymbol_unhook_ (ffesymbol s);
static void ffesymbol_whine_state_ (ffebad bad, ffelexToken t, char c);
static ffelexToken ffesymbol_token_blank_common_ = NULL;
static ffelexToken ffesymbol_token_unnamed_main_ = NULL;
static ffelexToken ffesymbol_token_unnamed_blockdata_ = NULL;
static ffenameSpace ffesymbol_global_ = NULL;
static ffenameSpace ffesymbol_local_ = NULL;
static ffenameSpace ffesymbol_sfunc_ = NULL;
static bool ffesymbol_retractable_ = FALSE;
static mallocPool ffesymbol_retract_pool_;
static ffesymbolRetract_ ffesymbol_retract_first_;
static ffesymbolRetract_ *ffesymbol_retract_list_;
static const char *const ffesymbol_state_name_[] =
{
"?",
"@",
"&",
"$",
};
static const char *const ffesymbol_attr_name_[] =
{
#define DEFATTR(ATTR,ATTRS,NAME) NAME,
#include "symbol.def"
#undef DEFATTR
};
static ffebad
ffesymbol_check_token_ (ffelexToken t, char *c)
{
char *p = ffelex_token_text (t);
ffeTokenLength len = ffelex_token_length (t);
ffebad bad;
ffeTokenLength i = 0;
ffebad skip_me = ((ffe_case_symbol () == FFE_caseINITCAP)
? FFEBAD_SYMBOL_NOLOWER_INITCAP : FFEBAD + 1);
ffebad stop_me = ((ffe_case_symbol () == FFE_caseINITCAP)
? FFEBAD : FFEBAD + 1);
if (len == 0)
return FFEBAD;
bad = ffesrc_bad_char_symbol_init (*p);
if (bad == FFEBAD)
{
for (++i, ++p; i < len; ++i, ++p)
{
bad = ffesrc_bad_char_symbol_noninit (*p);
if (bad == skip_me)
continue;
if (bad == stop_me)
break;
if (bad != FFEBAD)
break;
}
}
if (bad != FFEBAD)
{
if (i >= len)
*c = *(ffelex_token_text (t));
else
*c = *p;
}
return bad;
}
static void
ffesymbol_kill_manifest_ ()
{
if (ffesymbol_token_blank_common_ != NULL)
ffelex_token_kill (ffesymbol_token_blank_common_);
if (ffesymbol_token_unnamed_main_ != NULL)
ffelex_token_kill (ffesymbol_token_unnamed_main_);
if (ffesymbol_token_unnamed_blockdata_ != NULL)
ffelex_token_kill (ffesymbol_token_unnamed_blockdata_);
ffesymbol_token_blank_common_ = NULL;
ffesymbol_token_unnamed_main_ = NULL;
ffesymbol_token_unnamed_blockdata_ = NULL;
}
static ffesymbol
ffesymbol_new_ (ffename n)
{
ffesymbol s;
ffesymbolRetract_ r;
assert (n != NULL);
s = (ffesymbol) malloc_new_ks (FFESYMBOL_SPACE_POOL_, "FFESYMBOL",
sizeof (*s));
s->name = n;
s->other_space_name = NULL;
#if FFEGLOBAL_ENABLED
s->global = NULL;
#endif
s->attrs = FFESYMBOL_attrsetNONE;
s->state = FFESYMBOL_stateNONE;
s->info = ffeinfo_new_null ();
s->dims = NULL;
s->extents = NULL;
s->dim_syms = NULL;
s->array_size = NULL;
s->init = NULL;
s->accretion = NULL;
s->accretes = 0;
s->dummy_args = NULL;
s->namelist = NULL;
s->common_list = NULL;
s->sfunc_expr = NULL;
s->list_bottom = NULL;
s->common = NULL;
s->equiv = NULL;
s->storage = NULL;
#ifdef FFECOM_symbolHOOK
s->hook = FFECOM_symbolNULL;
#endif
s->sfa_dummy_parent = NULL;
s->func_result = NULL;
s->value = 0;
s->check_state = FFESYMBOL_checkstateNONE_;
s->check_token = NULL;
s->max_entry_num = 0;
s->num_entries = 0;
s->generic = FFEINTRIN_genNONE;
s->specific = FFEINTRIN_specNONE;
s->implementation = FFEINTRIN_impNONE;
s->is_save = FALSE;
s->is_init = FALSE;
s->do_iter = FALSE;
s->reported = FALSE;
s->explicit_where = FALSE;
s->namelisted = FALSE;
s->assigned = FALSE;
ffename_set_symbol (n, s);
if (!ffesymbol_retractable_)
{
s->have_old = FALSE;
return s;
}
r = (ffesymbolRetract_) malloc_new_kp (ffesymbol_retract_pool_,
"FFESYMBOL retract", sizeof (*r));
r->next = NULL;
r->command = FFESYMBOL_retractcommandDELETE_;
r->live = s;
r->symbol = NULL;
*ffesymbol_retract_list_ = r;
ffesymbol_retract_list_ = &r->next;
s->have_old = TRUE;
return s;
}
static ffesymbol
ffesymbol_unhook_ (ffesymbol s)
{
s->other_space_name = s->name = NULL;
if ((ffesymbol_attrs (s) & FFESYMBOL_attrsCBLOCK)
|| (ffesymbol_kind (s) == FFEINFO_kindNAMELIST))
ffebld_end_list (ffesymbol_ptr_to_listbottom (s));
if (s->check_state == FFESYMBOL_checkstatePENDING_)
ffelex_token_kill (s->check_token);
return s;
}
static void
ffesymbol_whine_state_ (ffebad bad, ffelexToken t, char c)
{
char badstr[2];
badstr[0] = c;
badstr[1] = '\0';
ffebad_start (bad);
ffebad_here (0, ffelex_token_where_line (t),
ffelex_token_where_column (t));
ffebad_string (badstr);
ffebad_finish ();
}
const char *
ffesymbol_attrs_string (ffesymbolAttrs attrs)
{
static char string[FFESYMBOL_attr * 12 + 20];
char *p;
ffesymbolAttr attr;
p = &string[0];
if (attrs == FFESYMBOL_attrsetNONE)
{
strcpy (p, "NONE");
return &string[0];
}
for (attr = 0; attr < FFESYMBOL_attr; ++attr)
{
if (attrs & ((ffesymbolAttrs) 1 << attr))
{
attrs &= ~((ffesymbolAttrs) 1 << attr);
strcpy (p, ffesymbol_attr_name_[attr]);
while (*p)
++p;
*(p++) = '|';
}
}
if (attrs == FFESYMBOL_attrsetNONE)
*--p = '\0';
else
sprintf (p, "?0x%" ffesymbolAttrs_f "x?", attrs);
assert (((size_t) (p - &string[0])) < ARRAY_SIZE (string));
return &string[0];
}
void
ffesymbol_check (ffesymbol s, ffelexToken t, bool maybe_intrin)
{
char c;
ffebad bad;
ffeintrinGen gen;
ffeintrinSpec spec;
ffeintrinImp imp;
if (!ffesrc_check_symbol ()
|| ((s->check_state != FFESYMBOL_checkstateNONE_)
&& ((s->check_state != FFESYMBOL_checkstateINHIBITED_)
|| ffebad_inhibit ())))
return;
bad = ffesymbol_check_token_ (t, &c);
if (bad == FFEBAD)
{
s->check_state = FFESYMBOL_checkstateCHECKED_;
return;
}
if (maybe_intrin
&& ffeintrin_is_intrinsic (ffelex_token_text (t), NULL, FALSE,
&gen, &spec, &imp))
{
s->check_state = FFESYMBOL_checkstatePENDING_;
s->check_token = ffelex_token_use (t);
return;
}
if (ffebad_inhibit ())
{
s->check_state = FFESYMBOL_checkstateINHIBITED_;
return;
}
s->check_state = FFESYMBOL_checkstateCHECKED_;
ffesymbol_whine_state_ (bad, t, c);
}
ffesymbol
ffesymbol_declare_blockdataunit (ffelexToken t, ffewhereLine wl,
ffewhereColumn wc)
{
ffename n;
ffesymbol s;
bool user = (t != NULL);
assert (!ffesymbol_retractable_);
if (t == NULL)
{
if (ffesymbol_token_unnamed_blockdata_ == NULL)
ffesymbol_token_unnamed_blockdata_
= ffelex_token_new_name (FFETARGET_nameUNNAMED_BLOCK_DATA, wl, wc);
t = ffesymbol_token_unnamed_blockdata_;
}
n = ffename_lookup (ffesymbol_local_, t);
if (n != NULL)
return ffename_symbol (n);
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
if (user)
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
if (user)
ffesymbol_check (s, t, FALSE);
n = ffename_find (ffesymbol_local_, t);
ffename_set_symbol (n, s);
s->other_space_name = n;
ffeglobal_new_blockdata (s, t);
return s;
}
ffesymbol
ffesymbol_declare_cblock (ffelexToken t, ffewhereLine wl, ffewhereColumn wc)
{
ffename n;
ffesymbol s;
bool blank;
assert (!ffesymbol_retractable_);
if (t == NULL)
{
blank = TRUE;
if (ffesymbol_token_blank_common_ == NULL)
ffesymbol_token_blank_common_
= ffelex_token_new_name (FFETARGET_nameBLANK_COMMON, wl, wc);
t = ffesymbol_token_blank_common_;
}
else
blank = FALSE;
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
if (!blank)
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
if (!blank)
ffesymbol_check (s, t, FALSE);
ffeglobal_new_common (s, t, blank);
return s;
}
ffesymbol
ffesymbol_declare_funcnotresunit (ffelexToken t)
{
ffename n;
ffesymbol s;
assert (t != NULL);
assert (!ffesymbol_retractable_);
n = ffename_lookup (ffesymbol_local_, t);
if (n != NULL)
return ffename_symbol (n);
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
ffesymbol_check (s, t, FALSE);
n = ffename_find (ffesymbol_local_, t);
ffename_set_symbol (n, s);
s->other_space_name = n;
ffeglobal_new_function (s, t);
return s;
}
ffesymbol
ffesymbol_declare_funcresult (ffelexToken t)
{
ffename n;
ffesymbol s;
assert (t != NULL);
assert (!ffesymbol_retractable_);
n = ffename_find (ffesymbol_local_, t);
s = ffename_symbol (n);
if (s != NULL)
return s;
return ffesymbol_new_ (n);
}
ffesymbol
ffesymbol_declare_funcunit (ffelexToken t)
{
ffename n;
ffesymbol s;
assert (t != NULL);
assert (!ffesymbol_retractable_);
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
ffesymbol_check (s, t, FALSE);
ffeglobal_new_function (s, t);
return s;
}
ffesymbol
ffesymbol_declare_local (ffelexToken t, bool maybe_intrin)
{
ffename n;
ffesymbol s;
assert (t != NULL);
if ((ffesymbol_sfunc_ != NULL)
&& ((n = ffename_lookup (ffesymbol_sfunc_, t)) != NULL))
return ffename_symbol (n);
n = ffename_find (ffesymbol_local_, t);
s = ffename_symbol (n);
if (s != NULL)
{
ffesymbol_check (s, t, maybe_intrin);
return s;
}
s = ffesymbol_new_ (n);
ffesymbol_check (s, t, maybe_intrin);
return s;
}
ffesymbol
ffesymbol_declare_programunit (ffelexToken t, ffewhereLine wl,
ffewhereColumn wc)
{
ffename n;
ffesymbol s;
bool user = (t != NULL);
assert (!ffesymbol_retractable_);
if (t == NULL)
{
if (ffesymbol_token_unnamed_main_ == NULL)
ffesymbol_token_unnamed_main_
= ffelex_token_new_name (FFETARGET_nameUNNAMED_MAIN, wl, wc);
t = ffesymbol_token_unnamed_main_;
}
n = ffename_lookup (ffesymbol_local_, t);
if (n != NULL)
return ffename_symbol (n);
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
if (user)
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
if (user)
ffesymbol_check (s, t, FALSE);
n = ffename_find (ffesymbol_local_, t);
ffename_set_symbol (n, s);
s->other_space_name = n;
ffeglobal_new_program (s, t);
return s;
}
ffesymbol
ffesymbol_declare_sfdummy (ffelexToken t)
{
ffename n;
ffesymbol s;
ffesymbol sp;
assert (t != NULL);
n = ffename_find (ffesymbol_local_, t);
sp = ffename_symbol (n);
if (sp == NULL)
sp = ffesymbol_new_ (n);
ffesymbol_check (sp, t, FALSE);
n = ffename_find (ffesymbol_sfunc_, t);
s = ffename_symbol (n);
if (s == NULL)
{
s = ffesymbol_new_ (n);
s->sfa_dummy_parent = sp;
}
else
assert (s->sfa_dummy_parent == sp);
return s;
}
ffesymbol
ffesymbol_declare_subrunit (ffelexToken t)
{
ffename n;
ffesymbol s;
assert (!ffesymbol_retractable_);
assert (t != NULL);
n = ffename_lookup (ffesymbol_local_, t);
if (n != NULL)
return ffename_symbol (n);
n = ffename_find (ffesymbol_global_, t);
s = ffename_symbol (n);
if (s != NULL)
{
ffesymbol_check (s, t, FALSE);
return s;
}
s = ffesymbol_new_ (n);
ffesymbol_check (s, t, FALSE);
n = ffename_find (ffesymbol_local_, t);
ffename_set_symbol (n, s);
s->other_space_name = n;
ffeglobal_new_subroutine (s, t);
return s;
}
void
ffesymbol_drive (ffesymbol (*fn) (ffesymbol))
{
assert (ffesymbol_sfunc_ == NULL);
ffename_space_drive_symbol (ffesymbol_local_, fn);
ffename_space_drive_symbol (ffesymbol_global_, fn);
}
void
ffesymbol_drive_sfnames (ffesymbol (*fn) (ffesymbol))
{
ffename_space_drive_symbol (ffesymbol_sfunc_, fn);
}
void
ffesymbol_error (ffesymbol s, ffelexToken t)
{
if ((t != NULL)
&& ffest_ffebad_start (FFEBAD_SYMERR))
{
ffebad_string (ffesymbol_text (s));
ffebad_here (0, ffelex_token_where_line (t),
ffelex_token_where_column (t));
ffebad_here (1, ffesymbol_where_line (s), ffesymbol_where_column (s));
ffebad_finish ();
}
if (ffesymbol_attr (s, FFESYMBOL_attrANY))
return;
ffesymbol_signal_change (s);
if ((ffesymbol_attrs (s) & FFESYMBOL_attrsCBLOCK)
|| (ffesymbol_kind (s) == FFEINFO_kindNAMELIST))
ffebld_end_list (ffesymbol_ptr_to_listbottom (s));
ffesymbol_set_attr (s, FFESYMBOL_attrANY);
ffesymbol_set_info (s, ffeinfo_new_any ());
ffesymbol_set_state (s, FFESYMBOL_stateUNDERSTOOD);
if (s->check_state == FFESYMBOL_checkstatePENDING_)
ffelex_token_kill (s->check_token);
s->check_state = FFESYMBOL_checkstateCHECKED_;
s = ffecom_sym_learned (s);
ffesymbol_signal_unreported (s);
}
void
ffesymbol_init_0 ()
{
ffesymbolAttrs attrs = FFESYMBOL_attrsetNONE;
assert (FFESYMBOL_state == ARRAY_SIZE (ffesymbol_state_name_));
assert (FFESYMBOL_attr == ARRAY_SIZE (ffesymbol_attr_name_));
assert (attrs == FFESYMBOL_attrsetNONE);
attrs = ((ffesymbolAttrs) 1 << FFESYMBOL_attr);
assert (attrs != 0);
}
void
ffesymbol_init_1 ()
{
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalFILE_
ffesymbol_global_ = ffename_space_new (ffe_pool_file ());
#endif
}
void
ffesymbol_init_2 ()
{
}
void
ffesymbol_init_3 ()
{
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalPROGUNIT_
ffesymbol_global_ = ffename_space_new (ffe_pool_program_unit ());
#endif
ffesymbol_local_ = ffename_space_new (ffe_pool_program_unit ());
}
void
ffesymbol_init_4 ()
{
ffesymbol_sfunc_ = ffename_space_new (ffe_pool_program_unit ());
}
ffesymbol
ffesymbol_lookup_local (ffelexToken t)
{
ffename n;
ffesymbol s;
assert (t != NULL);
n = ffename_lookup (ffesymbol_local_, t);
if (n == NULL)
return NULL;
s = ffename_symbol (n);
return s;
}
void
ffesymbol_reference (ffesymbol s, ffelexToken t, bool explicit)
{
ffename gn;
ffesymbol gs = NULL;
ffeinfoKind kind;
ffeinfoWhere where;
bool okay;
if (ffesymbol_retractable_)
return;
if (t == NULL)
t = ffename_token (s->name);
kind = ffesymbol_kind (s);
where = ffesymbol_where (s);
if (where == FFEINFO_whereINTRINSIC)
{
ffeglobal_ref_intrinsic (s, t,
explicit
|| s->explicit_where
|| ffeintrin_is_standard (s->generic, s->specific));
return;
}
if ((where != FFEINFO_whereGLOBAL)
&& ((where != FFEINFO_whereLOCAL)
|| ((kind != FFEINFO_kindFUNCTION)
&& (kind != FFEINFO_kindSUBROUTINE))))
return;
gn = ffename_lookup (ffesymbol_global_, t);
if (gn != NULL)
gs = ffename_symbol (gn);
if ((gs != NULL) && (gs != s))
{
ffesymbol_error (gs, t);
ffesymbol_error (s, NULL);
return;
}
switch (kind)
{
case FFEINFO_kindBLOCKDATA:
okay = ffeglobal_ref_blockdata (s, t);
break;
case FFEINFO_kindSUBROUTINE:
okay = ffeglobal_ref_subroutine (s, t);
break;
case FFEINFO_kindFUNCTION:
okay = ffeglobal_ref_function (s, t);
break;
case FFEINFO_kindNONE:
okay = ffeglobal_ref_external (s, t);
break;
default:
assert ("bad kind in global ref" == NULL);
return;
}
if (! okay)
ffesymbol_error (s, NULL);
}
void
ffesymbol_resolve_intrin (ffesymbol s)
{
char c;
ffebad bad;
if (!ffesrc_check_symbol ())
return;
if (s->check_state != FFESYMBOL_checkstatePENDING_)
return;
if (ffebad_inhibit ())
return;
if (ffesymbol_where (s) != FFEINFO_whereINTRINSIC)
{
bad = ffesymbol_check_token_ (s->check_token, &c);
assert (bad != FFEBAD);
ffesymbol_whine_state_ (bad, s->check_token, c);
}
s->check_state = FFESYMBOL_checkstateCHECKED_;
ffelex_token_kill (s->check_token);
}
void
ffesymbol_retract (bool retract)
{
ffesymbolRetract_ r;
ffename name;
ffename other_space_name;
ffesymbol ls;
ffesymbol os;
assert (ffesymbol_retractable_);
ffesymbol_retractable_ = FALSE;
for (r = ffesymbol_retract_first_; r != NULL; r = r->next)
{
ls = r->live;
os = r->symbol;
switch (r->command)
{
case FFESYMBOL_retractcommandDELETE_:
if (retract)
{
ffecom_sym_retract (ls);
name = ls->name;
other_space_name = ls->other_space_name;
ffesymbol_unhook_ (ls);
malloc_kill_ks (FFESYMBOL_SPACE_POOL_, ls, sizeof (*ls));
if (name != NULL)
ffename_set_symbol (name, NULL);
if (other_space_name != NULL)
ffename_set_symbol (other_space_name, NULL);
}
else
{
ffecom_sym_commit (ls);
ls->have_old = FALSE;
}
break;
case FFESYMBOL_retractcommandRETRACT_:
if (retract)
{
ffecom_sym_retract (ls);
ffesymbol_unhook_ (ls);
*ls = *os;
malloc_kill_ks (FFESYMBOL_SPACE_POOL_, os, sizeof (*os));
}
else
{
ffecom_sym_commit (ls);
ffesymbol_unhook_ (os);
malloc_kill_ks (FFESYMBOL_SPACE_POOL_, os, sizeof (*os));
ls->have_old = FALSE;
}
break;
default:
assert ("bad command" == NULL);
break;
}
}
}
bool
ffesymbol_retractable ()
{
return ffesymbol_retractable_;
}
void
ffesymbol_set_retractable (mallocPool pool)
{
assert (!ffesymbol_retractable_);
ffesymbol_retractable_ = TRUE;
ffesymbol_retract_pool_ = pool;
ffesymbol_retract_list_ = &ffesymbol_retract_first_;
ffesymbol_retract_first_ = NULL;
}
void
ffesymbol_signal_change (ffesymbol s)
{
ffesymbolRetract_ r;
ffesymbol sym;
if (!ffesymbol_retractable_ || s->have_old)
return;
r = (ffesymbolRetract_) malloc_new_kp (ffesymbol_retract_pool_,
"FFESYMBOL retract", sizeof (*r));
r->next = NULL;
r->command = FFESYMBOL_retractcommandRETRACT_;
r->live = s;
r->symbol = sym = (ffesymbol) malloc_new_ks (FFESYMBOL_SPACE_POOL_,
"FFESYMBOL", sizeof (*sym));
*sym = *s;
sym->info = ffeinfo_use (s->info);
if (s->check_state == FFESYMBOL_checkstatePENDING_)
sym->check_token = ffelex_token_use (s->check_token);
*ffesymbol_retract_list_ = r;
ffesymbol_retract_list_ = &r->next;
s->have_old = TRUE;
}
const char *
ffesymbol_state_string (ffesymbolState state)
{
if (state >= ARRAY_SIZE (ffesymbol_state_name_))
return "?\?\?";
return ffesymbol_state_name_[state];
}
void
ffesymbol_terminate_0 ()
{
}
void
ffesymbol_terminate_1 ()
{
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalFILE_
ffename_space_drive_symbol (ffesymbol_global_, ffesymbol_unhook_);
ffename_space_kill (ffesymbol_global_);
ffesymbol_global_ = NULL;
ffesymbol_kill_manifest_ ();
#endif
}
void
ffesymbol_terminate_2 ()
{
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalPROGUNIT_
ffesymbol_kill_manifest_ ();
#endif
}
void
ffesymbol_terminate_3 ()
{
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalPROGUNIT_
ffename_space_drive_symbol (ffesymbol_global_, ffesymbol_unhook_);
ffename_space_kill (ffesymbol_global_);
#endif
ffename_space_drive_symbol (ffesymbol_local_, ffesymbol_unhook_);
ffename_space_kill (ffesymbol_local_);
#if FFESYMBOL_globalCURRENT_ == FFESYMBOL_globalPROGUNIT_
ffesymbol_global_ = NULL;
#endif
ffesymbol_local_ = NULL;
}
void
ffesymbol_terminate_4 ()
{
ffename_space_drive_symbol (ffesymbol_sfunc_, ffesymbol_unhook_);
ffename_space_kill (ffesymbol_sfunc_);
ffesymbol_sfunc_ = NULL;
}
void
ffesymbol_update_init (ffesymbol s)
{
ffebld item;
if (s->is_init)
return;
s->is_init = TRUE;
if ((s->equiv != NULL)
&& !ffeequiv_is_init (s->equiv))
ffeequiv_update_init (s->equiv);
if ((s->storage != NULL)
&& !ffestorag_is_init (s->storage))
ffestorag_update_init (s->storage);
if ((s->common != NULL)
&& (!ffesymbol_is_init (s->common)))
ffesymbol_update_init (s->common);
for (item = s->common_list; item != NULL; item = ffebld_trail (item))
{
if (!ffesymbol_is_init (ffebld_symter (ffebld_head (item))))
ffesymbol_update_init (ffebld_symter (ffebld_head (item)));
}
}
void
ffesymbol_update_save (ffesymbol s)
{
ffebld item;
if (s->is_save)
return;
s->is_save = TRUE;
if ((s->equiv != NULL)
&& !ffeequiv_is_save (s->equiv))
ffeequiv_update_save (s->equiv);
if ((s->storage != NULL)
&& !ffestorag_is_save (s->storage))
ffestorag_update_save (s->storage);
if ((s->common != NULL)
&& (!ffesymbol_is_save (s->common)))
ffesymbol_update_save (s->common);
for (item = s->common_list; item != NULL; item = ffebld_trail (item))
{
if (!ffesymbol_is_save (ffebld_symter (ffebld_head (item))))
ffesymbol_update_save (ffebld_symter (ffebld_head (item)));
}
}