macros.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.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 macros.c:

Go to the source code of this file.

Data Structures
struct	macro_t

Functions
void	parser_init_macros_support (void)
	next available chunk More...
void	parser_close_macros_support (void)
static macro_t *	find_entity_macro (entity e)
bool	parser_entity_macro_p (entity e)
void	parser_add_a_macro (call c, expression e)
static bool	call_flt (call c)
static bool	untrusted_call_p (expression e)
static bool	expr_flt (expression e)
static void	expr_rwt (expression e)
static void	substitute_expression_in_expression (expression tree, expression initial, expression replacement)
	substitutes occurences of initial by replacement in tree More...
void	reset_substitute_expression_in_expression (void)
void	parser_macro_expansion (expression e)
void	parser_substitute_all_macros (statement s)
void	parser_substitute_all_macros_in_expression (expression e)

Variables
static macro_t *	current_macros
static int	current_macros_size = 0
static int	current_macro_index = 0
static bool	some_call
	is there a call to some untrusted function? More...
static expression	s_init = expression_undefined
	must take care not to substitute in an inserted expression More...
static expression	s_repl = expression_undefined
static list	already_subs = NIL
	of expression More...

Function Documentation

call_flt()

static bool call_flt ( call  c )

static

else untrusted!

Definition at line 152 of file macros.c.

{
    value v = entity_initial(call_function(c));
    if (value_intrinsic_p(v) || value_constant_p(v) || value_symbolic_p(v))
        return true;
    /* else untrusted!
     */
    some_call = true;
    gen_recurse_stop(NULL);
    return false;
}

References call_function, entity_initial, gen_recurse_stop(), some_call, value_constant_p, value_intrinsic_p, and value_symbolic_p.

Referenced by untrusted_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_flt()

static bool expr_flt ( expression  e )

static

Definition at line 180 of file macros.c.

{
    return !gen_in_list_p(e, already_subs);
}

References already_subs, and gen_in_list_p().

Referenced by substitute_expression_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_rwt()

static void expr_rwt ( expression  e )

static

Definition at line 185 of file macros.c.

{
    if (expression_equal_p(s_init, e)) 
    {
        free_syntax(expression_syntax(e));
        expression_syntax(e) = copy_syntax(expression_syntax(s_repl));
        already_subs = CONS(EXPRESSION, e, already_subs);
    }
}

References already_subs, CONS, copy_syntax(), EXPRESSION, expression_equal_p(), expression_syntax, free_syntax(), s_init, and s_repl.

Referenced by substitute_expression_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

find_entity_macro()

static macro_t* find_entity_macro ( entity  e )

static

not found

Definition at line 98 of file macros.c.

{
    int i;
    for (i=0; i<current_macro_index; i++)
        if (same_entity_p(e, call_function(current_macros[i].lhs)))
            return &current_macros[i];
    
    return NULL; /* not found */
}

References call_function, current_macro_index, current_macros, and same_entity_p().

Referenced by parser_add_a_macro(), parser_entity_macro_p(), and parser_macro_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_add_a_macro()

void parser_add_a_macro	(	call	c,
		expression	e
	)

resize!

expand macros in the macro! It is ok, because referenced macros must appear in preceding lines (F77 15-5, line 3-5).

store the result.

Definition at line 113 of file macros.c.

{
    entity macro = call_function(c);
 
    pips_debug(5, "adding macro %s\n", entity_name(macro));
    pips_assert("macros support initialized", current_macros_size>0);
 
    if (current_macro_index>=current_macros_size) /* resize! */
    {
        current_macros_size*=2;
        current_macros = (macro_t*) 
            realloc(current_macros, sizeof(macro_t)*current_macros_size);
        pips_assert("realloc ok", current_macros);
    }
    
    if (find_entity_macro(macro) != NULL) {
      pips_user_warning("Macro \"%s\" is not yet defined.\n", 
                        entity_name(macro));
      ParserError("parser_add_a_macro",
                  "It may be an undeclared array.\n");
    }
 
    /* expand macros in the macro! It is ok, because
     * referenced macros must appear in preceding lines (F77 15-5, line 3-5).
     */
    parser_substitute_all_macros_in_expression(e);
 
    /* store the result.
     */
    current_macros[current_macro_index].lhs = c;
    current_macros[current_macro_index].rhs = e;
    current_macro_index++;
}

References call_function, current_macro_index, current_macros, current_macros_size, entity_name, find_entity_macro(), macro_t::lhs, parser_substitute_all_macros_in_expression(), ParserError(), pips_assert, pips_debug, pips_user_warning, and macro_t::rhs.

Referenced by MakeAssignInst().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_close_macros_support()

void parser_close_macros_support

(

void

)

what about the entity? It might exist such a real top-level entity... what if added as a callee... the entity should be destroyed... best would be to have it as a local entity, and have the calles and top-level updates delayed.

Definition at line 72 of file macros.c.

{
    pips_debug(5, "closing macro-expansion support stuff\n");
 
    for (current_macro_index--; current_macro_index>=0; current_macro_index--)
    {
        call c;
        entity macro;
 
        free_expression(current_macros[current_macro_index].rhs);
        c = current_macros[current_macro_index].lhs;
 
        macro = call_function(c);
        free_call(c);
 
        /* what about the entity? 
         * It might exist such a real top-level entity...
         * what if added as a callee...
         * the entity should be destroyed...
         * best would be to have it as a local entity,
         * and have the calles and top-level updates delayed.
         */
        remove_from_called_modules(macro);
    }
}

References call_function, current_macro_index, current_macros, free_call(), free_expression(), macro_t::lhs, pips_debug, and remove_from_called_modules().

Referenced by EndOfProcedure().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_entity_macro_p()

bool parser_entity_macro_p

(

entity

e

)

Definition at line 108 of file macros.c.

{
    return find_entity_macro(e)==NULL;
}

References find_entity_macro().

Here is the call graph for this function:

parser_init_macros_support()

void parser_init_macros_support

(

void

)

next available chunk

macros.c

??? memory leak...

Definition at line 57 of file macros.c.

{
    pips_debug(5, "initializing macro-expansion support stuff\n");
 
    current_macro_index = 0; /* ??? memory leak... */
    
    if (current_macros_size==0)
    {
        current_macros_size = 10;
        current_macros = (macro_t*)
            malloc(sizeof(macro_t)*current_macros_size);
        pips_assert("malloc ok", current_macros);
    }
}

References current_macro_index, current_macros, current_macros_size, malloc(), pips_assert, and pips_debug.

Referenced by the_actual_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_macro_expansion()

void parser_macro_expansion

(

expression

e

)

of expression

get the macro definition.

duplicated, for latter subs.

replace each formal by its actual.

MUST be a simple reference

if the replacement is a constant, or a reference without calls to external functions, it should be safe

it is important to keep the same expression, for gen_recurse use.

Definition at line 224 of file macros.c.

{
    bool warned = false;
    macro_t * def;
    call c, lhs;
    entity macro;
    expression rhs;
    list /* of expression */ lactuals, lformals;
 
    if (!expression_call_p(e)) return;
    
    c = syntax_call(expression_syntax(e));
    macro = call_function(c);
    lactuals = call_arguments(c);
 
    /* get the macro definition. */
    def = find_entity_macro(macro);
 
    if (def==NULL) {
        pips_debug(5, "no macro definition for %s\n", entity_name(macro));
        return;
    }
 
    lhs = def->lhs;
    rhs = copy_expression(def->rhs); /* duplicated, for latter subs. */
 
    pips_assert("right macro function", macro == call_function(lhs));
    
    lformals = call_arguments(lhs);
 
    pips_assert("same #args", gen_length(lactuals)==gen_length(lformals));
 
    reset_substitute_expression_in_expression();
 
    /* replace each formal by its actual.
     */
    for (; !ENDP(lactuals); POP(lactuals), POP(lformals))
    {
        expression actu, form;
 
        form = EXPRESSION(CAR(lformals)); /* MUST be a simple reference */
        pips_assert("dummy arg ok", 
                    expression_reference_p(form) &&
          ENDP(reference_indices(syntax_reference(expression_syntax(form)))));
 
        /* if the replacement is a constant, or a reference without
         * calls to external functions, it should be safe 
         */
        actu = EXPRESSION(CAR(lactuals));
 
        if (!warned && untrusted_call_p(actu)) {
            pips_user_warning("maybe non safe substitution of macro %s!\n",
                              module_local_name(macro));
            warned = true;
        }
 
        substitute_expression_in_expression(rhs, form, actu);
    }
 
    reset_substitute_expression_in_expression();
 
    /* it is important to keep the same expression, for gen_recurse use.
     */
    free_syntax(expression_syntax(e));
    expression_syntax(e) = expression_syntax(rhs);
    expression_syntax(rhs) = syntax_undefined;
    free(rhs);
}

References call_arguments, call_function, CAR, copy_expression(), ENDP, entity_name, EXPRESSION, expression_call_p(), expression_reference_p(), expression_syntax, find_entity_macro(), free(), free_syntax(), gen_length(), macro_t::lhs, module_local_name(), pips_assert, pips_debug, pips_user_warning, POP, reference_indices, reset_substitute_expression_in_expression(), macro_t::rhs, substitute_expression_in_expression(), syntax_call, syntax_reference, syntax_undefined, and untrusted_call_p().

Referenced by parser_substitute_all_macros().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_substitute_all_macros()

void parser_substitute_all_macros

(

statement

s

)

Definition at line 294 of file macros.c.

{
    if (current_macro_index>0 &&
        get_bool_property("PARSER_EXPAND_STATEMENT_FUNCTIONS"))
        gen_recurse(s, expression_domain, gen_true, parser_macro_expansion);
}

References current_macro_index, expression_domain, gen_recurse, gen_true(), get_bool_property(), and parser_macro_expansion().

Referenced by EndOfProcedure(), and parser_substitute_all_macros_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_substitute_all_macros_in_expression()

void parser_substitute_all_macros_in_expression

(

expression

e

)

Definition at line 302 of file macros.c.

{
  parser_substitute_all_macros((statement)e);
}

References parser_substitute_all_macros().

Referenced by parser_add_a_macro().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_substitute_expression_in_expression()

void reset_substitute_expression_in_expression

(

void

)

Definition at line 218 of file macros.c.

{
    gen_free_list(already_subs); 
    already_subs = NIL;
}

References already_subs, gen_free_list(), and NIL.

Referenced by parser_macro_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_expression_in_expression()

static void substitute_expression_in_expression ( expression  tree, expression  initial, expression  replacement  )

static

substitutes occurences of initial by replacement in tree

ifdebug(8) {

pips_debug(8, "tree/initial/replacement\n");

print_expression(tree);

print_expression(initial);

print_expression(replacement);

}

Definition at line 197 of file macros.c.

{
    /* ifdebug(8) { */
    /*  pips_debug(8, "tree/initial/replacement\n"); */
    /*  print_expression(tree); */
    /*  print_expression(initial); */
    /*  print_expression(replacement); */
    /* } */
 
    s_init = initial; 
    s_repl = replacement;
 
    gen_recurse(tree, expression_domain, expr_flt, expr_rwt);
 
    s_init = expression_undefined;
    s_repl = expression_undefined;
}

References expr_flt(), expr_rwt(), expression_domain, expression_undefined, gen_recurse, s_init, and s_repl.

Referenced by parser_macro_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

untrusted_call_p()

static bool untrusted_call_p ( expression  e )

static

Definition at line 164 of file macros.c.

{
    some_call = false;
    gen_recurse(e, call_domain, call_flt, gen_null);
    return some_call;
}

References call_domain, call_flt(), gen_null(), gen_recurse, and some_call.

Referenced by parser_macro_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

already_subs

list already_subs = NIL

static

of expression

Definition at line 178 of file macros.c.

Referenced by expr_flt(), expr_rwt(), and reset_substitute_expression_in_expression().

current_macro_index

int current_macro_index = 0

static

Definition at line 55 of file macros.c.

Referenced by find_entity_macro(), parser_add_a_macro(), parser_close_macros_support(), parser_init_macros_support(), and parser_substitute_all_macros().

current_macros

macro_t* current_macros

static

Definition at line 53 of file macros.c.

Referenced by find_entity_macro(), parser_add_a_macro(), parser_close_macros_support(), and parser_init_macros_support().

current_macros_size

int current_macros_size = 0

static

Definition at line 54 of file macros.c.

Referenced by parser_add_a_macro(), and parser_init_macros_support().

s_init

expression s_init = expression_undefined

static

must take care not to substitute in an inserted expression

Definition at line 177 of file macros.c.

Referenced by expr_rwt(), MakeAssignedOrComputedGotoInst(), and substitute_expression_in_expression().

s_repl

expression s_repl = expression_undefined

static

Definition at line 177 of file macros.c.

Referenced by expr_rwt(), and substitute_expression_in_expression().

some_call

bool some_call

static

is there a call to some untrusted function?

Definition at line 150 of file macros.c.

Referenced by call_flt(), and untrusted_call_p().