995 lines
23 KiB
C
995 lines
23 KiB
C
/* top.c -- Implementation File (module.c template V1.0)
|
||
Copyright (C) 1995, 1996, 1997, 1999, 2001, 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:
|
||
The GNU Fortran Front End.
|
||
|
||
Modifications:
|
||
*/
|
||
|
||
/* Include files. */
|
||
|
||
#include "proj.h"
|
||
#include "top.h"
|
||
#include "bad.h"
|
||
#include "bit.h"
|
||
#include "bld.h"
|
||
#include "com.h"
|
||
#include "data.h"
|
||
#include "equiv.h"
|
||
#include "expr.h"
|
||
#include "global.h"
|
||
#include "implic.h"
|
||
#include "info.h"
|
||
#include "intrin.h"
|
||
#include "lab.h"
|
||
#include "lex.h"
|
||
#include "malloc.h"
|
||
#include "name.h"
|
||
#include "options.h"
|
||
#include "opts.h"
|
||
#include "src.h"
|
||
#include "st.h"
|
||
#include "storag.h"
|
||
#include "symbol.h"
|
||
#include "target.h"
|
||
#include "where.h"
|
||
#include "flags.h"
|
||
#include "toplev.h"
|
||
|
||
/* Externals defined here. */
|
||
|
||
bool ffe_is_do_internal_checks_ = FALSE;
|
||
bool ffe_is_90_ = FFETARGET_defaultIS_90;
|
||
bool ffe_is_automatic_ = FFETARGET_defaultIS_AUTOMATIC;
|
||
bool ffe_is_backslash_ = FFETARGET_defaultIS_BACKSLASH;
|
||
bool ffe_is_emulate_complex_ = FALSE;
|
||
bool ffe_is_underscoring_ = FFETARGET_defaultEXTERNAL_UNDERSCORED
|
||
|| FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED;
|
||
bool ffe_is_second_underscore_ = FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED;
|
||
bool ffe_is_debug_kludge_ = FALSE;
|
||
bool ffe_is_dollar_ok_ = FFETARGET_defaultIS_DOLLAR_OK;
|
||
bool ffe_is_f2c_ = FFETARGET_defaultIS_F2C;
|
||
bool ffe_is_f2c_library_ = FFETARGET_defaultIS_F2C_LIBRARY;
|
||
bool ffe_is_ffedebug_ = FALSE;
|
||
bool ffe_is_flatten_arrays_ = FALSE;
|
||
bool ffe_is_free_form_ = FFETARGET_defaultIS_FREE_FORM;
|
||
bool ffe_is_globals_ = TRUE;
|
||
bool ffe_is_init_local_zero_ = FFETARGET_defaultIS_INIT_LOCAL_ZERO;
|
||
bool ffe_is_mainprog_; /* TRUE if current prog unit known to be
|
||
main. */
|
||
bool ffe_is_onetrip_ = FALSE;
|
||
bool ffe_is_silent_ = TRUE;
|
||
bool ffe_is_typeless_boz_ = FALSE;
|
||
bool ffe_is_pedantic_ = FFETARGET_defaultIS_PEDANTIC;
|
||
bool ffe_is_saveall_; /* TRUE if mainprog or SAVE (no args) seen. */
|
||
bool ffe_is_ugly_args_ = TRUE;
|
||
bool ffe_is_ugly_assign_ = FALSE; /* Try and store pointer to ASSIGN labels in INTEGER vars. */
|
||
bool ffe_is_ugly_assumed_ = FALSE; /* DIMENSION X([...,]1) => DIMENSION X([...,]*) */
|
||
bool ffe_is_ugly_comma_ = FALSE;
|
||
bool ffe_is_ugly_complex_ = FALSE;
|
||
bool ffe_is_ugly_init_ = TRUE;
|
||
bool ffe_is_ugly_logint_ = FALSE;
|
||
bool ffe_is_version_ = FALSE;
|
||
bool ffe_is_vxt_ = FALSE;
|
||
bool ffe_is_warn_globals_ = TRUE;
|
||
bool ffe_is_warn_implicit_ = FALSE;
|
||
bool ffe_is_warn_surprising_ = FALSE;
|
||
bool ffe_is_zeros_ = FALSE;
|
||
ffeCase ffe_case_intrin_ = FFETARGET_defaultCASE_INTRIN;
|
||
ffeCase ffe_case_match_ = FFETARGET_defaultCASE_MATCH;
|
||
ffeCase ffe_case_source_ = FFETARGET_defaultCASE_SOURCE;
|
||
ffeCase ffe_case_symbol_ = FFETARGET_defaultCASE_SYMBOL;
|
||
ffeIntrinsicState ffe_intrinsic_state_badu77_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_gnu_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_f2c_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_f90_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_mil_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_unix_ = FFE_intrinsicstateENABLED;
|
||
ffeIntrinsicState ffe_intrinsic_state_vxt_ = FFE_intrinsicstateENABLED;
|
||
int ffe_fixed_line_length_ = FFETARGET_defaultFIXED_LINE_LENGTH;
|
||
mallocPool ffe_file_pool_ = NULL;
|
||
mallocPool ffe_any_unit_pool_ = NULL;
|
||
mallocPool ffe_program_unit_pool_ = NULL;
|
||
ffeCounter ffe_count_0 = 0;
|
||
ffeCounter ffe_count_1 = 0;
|
||
ffeCounter ffe_count_2 = 0;
|
||
ffeCounter ffe_count_3 = 0;
|
||
ffeCounter ffe_count_4 = 0;
|
||
bool ffe_in_0 = FALSE;
|
||
bool ffe_in_1 = FALSE;
|
||
bool ffe_in_2 = FALSE;
|
||
bool ffe_in_3 = FALSE;
|
||
bool ffe_in_4 = FALSE;
|
||
|
||
/* Simple definitions and enumerations. */
|
||
|
||
|
||
/* Internal typedefs. */
|
||
|
||
|
||
/* Private include files. */
|
||
|
||
|
||
/* Internal structure definitions. */
|
||
|
||
|
||
/* Static objects accessed by functions in this module. */
|
||
|
||
|
||
/* Static functions (internal). */
|
||
|
||
static bool ffe_is_digit_string_ (const char *s);
|
||
|
||
/* Internal macros. */
|
||
|
||
static bool
|
||
ffe_is_digit_string_ (const char *s)
|
||
{
|
||
const char *p;
|
||
|
||
for (p = s; ISDIGIT (*p); ++p)
|
||
;
|
||
|
||
return (p != s) && (*p == '\0');
|
||
}
|
||
|
||
/* Get ready for options handling. */
|
||
unsigned int
|
||
ffe_init_options (unsigned int argc ATTRIBUTE_UNUSED,
|
||
const char **argv ATTRIBUTE_UNUSED)
|
||
{
|
||
/* Set default options for Fortran. */
|
||
flag_move_all_movables = 1;
|
||
flag_reduce_all_givs = 1;
|
||
flag_argument_noalias = 2;
|
||
flag_merge_constants = 2;
|
||
flag_errno_math = 0;
|
||
flag_complex_divide_method = 1;
|
||
|
||
return CL_F77;
|
||
}
|
||
|
||
/* Handle command-line options. Returns 0 if unrecognized, 1 if
|
||
recognized and handled. */
|
||
int
|
||
ffe_handle_option (size_t scode, const char *arg, int value)
|
||
{
|
||
enum opt_code code = (enum opt_code) scode;
|
||
|
||
switch (code)
|
||
{
|
||
default:
|
||
abort();
|
||
|
||
case OPT_fversion:
|
||
ffe_set_is_version (TRUE);
|
||
ffe_set_is_do_internal_checks (TRUE);
|
||
break;
|
||
|
||
case OPT_ff66:
|
||
ffe_set_is_onetrip (value);
|
||
ffe_set_is_ugly_assumed (value);
|
||
break;
|
||
|
||
case OPT_ff77:
|
||
ffe_set_is_backslash (value);
|
||
if (value)
|
||
ffe_set_is_typeless_boz (FALSE);
|
||
break;
|
||
|
||
case OPT_ff90:
|
||
ffe_set_is_90 (value);
|
||
break;
|
||
|
||
case OPT_fautomatic:
|
||
ffe_set_is_automatic (value);
|
||
break;
|
||
|
||
case OPT_fdollar_ok:
|
||
ffe_set_is_dollar_ok (value);
|
||
break;
|
||
|
||
case OPT_ff2c:
|
||
ffe_set_is_f2c (value);
|
||
break;
|
||
|
||
case OPT_ff2c_library:
|
||
ffe_set_is_f2c_library (value);
|
||
break;
|
||
|
||
case OPT_fflatten_arrays:
|
||
ffe_set_is_f2c_library (value);
|
||
break;
|
||
|
||
case OPT_ffree_form:
|
||
ffe_set_is_free_form (value);
|
||
break;
|
||
|
||
case OPT_ffixed_form:
|
||
ffe_set_is_free_form (!value);
|
||
break;
|
||
|
||
case OPT_fpedantic:
|
||
ffe_set_is_pedantic (value);
|
||
break;
|
||
|
||
case OPT_fvxt:
|
||
ffe_set_is_vxt (value);
|
||
break;
|
||
|
||
case OPT_fvxt_not_f90:
|
||
warning ("-fvxt-not-f90 no longer supported -- try -fvxt");
|
||
break;
|
||
|
||
case OPT_ff90_not_vxt:
|
||
warning ("-ff90-not-vxt no longer supported -- try -fno-vxt -ff90");
|
||
break;
|
||
|
||
case OPT_fugly:
|
||
ffe_set_is_ugly_args (value);
|
||
ffe_set_is_ugly_assign (value);
|
||
ffe_set_is_ugly_assumed (value);
|
||
ffe_set_is_ugly_comma (value);
|
||
ffe_set_is_ugly_complex (value);
|
||
ffe_set_is_ugly_init (value);
|
||
ffe_set_is_ugly_logint (value);
|
||
break;
|
||
|
||
case OPT_fugly_args:
|
||
ffe_set_is_ugly_args (value);
|
||
break;
|
||
|
||
case OPT_fugly_assign:
|
||
ffe_set_is_ugly_assign (value);
|
||
break;
|
||
|
||
case OPT_fugly_assumed:
|
||
ffe_set_is_ugly_assumed (value);
|
||
break;
|
||
|
||
case OPT_fugly_comma:
|
||
ffe_set_is_ugly_comma (value);
|
||
break;
|
||
|
||
case OPT_fugly_complex:
|
||
ffe_set_is_ugly_complex (value);
|
||
break;
|
||
|
||
case OPT_fugly_init:
|
||
ffe_set_is_ugly_init (value);
|
||
break;
|
||
|
||
case OPT_fugly_logint:
|
||
ffe_set_is_ugly_logint (value);
|
||
break;
|
||
|
||
case OPT_fxyzzy:
|
||
ffe_set_is_ffedebug (value);
|
||
break;
|
||
|
||
case OPT_finit_local_zero:
|
||
ffe_set_is_init_local_zero (value);
|
||
break;
|
||
|
||
case OPT_femulate_complex:
|
||
ffe_set_is_emulate_complex (value);
|
||
break;
|
||
|
||
case OPT_fbackslash:
|
||
ffe_set_is_backslash (value);
|
||
break;
|
||
|
||
case OPT_funderscoring:
|
||
ffe_set_is_underscoring (value);
|
||
break;
|
||
|
||
case OPT_fsecond_underscore:
|
||
ffe_set_is_second_underscore (value);
|
||
break;
|
||
|
||
case OPT_fzeros:
|
||
ffe_set_is_zeros (value);
|
||
break;
|
||
|
||
case OPT_fdebug_kludge:
|
||
warning ("-fdebug-kludge is disabled, use normal debugging flags");
|
||
break;
|
||
|
||
case OPT_fonetrip:
|
||
ffe_set_is_onetrip (value);
|
||
break;
|
||
|
||
case OPT_fsilent:
|
||
ffe_set_is_silent (value);
|
||
break;
|
||
|
||
case OPT_fglobals:
|
||
ffe_set_is_globals (value);
|
||
break;
|
||
|
||
case OPT_ffortran_bounds_check:
|
||
flag_bounds_check = value;
|
||
break;
|
||
|
||
case OPT_ftypeless_boz:
|
||
ffe_set_is_typeless_boz (value);
|
||
break;
|
||
|
||
case OPT_fintrin_case_initcap:
|
||
ffe_set_case_intrin (FFE_caseINITCAP);
|
||
break;
|
||
|
||
case OPT_fintrin_case_lower:
|
||
ffe_set_case_intrin (FFE_caseLOWER);
|
||
break;
|
||
|
||
case OPT_fintrin_case_upper:
|
||
ffe_set_case_intrin (FFE_caseUPPER);
|
||
break;
|
||
|
||
case OPT_fintrin_case_any:
|
||
ffe_set_case_intrin (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fmatch_case_initcap:
|
||
ffe_set_case_match (FFE_caseINITCAP);
|
||
break;
|
||
|
||
case OPT_fmatch_case_lower:
|
||
ffe_set_case_match (FFE_caseLOWER);
|
||
break;
|
||
|
||
case OPT_fmatch_case_upper:
|
||
ffe_set_case_match (FFE_caseUPPER);
|
||
break;
|
||
|
||
case OPT_fmatch_case_any:
|
||
ffe_set_case_match (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fsource_case_lower:
|
||
ffe_set_case_source (FFE_caseLOWER);
|
||
break;
|
||
|
||
case OPT_fsource_case_preserve:
|
||
ffe_set_case_match (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fsource_case_upper:
|
||
ffe_set_case_source (FFE_caseUPPER);
|
||
break;
|
||
|
||
case OPT_fsymbol_case_initcap:
|
||
ffe_set_case_symbol (FFE_caseINITCAP);
|
||
break;
|
||
|
||
case OPT_fsymbol_case_lower:
|
||
ffe_set_case_symbol (FFE_caseLOWER);
|
||
break;
|
||
|
||
case OPT_fsymbol_case_upper:
|
||
ffe_set_case_symbol (FFE_caseUPPER);
|
||
break;
|
||
|
||
case OPT_fsymbol_case_any:
|
||
ffe_set_case_symbol (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fcase_strict_upper:
|
||
ffe_set_case_intrin (FFE_caseUPPER);
|
||
ffe_set_case_match (FFE_caseUPPER);
|
||
ffe_set_case_source (FFE_caseNONE);
|
||
ffe_set_case_symbol (FFE_caseUPPER);
|
||
break;
|
||
|
||
case OPT_fcase_strict_lower:
|
||
ffe_set_case_intrin (FFE_caseLOWER);
|
||
ffe_set_case_match (FFE_caseLOWER);
|
||
ffe_set_case_source (FFE_caseNONE);
|
||
ffe_set_case_symbol (FFE_caseLOWER);
|
||
break;
|
||
|
||
case OPT_fcase_initcap:
|
||
ffe_set_case_intrin (FFE_caseINITCAP);
|
||
ffe_set_case_match (FFE_caseINITCAP);
|
||
ffe_set_case_source (FFE_caseNONE);
|
||
ffe_set_case_symbol (FFE_caseINITCAP);
|
||
break;
|
||
|
||
case OPT_fcase_upper:
|
||
ffe_set_case_intrin (FFE_caseNONE);
|
||
ffe_set_case_match (FFE_caseNONE);
|
||
ffe_set_case_source (FFE_caseUPPER);
|
||
ffe_set_case_symbol (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fcase_lower:
|
||
ffe_set_case_intrin (FFE_caseNONE);
|
||
ffe_set_case_match (FFE_caseNONE);
|
||
ffe_set_case_source (FFE_caseLOWER);
|
||
ffe_set_case_symbol (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fcase_preserve:
|
||
ffe_set_case_intrin (FFE_caseNONE);
|
||
ffe_set_case_match (FFE_caseNONE);
|
||
ffe_set_case_source (FFE_caseNONE);
|
||
ffe_set_case_symbol (FFE_caseNONE);
|
||
break;
|
||
|
||
case OPT_fbadu77_intrinsics_delete:
|
||
ffe_set_intrinsic_state_badu77 (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_fbadu77_intrinsics_hide:
|
||
ffe_set_intrinsic_state_badu77 (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_fbadu77_intrinsics_disable:
|
||
ffe_set_intrinsic_state_badu77 (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_fbadu77_intrinsics_enable:
|
||
ffe_set_intrinsic_state_badu77 (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_fgnu_intrinsics_delete:
|
||
ffe_set_intrinsic_state_gnu (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_fgnu_intrinsics_hide:
|
||
ffe_set_intrinsic_state_gnu (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_fgnu_intrinsics_disable:
|
||
ffe_set_intrinsic_state_gnu (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_fgnu_intrinsics_enable:
|
||
ffe_set_intrinsic_state_gnu (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_ff2c_intrinsics_delete:
|
||
ffe_set_intrinsic_state_f2c (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_ff2c_intrinsics_hide:
|
||
ffe_set_intrinsic_state_f2c (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_ff2c_intrinsics_disable:
|
||
ffe_set_intrinsic_state_f2c (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_ff2c_intrinsics_enable:
|
||
ffe_set_intrinsic_state_f2c (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_ff90_intrinsics_delete:
|
||
ffe_set_intrinsic_state_f90 (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_ff90_intrinsics_hide:
|
||
ffe_set_intrinsic_state_f90 (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_ff90_intrinsics_disable:
|
||
ffe_set_intrinsic_state_f90 (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_ff90_intrinsics_enable:
|
||
ffe_set_intrinsic_state_f90 (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_fmil_intrinsics_delete:
|
||
ffe_set_intrinsic_state_mil (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_fmil_intrinsics_hide:
|
||
ffe_set_intrinsic_state_mil (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_fmil_intrinsics_disable:
|
||
ffe_set_intrinsic_state_mil (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_fmil_intrinsics_enable:
|
||
ffe_set_intrinsic_state_mil (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_funix_intrinsics_delete:
|
||
ffe_set_intrinsic_state_unix (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_funix_intrinsics_hide:
|
||
ffe_set_intrinsic_state_unix (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_funix_intrinsics_disable:
|
||
ffe_set_intrinsic_state_unix (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_funix_intrinsics_enable:
|
||
ffe_set_intrinsic_state_unix (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_fvxt_intrinsics_delete:
|
||
ffe_set_intrinsic_state_vxt (FFE_intrinsicstateDELETED);
|
||
break;
|
||
|
||
case OPT_fvxt_intrinsics_hide:
|
||
ffe_set_intrinsic_state_vxt (FFE_intrinsicstateHIDDEN);
|
||
break;
|
||
|
||
case OPT_fvxt_intrinsics_disable:
|
||
ffe_set_intrinsic_state_vxt (FFE_intrinsicstateDISABLED);
|
||
break;
|
||
|
||
case OPT_fvxt_intrinsics_enable:
|
||
ffe_set_intrinsic_state_vxt (FFE_intrinsicstateENABLED);
|
||
break;
|
||
|
||
case OPT_ffixed_line_length_:
|
||
if (strcmp (arg, "none") == 0)
|
||
ffe_set_fixed_line_length (0);
|
||
else if (ffe_is_digit_string_ (arg))
|
||
ffe_set_fixed_line_length (atol (arg));
|
||
else
|
||
return 0;
|
||
break;
|
||
|
||
case OPT_Wcomment:
|
||
case OPT_Wcomments:
|
||
case OPT_Wimport:
|
||
case OPT_Wtrigraphs:
|
||
case OPT_fpreprocessed:
|
||
/* These are for cpp. */
|
||
break;
|
||
|
||
case OPT_Wglobals:
|
||
ffe_set_is_warn_globals (value);
|
||
break;
|
||
|
||
case OPT_Wimplicit:
|
||
ffe_set_is_warn_implicit (value);
|
||
break;
|
||
|
||
case OPT_Wsurprising:
|
||
ffe_set_is_warn_surprising (value);
|
||
break;
|
||
|
||
case OPT_Wall:
|
||
set_Wunused (value);
|
||
/* We save the value of warn_uninitialized, since if they put
|
||
-Wuninitialized on the command line, we need to generate a
|
||
warning about not using it without also specifying -O. */
|
||
if (value)
|
||
{
|
||
if (warn_uninitialized != 1)
|
||
warn_uninitialized = 2;
|
||
}
|
||
else
|
||
warn_uninitialized = 0;
|
||
break;
|
||
|
||
case OPT_I:
|
||
ffecom_decode_include_option (arg);
|
||
break;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
/* Run the FFE on a source file (not an INCLUDEd file).
|
||
|
||
Runs the whole shebang.
|
||
|
||
Prepare and invoke the appropriate lexer. */
|
||
|
||
void
|
||
ffe_file (ffewhereFile wf, FILE *f)
|
||
{
|
||
ffe_init_1 ();
|
||
ffelex_set_handler ((ffelexHandler) ffest_first);
|
||
ffewhere_file_set (wf, TRUE, 0);
|
||
if (ffe_is_free_form_)
|
||
ffelex_file_free (wf, f);
|
||
else
|
||
ffelex_file_fixed (wf, f);
|
||
ffest_eof ();
|
||
ffe_terminate_1 ();
|
||
}
|
||
|
||
/* ffe_init_0 -- Initialize the FFE per image invocation
|
||
|
||
ffe_init_0();
|
||
|
||
Performs per-image invocation. */
|
||
|
||
void
|
||
ffe_init_0 (void)
|
||
{
|
||
++ffe_count_0;
|
||
ffe_in_0 = TRUE;
|
||
|
||
ffebad_init_0 ();
|
||
ffebit_init_0 ();
|
||
ffebld_init_0 ();
|
||
ffecom_init_0 ();
|
||
ffedata_init_0 ();
|
||
ffeequiv_init_0 ();
|
||
ffeexpr_init_0 ();
|
||
ffeglobal_init_0 ();
|
||
ffeimplic_init_0 ();
|
||
ffeinfo_init_0 ();
|
||
ffeintrin_init_0 ();
|
||
ffelab_init_0 ();
|
||
ffelex_init_0 ();
|
||
ffename_init_0 ();
|
||
ffesrc_init_0 ();
|
||
ffest_init_0 ();
|
||
ffestorag_init_0 ();
|
||
ffesymbol_init_0 ();
|
||
ffetarget_init_0 ();
|
||
ffetype_init_0 ();
|
||
ffewhere_init_0 ();
|
||
}
|
||
|
||
/* ffe_init_1 -- Initialize the FFE per source file
|
||
|
||
ffe_init_1();
|
||
|
||
Performs per-source-file invocation (not including INCLUDEd files). */
|
||
|
||
void
|
||
ffe_init_1 (void)
|
||
{
|
||
++ffe_count_1;
|
||
ffe_in_1 = TRUE;
|
||
|
||
assert (ffe_file_pool_ == NULL);
|
||
ffe_file_pool_ = malloc_pool_new ("File", malloc_pool_image (), 1024);
|
||
|
||
ffebad_init_1 ();
|
||
ffebit_init_1 ();
|
||
ffebld_init_1 ();
|
||
ffecom_init_1 ();
|
||
ffedata_init_1 ();
|
||
ffeequiv_init_1 ();
|
||
ffeexpr_init_1 ();
|
||
ffeglobal_init_1 ();
|
||
ffeimplic_init_1 ();
|
||
ffeinfo_init_1 ();
|
||
ffeintrin_init_1 ();
|
||
ffelab_init_1 ();
|
||
ffelex_init_1 ();
|
||
ffename_init_1 ();
|
||
ffesrc_init_1 ();
|
||
ffest_init_1 ();
|
||
ffestorag_init_1 ();
|
||
ffesymbol_init_1 ();
|
||
ffetarget_init_1 ();
|
||
ffetype_init_1 ();
|
||
ffewhere_init_1 ();
|
||
|
||
ffe_init_2 ();
|
||
}
|
||
|
||
/* ffe_init_2 -- Initialize the FFE per outer program unit
|
||
|
||
ffe_init_2();
|
||
|
||
Performs per-program-unit invocation. */
|
||
|
||
void
|
||
ffe_init_2 (void)
|
||
{
|
||
++ffe_count_2;
|
||
ffe_in_2 = TRUE;
|
||
|
||
assert (ffe_program_unit_pool_ == NULL);
|
||
ffe_program_unit_pool_ = malloc_pool_new ("Program unit", ffe_file_pool_, 1024);
|
||
ffe_is_mainprog_ = FALSE;
|
||
ffe_is_saveall_ = !ffe_is_automatic_;
|
||
|
||
ffebad_init_2 ();
|
||
ffebit_init_2 ();
|
||
ffebld_init_2 ();
|
||
ffecom_init_2 ();
|
||
ffedata_init_2 ();
|
||
ffeequiv_init_2 ();
|
||
ffeexpr_init_2 ();
|
||
ffeglobal_init_2 ();
|
||
ffeimplic_init_2 ();
|
||
ffeinfo_init_2 ();
|
||
ffeintrin_init_2 ();
|
||
ffelab_init_2 ();
|
||
ffelex_init_2 ();
|
||
ffename_init_2 ();
|
||
ffesrc_init_2 ();
|
||
ffest_init_2 ();
|
||
ffestorag_init_2 ();
|
||
ffesymbol_init_2 ();
|
||
ffetarget_init_2 ();
|
||
ffetype_init_2 ();
|
||
ffewhere_init_2 ();
|
||
|
||
ffe_init_3 ();
|
||
}
|
||
|
||
/* ffe_init_3 -- Initialize the FFE per any program unit
|
||
|
||
ffe_init_3();
|
||
|
||
Performs per-any-unit initialization; does NOT do
|
||
per-statement-function-definition initialization (i.e. the chain
|
||
of inits, from 0-3, breaks here; level 4 must be invoked independently). */
|
||
|
||
void
|
||
ffe_init_3 (void)
|
||
{
|
||
++ffe_count_3;
|
||
ffe_in_3 = TRUE;
|
||
|
||
assert (ffe_any_unit_pool_ == NULL);
|
||
ffe_any_unit_pool_ = malloc_pool_new ("Any unit", ffe_program_unit_pool_, 1024);
|
||
|
||
ffebad_init_3 ();
|
||
ffebit_init_3 ();
|
||
ffebld_init_3 ();
|
||
ffecom_init_3 ();
|
||
ffedata_init_3 ();
|
||
ffeequiv_init_3 ();
|
||
ffeexpr_init_3 ();
|
||
ffeglobal_init_3 ();
|
||
ffeimplic_init_3 ();
|
||
ffeinfo_init_3 ();
|
||
ffeintrin_init_3 ();
|
||
ffelab_init_3 ();
|
||
ffelex_init_3 ();
|
||
ffename_init_3 ();
|
||
ffesrc_init_3 ();
|
||
ffest_init_3 ();
|
||
ffestorag_init_3 ();
|
||
ffesymbol_init_3 ();
|
||
ffetarget_init_3 ();
|
||
ffetype_init_3 ();
|
||
ffewhere_init_3 ();
|
||
}
|
||
|
||
/* ffe_init_4 -- Initialize the FFE per statement function definition
|
||
|
||
ffe_init_4(); */
|
||
|
||
void
|
||
ffe_init_4 (void)
|
||
{
|
||
++ffe_count_4;
|
||
ffe_in_4 = TRUE;
|
||
|
||
ffebad_init_4 ();
|
||
ffebit_init_4 ();
|
||
ffebld_init_4 ();
|
||
ffecom_init_4 ();
|
||
ffedata_init_4 ();
|
||
ffeequiv_init_4 ();
|
||
ffeexpr_init_4 ();
|
||
ffeglobal_init_4 ();
|
||
ffeimplic_init_4 ();
|
||
ffeinfo_init_4 ();
|
||
ffeintrin_init_4 ();
|
||
ffelab_init_4 ();
|
||
ffelex_init_4 ();
|
||
ffename_init_4 ();
|
||
ffesrc_init_4 ();
|
||
ffest_init_4 ();
|
||
ffestorag_init_4 ();
|
||
ffesymbol_init_4 ();
|
||
ffetarget_init_4 ();
|
||
ffetype_init_4 ();
|
||
ffewhere_init_4 ();
|
||
}
|
||
|
||
/* ffe_terminate_0 -- Terminate the FFE prior to image termination
|
||
|
||
ffe_terminate_0(); */
|
||
|
||
void
|
||
ffe_terminate_0 (void)
|
||
{
|
||
ffe_count_1 = 0;
|
||
ffe_in_0 = FALSE;
|
||
|
||
ffebad_terminate_0 ();
|
||
ffebit_terminate_0 ();
|
||
ffebld_terminate_0 ();
|
||
ffecom_terminate_0 ();
|
||
ffedata_terminate_0 ();
|
||
ffeequiv_terminate_0 ();
|
||
ffeexpr_terminate_0 ();
|
||
ffeglobal_terminate_0 ();
|
||
ffeimplic_terminate_0 ();
|
||
ffeinfo_terminate_0 ();
|
||
ffeintrin_terminate_0 ();
|
||
ffelab_terminate_0 ();
|
||
ffelex_terminate_0 ();
|
||
ffename_terminate_0 ();
|
||
ffesrc_terminate_0 ();
|
||
ffest_terminate_0 ();
|
||
ffestorag_terminate_0 ();
|
||
ffesymbol_terminate_0 ();
|
||
ffetarget_terminate_0 ();
|
||
ffetype_terminate_0 ();
|
||
ffewhere_terminate_0 ();
|
||
}
|
||
|
||
/* ffe_terminate_1 -- Terminate the FFE after seeing source file EOF
|
||
|
||
ffe_terminate_1(); */
|
||
|
||
void
|
||
ffe_terminate_1 (void)
|
||
{
|
||
ffe_count_2 = 0;
|
||
ffe_in_1 = FALSE;
|
||
|
||
ffe_terminate_2 ();
|
||
|
||
ffebad_terminate_1 ();
|
||
ffebit_terminate_1 ();
|
||
ffebld_terminate_1 ();
|
||
ffecom_terminate_1 ();
|
||
ffedata_terminate_1 ();
|
||
ffeequiv_terminate_1 ();
|
||
ffeexpr_terminate_1 ();
|
||
ffeglobal_terminate_1 ();
|
||
ffeimplic_terminate_1 ();
|
||
ffeinfo_terminate_1 ();
|
||
ffeintrin_terminate_1 ();
|
||
ffelab_terminate_1 ();
|
||
ffelex_terminate_1 ();
|
||
ffename_terminate_1 ();
|
||
ffesrc_terminate_1 ();
|
||
ffest_terminate_1 ();
|
||
ffestorag_terminate_1 ();
|
||
ffesymbol_terminate_1 ();
|
||
ffetarget_terminate_1 ();
|
||
ffetype_terminate_1 ();
|
||
ffewhere_terminate_1 ();
|
||
|
||
assert (ffe_file_pool_ != NULL);
|
||
malloc_pool_kill (ffe_file_pool_);
|
||
ffe_file_pool_ = NULL;
|
||
}
|
||
|
||
/* ffe_terminate_2 -- Terminate the FFE after seeing outer program unit END
|
||
|
||
ffe_terminate_2(); */
|
||
|
||
void
|
||
ffe_terminate_2 (void)
|
||
{
|
||
ffe_count_3 = 0;
|
||
ffe_in_2 = FALSE;
|
||
|
||
ffe_terminate_3 ();
|
||
|
||
ffebad_terminate_2 ();
|
||
ffebit_terminate_2 ();
|
||
ffebld_terminate_2 ();
|
||
ffecom_terminate_2 ();
|
||
ffedata_terminate_2 ();
|
||
ffeequiv_terminate_2 ();
|
||
ffeexpr_terminate_2 ();
|
||
ffeglobal_terminate_2 ();
|
||
ffeimplic_terminate_2 ();
|
||
ffeinfo_terminate_2 ();
|
||
ffeintrin_terminate_2 ();
|
||
ffelab_terminate_2 ();
|
||
ffelex_terminate_2 ();
|
||
ffename_terminate_2 ();
|
||
ffesrc_terminate_2 ();
|
||
ffest_terminate_2 ();
|
||
ffestorag_terminate_2 ();
|
||
ffesymbol_terminate_2 ();
|
||
ffetarget_terminate_2 ();
|
||
ffetype_terminate_2 ();
|
||
ffewhere_terminate_2 ();
|
||
|
||
assert (ffe_program_unit_pool_ != NULL);
|
||
malloc_pool_kill (ffe_program_unit_pool_);
|
||
ffe_program_unit_pool_ = NULL;
|
||
}
|
||
|
||
/* ffe_terminate_3 -- Terminate the FFE after seeing any program unit END
|
||
|
||
ffe_terminate_3(); */
|
||
|
||
void
|
||
ffe_terminate_3 (void)
|
||
{
|
||
ffe_count_4 = 0;
|
||
ffe_in_3 = FALSE;
|
||
|
||
ffebad_terminate_3 ();
|
||
ffebit_terminate_3 ();
|
||
ffebld_terminate_3 ();
|
||
ffecom_terminate_3 ();
|
||
ffedata_terminate_3 ();
|
||
ffeequiv_terminate_3 ();
|
||
ffeexpr_terminate_3 ();
|
||
ffeglobal_terminate_3 ();
|
||
ffeimplic_terminate_3 ();
|
||
ffeinfo_terminate_3 ();
|
||
ffeintrin_terminate_3 ();
|
||
ffelab_terminate_3 ();
|
||
ffelex_terminate_3 ();
|
||
ffename_terminate_3 ();
|
||
ffesrc_terminate_3 ();
|
||
ffest_terminate_3 ();
|
||
ffestorag_terminate_3 ();
|
||
ffesymbol_terminate_3 ();
|
||
ffetarget_terminate_3 ();
|
||
ffetype_terminate_3 ();
|
||
ffewhere_terminate_3 ();
|
||
|
||
assert (ffe_any_unit_pool_ != NULL);
|
||
malloc_pool_kill (ffe_any_unit_pool_);
|
||
ffe_any_unit_pool_ = NULL;
|
||
}
|
||
|
||
/* ffe_terminate_4 -- Terminate the FFE after seeing sfunc def expression
|
||
|
||
ffe_terminate_4(); */
|
||
|
||
void
|
||
ffe_terminate_4 (void)
|
||
{
|
||
ffe_in_4 = FALSE;
|
||
|
||
ffebad_terminate_4 ();
|
||
ffebit_terminate_4 ();
|
||
ffebld_terminate_4 ();
|
||
ffecom_terminate_4 ();
|
||
ffedata_terminate_4 ();
|
||
ffeequiv_terminate_4 ();
|
||
ffeexpr_terminate_4 ();
|
||
ffeglobal_terminate_4 ();
|
||
ffeimplic_terminate_4 ();
|
||
ffeinfo_terminate_4 ();
|
||
ffeintrin_terminate_4 ();
|
||
ffelab_terminate_4 ();
|
||
ffelex_terminate_4 ();
|
||
ffename_terminate_4 ();
|
||
ffesrc_terminate_4 ();
|
||
ffest_terminate_4 ();
|
||
ffestorag_terminate_4 ();
|
||
ffesymbol_terminate_4 ();
|
||
ffetarget_terminate_4 ();
|
||
ffetype_terminate_4 ();
|
||
ffewhere_terminate_4 ();
|
||
}
|