fortran90.c File Reference

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

Include dependency graph for fortran90.c:

Go to the source code of this file.

Functions
expression	update_range (f, r, expression lw, expression up, expression in, bool left)
	Prettyprint one FORTRAN 90 loop as an array expression. More...

Function Documentation

update_range()

expression update_range	(	f	,
		r	,
		expression	lw,
		expression	up,
		expression	in,
		bool	left
	)

Prettyprint one FORTRAN 90 loop as an array expression.

Pierre Jouvelot

For one level only loop, with one assignment as body. Replaces occurences of the index variable by ranges in expressions. Ranges are prettyprinted as triplet when they occur as subscript expressions and as vectors with implicit DO otherwise. If the replacement cannot occur, for instance because subscript expressions are coupled, the loop is printed as a loop.

There are/were memory leaks here since a new expression is constructed. Entity f is supposed to be a binary operator, not always commutative but meaningful for a range and a scalar or for two ranges. Boolean argument left means that range r appears on the left of f, i.e. as first operator.

No sharing is created between the new expression e and arguments r, lw, up or in.

expression "in" must be integer constant 1

Definition at line 61 of file fortran90.c.

{
    range new_r = copy_range(r);
    intptr_t val = 0;
    expression new_up = copy_expression(up);
    expression new_lw = copy_expression(lw);
    expression new_in = copy_expression(in);
    expression e = expression_undefined;
 
    pips_assert("new_r is consistent before update", range_consistent_p(new_r));
 
    if(left) {
        range_lower( new_r ) = MakeBinaryCall(f, range_lower(new_r), new_lw);
        range_upper( new_r ) = MakeBinaryCall(f, range_upper(new_r), new_up);
    }
    else {
        range_lower( new_r ) = MakeBinaryCall(f, new_lw, range_lower(new_r));
        range_upper( new_r ) = MakeBinaryCall(f, new_up, range_upper(new_r));
    }
 
    pips_assert("new_r is consistent", range_consistent_p(new_r));
        
    if( strcmp( entity_local_name( f ), MULTIPLY_OPERATOR_NAME ) == 0 ) {
        /* expression "in" must be integer constant 1 */
        pips_assert("This is a scalar value", lw==up);
        free_expression(range_increment( new_r ));
        range_increment( new_r ) = 
                MakeBinaryCall(f, new_in, copy_expression(range_lower(new_r))) ;
    }
        
    if( !left && (strcmp( entity_local_name( f ), MINUS_OPERATOR_NAME ) == 0) ) {
        entity um = entity_intrinsic(UNARY_MINUS_OPERATOR_NAME);
 
        range_increment( new_r ) = 
                MakeUnaryCall(um, range_increment(new_r)) ;
    }
 
    if(expression_integer_value(range_lower(new_r), &val)) {
        free_expression(range_lower(new_r));
        range_lower(new_r) = int_to_expression(val);
    }
 
    if(expression_integer_value(range_upper(new_r), &val)) {
        free_expression(range_upper(new_r));
        range_upper(new_r) = int_to_expression(val);
    }
 
    if(expression_integer_value(range_increment(new_r), &val)) {
        free_expression(range_increment(new_r));
        range_increment(new_r) = int_to_expression(val);
    }
 
    pips_assert("new_r is consistent after simplification", range_consistent_p(new_r));
 
    e = make_expression(make_syntax(is_syntax_range, new_r),
                        normalized_undefined);
 
    return e;
}

References copy_expression(), copy_range(), entity_intrinsic(), entity_local_name(), expression_integer_value(), expression_undefined, f(), free_expression(), int_to_expression(), intptr_t, is_syntax_range, make_expression(), make_syntax(), MakeBinaryCall(), MakeUnaryCall(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, normalized_undefined, pips_assert, range_consistent_p(), range_increment, range_lower, range_upper, and UNARY_MINUS_OPERATOR_NAME.

Referenced by expand_call().

Here is the call graph for this function:

Here is the caller graph for this function: