return.c File Reference

#include <stdio.h>
#include "genC.h"
#include "parser_private.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
#include "properties.h"
#include "syntax.h"

Include dependency graph for return.c:

Go to the source code of this file.

Macros
#define	GET_RC_PREFIX   "GET_"
#define	SET_RC_PREFIX   "SET_"

Functions
void	SubstituteAlternateReturns (const char *option)
	return.c More...
bool	SubstituteAlternateReturnsP ()
entity	GetReturnCodeVariable ()
static entity	GetFullyDefinedReturnCodeVariable ()
bool	ReturnCodeVariableP (entity rcv)
void	ResetReturnCodeVariable ()
bool	uses_alternate_return_p ()
void	uses_alternate_return (bool use)
void	set_current_number_of_alternate_returns ()
void	reset_current_number_of_alternate_returns ()
int	get_current_number_of_alternate_returns ()
list	add_formal_return_code (list fpl)
	Update the formal and actual parameter lists by adding the return code variable as last argument. More...
list	add_actual_return_code (list apl)
void	add_alternate_return (string label_name)
list	get_alternate_returns ()
void	set_alternate_returns ()
void	reset_alternate_returns ()
void	soft_reset_alternate_returns ()
	ParserError() cannot guess if it has been performed or not, because it is reinitialized before and after each call statement. More...
static statement	make_get_rc_statement (expression rc_ref)
instruction	generate_return_code_checks (list labels)
static entity	set_rc_function ()
static statement	make_set_rc_statement (expression e)
	The return code may be directly assigned or indirectly through a PIPS run-time function call. More...
instruction	MakeReturn (expression e)
void	GenerateReturn ()
	Generate a unique call to RETURN per module. More...

Variables
static bool	substitute_rc_p = false
	Handling of RETURN statements and substitution of alternate returns. More...
static bool	substitute_stop_p = false
static bool	hide_rc_p = false
static entity	return_code_variable = entity_undefined
	Variable used to carry return code replacing the alternate returns. More...
static bool	current_module_uses_alternate_returns = false
	Remember if the current module uses alternate returns. More...
static int	current_number_of_alternate_returns = -1
	The current number of alternate returns is used to process a module declaration. More...
static list	alternate_returns = list_undefined
	Keep track of the labels used as actual arguments for alternate returns and generate the tests to check the return code. More...
LOCAL entity	end_label = entity_undefined
	This function creates a goto instruction to label end_label. More...
LOCAL char *	end_label_local_name = RETURN_LABEL_NAME

Macro Definition Documentation

GET_RC_PREFIX

#define GET_RC_PREFIX   "GET_"

Definition at line 55 of file return.c.

SET_RC_PREFIX

#define SET_RC_PREFIX   "SET_"

Definition at line 56 of file return.c.

Function Documentation

add_actual_return_code()

list add_actual_return_code

(

list

apl

)

Parameters

apl

pl

Definition at line 222 of file return.c.

{
  list new_apl = apl;
 
  if(substitute_rc_p && !hide_rc_p && !ENDP(get_alternate_returns())) {
    entity frc = GetFullyDefinedReturnCodeVariable();
 
    new_apl = gen_nconc(apl, CONS(EXPRESSION, entity_to_expression(frc), NIL));
  }
 
  return new_apl;
}

References CONS, ENDP, entity_to_expression(), EXPRESSION, gen_nconc(), get_alternate_returns(), GetFullyDefinedReturnCodeVariable(), hide_rc_p, NIL, and substitute_rc_p.

Referenced by MakeCallInst().

Here is the call graph for this function:

Here is the caller graph for this function:

add_alternate_return()

void add_alternate_return

(

string

label_name

)

Parameters

label_name

abel_name

Definition at line 242 of file return.c.

{
    entity l = entity_undefined;
 
    if(substitute_rc_p) {
        l = MakeLabel(label_name);
        alternate_returns = arguments_add_entity(alternate_returns, l);
    }
    else {
        pips_user_warning("Lines %d-%d: Alternate return towards label %s not supported. "
                          "Actual label argument internally substituted by a character string.\n",
                          line_b_I, line_e_I, label_name);
    }
}

References alternate_returns, arguments_add_entity(), entity_undefined, line_b_I, line_e_I, MakeLabel(), pips_user_warning, and substitute_rc_p.

Here is the call graph for this function:

add_formal_return_code()

list add_formal_return_code

(

list

fpl

)

Update the formal and actual parameter lists by adding the return code variable as last argument.

To avoid an explicit check in gram.y which is large enough, the additions are conditional to the alternate return substitution.

Type, storage and initial value are set up later in MakeFormalParameter()

Parameters

fpl

pl

Definition at line 209 of file return.c.

{
    list new_fpl = fpl;
 
    if(uses_alternate_return_p() && !hide_rc_p && substitute_rc_p) {
        entity frc = GetReturnCodeVariable();
 
        /* Type, storage and initial value are set up later in MakeFormalParameter() */
        new_fpl = gen_nconc(fpl, CONS(ENTITY, frc, NIL));
    }
    return new_fpl;
}

References CONS, ENTITY, gen_nconc(), GetReturnCodeVariable(), hide_rc_p, NIL, substitute_rc_p, and uses_alternate_return_p().

Referenced by MakeCurrentFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_return_code_checks()

instruction generate_return_code_checks

(

list

labels

)

The reset is controlled from gram.y, as is the set

reset_alternate_returns();

ifdebug(2) {

pips_debug(2, "Additional statement generated for hide_rc_p:\n");

print_statement(s_init_rcv);

}

Parameters

labels

abels

Definition at line 337 of file return.c.

{
    instruction i = instruction_undefined;
    list lln = NIL;
    entity rcv = GetFullyDefinedReturnCodeVariable();
    expression ercv = expression_undefined;
 
    pips_assert("The label list is not empty", !ENDP(labels));
 
 
 
    ercv = entity_to_expression(rcv);
 
    FOREACH(ENTITY, l, labels) {
        lln = CONS(STRING, (char*)label_local_name(l), lln);
    }
 
    i = MakeComputedGotoInst(lln, ercv);
 
    /* The reset is controlled from gram.y, as is the set */
    /* reset_alternate_returns(); */
    gen_free_list(lln);
 
    instruction_consistent_p(i);
 
    if(hide_rc_p) {
      statement s_init_rcv = make_get_rc_statement(entity_to_expression(rcv));
 
      /* ifdebug(2) { */
      /*        pips_debug(2, "Additional statement generated for hide_rc_p:\n"); */
      /*        print_statement(s_init_rcv); */
      /*        } */
      pips_assert("i is a sequence", instruction_block_p(i));
      instruction_block(i) = CONS(STATEMENT, s_init_rcv, instruction_block(i));
      instruction_consistent_p(i);
    }
 
    return i;
}

References CONS, ENDP, ENTITY, entity_to_expression(), expression_undefined, FOREACH, gen_free_list(), GetFullyDefinedReturnCodeVariable(), hide_rc_p, instruction_block, instruction_block_p, instruction_consistent_p(), instruction_undefined, label_local_name(), make_get_rc_statement(), MakeComputedGotoInst(), NIL, pips_assert, STATEMENT, and STRING.

Referenced by MakeCallInst().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateReturn()

void GenerateReturn

(

void

)

Generate a unique call to RETURN per module.

statement c = MakeStatement(l, make_continue_instruction());

Definition at line 499 of file return.c.

{
    instruction inst = instruction_undefined;
    /* statement c = MakeStatement(l, make_continue_instruction()); */
 
 
    if(substitute_rc_p && uses_alternate_return_p()) {
        entity l = MakeLabel(strdup(end_label_local_name));
        expression rc = int_to_expression(0);
        statement src = make_set_rc_statement(rc);
        statement jmp = statement_undefined;
            (MakeZeroOrOneArgCallInst("RETURN", expression_undefined));
 
        statement_number(src) = get_statement_number();
        jmp = MakeStatement(l, MakeZeroOrOneArgCallInst("RETURN", expression_undefined));
        /*
        statement_number(jmp) = get_statement_number();
        (void) get_next_statement_number();
        */
        inst = make_instruction_block(CONS(STATEMENT, src, CONS(STATEMENT, jmp, NIL)));
        instruction_consistent_p(inst);
    }
    else {
        strcpy(lab_I, end_label_local_name);
        inst = MakeZeroOrOneArgCallInst("RETURN", expression_undefined);
    }
 
    LinkInstToCurrentBlock(inst, true);
}

References CONS, end_label_local_name, expression_undefined, get_statement_number(), instruction_consistent_p(), instruction_undefined, int_to_expression(), lab_I, LinkInstToCurrentBlock(), make_instruction_block(), make_set_rc_statement(), MakeLabel(), MakeStatement(), MakeZeroOrOneArgCallInst(), NIL, src, STATEMENT, statement_number, statement_undefined, strdup(), substitute_rc_p, and uses_alternate_return_p().

Referenced by EndOfProcedure().

Here is the call graph for this function:

Here is the caller graph for this function:

get_alternate_returns()

list get_alternate_returns

(

void

)

Definition at line 258 of file return.c.

{
    return alternate_returns;
}

References alternate_returns.

Referenced by add_actual_return_code(), and MakeCallInst().

Here is the caller graph for this function:

get_current_number_of_alternate_returns()

int get_current_number_of_alternate_returns

(

void

)

Definition at line 197 of file return.c.

{
  return current_number_of_alternate_returns;
}

References current_number_of_alternate_returns.

GetFullyDefinedReturnCodeVariable()

static entity GetFullyDefinedReturnCodeVariable ( )

static

Type, storage and initial value may have been set up earlier in MakeFormalParameter().

We must be dealing with the actual variable, not with the formal variable.

Definition at line 115 of file return.c.

{
  entity rc = GetReturnCodeVariable();
 
  /* Type, storage and initial value may have been set up earlier in
     MakeFormalParameter(). */
  if(type_undefined_p(entity_type(rc))) {
    /* We must be dealing with the actual variable, not with the formal
       variable. */
    const char* module_name = get_current_module_name();
    entity f = local_name_to_top_level_entity(module_name);
    entity a = FindEntity(module_name, DYNAMIC_AREA_LOCAL_NAME);
 
    entity_type(rc) = MakeTypeVariable(make_basic(is_basic_int, (void *) 4), NIL);
 
    entity_storage(rc) =
      make_storage(is_storage_ram,
                   make_ram(f, a,
                            add_variable_to_area(a, rc),
                            NIL));
 
    entity_initial(rc) = make_value_unknown();
  }
 
  pips_assert("rc is defined", !entity_undefined_p(rc));
 
  return rc;
}

References add_variable_to_area(), DYNAMIC_AREA_LOCAL_NAME, entity_initial, entity_storage, entity_type, entity_undefined_p, f(), FindEntity(), get_current_module_name(), GetReturnCodeVariable(), is_basic_int, is_storage_ram, local_name_to_top_level_entity(), make_basic(), make_ram(), make_storage(), make_value_unknown(), MakeTypeVariable(), module_name(), NIL, pips_assert, and type_undefined_p.

Referenced by add_actual_return_code(), and generate_return_code_checks().

Here is the call graph for this function:

Here is the caller graph for this function:

GetReturnCodeVariable()

entity GetReturnCodeVariable

(

void

)

Cannot be asserted because the return_code_variable may either be a formal parameter if the current module uses multiple return, or a dynamic variable if it does not and if it calls a subroutine using alternate returns

Definition at line 95 of file return.c.

{
  const char* rc_name = get_string_property("PARSER_RETURN_CODE_VARIABLE");
  /* Cannot be asserted because the return_code_variable may either be a
   * formal parameter if the current module uses multiple return, or
   * a dynamic variable if it does not and if it calls a subroutine
   * using alternate returns
   */
  /*
    pips_assert("entity return_code_variable is undefined",
    entity_undefined_p(return_code_variable));
  */
  return_code_variable = FindEntity(get_current_module_name(), rc_name);
  if(entity_undefined_p(return_code_variable)) {
    return_code_variable = FindOrCreateEntity(get_current_module_name(), rc_name);
  }
 
  return return_code_variable;
}

References entity_undefined_p, FindEntity(), FindOrCreateEntity(), get_current_module_name(), get_string_property(), and return_code_variable.

Referenced by add_formal_return_code(), GetFullyDefinedReturnCodeVariable(), and make_set_rc_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_get_rc_statement()

static statement make_get_rc_statement ( expression  rc_ref )

static

get_rc takes an argument and returns void

Definition at line 291 of file return.c.

{
  statement s_get = statement_undefined;
  instruction i_get = instruction_undefined;
  string get_rc_name = strdup(concatenate(GET_RC_PREFIX,
                                          get_string_property("PARSER_RETURN_CODE_VARIABLE"),
                                          NULL));
  entity get_rc = FindEntity(TOP_LEVEL_MODULE_NAME, get_rc_name);
 
  if(entity_undefined_p(get_rc)) {
    get_rc = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, get_rc_name);
    /* get_rc takes an argument and returns void */
    entity_type(get_rc) =
      make_type(is_type_functional,
                make_functional(CONS(PARAMETER,
                                     make_parameter(make_type(is_type_variable,
                                                              make_variable(make_basic(is_basic_int, (value) 4),
                                                                            NIL,NIL)),
                                                    make_mode(is_mode_reference, UU),
                                                    make_dummy_unknown()),
                                     NIL),
                                make_type(is_type_void, UU)));
    /*
    entity_type(get_rc) =
      make_type(is_type_functional,
                make_functional(NIL,
                                make_type(is_type_variable,
                                          make_variable(make_basic(is_basic_int, (value) 4),
                                                        NIL,NIL))));
    */
    entity_storage(get_rc) = make_storage(is_storage_rom, UU);
    entity_initial(get_rc) = make_value(is_value_code, code_undefined);
    update_called_modules(get_rc);
  }
 
  pips_assert("Function get_rc is defined", !entity_undefined_p(get_rc));
 
  i_get = make_instruction(is_instruction_call,
                           make_call(get_rc, CONS(EXPRESSION, rc_ref, NIL)));
  s_get = instruction_to_statement(i_get);
  statement_number(s_get) = get_statement_number();
 
  return s_get;
}

References code_undefined, concatenate(), CONS, entity_initial, entity_storage, entity_type, entity_undefined_p, EXPRESSION, FindEntity(), FindOrCreateEntity(), GET_RC_PREFIX, get_statement_number(), get_string_property(), instruction_to_statement(), instruction_undefined, is_basic_int, is_instruction_call, is_mode_reference, is_storage_rom, is_type_functional, is_type_variable, is_type_void, is_value_code, make_basic(), make_call(), make_dummy_unknown(), make_functional(), make_instruction(), make_mode(), make_parameter(), make_storage(), make_type(), make_value(), make_variable(), NIL, PARAMETER, pips_assert, statement_number, statement_undefined, strdup(), TOP_LEVEL_MODULE_NAME, update_called_modules(), and UU.

Referenced by generate_return_code_checks().

Here is the call graph for this function:

Here is the caller graph for this function:

make_set_rc_statement()

static statement make_set_rc_statement ( expression  e )

static

The return code may be directly assigned or indirectly through a PIPS run-time function call.

ifdebug(2) {

pips_debug(2, "Statement generated: ");

print_statement(src);

}

Definition at line 421 of file return.c.

{
  expression rc = expression_undefined_p(e)? int_to_expression(0) : e;
  statement src = statement_undefined;
 
  if(hide_rc_p) {
    instruction isrc = make_instruction(is_instruction_call,
                                        make_call(set_rc_function(),
                                                  CONS(EXPRESSION, rc, NIL)));
 
    src = instruction_to_statement(isrc);
  }
  else {
    src = make_assign_statement(entity_to_expression(GetReturnCodeVariable()), rc);
  }
 
  /* ifdebug(2) { */
  /*   pips_debug(2, "Statement generated: "); */
  /*   print_statement(src); */
  /* } */
 
  return src;
}

References CONS, entity_to_expression(), EXPRESSION, expression_undefined_p, GetReturnCodeVariable(), hide_rc_p, instruction_to_statement(), int_to_expression(), is_instruction_call, make_assign_statement(), make_call(), make_instruction(), NIL, set_rc_function(), src, and statement_undefined.

Referenced by GenerateReturn(), and MakeReturn().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeReturn()

instruction MakeReturn

(

expression

e

)

Assign e to the return code variable, but be sure not to count this assignment as a user instruction. Wrap if with the Go To in a block and return the block instruction.

See how code is synthesized for computed goto's...

Let's try to provide more useful information to the user

inst = MakeZeroOrOneArgCallInst("STOP", e);

Definition at line 445 of file return.c.

{
  instruction inst = instruction_undefined;
 
  if(!expression_undefined_p(e) && !substitute_rc_p && !substitute_stop_p) {
    user_error("MakeReturn",
               "Lines %d-%d: Alternate return not supported. "
               "Standard return generated\n",
               line_b_I,line_e_I);
  }
 
  if (end_label == entity_undefined) {
    end_label = MakeLabel(end_label_local_name);
  }
 
  if(substitute_rc_p && uses_alternate_return_p()) {
    /* Assign e to the return code variable, but be sure not to count
     * this assignment as a user instruction. Wrap if with the Go To
     * in a block and return the block instruction.
     *
     * See how code is synthesized for computed goto's...
     */
    statement src = make_set_rc_statement(e);
    statement jmp = instruction_to_statement(MakeGotoInst(end_label_local_name));
 
    statement_number(src) = get_statement_number();
    statement_number(jmp) = get_statement_number();
    //    (void) get_next_statement_number();
    inst = make_instruction_block(CONS(STATEMENT, src, CONS(STATEMENT, jmp, NIL)));
    instruction_consistent_p(inst);
  }
  else if(!expression_undefined_p(e) && substitute_stop_p && uses_alternate_return_p()) {
    /* Let's try to provide more useful information to the user */
    /* inst = MakeZeroOrOneArgCallInst("STOP", e); */
    if(expression_call_p(e)) {
      const char* mn = get_current_module_name();
      const char* sn = entity_local_name(call_function(syntax_call(expression_syntax(e))));
 
      inst = MakeZeroOrOneArgCallInst
        ("STOP",
         MakeCharacterConstantExpression(strdup(concatenate("\"", sn, " in ", mn, "\"", NULL))));
    }
    else {
      pips_internal_error("unexpected argument type for RETURN");
    }
  }
  else {
    inst = MakeGotoInst(end_label_local_name);
  }
 
  return inst;
}

References call_function, concatenate(), CONS, end_label, end_label_local_name, entity_local_name(), entity_undefined, expression_call_p(), expression_syntax, expression_undefined_p, get_current_module_name(), get_statement_number(), instruction_consistent_p(), instruction_to_statement(), instruction_undefined, line_b_I, line_e_I, make_instruction_block(), make_set_rc_statement(), MakeCharacterConstantExpression(), MakeGotoInst(), MakeLabel(), MakeZeroOrOneArgCallInst(), NIL, pips_internal_error, src, STATEMENT, statement_number, strdup(), substitute_rc_p, substitute_stop_p, syntax_call, user_error, and uses_alternate_return_p().

Here is the call graph for this function:

reset_alternate_returns()

void reset_alternate_returns

(

void

)

Definition at line 272 of file return.c.

{
    pips_assert("alternate return list is defined", !list_undefined_p(alternate_returns));
    gen_free_list(alternate_returns);
    alternate_returns = list_undefined;
    current_number_of_alternate_returns = -1;
}

References alternate_returns, current_number_of_alternate_returns, gen_free_list(), list_undefined, list_undefined_p, and pips_assert.

Referenced by soft_reset_alternate_returns().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_current_number_of_alternate_returns()

void reset_current_number_of_alternate_returns

(

void

)

Definition at line 192 of file return.c.

{
  current_number_of_alternate_returns = -1;
}

References current_number_of_alternate_returns.

ResetReturnCodeVariable()

void ResetReturnCodeVariable

(

void

)

Definition at line 151 of file return.c.

{
    return_code_variable = entity_undefined;
}

References entity_undefined, and return_code_variable.

Referenced by EndOfProcedure(), and ParserError().

Here is the caller graph for this function:

ReturnCodeVariableP()

bool ReturnCodeVariableP

(

entity

rcv

)

Parameters

rcv

cv

Definition at line 145 of file return.c.

{
    return rcv == return_code_variable;
}

References return_code_variable.

Referenced by MakeFormalParameter().

Here is the caller graph for this function:

set_alternate_returns()

void set_alternate_returns

(

void

)

Definition at line 264 of file return.c.

{
    pips_assert("alternate return list is undefined", list_undefined_p(alternate_returns));
    alternate_returns = NIL;
    current_number_of_alternate_returns = 0;
}

References alternate_returns, current_number_of_alternate_returns, list_undefined_p, NIL, and pips_assert.

set_current_number_of_alternate_returns()

void set_current_number_of_alternate_returns

(

void

)

Definition at line 187 of file return.c.

{
  current_number_of_alternate_returns = 0;
}

References current_number_of_alternate_returns.

Referenced by gfc2pips_args().

Here is the caller graph for this function:

set_rc_function()

static entity set_rc_function ( )

static

set_rc takes no argument and returns a scalar int

Definition at line 389 of file return.c.

{
  string set_rc_name = strdup(concatenate(SET_RC_PREFIX,
                                          get_string_property("PARSER_RETURN_CODE_VARIABLE"),
                                          NULL));
  entity set_rc = FindEntity(TOP_LEVEL_MODULE_NAME, set_rc_name);
 
  if(entity_undefined_p(set_rc)) {
    set_rc = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, set_rc_name);
    /* set_rc takes no argument and returns a scalar int */
    entity_type(set_rc) =
      make_type(is_type_functional,
                make_functional(CONS(PARAMETER,
                                     make_parameter(make_type(is_type_variable,
                                                              make_variable(make_basic(is_basic_int, (value) 4),
                                                                            NIL,NIL)),
                                                    make_mode(is_mode_reference, UU),
                                                    make_dummy_unknown()),
                                     NIL),
                                make_type(is_type_void, UU)));
    entity_storage(set_rc) = make_storage(is_storage_rom, UU);
    entity_initial(set_rc) = make_value(is_value_code, code_undefined);
    update_called_modules(set_rc);
  }
 
  pips_assert("Function set_rc is defined", !entity_undefined_p(set_rc));
 
  return set_rc;
}

References code_undefined, concatenate(), CONS, entity_initial, entity_storage, entity_type, entity_undefined_p, FindEntity(), FindOrCreateEntity(), get_string_property(), is_basic_int, is_mode_reference, is_storage_rom, is_type_functional, is_type_variable, is_type_void, is_value_code, make_basic(), make_dummy_unknown(), make_functional(), make_mode(), make_parameter(), make_storage(), make_type(), make_value(), make_variable(), NIL, PARAMETER, pips_assert, SET_RC_PREFIX, strdup(), TOP_LEVEL_MODULE_NAME, update_called_modules(), and UU.

Referenced by make_set_rc_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

soft_reset_alternate_returns()

void soft_reset_alternate_returns

(

void

)

ParserError() cannot guess if it has been performed or not, because it is reinitialized before and after each call statement.

If the error occurs within a call, alternate returns must be reset. Else they should not be reset.

Definition at line 284 of file return.c.

{
  if(!list_undefined_p(alternate_returns)) {
    reset_alternate_returns();
  }
}

References alternate_returns, list_undefined_p, and reset_alternate_returns().

Referenced by ParserError().

Here is the call graph for this function:

Here is the caller graph for this function:

SubstituteAlternateReturns()

void SubstituteAlternateReturns

(

const char *

option

)

return.c

Parameters

option

ption

Definition at line 59 of file return.c.

{
    substitute_rc_p = (strcmp(option, "RC")==0) || (strcmp(option, "HRC")==0) ;
    hide_rc_p = (strcmp(option, "HRC")==0) ;
    substitute_stop_p = (strcmp(option, "STOP")==0);
 
    if(!(substitute_rc_p || substitute_stop_p || strcmp(option, "NO")==0)) {
        user_log("Unknown option \"%s\" for property "
                 "PARSER_SUBSTITUTE_ALTERNATE_RETURNS.\n"
                 "Three options are available for alternate return handling: "
                 "\"NO\", \"RC\" and \"STOP\"\n", option);
        ParserError("SubstituteAlternateReturns", "Illegal property value");
    }
 
    if((substitute_rc_p || substitute_stop_p)
       && !get_bool_property("PRETTYPRINT_ALL_DECLARATIONS"))
        user_warning("SubstituteAlternateReturns",
                     "Module declarations should be regenerated."
                     " Set property PRETTYPRINT_ALL_DECLARATIONS.\n");
}

References get_bool_property(), hide_rc_p, ParserError(), substitute_rc_p, substitute_stop_p, user_log(), and user_warning.

Referenced by EndOfProcedure(), MakeCurrentFunction(), and ParserError().

Here is the call graph for this function:

Here is the caller graph for this function:

SubstituteAlternateReturnsP()

bool SubstituteAlternateReturnsP

(

void

)

Definition at line 81 of file return.c.

{
    return substitute_rc_p;
}

References substitute_rc_p.

Referenced by MakeCallInst(), and MakeFormalParameter().

Here is the caller graph for this function:

uses_alternate_return()

void uses_alternate_return

(

bool

use

)

Parameters

use

se

Definition at line 171 of file return.c.

{
  if(use && strcmp(get_string_property("PARSER_SUBSTITUTE_ALTERNATE_RETURNS"), "NO")==0) {
    pips_user_warning
      ("Lines %d-%d: Alternate return not processed with current option \"%s\". "
       "Formal label * ignored.\n"
       "See property PARSER_SUBSTITUTE_ALTERNATE_RETURNS for other options\n",
       line_b_I, line_e_I, get_string_property("PARSER_SUBSTITUTE_ALTERNATE_RETURNS"));
    ParserError("uses_alternate_return", "Alternate returns prohibited by user\n");
  }
 
  current_number_of_alternate_returns++;
 
  current_module_uses_alternate_returns = use;
}

References current_module_uses_alternate_returns, current_number_of_alternate_returns, get_string_property(), line_b_I, line_e_I, ParserError(), and pips_user_warning.

Referenced by EndOfProcedure(), and ParserError().

Here is the call graph for this function:

Here is the caller graph for this function:

uses_alternate_return_p()

bool uses_alternate_return_p

(

void

)

Definition at line 166 of file return.c.

{
    return current_module_uses_alternate_returns;
}

References current_module_uses_alternate_returns.

Referenced by add_formal_return_code(), GenerateReturn(), and MakeReturn().

Here is the caller graph for this function:

Variable Documentation

alternate_returns

list alternate_returns = list_undefined

static

Keep track of the labels used as actual arguments for alternate returns and generate the tests to check the return code.

Definition at line 239 of file return.c.

Referenced by add_alternate_return(), get_alternate_returns(), reset_alternate_returns(), set_alternate_returns(), and soft_reset_alternate_returns().

current_module_uses_alternate_returns

bool current_module_uses_alternate_returns = false

static

Remember if the current module uses alternate returns.

If yes, the RETURN statements must include an assignment to the return code variable.

Definition at line 161 of file return.c.

Referenced by uses_alternate_return(), and uses_alternate_return_p().

current_number_of_alternate_returns

int current_number_of_alternate_returns = -1

static

The current number of alternate returns is used to process a module declaration.

Definition at line 164 of file return.c.

Referenced by get_current_number_of_alternate_returns(), reset_alternate_returns(), reset_current_number_of_alternate_returns(), set_alternate_returns(), set_current_number_of_alternate_returns(), and uses_alternate_return().

end_label

LOCAL entity end_label = entity_undefined

This function creates a goto instruction to label end_label.

This is done to eliminate return statements.

Note: I was afraid the mouse trap would not work to analyze multiple procedures but there is no problem. I guess that MakeGotoInst() generates the proper label entity regardless of end_label. FI.

Definition at line 386 of file return.c.

Referenced by MakeReturn().

end_label_local_name

LOCAL char* end_label_local_name = RETURN_LABEL_NAME

Definition at line 387 of file return.c.

Referenced by GenerateReturn(), and MakeReturn().

hide_rc_p

bool hide_rc_p = false

static

Definition at line 54 of file return.c.

Referenced by add_actual_return_code(), add_formal_return_code(), generate_return_code_checks(), make_set_rc_statement(), and SubstituteAlternateReturns().

return_code_variable

entity return_code_variable = entity_undefined

static

Variable used to carry return code replacing the alternate returns.

This variable may be either a formal parameter if the module uses alternate returns, or a dynamic variable if it uses such a module. When both conditions are true, the return code is a formal parameter.

Definition at line 93 of file return.c.

Referenced by GetReturnCodeVariable(), ResetReturnCodeVariable(), and ReturnCodeVariableP().

substitute_rc_p

bool substitute_rc_p = false

static

Handling of RETURN statements and substitution of alternate returns.

Most of the code deals with alternate returns. Functions GenerateReturn() and MakeReturn() are sufficient to process regular RETURN statements.

Francois Irigoin Should alternate returns be substituted or not ?

If alternate returns are substituted, the code declarations should be regenerated unless hide_rc_p is true and some PIPS run-time Fortran functions provided. The corresponding property should be checked.

Definition at line 52 of file return.c.

Referenced by add_actual_return_code(), add_alternate_return(), add_formal_return_code(), GenerateReturn(), MakeReturn(), SubstituteAlternateReturns(), and SubstituteAlternateReturnsP().

substitute_stop_p

bool substitute_stop_p = false

static

Definition at line 53 of file return.c.

Referenced by MakeReturn(), and SubstituteAlternateReturns().