phrase_tools.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "text-util.h"
#include "dg.h"
#include "phrase_tools.h"

Include dependency graph for phrase_tools.c:

Go to the source code of this file.

Data Structures
struct	statement_checking_context
struct	sequence_searching_context

Functions
string	statement_type_as_string (statement stat)
	DEBUG FUNCTION: return a string representing the type of the statement (SEQUENCE, CALL, etc...) More...
void	debug_statement (const char *comments, statement stat, int debug_level)
	DEBUG FUNCTION: print debugging informations for a statement stat. More...
void	debug_control (const char *comments, control a_control, int debug_level)
	DEBUG FUNCTION: print debugging informations for a control a_control. More...
void	debug_unstructured (unstructured an_unstructured, int debug_level)
	DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured. More...
void	short_debug_unstructured (unstructured an_unstructured, int debug_level)
	DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured (short version) More...
entity	clone_variable_with_new_name (entity a_variable, const char *new_name, const char *module_name)
	This function build and return new variable from a variable a_variable, with name new_name. More...
entity	make_variable_from_name_and_entity (entity cloned_variable, const char *base_name, statement stat, const char *module_name)
	Build and return new entity obtained by cloning variable cloned_variable, with a name obtained by the concatenation of base_name and the statement ordering of statement stat. More...
statement	make_binary_call_statement (const char *operator_name, expression expression1, expression expression2, statement stat)
	Build and return new statement which is a binary call with the 2 expressions expression1 and expression2, with empty label, statement number and ordering of statement stat, and empty comments. More...
statement	make_assignement_statement (entity a_variable, expression an_expression, statement stat)
	Build and return new statement which is a assignement of variable a_variable with expression an_expression, with empty label, statement number and ordering of statement stat, and empty comments. More...
int	beautify_ordering (int an_ordering)
	Special function made for Ronan Keryell who likes a lot when a integer number is coded on 3 bits :-) More...
void	clean_statement_from_tags (const char *comment_portion, statement stat)
static void	check_if_statement_contains_comment (statement s, void *a_context)
list	get_statements_with_comments_containing (const char *comment_portion, statement stat)
bool	statement_is_contained_in_a_sequence_p (statement root_statement, statement searched_stat)
static void	search_sequence_containing (statement s, void *a_context)
statement	sequence_statement_containing (statement root_statement, statement searched_stat)
void	replace_in_sequence_statement_with (statement old_stat, statement new_stat, statement root_stat)
	Replace statement old_stat by statement new_stat, asserting that this statement is contained in a sequence. More...
list	references_for_regions (list l_regions)
	Return a list of references corresponding to a list of regions. More...

Function Documentation

beautify_ordering()

int beautify_ordering

(

int

an_ordering

)

Special function made for Ronan Keryell who likes a lot when a integer number is coded on 3 bits :-)

Parameters

an_ordering

n_ordering

Definition at line 407 of file phrase_tools.c.

{
  int ordering_up = (an_ordering & 0xffff0000) >> 16;
  int ordering_down = (an_ordering & 0x0000ffff);
  return ordering_up + ((ordering_down-1) << 16);
}

Referenced by debug_unstructured(), entry_state_variable_value_for_unstructured(), and make_transition_statement().

Here is the caller graph for this function:

check_if_statement_contains_comment()

static void check_if_statement_contains_comment ( statement  s, void *  a_context  )

static

ips_debug(5, "Searching comment: [%s] in [%s]\n", context->searched_string, comments);

Definition at line 459 of file phrase_tools.c.

{
  statement_checking_context* context = (statement_checking_context*)a_context;
  string comments;
 
  if (!statement_with_empty_comment_p(s)) {
   
    comments = strdup(statement_comments(s));
   
    /*pips_debug(5, "Searching comment: [%s] in [%s]\n",
      context->searched_string, comments);*/
     
    if (strstr(comments,context->searched_string) != NULL) {
      context->list_of_statements
        = CONS(STATEMENT,s,context->list_of_statements);
    }
  }
}

References CONS, STATEMENT, statement_comments, statement_with_empty_comment_p(), and strdup().

Referenced by get_statements_with_comments_containing().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_statement_from_tags()

void clean_statement_from_tags	(	const char *	comment_portion,
		statement	stat
	)

Parameters

comment_portion	omment_portion
stat	tat

Definition at line 414 of file phrase_tools.c.

{
  string comments;
  char*  next_line;
  string searched_string;
 
  if (!statement_with_empty_comment_p(stat)) {
 
    string new_comments = NULL;
 
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok (comments, "\n");
    if (next_line != NULL) {
      do {
        if (strstr(next_line,searched_string) == NULL) {
          if (new_comments != NULL) {
            new_comments = strdup(concatenate(new_comments, next_line, "\n", NULL));
          }
          else {
            new_comments = strdup(concatenate("", next_line, "\n", NULL));
          }
        }
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
   
    if (new_comments != NULL) {
      statement_comments(stat) = new_comments;
    }
    else {
      statement_comments(stat) = empty_comments;
    }
  }
   
}

References concatenate(), empty_comments, statement_comments, statement_with_empty_comment_p(), and strdup().

Referenced by remove_begin_tag(), and remove_end_tag().

Here is the call graph for this function:

Here is the caller graph for this function:

clone_variable_with_new_name()

entity clone_variable_with_new_name	(	entity	a_variable,
		const char *	new_name,
		const char *	module_name
	)

This function build and return new variable from a variable a_variable, with name new_name.

If an entity called new_name already exists, return NULL. New variable is added to declarations

Assert that module represent a value code

This entity does not exist, we can safely create it

new_variable = copy_entity (a_variable); entity_name(new_variable) = strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL));

ew_variable = find_or_create_scalar_entity (strdup(concatenate(module_name, MODULE_SEP_STRING, new_name, NULL)),module_name, is_basic_int);

This entity already exist, we return null

Parameters

a_variable	_variable
new_name	ew_name
module_name	odule_name

Definition at line 269 of file phrase_tools.c.

{
  entity module;
  entity new_variable;
 
  module = module_name_to_entity(module_name);
  /* Assert that module represent a value code */
  pips_assert("it is a code", value_code_p(entity_initial(module)));
 
  if ((gen_find_tabulated(concatenate(module_name,
                                      MODULE_SEP_STRING,
                                      new_name,
                                      NULL),
                          entity_domain)) == entity_undefined)
    {
      /* This entity does not exist, we can safely create it */
     
      /* new_variable = copy_entity (a_variable);
         entity_name(new_variable) 
         = strdup(concatenate(module_name,
         MODULE_SEP_STRING,
         new_name, NULL)); */
     
      new_variable = make_entity (strdup(concatenate(module_name,
                                                     MODULE_SEP_STRING,
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  copy_storage (entity_storage(a_variable)),
                                  copy_value (entity_initial(a_variable)));
     
      /*new_variable
        = find_or_create_scalar_entity (strdup(concatenate(module_name,
        MODULE_SEP_STRING,
        new_name, NULL)),module_name,
        is_basic_int);*/
     
      AddEntityToDeclarations(new_variable,module);
      return new_variable;
    }
  else
    {
      /* This entity already exist, we return null */
      return NULL;
    }
}

References a_variable, AddEntityToDeclarations(), concatenate(), copy_storage(), copy_type(), copy_value(), entity_domain, entity_initial, entity_storage, entity_type, entity_undefined, gen_find_tabulated(), make_entity, module, module_name(), module_name_to_entity(), MODULE_SEP_STRING, new_variable, pips_assert, strdup(), and value_code_p.

Referenced by make_variable_from_name_and_entity(), and new_local_image_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_control()

void debug_control	(	const char *	comments,
		control	a_control,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for a control a_control.

Parameters

comments	omments
a_control	_control
debug_level	ebug_level

Definition at line 134 of file phrase_tools.c.

                                                                              {
 
  debug_statement (comments, control_statement(a_control), debug_level);
  pips_debug(debug_level,"  predecessors          = %zd\n", gen_length(control_predecessors(a_control)));
  pips_debug(debug_level,"  successors            = %zd\n", gen_length(control_successors(a_control)));
 
}

References control_predecessors, control_statement, control_successors, debug_statement(), gen_length(), and pips_debug.

Referenced by flatten_unstructured(), full_spaghettify_module(), and make_transition_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_statement()

void debug_statement	(	const char *	comments,
		statement	stat,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for a statement stat.

Parameters

comments	omments
stat	tat
debug_level	ebug_level

Definition at line 111 of file phrase_tools.c.

{
  ifdebug(debug_level) {
    pips_debug(debug_level,"%s\n",comments);
    print_statement(stat);
    pips_debug(debug_level,"domain number         = %"PRIdPTR"\n", statement_domain_number(stat));
    pips_debug(debug_level,"entity                = UNDEFINED\n");
    pips_debug(debug_level,"statement number      = %"PRIdPTR"\n", statement_number(stat));
    pips_debug(debug_level,"statement ordering    = %"PRIdPTR"\n", statement_ordering(stat));
    if (statement_with_empty_comment_p(stat)) {
      pips_debug(debug_level,"statement comments   = EMPTY\n");
    }
    else {
      pips_debug(debug_level,"statement comments  = %s\n", statement_comments(stat));
    }
    pips_debug(debug_level,"statement instruction = %s\n", statement_type_as_string(stat));
  }
}

References ifdebug, pips_debug, print_statement(), statement_comments, statement_domain_number, statement_number, statement_ordering, statement_type_as_string(), and statement_with_empty_comment_p().

Referenced by debug_control(), and full_spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_unstructured()

void debug_unstructured	(	unstructured	an_unstructured,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured.

f (ordering > 65535) ordering = ordering >> 16;

f (ordering > 65535) ordering = ordering >> 16;

f (ordering > 65535) ordering = ordering >> 16;

Parameters

an_unstructured	n_unstructured
debug_level	ebug_level

Definition at line 146 of file phrase_tools.c.

{
  list blocs = NIL ;
  string line = "***********************************************************************\n";
 
  ifdebug (debug_level) {
    CONTROL_MAP (current_control, {
      statement s = control_statement (current_control);
      string next_nodes_as_string = "";
      string previous_nodes_as_string = "";
      char *title;
      list predecessors = control_predecessors(current_control);
      list successors = control_successors(current_control);
      char *temp;
      size_t i;
      int ordering = 0;
 
      for (i=0; i<gen_length(predecessors); i++) {
        ordering = statement_ordering(control_statement
                                      (CONTROL(gen_nth(i,predecessors))));
        ordering = beautify_ordering (ordering);
        /*if (ordering > 65535) ordering = ordering >> 16;*/
        asprintf (&temp, "[%d] ",ordering);
        previous_nodes_as_string = strdup (concatenate(previous_nodes_as_string,
                                                       temp,
                                                       NULL));
    free(temp);
      }
     
      for (i=0; i<gen_length(successors); i++) {
        ordering = statement_ordering(control_statement
                                      (CONTROL(gen_nth(i,successors))));
        ordering = beautify_ordering (ordering);
        /*if (ordering > 65535) ordering = ordering >> 16;*/
        asprintf (&temp, "[%d] ",ordering);
        next_nodes_as_string = strdup (concatenate(next_nodes_as_string,
                                                   (temp),
                                                   NULL));
    free(temp);
      }
     
      ordering = beautify_ordering (ordering);
      ordering = statement_ordering(s);
      /*if (ordering > 65535) ordering = ordering >> 16;*/
      ifdebug(debug_level) {
      asprintf (&title, "CONTROL: %d\n", ordering);
        pips_debug(debug_level, "%s\n",
                   strdup(concatenate("\n", line,
                                      "* ", (title),
                                      line, NULL)));
        print_statement(s);
        pips_debug(debug_level, "%s\n",
                   strdup(concatenate("\n", line,
                                      "NEXT: ", next_nodes_as_string, "\n",
                                      "PREVIOUS: ", previous_nodes_as_string, "\n",
                                      line, NULL)));
    free(title);
      }
    }, unstructured_entry(an_unstructured), blocs);
  }
}

References asprintf, beautify_ordering(), concatenate(), CONTROL, CONTROL_MAP, control_predecessors, control_statement, control_successors, free(), gen_length(), gen_nth(), ifdebug, line, NIL, pips_debug, predecessors(), print_statement(), statement_ordering, strdup(), successors(), and unstructured_entry.

Here is the call graph for this function:

get_statements_with_comments_containing()

list get_statements_with_comments_containing	(	const char *	comment_portion,
		statement	stat
	)

First, set searched_string (we remove format information)

Reset list

fdebug(5) { pips_debug(5, "Searching statements with comments: %s\n", context.searched_string);
pips_debug(5, "In statement:\n");
print_statement(stat); }

Parameters

comment_portion	omment_portion
stat	tat

Definition at line 481 of file phrase_tools.c.

{
  statement_checking_context context;
 
  /* First, set searched_string (we remove format information)*/
  context.searched_string = strdup(comment_portion);
  context.searched_string[strcspn(comment_portion, "%s")] = '\0';
 
  /* Reset list */
  context.list_of_statements = NIL;
 
  /*ifdebug(5) {
    pips_debug(5, "Searching statements with comments: %s\n",
               context.searched_string);     
    pips_debug(5, "In statement:\n");     
    print_statement(stat);
    }*/
 
  gen_context_recurse(stat, &context,
    statement_domain, gen_true2, check_if_statement_contains_comment);
 
  return context.list_of_statements;
 
}

References check_if_statement_contains_comment(), gen_context_recurse, gen_true2(), NIL, statement_domain, and strdup().

Referenced by controlize_distribution(), identify_analyzed_statements_to_distribute(), and identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

make_assignement_statement()

statement make_assignement_statement	(	entity	a_variable,
		expression	an_expression,
		statement	stat
	)

Build and return new statement which is a assignement of variable a_variable with expression an_expression, with empty label, statement number and ordering of statement stat, and empty comments.

Parameters

a_variable	_variable
an_expression	n_expression
stat	tat

Definition at line 392 of file phrase_tools.c.

{
  return make_binary_call_statement (ASSIGN_OPERATOR_NAME,
                                     entity_to_expression(a_variable),
                                     an_expression,
                                     stat);
}

References a_variable, ASSIGN_OPERATOR_NAME, entity_to_expression(), and make_binary_call_statement().

Referenced by make_body_from_loop(), make_global_common_and_initialize(), and make_initialization_from_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_binary_call_statement()

statement make_binary_call_statement	(	const char *	operator_name,
		expression	expression1,
		expression	expression2,
		statement	stat
	)

Build and return new statement which is a binary call with the 2 expressions expression1 and expression2, with empty label, statement number and ordering of statement stat, and empty comments.

Parameters

operator_name	perator_name
expression1	xpression1
expression2	xpression2
stat	tat

Definition at line 354 of file phrase_tools.c.

{
  call assignment_call
    = make_call (entity_intrinsic(operator_name),
                 CONS(EXPRESSION,
                      expression1,
                      CONS(EXPRESSION, expression2, NIL)));
 
  if (stat == NULL) {
    return make_statement(entity_empty_label(),
                          STATEMENT_NUMBER_UNDEFINED,
                          STATEMENT_ORDERING_UNDEFINED,
                          empty_comments,
                          make_instruction (is_instruction_call,
                                            assignment_call),
                          NIL,NULL,
                          empty_extensions (), make_synchronization_none()); 
  }
  else {
    return make_statement(entity_empty_label(),
                          statement_number(stat),
                          statement_ordering(stat),
                          empty_comments,
                          make_instruction (is_instruction_call,
                                            assignment_call),
                          NIL,NULL,
                          statement_extensions(stat), make_synchronization_none());
  }
}

References CONS, empty_comments, empty_extensions(), entity_empty_label(), entity_intrinsic(), EXPRESSION, is_instruction_call, make_call(), make_instruction(), make_statement(), make_synchronization_none(), NIL, statement_extensions, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by make_array_communication_statement(), make_assignement_statement(), and make_communication_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_variable_from_name_and_entity()

entity make_variable_from_name_and_entity	(	entity	cloned_variable,
		const char *	base_name,
		statement	stat,
		const char *	module_name
	)

Build and return new entity obtained by cloning variable cloned_variable, with a name obtained by the concatenation of base_name and the statement ordering of statement stat.

If such entity already exist, increment statement ordering to get first free name. We assume then that created entity's name is unique.

Parameters

cloned_variable	loned_variable
base_name	ase_name
stat	tat
module_name	odule_name

Definition at line 325 of file phrase_tools.c.

{
  string variable_name;
  entity returned_variable = NULL;
  int index = statement_ordering(stat);
  //char *buffer;
 
  while (returned_variable == NULL) {
   
    asprintf(&variable_name, base_name, index++);
    returned_variable
      = clone_variable_with_new_name (cloned_variable,
                                      variable_name,
                                      module_name);
  }
 
  return returned_variable;
 
}

References asprintf, clone_variable_with_new_name(), module_name(), statement_ordering, and variable_name().

Referenced by make_begin_variable(), make_end_variable(), make_increment_variable(), and make_index_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

references_for_regions()

list references_for_regions

(

list

l_regions

)

Return a list of references corresponding to a list of regions.

Parameters

l_regions

_regions

Definition at line 603 of file phrase_tools.c.

{
  list l_ref = NIL;
 
  MAP (EFFECT, reg, {
    reference ref = effect_any_reference(reg);
    l_ref = CONS (REFERENCE, ref, l_ref);
    print_reference(ref);
    pips_debug(4,"Entity: %s\n", entity_local_name(reference_variable(ref)));
  },l_regions);
 
  return l_ref;
}

References CONS, EFFECT, effect_any_reference, entity_local_name(), MAP, NIL, pips_debug, print_reference(), ref, REFERENCE, and reference_variable.

Referenced by create_module_with_statement(), and distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_in_sequence_statement_with()

void replace_in_sequence_statement_with	(	statement	old_stat,
		statement	new_stat,
		statement	root_stat
	)

Replace statement old_stat by statement new_stat, asserting that this statement is contained in a sequence.

en_insert_after (new_stat, old_stat, stats_list); gen_remove (&stats_list, old_stat);

Parameters

old_stat	ld_stat
new_stat	ew_stat
root_stat	oot_stat

Definition at line 554 of file phrase_tools.c.

{
  statement sequence_statement = sequence_statement_containing (root_stat,
                                                                old_stat);
  list stats_list;
  list new_stats_list = NIL;
 
  pips_debug(5, "BEGIN replace_in_sequence_statement_with:\n");
 
  pips_assert("Statement is contained in a sequence",
              sequence_statement != NULL);
 
  stats_list = sequence_statements(instruction_sequence(statement_instruction(sequence_statement)));
 
  MAP (STATEMENT, s, {
    ifdebug(7) {
      pips_debug(7, "Iterate on statement:\n");
      print_statement(s);
    }
    if (s == old_stat) {
      pips_debug(7, "Replace this statement:\n");
      new_stats_list = CONS(STATEMENT,new_stat,new_stats_list);
    }
    else {
      pips_debug(7, "Keep this statement:\n");
      new_stats_list = CONS(STATEMENT,s,new_stats_list);
    }
  }, stats_list);
 
  sequence_statements(instruction_sequence(statement_instruction(sequence_statement))) = gen_nreverse(new_stats_list);
 
  /*gen_insert_after (new_stat, old_stat, stats_list);
    gen_remove (&stats_list, old_stat);*/
 
  ifdebug(7) {
    pips_debug(7, "I've got this for the sequence\n");
    print_statement(sequence_statement);   
    pips_debug(7, "I've got this for the root statement\n");
    print_statement(root_stat);   
  }
 
  pips_debug(5, "END replace_in_sequence_statement_with:\n");
}

References CONS, gen_nreverse(), ifdebug, instruction_sequence, MAP, NIL, pips_assert, pips_debug, print_statement(), sequence_statement_containing(), sequence_statements, STATEMENT, and statement_instruction.

Referenced by distribute_code().

Here is the call graph for this function:

Here is the caller graph for this function:

search_sequence_containing()

static void search_sequence_containing ( statement  s, void *  a_context  )

static

Definition at line 520 of file phrase_tools.c.

{
  sequence_searching_context* context
    = (sequence_searching_context*)a_context;
  instruction i = statement_instruction(s);
 
  if (instruction_tag(i) == is_instruction_sequence) {
    MAP (STATEMENT, s2, {
      if (s2 == context->searched_statement) {
        context->found_sequence_statement = s;
      }
    }, sequence_statements(instruction_sequence(i)));
  }
}

References instruction_sequence, instruction_tag, is_instruction_sequence, MAP, sequence_statements, STATEMENT, and statement_instruction.

Referenced by sequence_statement_containing().

Here is the caller graph for this function:

sequence_statement_containing()

statement sequence_statement_containing	(	statement	root_statement,
		statement	searched_stat
	)

Parameters

root_statement	oot_statement
searched_stat	earched_stat

Definition at line 536 of file phrase_tools.c.

{
  sequence_searching_context context;
 
  context.searched_statement = searched_stat;
  context.found_sequence_statement = NULL;
 
  gen_context_recurse(root_statement, &context,
                      statement_domain, gen_true2, search_sequence_containing);
 
  return context.found_sequence_statement;
}

References gen_context_recurse, gen_true2(), search_sequence_containing(), and statement_domain.

Referenced by compute_distribution_context(), identify_statements_to_distribute(), replace_in_sequence_statement_with(), and statement_is_contained_in_a_sequence_p().

Here is the call graph for this function:

Here is the caller graph for this function:

short_debug_unstructured()

void short_debug_unstructured	(	unstructured	an_unstructured,
		int	debug_level
	)

DEBUG FUNCTION: print debugging informations for an unstructured an_unstructured (short version)

Parameters

an_unstructured	n_unstructured
debug_level	ebug_level

Definition at line 213 of file phrase_tools.c.

{
  ifdebug (debug_level) {
 
    list blocs = NIL;
    string entry_as_string, exit_as_string, temp;
    asprintf (&temp, "[%p] ",unstructured_entry(an_unstructured));
    entry_as_string = strdup(temp);
    asprintf (&temp, "[%p] ",unstructured_exit(an_unstructured));
    exit_as_string = strdup(temp);
    pips_debug(debug_level, "%s\n",
               strdup(concatenate("UNSTRUCTURED\n",
                                  "ENTRY: ", entry_as_string, "\n",
                                  "PREVIOUS: ", exit_as_string, "\n",
                                  NULL)));
 
    CONTROL_MAP (current_control, {
      string next_nodes_as_string = "";
      string previous_nodes_as_string = "";
      char *title;
 
      MAP(CONTROL, c, {
        asprintf (&temp, "[%p] ",c);
        previous_nodes_as_string = strdup (concatenate(previous_nodes_as_string,
                                                       (temp),
                                                       NULL));
    free(temp);
      }, control_predecessors(current_control));
 
      MAP(CONTROL, c, {
        asprintf (&temp, "[%p] ",c);
        next_nodes_as_string = strdup (concatenate(next_nodes_as_string,
                                                   (temp),
                                                   NULL));
    free(temp);
      }, control_successors(current_control));
 
      asprintf (&title, "CONTROL: %p\n", current_control);
      pips_debug(debug_level, "%s\n",
                 strdup(concatenate(title,
                                    "NEXT: ", next_nodes_as_string, "\n",
                                    "PREVIOUS: ", previous_nodes_as_string, "\n",
                                    NULL)));
      free(title);
    }, unstructured_entry(an_unstructured), blocs);
  }
}

References asprintf, concatenate(), CONTROL, CONTROL_MAP, control_predecessors, control_successors, free(), ifdebug, MAP, NIL, pips_debug, strdup(), unstructured_entry, and unstructured_exit.

Referenced by flatten_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_is_contained_in_a_sequence_p()

bool statement_is_contained_in_a_sequence_p	(	statement	root_statement,
		statement	searched_stat
	)

Parameters

root_statement	oot_statement
searched_stat	earched_stat

Definition at line 507 of file phrase_tools.c.

{
  return (sequence_statement_containing (root_statement,
                                         searched_stat) != NULL);
}

References sequence_statement_containing().

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_type_as_string()

string statement_type_as_string

(

statement

stat

)

DEBUG FUNCTION: return a string representing the type of the statement (SEQUENCE, CALL, etc...)

phrase_tools.c

Parameters

stat

tat

Definition at line 65 of file phrase_tools.c.

{
  instruction i = statement_instruction(stat);
  switch (instruction_tag(i)) {
  case is_instruction_test: {
    return strdup("TEST");  
    break;
  }
  case is_instruction_sequence: {
    return strdup("SEQUENCE");  
    break;
  }
  case is_instruction_loop: {
    return strdup("LOOP");  
    break;
  }
  case is_instruction_whileloop: {
    return strdup("WHILELOOP");  
    break;
  }
  case is_instruction_forloop: {
    return strdup("FORLOOP");  
    break;
  }
  case is_instruction_call: {
    return strdup("CALL");  
    break;
  }
  case is_instruction_unstructured: {
    return strdup("UNSTRUCTURED");  
    break;
  }
  case is_instruction_goto: {
    return strdup("GOTO");  
    break;
  }
  default:
    return strdup("UNDEFINED");  
    break;
  }
}

References instruction_tag, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, statement_instruction, and strdup().

Referenced by debug_statement(), fsmize_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function: