25 #include "pips_config.h"
97 "Reference to formal functional entity %s to be substituted\n",
105 "Functional variable %s is used as an actual argument\n"
106 "This is not yet fully supported by PIPS.\n",
199 pips_assert(
"The parser should not have to know about unstructured\n",
false);
202 FatalError(
"substitute_ghost_variable_in_statement",
"Unexpected instruction tag");
214 pips_assert(
"Entity e is defined and has type \"variable\" if substitution is required\n",
220 "Entity \"%s\" does not really exist but appears"
221 " in an equivalence chain!\n",
224 "Cannot remove still accessible ghost variable\n")) {
234 pips_assert(
"Entity fe cannot be undefined",
false);
237 pips_assert(
"Type for entity fe cannot be undefined",
false);
254 "Start substitution of variable %s by module %s\n",
258 "End for substitution of variable %s by module %s\n",
263 pips_assert(
"Type t for entity fe should be functional",
false);
311 bool already_here =
false;
321 "Recursive call are not supported\n");
346 if (! already_here) {
422 pips_debug(8,
"Storage for entity %s must be static or made static\n",
440 (
"Variable %s is declared dynamic in a BLOCKDATA\n",
443 "No dynamic variables in BLOCKDATA\n");
455 (
"DATA for variable %s declared is impossible:"
456 " it should be declared in a COMMON instead\n",
459 "Improper DATA declaration in BLOCKDATA");
466 (
"DATA for variable %s declared in COMMON %s:"
467 " not standard compliant,"
468 " use a BLOCKDATA\n",
472 "Improper DATA declaration, use a BLOCKDATA"
473 " or set property PARSER_ACCEPT_ANSI_EXTENSIONS");
481 "(storage tag = %d)\n",
484 "DATA statement initializes non RAM variable\n");
508 "Scalar variable initialized by an DATA implied do");
522 "Fortran standard prohibit varying size array in DATA statements.\n");
549 ParserError(
"expression_reference_number",
"Unexpected function call");
553 ParserError(
"expression_reference_number",
"Unexpected range");
593 pips_assert(
"The second argument of an implied do is a range",
601 "Only constant loop bounds with non-zero increment"
602 " are supported by the PIPS parser in DATA statement\n",
617 pips_debug(2,
"Begin for target ctp=%d with window [%d, %d]\n", ctp, *pmin_cp, *pmax_cp);
620 while(ctp > *pmax_cp) {
623 pips_debug(2,
"Iterate for target ctp=%d with window [%d, %d]\n", ctp, *pmin_cp, *pmax_cp);
628 ParserError(
"find_target_position",
"Not enough values in DATA statement");
634 *pmin_cp = *pmax_cp+1;
664 pips_debug(2,
"ctp=%d, *pmin_cp=%d, *pmax_cp=%d\n", ctp, *pmin_cp, *pmax_cp);
667 pips_debug(2,
"End for target ctp=%d with window [%d, %d]\n", ctp, *pmin_cp, *pmax_cp);
687 pips_debug(2,
"Begin for variable %s and expression\n",
702 pips_user_warning(
"Type coercion needed for variable %s and its DATA expression value\n",
727 ParserError(
"store_initial_value",
"Conflicting DATA statements");
746 pips_assert(
"The constant value expression is a CALL",
753 pips_assert(
"The constant value expression is still a CALL",
776 ParserError(
"store_initial_value",
"Illegal initialization of a LOGICAL variable");
822 for(cvp=svps, civl = isvs;!
ENDP(cvp);
POP(cvp),
POP(civl)) {
828 pips_assert(
"The value window is not empty", min_cp<=max_cp);
829 if(ctp>=min_cp && ctp <= max_cp) {
835 pips_user_warning(
"No value in value list for variable %s and the following ones.\n",
837 ParserError(
"process_value_list",
"Not enough values for reference list");
840 else if(ctp>=min_cp) {
847 " it should have been satisfied earlier\n");
867 pips_assert(
"This is a call to the static initialization function",
889 ParserError(
"",
"Redundant/Conflicting initialization");
892 pips_debug(2,
"Variable %s with value at position %td\n",
915 pips_assert(
"The variable and positions lists have the same length",
918 pips_debug(2,
"List of initialized scalar variables with value positions:\n");
921 fprintf(stderr,
"Variable %s has value at position %d\n",
926 pips_debug(2,
"The DATA statement is %s decoded (cvp=%td)\n",
927 ((
gen_length(isvs)==0)?
"not" : ((cvp==-1)?
"partially" :
"fully")), cvp);
935 "Empty value list in DATA statement\n");
986 pips_debug(8,
"checking code consistency = %d\n",
990 pips_debug(8,
"Declarations inherited from module %s:\n",
999 if (strlen(
lab_I) != 0 ) {
1014 "bad program structure: missing ENDDO and/or ENDIF\n");
1058 fprintf(stderr,
"Parser: checking callees consistency = %d\n",
1103 pips_debug(5,
"checking code consistency = %d\n",
1117 pips_debug(5,
"checking code consistency after resettings = %d\n",
1162 pips_assert(
"Parameter type list should be empty",
1165 for (pc = l; pc != NULL; pc =
CDR(pc)) {
1197 for(i = 0; i < module_list_length; i++) {
1210 "Declaration of module %s removed from %s's declarations",
1300 user_warning(
"MakeCurrentFunction",
"Global name %s used for a function or subroutine"
1301 " and for a %s\n", cfn, msf==
TK_BLOCKDATA?
"blockdata" :
"main");
1302 ParserError(
"MakeCurrentFunction",
"Name conflict\n");
1306 pips_debug(1,
"Entity \"%s\" does not really exist."
1307 " A blockdata is declared in an EXTERNAL statement.",
1318 "Intrinsic %s redefined.\n"
1319 "This is not supported by PIPS. Please rename %s\n",
1328 "Name conflict between a "
1329 "subroutine and/or a function and an intrinsic\n");
1353 FatalError(
"MakeCurrentFunction",
"bad type\n");
1585 pips_debug(1,
"Begin for static area %s in module %s\n",
1589 pips_debug(1,
"End: no static variables in module %s\n",
1602 pips_debug(1,
"Static area %s without aliasing in module %s\n",
1605 pips_debug(1,
"Static area %s with aliasing in module %s\n",
1622 "Entries with aliased static variables not yet supported by PIPS\n");
1633 " for entries in module %s failed",
1666 pips_debug(1,
"New common %s for static area %s in module %s\n",
1671 pips_debug(1,
"End for static area %s in module %s\n",
1696 "Unexpected storage class for top level entity\n");
1710 pips_debug(1,
"external function %s re-declared as %s\n",
1725 pips_debug(1,
"entity %s to be preserved to carry function result\n",
1731 "They are not (yet) supported by PIPS.\n",
1746 pips_assert(
"Entity is global or it is a formal functional parameter",
1930 for(cc = lfp; !
ENDP(cc);
POP(cc)) {
1947 pips_debug(1,
"Entity %s removed from declarations for %s\n",
1951 " as a formal parameter for entry %s. It is legal "
1952 "if it only appears in a type statement.\n",
1974 (void)
fprintf(stderr,
"Declarations of formal parameters for entry %s:\n",
1977 (void)
fprintf(stderr,
"Declarations for current module %s:\n",
2003 pips_debug(1,
"Begin for entry %s in module %s\n",
2020 pips_assert(
"cms is the second statement of the block",
2030 pips_debug(1,
"End for entry %s in module %s\n",
2049 bool line_numbering_p =
false;
2051 pips_debug(1,
"Begin for entry %s of module %s\n",
2073 (void)
fprintf(stderr,
"Declarations inherited from module %s:\n",
2076 (void)
fprintf(stderr,
"Declarations of formal parameters for entry %s:\n",
2087 bool use_new_controlizer_p =
2088 #ifdef BUILDER_NEW_CONTROLIZER
2095 use_new_controlizer_p |=
2097 use_new_controlizer_p &=
2100 if (use_new_controlizer_p)
2119 (void)
fprintf(stderr,
"Declarations of all variables for entry %s:\n",
2166 pips_debug(1,
"End for entry %s of module %s\n",
2247 pips_assert(
"Unexpected kind of functional entity!",
true);
2298 "Type redefinition of result for function %s\n",
2302 "Currently declared result is %s\n",
2307 "Redeclared result is %s\n",
2311 "Functional type redefinition.\n");
2446 "Name conflict between user declared module %s and intrinsic %s\n",
2449 "Name conflict with intrinsic because PIPS does not support"
2450 " a specific name space for intrinsics. "
2451 "Please change your function or subroutine name.");
2476 "formal parameter should not be already typed");
2511 for (pc = l, nfp = 1; pc != NULL; pc =
CDR(pc), nfp += 1) {
2529 for (fpc = lfp, fpo = 1; !
ENDP(fpc);
POP(fpc), fpo += 1) {
2533 pips_assert(
"Formal parameter fp must be in scope of module m",
dummy make_dummy_identifier(entity _field_)
functional make_functional(list a1, type a2)
constant make_constant(enum constant_utype tag, void *val)
value make_value_unknown(void)
parameter make_parameter(type a1, mode a2, dummy a3)
language make_language_fortran(void)
basic make_basic(enum basic_utype tag, void *val)
storage make_storage_rom(void)
void free_entity(entity p)
type copy_type(type p)
TYPE.
storage make_storage(enum storage_utype tag, void *val)
ram make_ram(entity a1, entity a2, intptr_t a3, list a4)
statement copy_statement(statement p)
STATEMENT.
value make_value(enum value_utype tag, void *val)
bool statement_consistent_p(statement p)
bool storage_defined_p(storage p)
statement make_statement(entity a1, intptr_t a2, intptr_t a3, string a4, instruction a5, list a6, string a7, extensions a8, synchronization a9)
variable make_variable(basic a1, list a2, list a3)
value copy_value(value p)
VALUE.
code make_code(list a1, string a2, sequence a3, list a4, language a5)
void free_storage(storage p)
instruction make_instruction(enum instruction_utype tag, void *val)
synchronization make_synchronization_none(void)
sequence make_sequence(list a)
void free_statement(statement p)
type make_type(enum type_utype tag, void *val)
callees make_callees(list a)
bool callees_consistent_p(callees p)
formal make_formal(entity a1, intptr_t a2)
bool active_phase_p(const char *phase)
static reference ref
Current stmt (an integer)
bool entity_is_argument_p(entity e, cons *args)
cons * arguments_add_entity(cons *a, entity e)
cons * arguments_rm_entity(cons *a, entity e)
void dump_arguments(cons *args)
entity_name is a macro, hence the code replication
size_t gen_array_nitems(const gen_array_t a)
void gen_array_full_free(gen_array_t a)
void * gen_array_item(const gen_array_t a, size_t i)
entity DynamicArea
These global variables are declared in ri-util/util.c.
void CleanLocalEntities(entity function)
Fortran version.
#define USE_OLD_CONTROLIZER_ENV_VAR_NAME
The name of the one to force the use of the old controlizer:
#define USE_NEW_CONTROLIZER_ENV_VAR_NAME
– control.h
void unspaghettify_statement(statement)
The real entry point of unspaghettify:
void InitImplicit()
this function initializes the data structure used to compute implicit types
void update_user_common_layouts(entity m)
Check...
void update_common_sizes(void)
void reset_common_size_map()
void DeclareVariable(entity e, type t, list d, storage s, value v)
void DeclareVariable(e, t, d, s, v): update entity e description as declaration statements are encoun...
void SaveEntity(entity e)
These two functions transform a dynamic variable into a static one.
bool implicit_type_p(entity e)
This function checks that entity e has an undefined or an implicit type which can be superseded by an...
entity MakeCommon(entity e)
MakeCommon: This function creates a common block.
type ImplicitType(entity e)
This function computes the Fortran implicit type of entity e.
void initialize_common_size_map()
void SaveChains()
Initialize the shared fields of aliased variables.
bool entity_in_equivalence_chains_p(entity e)
void SetChains()
initialize chains before each call to the parser
void ResetChains()
undefine chains between two successives calls to parser
void ComputeEquivalences()
This function merges all the equivalence chains to take into account equivalences due to transitivity...
void ComputeAddresses()
This function computes an address for every variable.
char * get_string_property(const char *)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#define gen_recurse(start, domain_number, flt, rwt)
statement make_block_statement(list)
Make a block statement from a list of statement.
statement instruction_to_statement(instruction)
Build a statement from a give instruction.
unstructured control_graph(statement)
CONTROL_GRAPH returns the control graph of the statement ST.
statement hcfg(statement)
Compute the hierarchical control flow graph (HCFG) of a statement.
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
statement set_current_module_statement(statement)
Set the current module statement.
statement get_current_module_statement(void)
Get the current module statement.
entity set_current_module_entity(entity)
static.c
entity get_current_module_entity(void)
Get the entity of the current module.
void gen_null(__attribute__((unused)) void *unused)
Ignore the argument.
instruction make_instruction_block(list statements)
Build an instruction block from a list of statements.
instruction make_continue_instruction()
Creates a CONTINUE instruction, that is the FORTRAN nop, the ";" in C or the "pass" in Python for exa...
#define ENDP(l)
Test if a list is empty.
#define list_undefined_p(c)
Return if a list is undefined.
list gen_nreverse(list cp)
reverse a list in place
void gen_remove(list *cpp, const void *o)
remove all occurences of item o from list *cpp, which is thus modified.
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
list gen_once(const void *vo, list l)
Prepend an item to a list only if it is not already in the list.
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
bool gen_in_list_p(const void *vo, const list lx)
tell whether vo belongs to lx
#define CDR(pcons)
Get the list less its first element.
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
#define list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
gen_array_t db_get_module_list(void)
Get an array of all the modules (functions, procedures and compilation units) of a workspace.
#define DB_PUT_MEMORY_RESOURCE(res_name, own_name, res_val)
conform to old interface.
call statement_call(statement)
Get the call of a statement.
bool statement_call_p(statement)
statement make_continue_statement(entity)
void parser_substitute_all_macros(statement s)
void parser_close_macros_support(void)
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define user_warning(fn,...)
static statement init_stmt
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
#define MODULE_SEP_STRING
void print_arguments(list args)
char * i2a(int)
I2A (Integer TO Ascii) yields a string for a given Integer.
string concatenate(const char *,...)
Return the concatenation of the given strings.
#define same_string_p(s1, s2)
void * gen_find_tabulated(const char *, int)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
void print_expression(expression e)
no file descriptor is passed to make is easier to use in a debugging stage.
text text_named_module(entity, entity, statement)
bool make_text_resource_and_free(const char *, const char *, const char *, text)
string basic_to_string(basic)
void AddEntryLabel(entity l)
type MakeResultType(entity e, type r)
The result type of a function may be carried by e, by r or be implicit.
void substitute_ghost_variable_in_expression(expression expr, entity v, entity f)
entity SafeLocalToGlobal(entity e, type r)
A local entity might have been created but found out later to be global, depending on the order of de...
entity LocalToGlobal(entity e)
bool IsEffectiveFormalParameterP(entity f)
void ScanFormalParameters(entity m, list l)
this function scans the formal parameter list.
entity MakeExternalFunction(entity e, type r)
void remove_from_called_modules(entity e)
macros are added, although they should not have been.
void MakeCurrentFunction(type t, int msf, const char *cfn, list lfp)
this function creates one entity cf that represents the Fortran function f being analyzed.
static void process_static_initialization(call c)
void add_ghost_variable_entity(entity e)
void AddEntryTarget(statement s)
bool ghost_variable_entity_p(entity e)
static void ProcessEntry(entity cm, entity e, statement t)
void EndOfProcedure()
This function is called when the parsing of a procedure is completed.
void BeginingOfProcedure()
this function is called each time a new procedure is encountered.
void update_called_modules(entity e)
void init_ghost_variable_entities()
procedure.c
static void store_initial_value(entity var, expression val)
Integer and bool initial values are stored as int, float, string and maybe complex initial values are...
static list entry_entities
void AddEffectiveFormalParameter(entity f)
Keep track of the formal parameters for the current module.
static statement function_body
statement of current function
entity DeclareExternalFunction(entity e)
static list effective_formal_parameters
static int expression_reference_number(expression e)
static list ghost_variable_entities
list of potential local or top-level variables that turned out to be useless.
static statement BuildStatementForEntry(entity cm, entity e, statement t)
Build an entry version of the current module statement.
static void process_static_initializations()
static list implicit_do_index_set
static void process_value_list(list vl, list isvs, list svps)
static list find_target_position(list cvl, int ctp, int *pmin_cp, int *pmax_cp, expression *pcve)
static list TranslateEntryFormals(entity e, list lfp)
list of formal parameters wrongly declared in current module
static int implied_do_reference_number(expression)
forward declaration
void UpdateFormalStorages(entity m, list lfp)
this function check and set if necessary the storage of formal parameters in lfp.
static list entry_labels
Processing of entries: when an ENTRY statement is encountered, it is replaced by a labelled CONTINUE ...
void reify_ghost_variable_entity(entity e)
It is possible to change one's mind and effectively use an entity which was previously assumed useles...
instruction MakeEntry(entity e, list lfp)
An ENTRY statement is substituted by a labelled continue.
void MakeFormalParameter(entity m, entity fp, int nfp)
This function transforms an untyped entity into a formal parameter.
static bool fix_storage(reference r)
void AddEntryEntity(entity e)
void substitute_ghost_variable_in_statement(statement stmt, entity v, entity f)
entity NameToFunctionalEntity(string name)
static list called_modules
list of called subroutines or functions
void remove_module_entity(entity m)
void remove_ghost_variable_entities(bool substitute_p)
static bool gather_implicit_indices(call c)
static list entry_targets
void UpdateFunctionalType(entity f, list l)
This function analyzes the CurrentFunction formal parameter list to determine the CurrentFunction fun...
static void MakeEntryCommon(entity m, entity a)
Static variables in a module with entries must be redeclared as stored in a common in order to be acc...
void TypeFunctionalEntity(entity fe, type r)
void set_bool_property(const char *, bool)
static const char * prefix
#define SUBSTRING_FUNCTION_NAME
#define ENTITY_UNARY_MINUS_P(e)
#define ENTITY_IMPLIEDDO_P(e)
#define UNKNOWN_RAM_OFFSET
#define STATEMENT_NUMBER_UNDEFINED
default values
#define ENTITY_STATIC_INITIALIZATION_P(e)
Fortran DATA management.
#define entity_declarations(e)
MISC: newgen shorthands.
#define ENTITY_REPEAT_VALUE_P(e)
#define MAKE_ORDERING(u, s)
On devrait utiliser Newgen pour cela, mais comme on ne doit pas les utiliser directement (mais via st...
#define instruction_block(i)
#define empty_comments
Empty comments (i.e.
#define IO_LIST_STRING_NAME
#define ENTITY_FALSE_P(e)
#define ENTITY_DATA_LIST_P(e)
bool dynamic_area_p(entity aire)
void print_common_layout(FILE *fd, entity c, bool debug_p)
bool static_area_p(entity aire)
void fprint_functional(FILE *fd, functional f)
This function is called from c_parse() via ResetCurrentModule() and fprint_environment()
void fprint_environment(FILE *fd, entity m)
entity FindEntity(const char *package, const char *name)
Retrieve an entity from its package/module name and its local name.
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
entity FindOrCreateEntity(const char *package, const char *local_name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
bool intrinsic_entity_p(entity e)
entity local_name_to_top_level_entity(const char *n)
This function try to find a top-level entity from a local name.
code entity_code(entity e)
bool entity_function_p(entity e)
entity entity_empty_label(void)
const char * module_local_name(entity e)
Returns the module local user name.
bool entity_blockdata_p(entity e)
code EntityCode(entity e)
this function checks that e has an initial value code.
bool top_level_entity_p(entity e)
Check if the scope of entity e is global.
entity make_new_label(entity module)
This function returns a new label.
const char * entity_module_name(entity e)
See comments about module_name().
list common_members_of_module(entity common, entity module, bool only_primary)
returns the list of entity to appear in the common declaration.
bool range_count(range r, intptr_t *pcount)
The range count only can be evaluated if the three range expressions are constant and if the incremen...
bool expression_call_p(expression e)
int expression_to_int(expression exp)
================================================================
bool expression_reference_p(expression e)
Test if an expression is a reference.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
extensions empty_extensions(void)
extension.c
bool hpf_directive_string_p(const char *s)
recognize an hpf directive special entity.
bool keep_directive_in_code_p(const char *s)
whether an entity must be kept in the code.
bool formal_label_replacement_p(entity)
basic basic_of_expression(expression)
basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
void remove_variable_entity(entity)
void error_reset_current_module_statement(void)
To be called by an error management routine only.
bool NumberOfElements(basic, list, int *)
mode MakeModeReference(void)
bool entity_scalar_p(entity)
The concrete type of e is a scalar type.
void AddEntityToDeclarations(entity, entity)
END_EOLE.
bool type_equal_p(type, type)
bool basic_equal_p(basic, basic)
bool overloaded_type_p(type)
Returns true if t is a variable type with a basic overloaded.
type MakeTypeVariable(basic, cons *)
BEGIN_EOLE.
string type_to_string(const type)
type.c
#define type_functional_p(x)
#define value_undefined_p(x)
#define functional_result(x)
#define storage_formal_p(x)
#define value_constant(x)
#define syntax_reference(x)
#define reference_undefined
#define code_undefined_p(x)
#define reference_variable(x)
#define value_intrinsic_p(x)
#define instruction_loop(x)
#define type_functional(x)
#define instruction_goto(x)
#define value_unknown_p(x)
#define entity_storage(x)
#define code_declarations(x)
#define range_increment(x)
#define value_constant_p(x)
#define call_domain
newgen_callees_domain_defined
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define statement_label(x)
#define type_undefined_p(x)
#define entity_undefined_p(x)
#define reference_domain
newgen_range_domain_defined
#define constant_int_p(x)
#define expression_undefined
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_sequence
#define instruction_tag(x)
#define whileloop_label(x)
#define functional_parameters(x)
#define code_initializations(x)
#define PARAMETER(x)
PARAMETER.
#define sequence_statements(x)
#define reference_indices(x)
#define constant_call_p(x)
#define expression_undefined_p(x)
#define test_condition(x)
#define instruction_whileloop(x)
#define variable_dimensions(x)
#define whileloop_body(x)
#define code_decls_text(x)
#define statement_instruction(x)
#define instruction_call(x)
#define call_arguments(x)
#define instruction_test(x)
#define whileloop_condition(x)
#define syntax_range_p(x)
#define expression_syntax(x)
#define type_variable_p(x)
#define storage_undefined_p(x)
#define whileloop_undefined
#define entity_domain
newgen_syntax_domain_defined
#define variable_basic(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
#define storage_undefined
#define entity_initial(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
int var_t
Type of variables.
The structure used to build lists in NewGen.
cons * FormalParameters
the current function
int line_b_I
Indicates where the current instruction (in fact statement) starts and ends in the input file and giv...
bool ParserError(const char *f, const char *m)
const char * CurrentPackage
the name of the current package, i.e.
void SubstituteAlternateReturns(const char *option)
return.c
bool SubstituteAlternateReturnsP()
void uses_alternate_return(bool use)
list add_formal_return_code(list fpl)
Update the formal and actual parameter lists by adding the return code variable as last argument.
void ResetReturnCodeVariable()
void GenerateReturn()
Generate a unique call to RETURN per module.
bool ReturnCodeVariableP(entity rcv)
void PushBlock(instruction i, string l)
instruction MakeEmptyInstructionBlock()
this function creates an empty block
void CheckAndInitializeStmt(void)
this function looks for undefined labels.
void LinkInstToCurrentBlock(instruction i, bool number_it)
this function links the instruction i to the current block of statements.
@ empty
b1 < bj -> h1/hj = empty