control.c File Reference

#include "local.h"

Include dependency graph for control.c:

Go to the source code of this file.

Functions
void	modify_blocks (control c)
	– control.c More...
void	atom_get_blocs (c, l)
	=========================================================================== More...
control	find_control_block (control c)
	=========================================================================== More...

Function Documentation

atom_get_blocs()

void atom_get_blocs	(	c	,
		l
	)

===========================================================================

void atom_get_blocs(control c, cons **l): Almost the get_blocs() of the file control/control.h; the only modification is the call to modify_blocks() which adds a node to the control graph that will contain the instructions created by the translation of the statement contained in "c".

Definition at line 85 of file control.c.

{
MAPL( cs, {if( CONTROL( CAR( cs )) == c ) return ;}, *l ) ;
*l = CONS( CONTROL, c, *l ) ;
 
modify_blocks(c);
 
MAPL( cs, {atom_get_blocs( CONTROL( CAR( cs )), l );},
      control_successors( c )) ;
 
MAPL( ps, {atom_get_blocs( CONTROL( CAR( ps )), l );},
      control_predecessors( c )) ;
}

References CAR, CONS, CONTROL, control_predecessors, control_successors, MAPL, and modify_blocks().

Here is the call graph for this function:

find_control_block()

control find_control_block

(

control

c

)

===========================================================================

control find_control_block(control c): Returns the current control found in the static variable "cont_block".

The use of this function is: _ first, in order to initialize the static "cont_block" this function is called with the control we want to memorize. _ then, when we need to get this control, this function is called with the argument "control_undefined".

This is used by atomizer_of_statement() when we generate new statements.

Definition at line 115 of file control.c.

{
static control cont_block;
 
if(c != control_undefined)
  {
  instruction inst = statement_instruction(control_statement(c));
  if(instruction_tag(inst) != is_instruction_block)
    cont_block = CONTROL(CAR(control_predecessors(c)));
  else
    cont_block = control_undefined;
  }
 
return(cont_block);
}

References CAR, CONTROL, control_predecessors, control_statement, control_undefined, instruction_tag, is_instruction_block, and statement_instruction.

Referenced by atomizer_of_statement(), and atomizer_of_unstructured().

Here is the caller graph for this function:

modify_blocks()

void modify_blocks

(

control

c

)

– control.c

control.c

package atomizer : Alexis Platonoff, juillet 91

Functions for the manipulations and modifications of the control graph. =========================================================================== void modify_blocks(control c): Adds a node to the control graph when the statement of "c" is not an "instruction_block".

This node is added just before "c". "c" predecessor became the new node. The latter's predecessors are those of "c", its successor is "c".

"l_inst" keep the reference to the instructions for which a new node is added. It is a global variable that will be used when we will generate new statements (see atomizer_of_statement(), in atomizer.c).

Called functions : _ make_empty_statement() : ri-util/statement.c

Definition at line 51 of file control.c.

{
extern list l_inst;
 
control nc;
instruction inst = statement_instruction(control_statement(c));
 
if (instruction_tag(inst) != is_instruction_block)
  {
  if (! instruction_in_list_p(inst, l_inst))
    {
    nc = make_control(control_statement(c), NIL, NIL);
    control_statement(c) = make_empty_statement();
 
    control_successors(nc) = control_successors(c);
    control_predecessors(nc) = CONS(CONTROL, c, NIL);
 
    control_successors(c) = CONS(CONTROL, nc, NIL);
 
    l_inst = CONS(INSTRUCTION, inst, l_inst);
    }
  }
}

References CONS, CONTROL, control_predecessors, control_statement, control_successors, INSTRUCTION, instruction_in_list_p(), instruction_tag, is_instruction_block, l_inst, make_control(), make_empty_statement, NIL, and statement_instruction.

Referenced by atom_get_blocs().

Here is the call graph for this function:

Here is the caller graph for this function: