xml_prettyprinter.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "pipsdbm.h"
#include "misc.h"
#include "properties.h"
#include "text.h"
#include "effects.h"
#include "ri.h"
#include "ri-util.h"
#include "text-util.h"
#include "control.h"
#include "effects-util.h"
#include "transformer.h"
#include "prettyprint.h"
#include "dg.h"
#include "graph.h"
#include "rice.h"
#include "ricedg.h"
#include "effects-convex.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "complexity_ri.h"
#include "complexity.h"
#include "semantics.h"
#include "modeling.h"

Include dependency graph for xml_prettyprinter.c:

Go to the source code of this file.

Data Structures
struct	expression_ctxt
struct	Spattern
struct	callst
struct	alias_in_args

Macros
#define	DEBUG_XML   1
#define	COMMA   ","
#define	EMPTY   ""
#define	NL   "\n"
#define	TAB   " "
#define	SEMICOLON   ";" NL
#define	SPACE   " "
#define	OPENBRACKET   "["
#define	CLOSEBRACKET   "]"
#define	OPENPAREN   "("
#define	CLOSEPAREN   ")"
#define	OPENBRACE   "{"
#define	CLOSEBRACE   "}"
#define	OPENANGLE   "<"
#define	CLOSEANGLE   ">"
#define	SLASH   "/"
#define	SHARPDEF   "#define"
#define	COMMENT   "//" SPACE
#define	QUOTE   "\""
#define	XML_TASK_PREFIX   "T_"
#define	XML_MOTIF_PREFIX   "M_"
#define	XML_ARRAY_PREFIX   "A_"
#define	XML_RL   NL,TAB,TAB
#define	code_is_a_box   0
#define	code_is_a_te   1
#define	code_is_a_main   2
#define	USER_MAIN   "main"
#define	BL   " "
#define	TB1   "\t"
#define	MEM_PREFIX   "-MEM:"
#define	current_module_is_a_function()    (entity_function_p(get_current_module_entity()))
#define	RESULT_NAME   "result"
#define	ITEM_NOT_IN_ARRAY   -1
#define	XML_ARRAY_PREFIX   "A_"
#define	MONMAX(a, b)   ((a<b)?b:a)

Typedefs
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label
typedef struct Spattern	Spattern
typedef struct Spattern *	Ppattern
typedef struct callst	callst
typedef struct callst *	Pcallst

Functions
static void	def_to_task_init (void)
static void	def_to_task_set (entity_to_entity mapping)
static void	def_to_task_reset (void)
static void	def_to_task_store (entity var, entity fun)
static entity	def_to_task_get (entity var)
static bool	variable_p (entity e)
static string	xml_entity_local_name (entity var)
static string	xml_expression (expression)
	forward declaration More...
static string	xml_reference_with_explicit_motif (reference r)
	Attention with Fortran: the indices are reversed. More...
static int	gen_array_index (gen_array_t ar, string item)
static string	xml_dim_string (list ldim, string name)
static string	this_entity_xmldeclaration (entity var)
static string	xml_declarations_with_explicit_motif (entity module, bool(*consider_this_entity)(entity), string separator, bool lastsep)
static string	xml_array_in_task (reference r, bool first, int task_number)
static string	xml_call_from_assignation (call c, int task_number, bool *input_provided)
static void	xml_call_from_indice (call c, string *offset_array, string paving_array[], string fitting_array[])
static string	xml_call_from_loopnest (call c, int task_number)
static call	sequence_call (sequence seq)
static loop	sequence_loop (sequence seq)
static call	xml_loop_from_loop (loop l, string *result, int task_number)
static string	xml_loop_from_sequence (loop l, int task_number)
	We enter a loop nest. More...
static string	xml_statement_from_sequence (statement s, int task_number)
	We are here at the highest level of statements. More...
static string	xml_sequence_from_task (sequence seq)
	Concatentates each task to the final result. More...
static string	xml_tasks_with_motif (statement stat)
	Manages tasks. More...
static string	xml_code_string (entity module, statement stat)
	Creates string for xml pretty printer. More...
bool	print_xml_code_with_explicit_motif (const char *module_name)
	Initiates xml pretty print modules. More...
static bool	print_full_name_p ()
	======================================================= More...
static bool	print_name_1_level_p ()
static void	xml_declarations (entity module, string_buffer result)
static void	push_current_statement (statement s, nest_context_p nest)
static void	pop_current_statement (statement s __attribute__((unused)), nest_context_p nest)
static void	push_loop (loop l, nest_context_p nest)
static void	pop_loop (_UNUSED_ loop l, nest_context_p nest)
static void	push_if (_UNUSED_ test l, nest_context_p nest)
static void	pop_if (test l __attribute__((unused)), nest_context_p nest)
static void	search_1r_function_call (call c)
static bool	call_selection (call c, nest_context_p nest __attribute__((unused)))
static void	store_call_context (call c __attribute__((unused)), nest_context_p nest)
static bool	push_test (test t __attribute__((unused)), nest_context_p nest __attribute__((unused)))
static void	pop_test (test t __attribute__((unused)), nest_context_p nest __attribute__((unused)))
static void	search_nested_loops_and_calls (statement stmp, nest_context_p nest)
static void	__attribute__ ((unused))
static expression	expression_plusplus (expression e)
static void	xml_loop (stack st, string_buffer result)
static void	xml_reference (int taskNumber __attribute__((unused)), reference r, bool wmode, string_buffer result)
static void	find_motif (Psysteme ps, Pvecteur nested_indices, int dim, int nb_dim __attribute__((unused)), Pcontrainte *bound_inf, Pcontrainte *bound_sup, Pcontrainte *iterator, int *motif_up_bound, int *lowerbound, int *upperbound)
static void	xml_tiling (int taskNumber, reference ref, region reg, stack indices, string_buffer result)
static void	xml_references (int taskNumber, list l_regions, stack indices, string_buffer result)
static void	xml_data (int taskNumber, statement s, stack indices, string_buffer result)
static string	task_complexity (statement s)
static void	xml_task (int taskNumber, nest_context_p nest, string_buffer result)
static void	xml_tasks (statement stat, string_buffer result)
static string	xml_code (entity module, statement stat)
	Creates string for xml pretty printer. More...
static bool	valid_specification_p (entity module __attribute__((unused)), statement stat __attribute__((unused)))
bool	print_xml_code (const char *module_name)
	Initiates xml pretty print modules. More...
static string	vect_to_string (Pvecteur pv)
static void	type_and_size_of_var (entity var, const char **datatype, int *size)
	UNUSED static bool vect_one_p(Pvecteur v) { return (!VECTEUR_NUL_P(v) && vect_size(v) == 1 && vect_coeff(TCST, v) ==1); }. More...
static void	add_margin (int gm, string_buffer sb_result)
static void	string_buffer_append_word (string str, string_buffer sb_result)
static void	string_buffer_append_symbolic (string str, string_buffer sb_result)
static void	two_string_buffer_append_symbolic (string str1, string str2, string_buffer sb_result)
static void	string_buffer_append_numeric (string str, string_buffer sb_result)
static void	find_loops_and_calls_in_box (statement stmp, nest_context_p nest)
static void	xml_Library (string_buffer sb_result)
static void	xml_Returns (string_buffer sb_result __attribute__((unused)))
static void	xml_Timecosts (string_buffer sb_result __attribute__((unused)))
static void	xml_AccessFunction (string_buffer sb_result __attribute__((unused)))
static void	xml_Regions (string_buffer sb_result __attribute__((unused)))
static void	xml_CodeSize (string_buffer sb_result)
static bool	entity_xml_parameter_p (entity e)
static void	choose_pattern (Ppattern *patt)
static void	find_pattern (Psysteme ps, Pvecteur paving_indices, Pvecteur formal_parameters, int dim, Ppattern *patt)
static void	xml_Pattern_Paving (region reg, entity var, bool effet_read, Pvecteur formal_parameters, Pvecteur paving_indices, string_buffer sb_result)
static void	vars_read_and_written (list effects_list, Pvecteur *vr, Pvecteur *vw)
	UNUSED static void array_vars_read_or_written(list effects_list, Pvecteur *vl) { Pvecteur vin=VECTEUR_NUL; Pvecteur vout = VECTEUR_NUL; list pc; for (pc= effects_list;pc != NIL; pc = CDR(pc)){ effect e = EFFECT(CAR(pc)); reference r = effect_any_reference(e); if (store_effect_p(e) && array_entity_p(reference_variable(r))) { entity v = reference_variable(r); if (effect_read_p(e)) vect_add_elem(&vin,v,1); else vect_add_elem(&vout,v,1); } } vin = base_normalize(vin); vout = base_normalize(vout); vl = vect_substract(vin,vout); vl= base_normalize(*vl); vect_rm(vin); vect_rm(vout); }. More...
static void	xml_Region_Range (region reg, string_buffer sb_result)
static bool	region_range_nul_p (region reg, Variable phi)
	tatic bool string_in_list_p(string ts,list lr){ bool trouve=false; MAPL(tt, {trouve= trouve || strcmp(STRING(CAR(tt)),ts) == 0;}, lr); return trouve; } More...
char *	str_sub (const char *s, int start, int end)
char *	pointer_to_initial_name (char *ts, _UNUSED_ char *ste)
static const char *	words_points_to_reference (reference rv, bool suffix_only_p, region reg)
static void	xml_Full_Type (type pt, int max_step, string_buffer type_result)
static void	xml_Type_Entity (entity vv, string_buffer type_buffer)
static void	xml_Region_Parameter (list pattern_region, string_buffer sb_result)
static int	find_effect_actions_for_entity (list leff, effect *effr, effect *effw, entity e)
static void	same_entities (reference r, expression_ctxt *ctxt)
static bool	entity_in_expression_p (expression exp, entity e)
static void	xml_ParameterUseToArrayBound (entity var, string_buffer sb_result)
static bool	same_callst_p (Pcallst c1, Pcallst c2)
static void	update_def_into_tasks_table (entity v, Pcallst c1)
static void	add_def_into_tasks_table (entity v, Pcallst c1)
static void	xml_TaskReturnParameter (entity function, _UNUSED_ int statnb, string_buffer sb_result)
static void	xml_TaskParameter (bool assign_function, _UNUSED_ entity function, int statnb, bool is_not_main_p, entity var, Pvecteur formal_parameters, list pattern_region, Pvecteur paving_indices, string_buffer sb_result, string_buffer buffer_assign)
static void	cumul_and_update_effects_of_statement (statement s)
static void	cumul_effects_of_statement (statement s)
static void	xml_TaskParameters (statement stat, bool assign_function, int code_tag, entity module, list pattern_region, Pvecteur paving_indices, string_buffer sb_result)
bool	eval_linear_expression (expression exp, transformer ps, int *val, int *min, int *max)
static void	xml_Bounds (expression elow, expression eup, transformer t, _UNUSED_ Psysteme prec, bool formal_p, string_buffer sb_result)
	UNUSED static bool eval_linear_expression2( expression exp, Psysteme ps, int *val, int *min, int *max) { normalized norm= normalized_undefined; Pvecteur vexp,pv; bool result = true,result_exact = true,min_exact=true,max_exact=true; val = 0; min=0; max=0;. More...
static void	xml_Bounds_and_Stride (expression elow, expression eup, expression stride, transformer t, Psysteme prec, bool formal_p, string_buffer sb_result)
static void	find_memory_comment_on_array (statement s)
static string	memory_location_for_array_p (const char *sa)
static void	xml_Array (entity var, transformer t, Psysteme prec, bool formal_p, string_buffer sb_result)
static void	xml_Scalar (entity var, _UNUSED_ Psysteme prec, string_buffer sb_result)
static void	xml_GlobalVariables (transformer t, Psysteme prec, bool printp, string_buffer sb_result)
static void	store_local_array_declaration (statement s)
static void	xml_LocalVariables (entity module, transformer t, Psysteme prec, string_buffer sb_result)
static void	xml_FormalVariables (entity module, transformer t, Psysteme prec, string_buffer sb_result)
static bool	pragma_motif_p (statement s)
static void	motif_in_statement (statement s)
static void	box_in_statement (statement s)
	currently unused static void motif_in_statement2(statement s) { string comm = statement_comments(s); if (!string_undefined_p(comm) && strstr(comm,"MOTIF")!=NULL) motif_in_statement_p= true; } More...
static bool	string_parameter_p (entity e)
static void	xml_Loop (statement s, string_buffer sb_result)
static void	xml_Loops (stack st, bool call_external_loop_p, list *pattern_region, Pvecteur *paving_indices, Pvecteur *pattern_indices, bool motif_in_te_p, string_buffer sb_result)
static transformer	first_precondition_of_module (const char *module_name __attribute__((unused)), Psysteme *ps)
static void	matrix_init (Pmatrix mat, int n, int m)
static void	xml_Matrix (Pmatrix mat, int n, int m, string_buffer sb_result)
static int	int_compare (void const *a, void const *b)
static void	tri_abc (int a[12], int dim, int result[12])
static void	xml_Transposed_Matrix2D (Pmatrix mat)
static void	xml_Transposed_Matrix3_5D (Pmatrix mat, int a[12], int ArrayDim1, _UNUSED_ int ArrayDim2)
static expression	skip_cast_expression (expression exp)
static expression	skip_field_and_cast_expression (expression exp)
static expression	skip_cast_and_addop_expression (expression exp)
static void	xml_Transposition (statement s, call c, int d, string_buffer sb_result, int version)
static void	xml_Task (const char *module_name, int code_tag, string_buffer sb_result)
static void	xml_Connection (list ActualArrayInd, int ActualArrayDim, int FormalArrayDim, string_buffer sb_result)
static void	xml_LoopOffset (list ActualArrayInd, int ActualArrayDim, Pvecteur loop_indices, string_buffer sb_result)
static void	xml_ConstOffset (list ActualArrayInd, int ActualArrayDim, string_buffer sb_result)
static int	check_alias_args (reference r, alias_in_args *p)
static bool	aliasing_p (call c, reference refname)
static void	xml_Argument (statement s, entity function, int statnb, bool assign_func, expression exp0, entity FormalName, Pvecteur loop_indices, transformer t, _UNUSED_ Psysteme prec, string_buffer sb_result)
static void	xml_AssignArgument (_UNUSED_ statement s, entity function, int statnb, bool assign_func, expression exp, entity FormalName, Pvecteur loop_indices, transformer t, _UNUSED_ Psysteme prec, string_buffer sb_result)
static void	xml_Arguments (statement s, entity function, int statnb, bool assign_func, Pvecteur loop_indices, transformer t, Psysteme prec, string_buffer sb_result)
static void	statement_in_truebranch (statement s)
static bool	logic_condition_filter (statement s1, statement sx, entity *cond, expression *lhs, expression *rhs)
static void	dependencies_filter (statement s1, int *k1)
static bool	indice_p (stack indices, entity v)
static void	xml_Chain_Graph (entity module, statement mod_stat, graph mod_graph, nest_context_p nest, string_buffer sb_result)
static void	xml_Chains (entity module, const char *mod_name, statement mod_stat, nest_context_p nest, string_buffer sb_result)
static void	print_call_precondition (Psysteme prec, string_buffer sb_result)
static void	xml_Call (entity module, int code_tag, int taskNumber, nest_context_p nest, string_buffer sb_result)
static void	xml_Compute_and_Need (entity func, list effects_list, Pvecteur vargs, string_buffer sb_result)
static int	find_code_status (const char *module_name)
static void	xml_Boxes (const char *module_name, int code_tag, string_buffer sb_result)
static void	xml_Application (const char *module_name, int code_tag, string_buffer sb_result)
static bool	generic_print_xml_application (const char *module_name, bool is_app)
bool	print_xml_application_with_points_to (const char *module_name)
bool	print_xml_application (const char *module_name)
bool	print_xml_application_main (const char *module_name)
bool	print_xml_application_main_with_points_to (const char *module_name)

Variables
static gen_array_t	extern_indices_array
	array containing extern loop indices names More...
static gen_array_t	intern_indices_array
	array containing intern loop indices (name : "M_") More...
static gen_array_t	extern_upperbounds_array
	array containing extern upperbounds More...
static gen_array_t	intern_upperbounds_array
	array containing intern upperbounds More...
static gen_array_t	tasks_names
	array containing the tasks names More...
static const char *	global_module_name
static hash_table	hash_entity_def_into_tasks = hash_table_undefined
static int	global_margin =0
static bool	fortran_appli = true
static bool	box_in_statement_p = false
static bool	motif_in_statement_p = false
static bool	statement_in_truebranch_p = false
static list	cumulated_list = NIL
static statement	test_statement_of_reference
static list	local_declaration_list = NIL
static call	encapsulated_call = call_undefined
static string	array_location_string
static string	array_mem_string
static Pvecteur	global_application_variables = VECTEUR_NUL
static Pvecteur	local_application_variables = VECTEUR_NUL
static entity_to_entity	def_to_task_mapping = entity_to_entity_undefined
static gen_array_t	array_names
static gen_array_t	array_dims

Macro Definition Documentation

BL

#define BL   " "

Definition at line 116 of file xml_prettyprinter.c.

CLOSEANGLE

#define CLOSEANGLE   ">"

Definition at line 85 of file xml_prettyprinter.c.

CLOSEBRACE

#define CLOSEBRACE   "}"

Definition at line 82 of file xml_prettyprinter.c.

CLOSEBRACKET

#define CLOSEBRACKET   "]"

Definition at line 76 of file xml_prettyprinter.c.

CLOSEPAREN

#define CLOSEPAREN   ")"

Definition at line 79 of file xml_prettyprinter.c.

code_is_a_box

#define code_is_a_box   0

Definition at line 99 of file xml_prettyprinter.c.

code_is_a_main

#define code_is_a_main   2

Definition at line 101 of file xml_prettyprinter.c.

code_is_a_te

#define code_is_a_te   1

Definition at line 100 of file xml_prettyprinter.c.

COMMA

#define COMMA   ","

Definition at line 68 of file xml_prettyprinter.c.

COMMENT

#define COMMENT   "//" SPACE

Definition at line 89 of file xml_prettyprinter.c.

current_module_is_a_function

#define current_module_is_a_function

(

)

(entity_function_p(get_current_module_entity()))

Definition at line 184 of file xml_prettyprinter.c.

DEBUG_XML

#define DEBUG_XML   1

Definition at line 30 of file xml_prettyprinter.c.

EMPTY

#define EMPTY   ""

Definition at line 69 of file xml_prettyprinter.c.

ITEM_NOT_IN_ARRAY

#define ITEM_NOT_IN_ARRAY   -1

Definition at line 296 of file xml_prettyprinter.c.

MEM_PREFIX

#define MEM_PREFIX   "-MEM:"

Definition at line 133 of file xml_prettyprinter.c.

MONMAX

#define MONMAX	(		a,
			b
	)		((a<b)?b:a)

NL

#define NL   "\n"

Definition at line 70 of file xml_prettyprinter.c.

OPENANGLE

#define OPENANGLE   "<"

Definition at line 84 of file xml_prettyprinter.c.

OPENBRACE

#define OPENBRACE   "{"

Definition at line 81 of file xml_prettyprinter.c.

OPENBRACKET

#define OPENBRACKET   "["

Definition at line 75 of file xml_prettyprinter.c.

OPENPAREN

#define OPENPAREN   "("

Definition at line 78 of file xml_prettyprinter.c.

QUOTE

#define QUOTE   "\""

Definition at line 90 of file xml_prettyprinter.c.

RESULT_NAME

#define RESULT_NAME   "result"

Definition at line 195 of file xml_prettyprinter.c.

SEMICOLON

#define SEMICOLON   ";" NL

Definition at line 72 of file xml_prettyprinter.c.

SHARPDEF

#define SHARPDEF   "#define"

Definition at line 88 of file xml_prettyprinter.c.

SLASH

#define SLASH   "/"

Definition at line 86 of file xml_prettyprinter.c.

SPACE

#define SPACE   " "

Definition at line 73 of file xml_prettyprinter.c.

TAB

#define TAB   " "

Definition at line 71 of file xml_prettyprinter.c.

TB1

#define TB1   "\t"

Definition at line 117 of file xml_prettyprinter.c.

USER_MAIN

#define USER_MAIN   "main"

Definition at line 102 of file xml_prettyprinter.c.

XML_ARRAY_PREFIX [1/2]

#define XML_ARRAY_PREFIX   "A_"

Definition at line 559 of file xml_prettyprinter.c.

XML_ARRAY_PREFIX [2/2]

#define XML_ARRAY_PREFIX   "A_"

Definition at line 559 of file xml_prettyprinter.c.

XML_MOTIF_PREFIX

#define XML_MOTIF_PREFIX   "M_"

Definition at line 94 of file xml_prettyprinter.c.

XML_RL

#define XML_RL   NL,TAB,TAB

Definition at line 97 of file xml_prettyprinter.c.

XML_TASK_PREFIX

#define XML_TASK_PREFIX   "T_"

Definition at line 93 of file xml_prettyprinter.c.

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 54 of file xml_prettyprinter.c.

callst

typedef struct callst callst

Pcallst

typedef struct callst * Pcallst

Ppattern

typedef struct Spattern * Ppattern

Spattern

typedef struct Spattern Spattern

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 55 of file xml_prettyprinter.c.

Function Documentation

__attribute__()

static void __attribute__ ( (unused)  )

static

print_statement(s); stack_map( st, print_statement);

Definition at line 1392 of file xml_prettyprinter.c.

{
  int j;
  int numberOfTasks=(int) gen_array_nitems(nest->nested_call);
  for (j = 0; j<numberOfTasks; j++)
    {
      //statement s = gen_array_item(nest->nested_call,j);
      //stack st = gen_array_item(nest->nested_loops,j);
      /*   print_statement(s);
           stack_map( st, print_statement);*/
    }
}

References gen_array_nitems(), int, and nest_context_t::nested_call.

Here is the call graph for this function:

add_def_into_tasks_table()

static void add_def_into_tasks_table ( entity  v, Pcallst  c1  )

static

Definition at line 3178 of file xml_prettyprinter.c.

{
  Pcallst ldef = (Pcallst) hash_get(hash_entity_def_into_tasks,(char *) v);
  if (ldef == (Pcallst) HASH_UNDEFINED_VALUE) {
    hash_put(hash_entity_def_into_tasks,(char *) v,(char *)c1);
  }
}

References hash_entity_def_into_tasks, hash_get(), hash_put(), and HASH_UNDEFINED_VALUE.

Referenced by cumul_and_update_effects_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

add_margin()

static void add_margin ( int  gm, string_buffer  sb_result  )

static

Definition at line 1981 of file xml_prettyprinter.c.

                                                        {
  int i;
  for (i=1;i<=gm;i++)
    string_buffer_append(sb_result, "  ");
}

References string_buffer_append().

Referenced by print_call_precondition(), string_buffer_append_numeric(), string_buffer_append_symbolic(), string_buffer_append_word(), two_string_buffer_append_symbolic(), xml_Application(), xml_Argument(), xml_Array(), xml_AssignArgument(), xml_Bounds(), xml_Boxes(), xml_Call(), xml_Chain_Graph(), xml_Compute_and_Need(), xml_Full_Type(), xml_Loop(), xml_Matrix(), xml_ParameterUseToArrayBound(), xml_Pattern_Paving(), xml_Region_Parameter(), xml_Scalar(), xml_Task(), xml_TaskParameter(), xml_TaskReturnParameter(), xml_Transposition(), and xml_Type_Entity().

Here is the call graph for this function:

Here is the caller graph for this function:

aliasing_p()

static bool aliasing_p ( call  c, reference  refname  )

static

Definition at line 4519 of file xml_prettyprinter.c.

{
  alias_in_args p = { refname, 0 };
  list largs = call_arguments(c);
  FOREACH(EXPRESSION, exp, largs) {
    gen_context_recurse(exp, &p, reference_domain, check_alias_args, gen_null2);
  }
  return p.alias_arg_p > 1;
}

References alias_in_args::alias_arg_p, call_arguments, check_alias_args(), exp, EXPRESSION, FOREACH, gen_context_recurse, gen_null2(), and reference_domain.

Referenced by xml_Argument().

Here is the call graph for this function:

Here is the caller graph for this function:

box_in_statement()

static void box_in_statement ( statement  s )

static

currently unused static void motif_in_statement2(statement s) { string comm = statement_comments(s); if (!string_undefined_p(comm) && strstr(comm,"MOTIF")!=NULL) motif_in_statement_p= true; }

Definition at line 3989 of file xml_prettyprinter.c.

{
  string comm = statement_comments(s);
  if (!string_undefined_p(comm) && strstr(comm,"BOX")!=NULL)
    box_in_statement_p= true;
}

References box_in_statement_p, statement_comments, and string_undefined_p.

Referenced by find_code_status().

Here is the caller graph for this function:

call_selection()

static bool call_selection ( call  c, nest_context_p nest   __attribute__(unused)  )

static

CA il faut implemeter un choix judicieux ... distribution ou encapsulation

pour le moment distribution systematique de tout call

il faut recuperer les appels de fonction value_code_p(entity_initial(f)

Definition at line 1338 of file xml_prettyprinter.c.

{
  /* CA il faut implemeter  un choix judicieux ... distribution ou encapsulation*/
  /* pour le moment distribution systematique de tout call */
  /* il faut recuperer les appels de fonction value_code_p(entity_initial(f)*/
  entity f = call_function(c);
  if  (ENTITY_ASSIGN_P(f) || entity_subroutine_p(f)|| entity_function_p(f))
    return true;
  else return false;
}

References call_function, ENTITY_ASSIGN_P, entity_function_p(), entity_subroutine_p(), and f().

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

check_alias_args()

static int check_alias_args ( reference  r, alias_in_args *  p  )

static

Definition at line 4513 of file xml_prettyprinter.c.

{
  p->alias_arg_p +=(reference_equal_p(r,p->rf))? 1:0;
  return p->alias_arg_p;
}

References alias_in_args::alias_arg_p, reference_equal_p(), and alias_in_args::rf.

Referenced by aliasing_p().

Here is the call graph for this function:

Here is the caller graph for this function:

choose_pattern()

static void choose_pattern ( Ppattern *  patt )

static

Definition at line 2107 of file xml_prettyprinter.c.

{
  Ppattern patt1= NULL,
    pattn= NULL,
    pattc1= NULL,
    pattcx= NULL,
    pattcp= NULL;
  Pvecteur pv;
  for(patt1 = *patt; patt1 !=NULL; patt1=patt1->next)  {
    if  (vect_size(patt1->diff) ==1) {
      if (vect_dimension(patt1->diff)==0) // borne constante numerique
        pattn = patt1;
      else  { // borne constante symbolique
        for (pv = patt1->diff;pv!=NULL;pv=pv->succ) {
          if (pv->var!= TCST) {
            if (pv->val ==1)
              pattc1=patt1;
            else pattcx = patt1;
          }
        }
      }
    }
    else pattcp = patt1;
  }
    if (pattn!=NULL ) *patt=pattn;
    else if (pattc1!= NULL) *patt=pattc1;
    else if (pattcx!=NULL ) *patt=pattcx;
    else *patt=pattcp;
}

References Spattern::diff, Spattern::next, Svecteur::succ, TCST, Svecteur::val, Svecteur::var, vect_dimension(), and vect_size().

Referenced by find_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

cumul_and_update_effects_of_statement()

static void cumul_and_update_effects_of_statement ( statement  s )

static

Definition at line 3357 of file xml_prettyprinter.c.

                                                               {
  list l = load_proper_rw_effects_list(s);
  if (!ENDP(l) && !list_undefined_p(l)) {
    cumulated_list = gen_append(cumulated_list, l);
 
    for (list pc = l; pc != NIL; pc = CDR(pc)) {
      effect e = EFFECT(CAR(pc));
      reference r = effect_any_reference(e);
      action ac = effect_action(e);
      entity v = reference_variable(r);
      if (store_effect_p(e)
          && !effects_package_entity_p(v) && !std_file_entity_p(v) //&& !variable_heap_p(v)
          && action_write_p(ac) &&
          !(entity_static_variable_p(v) && !top_level_entity_p(v))) {
        {
          Pcallst cst1 = (callst *)malloc(sizeof(callst));
          cst1->func = entity_undefined;
          cst1->stat_nb = statement_number(s);
          cst1->succ = (Pcallst)NULL;
          add_def_into_tasks_table(v, cst1);
        }
      }
    }
  }
}

References action_write_p, add_def_into_tasks_table(), CAR, CDR, cumulated_list, EFFECT, effect_action, effect_any_reference, effects_package_entity_p(), ENDP, entity_static_variable_p(), entity_undefined, callst::func, gen_append(), list_undefined_p, load_proper_rw_effects_list(), malloc(), NIL, reference_variable, callst::stat_nb, statement_number, std_file_entity_p(), store_effect_p(), callst::succ, and top_level_entity_p().

Referenced by xml_Chain_Graph().

Here is the call graph for this function:

Here is the caller graph for this function:

cumul_effects_of_statement()

static void cumul_effects_of_statement ( statement  s )

static

Definition at line 3383 of file xml_prettyprinter.c.

{
  list l=load_proper_rw_effects_list(s);
  if (!ENDP(l) && !list_undefined_p(l))
    cumulated_list = gen_append(cumulated_list,l);
 
}

References cumulated_list, ENDP, gen_append(), list_undefined_p, and load_proper_rw_effects_list().

Referenced by xml_Application(), and xml_GlobalVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

def_to_task_get()

static entity def_to_task_get ( entity  var )

static

Definition at line 176 of file xml_prettyprinter.c.

{
  return bound_entity_to_entity_p(def_to_task_mapping, var)?
    apply_entity_to_entity(def_to_task_mapping, var): NULL;
}

References apply_entity_to_entity(), bound_entity_to_entity_p(), and def_to_task_mapping.

Referenced by xml_Compute_and_Need().

Here is the call graph for this function:

Here is the caller graph for this function:

def_to_task_init()

static void def_to_task_init ( void  )

static

Definition at line 147 of file xml_prettyprinter.c.

{
  pips_assert("def_to_task_mapping is undefined",
              entity_to_entity_undefined_p(def_to_task_mapping));
  def_to_task_mapping = make_entity_to_entity();
}

References def_to_task_mapping, entity_to_entity_undefined_p, make_entity_to_entity(), and pips_assert.

Referenced by generic_print_xml_application().

Here is the call graph for this function:

Here is the caller graph for this function:

def_to_task_reset()

static void def_to_task_reset ( void  )

static

Definition at line 161 of file xml_prettyprinter.c.

{
  pips_assert("def_to_task_mapping is defined",
              !entity_to_entity_undefined_p(def_to_task_mapping));
  def_to_task_mapping = entity_to_entity_undefined;
}

References def_to_task_mapping, entity_to_entity_undefined, entity_to_entity_undefined_p, and pips_assert.

Referenced by generic_print_xml_application().

Here is the caller graph for this function:

def_to_task_set()

static void def_to_task_set ( entity_to_entity  mapping )

static

Definition at line 154 of file xml_prettyprinter.c.

{
  pips_assert("def_to_task_mapping is undefined",
              entity_to_entity_undefined_p(def_to_task_mapping));
  def_to_task_mapping = mapping;
}

References def_to_task_mapping, entity_to_entity_undefined_p, and pips_assert.

Referenced by generic_print_xml_application().

Here is the caller graph for this function:

def_to_task_store()

static void def_to_task_store ( entity  var, entity  fun  )

static

Definition at line 168 of file xml_prettyprinter.c.

{
  if (bound_entity_to_entity_p(def_to_task_mapping, var))
    update_entity_to_entity(def_to_task_mapping, var, fun);
  else
    extend_entity_to_entity(def_to_task_mapping, var, fun);
}

References bound_entity_to_entity_p(), def_to_task_mapping, extend_entity_to_entity(), and update_entity_to_entity().

Referenced by xml_Chain_Graph(), and xml_Compute_and_Need().

Here is the call graph for this function:

Here is the caller graph for this function:

dependencies_filter()

static void dependencies_filter ( statement  s1, int *  k1  )

static

Definition at line 4897 of file xml_prettyprinter.c.

{
  entity func1=entity_undefined;
  instruction inst;
  // Filtering  function call and another function call or a declaration or a conditional
  if (declaration_statement_p(s1))
    *k1=2;
  else {
    inst = statement_instruction(s1);
    switch(instruction_tag(inst)) {
    case is_instruction_call : {
      func1 = call_function(instruction_call(statement_instruction(s1)));
      //      call_func_p1=((ENTITY_ASSIGN_P(func1)) ||entity_subroutine_p(func1)|| entity_function_p(func1));
      *k1= ENTITY_ASSIGN_P(func1)? 0 : 1;
      break;
    }
    case is_instruction_test : {
      *k1=3;
      break;
    }
    default:break;
    }
  }
}

References call_function, declaration_statement_p(), ENTITY_ASSIGN_P, entity_undefined, instruction_call, instruction_tag, is_instruction_call, is_instruction_test, k1, s1, and statement_instruction.

Referenced by xml_Chain_Graph().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_in_expression_p()

static bool entity_in_expression_p ( expression  exp, entity  e  )

static

Definition at line 3101 of file xml_prettyprinter.c.

{
 
  expression_ctxt ctxt = { e, false };
  gen_context_recurse(exp, &ctxt, reference_domain, gen_true2, same_entities);
  return ctxt.entity_in_p;
}

References expression_ctxt::entity_in_p, exp, gen_context_recurse, gen_true2(), reference_domain, and same_entities().

Referenced by xml_ParameterUseToArrayBound().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_xml_parameter_p()

static bool entity_xml_parameter_p ( entity  e )

static

Definition at line 2079 of file xml_prettyprinter.c.

{
  const char* s = entity_local_name(e);
  bool b=false;
  if (strstr(s,"PARAM")!=NULL || strstr(s,"param")!=NULL) b = true;
  return (b);
}

References entity_local_name().

Referenced by xml_Array(), xml_Region_Parameter(), xml_Scalar(), and xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

eval_linear_expression()

bool eval_linear_expression	(	expression	exp,
		transformer	ps,
		int *	val,
		int *	min,
		int *	max
	)

printf("Eval expression :\n"); print_expression(exp); Psysteme prec = sc_dup((Psysteme) predicate_system(transformer_relation(ps))); printf("In context :\n"); sc_print(prec, (get_variable_name_t) entity_local_name);

Parameters

exp	xp
ps	s
val	al
min	in
max	ax

Definition at line 3469 of file xml_prettyprinter.c.

{
  bool result=true;
  *val = 0;
  *min=0;
  *max=0;
  /* printf("Eval expression :\n");
     print_expression(exp);
     Psysteme prec = sc_dup((Psysteme) predicate_system(transformer_relation(ps)));
     printf("In context :\n");
     sc_print(prec, (get_variable_name_t) entity_local_name);
  */
 
  if (!transformer_undefined_p(ps) && transformer_is_rn_p(ps)) {
    *min=INT_MIN,*max =INT_MAX;
    return(false);
  }
   
  // Should  be part of semantics/utils.c FI
  set_analyzed_types();
  transformer psr=transformer_range(ps);
  type et = compute_basic_concrete_type(expression_to_type(exp));
  if (integer_type_p(et)) {
    integer_expression_and_precondition_to_integer_interval(exp,psr, min,max);
    // DEBUG - printf("Min = %d, Max = %d \n", *min,*max);
  }
  else result = false;
  free_transformer(psr);
  reset_analyzed_types();
  if (*max<*min) {
    *min=INT_MIN,*max =INT_MAX;
    result= false;
  }
  else if (*max==*min && result) {
    *val = *min;
  }
  return (result);
}

References compute_basic_concrete_type(), exp, expression_to_type(), free_transformer(), integer_expression_and_precondition_to_integer_interval(), integer_type_p(), max, min, reset_analyzed_types(), set_analyzed_types(), transformer_is_rn_p(), transformer_range(), and transformer_undefined_p.

Referenced by xml_Argument(), xml_AssignArgument(), xml_Bounds(), and xml_Bounds_and_Stride().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_plusplus()

static expression expression_plusplus ( expression  e )

static

Definition at line 1406 of file xml_prettyprinter.c.

{
  expression new_e;
  if (expression_constant_p(e)) {
    new_e = int_to_expression(1+ expression_to_int(e));
  }
  else {
    entity add_ent = entity_intrinsic(PLUS_OPERATOR_NAME);
    new_e =  make_call_expression(add_ent,
                                  CONS(EXPRESSION, e, CONS(EXPRESSION,  int_to_expression(1), NIL)));
  }
  return new_e;
}

References CONS, entity_intrinsic(), EXPRESSION, expression_constant_p(), expression_to_int(), int_to_expression(), make_call_expression(), NIL, and PLUS_OPERATOR_NAME.

Referenced by xml_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

find_code_status()

static int find_code_status ( const char *  module_name )

static

Definition at line 5922 of file xml_prettyprinter.c.

{
  statement stat=(statement) db_get_memory_resource(DBR_CODE,
                                                    module_name, true);
  bool wmotif = false;
  bool wbox = false;
  motif_in_statement_p = false;
  gen_recurse(stat, statement_domain, gen_true, motif_in_statement);
  wmotif = motif_in_statement_p;
  box_in_statement_p = false;
  gen_recurse(stat, statement_domain, gen_true, box_in_statement);
  wbox = box_in_statement_p;
 
  if (same_string_p(module_name, get_string_property("XML_APPLICATION_MAIN")))
    return code_is_a_main;
  else {
    if (wmotif && !wbox)
      return code_is_a_te;
    else
      return code_is_a_box;
  }
}

References box_in_statement(), box_in_statement_p, code_is_a_box, code_is_a_main, code_is_a_te, db_get_memory_resource(), gen_recurse, gen_true(), get_string_property(), module_name(), motif_in_statement(), motif_in_statement_p, same_string_p, and statement_domain.

Referenced by generic_print_xml_application().

Here is the call graph for this function:

Here is the caller graph for this function:

find_effect_actions_for_entity()

static int find_effect_actions_for_entity ( list  leff, effect *  effr, effect *  effw, entity  e  )

static

Definition at line 3071 of file xml_prettyprinter.c.

{
  // return effet_rwb = 1 for Read, 2 for Write, 3 for Read/Write
  int effet_rwb=0;
  list lr = NIL;
  bool er = false;
  bool ew = false;
  //fprintf(stdout,"DEBUG - Effects for var =%s\n",entity_user_name(e));
  //print_effects(leff);
  for ( lr = leff; !ENDP(lr); lr = CDR(lr)) {
    effect eff=  EFFECT(CAR(lr));
    reference ref = effect_any_reference(eff);
    entity v = reference_variable(ref);
    if (store_effect_p(eff) && same_entity_p(v,e) && !environment_effect_p(eff)) {
      if (action_read_p(effect_action(eff)))
        er = true, *effr =eff;
      else ew = true, *effw=eff;
    }
  }
  effet_rwb = (er?1:0) +(ew?2:0);
  return (effet_rwb);
}

References action_read_p, CAR, CDR, EFFECT, effect_action, effect_any_reference, ENDP, environment_effect_p(), NIL, ref, reference_variable, same_entity_p(), and store_effect_p().

Referenced by xml_Argument(), and xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

find_loops_and_calls_in_box()

static void find_loops_and_calls_in_box ( statement  stmp, nest_context_p  nest  )

static

Definition at line 2030 of file xml_prettyprinter.c.

{
  gen_context_multi_recurse(stmp,nest, loop_domain,push_loop,pop_loop,
                            statement_domain, push_current_statement,pop_current_statement,
                            test_domain, push_if, pop_if,
                            call_domain,call_selection,store_call_context,
                            NULL);
}

References call_domain, call_selection(), gen_context_multi_recurse(), loop_domain, pop_current_statement(), pop_if(), pop_loop(), push_current_statement(), push_if(), push_loop(), statement_domain, store_call_context(), and test_domain.

Referenced by xml_Boxes(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

find_memory_comment_on_array()

static void find_memory_comment_on_array ( statement  s )

static

Definition at line 3674 of file xml_prettyprinter.c.

{
  string comm = statement_comments(s);
  string result = NULL;
 
  if (!string_undefined_p(comm)
      && (result=strstr(comm,array_mem_string))!=NULL)
    array_location_string = result;
}

References array_location_string, array_mem_string, statement_comments, and string_undefined_p.

Referenced by memory_location_for_array_p().

Here is the caller graph for this function:

find_motif()

static void find_motif ( Psysteme  ps, Pvecteur  nested_indices, int  dim, int nb_dim   __attribute__(unused), Pcontrainte *  bound_inf, Pcontrainte *  bound_sup, Pcontrainte *  iterator, int *  motif_up_bound, int *  lowerbound, int *  upperbound  )

static

elimination des variables autres de les phi et les indices de boucles englobants copie de la base + mise a zero des indices englobants + projection selon les elem de ce vecteur

printf("Base des variables :\n"); vect_print(vars_to_eliminate, entity_local_name);

printf("Elimination des variables :\n"); vect_print(vars_to_eliminate, entity_local_name);

printf("Tri de la contrainte :\n"); vect_print(c->vecteur, entity_local_name);

printf(" bornes inf avec indices de boucles englobants :\n"); vect_print(bounds[upper][nb_indices+1]->vecteur, entity_local_name);

printf(" bornes inf avec indices de boucles englobants :\n"); vect_print(bounds[lower][nb_indices+1]->vecteur, entity_local_name);

printf(" indices contenus dans la contrainte :\n"); vect_print(bounds[ind][nb_indices+1]->vecteur, entity_local_name);

printf("Nb borne inf = %d, Nb borne sup = %d ;\n",nb_lower,nb_upper);

case with 1 loop index in the loop bound constraints

printf("Tests de la negation des contraintes :\n"); vect_print(cl->vecteur, entity_local_name); vect_print(cu->vecteur, entity_local_name);

case where loop bounds are numeric

Only bounds with several loop indices

printf("PB - Only bounds with several loop indices\n");

Definition at line 1461 of file xml_prettyprinter.c.

{
  Variable phi;
  Value v;
  Pvecteur pi;
  Pcontrainte c, next, cl, cu, cl_dup, cu_dup,lind, lind_dup,
    list_cl=NULL,
    list_cu=NULL,
    list_ind=NULL;
  int lower =1;
  int upper =2;
  int ind =3;
  Pcontrainte bounds[4][4];
  int nb_bounds =0;
  int nb_lower = 0;
  int nb_upper = 0;
  int nb_indices=0;
  int i,j;
  Pbase vars_to_eliminate = BASE_NULLE;
 
  for (i=1; i<=3;i++)
    for (j=1; j<=3;j++)
      bounds[i][j]=CONTRAINTE_UNDEFINED;
 
  phi = (Variable) make_phi_entity(dim);
  /* elimination des variables autres de les phi et les indices de boucles englobants
     copie de la base + mise a zero des indices englobants + projection selon les elem de ce vecteur*/
 
  if (!SC_EMPTY_P(ps)) {
    vars_to_eliminate = vect_copy(ps->base);
    /* printf("Base des variables :\n");
       vect_print(vars_to_eliminate, entity_local_name);
    */
    vect_erase_var(&vars_to_eliminate, phi);
    for (pi = nested_indices; !VECTEUR_NUL_P(pi); pi = pi->succ)
      vect_erase_var(&vars_to_eliminate, var_of(pi));
 
    /* printf("Elimination des variables :\n");
       vect_print(vars_to_eliminate, entity_local_name);
    */
 
    sc_projection_along_variables_ofl_ctrl(&ps,vars_to_eliminate , NO_OFL_CTRL);
 
    for(c = sc_inegalites(ps), next=(c==NULL ? NULL : c->succ);
        c!=NULL;
        c=next, next=(c==NULL ? NULL : c->succ))
      {
        Pvecteur indices_in_vecteur = VECTEUR_NUL;
        /* printf("Tri de la contrainte :\n");
           vect_print(c->vecteur, entity_local_name);
        */
        v = vect_coeff(phi, c->vecteur);
        for (pi = nested_indices; !VECTEUR_NUL_P(pi); pi = pi->succ)
          {
            int coeff_index = vect_coeff(var_of(pi),c->vecteur);
            if (coeff_index)
              vect_add_elem(&indices_in_vecteur,var_of(pi), coeff_index);
          }
 
        nb_indices=vect_size(indices_in_vecteur);
        nb_indices = (nb_indices >2) ? 2 : nb_indices;
 
        if (value_pos_p(v)) {
          c->succ = bounds[upper][nb_indices+1];
          bounds[upper][nb_indices+1] = c;
          /* printf(" bornes inf avec indices de boucles englobants :\n");
             vect_print(bounds[upper][nb_indices+1]->vecteur, entity_local_name); */
          nb_upper ++;
        }
        else if (value_neg_p(v)) {
          c->succ = bounds[lower][nb_indices+1];
          bounds[lower][nb_indices+1] = c;
          /* printf(" bornes inf avec indices de boucles englobants :\n");
             vect_print(bounds[lower][nb_indices+1]->vecteur, entity_local_name);*/
          lind = contrainte_make(indices_in_vecteur);
          lind->succ = bounds[ind][nb_indices+1];
          bounds[ind][nb_indices+1] = lind;
          /* printf(" indices contenus dans la contrainte :\n");
             vect_print(bounds[ind][nb_indices+1]->vecteur, entity_local_name); */
          nb_lower ++;
        }
      }
    /* printf("Nb borne inf = %d, Nb borne sup = %d ;\n",nb_lower,nb_upper); */
 
    if  (!CONTRAINTE_UNDEFINED_P(bounds[lower][2])) {
      /* case with 1 loop index in the loop bound constraints */
      for(cl = bounds[lower][2], lind= bounds[ind][2]; cl !=NULL; cl=cl->succ,lind=lind->succ)  {
        for(cu = bounds[upper][2]; cu !=NULL; cu =cu->succ) {
          /*  printf("Tests de la negation des  contraintes :\n");
              vect_print(cl->vecteur, entity_local_name);
              vect_print(cu->vecteur, entity_local_name); */
          if (vect_opposite_except(cl->vecteur,cu->vecteur,TCST)){
            cl_dup = contrainte_dup(cl);
            cl_dup->succ = list_cl, list_cl=cl_dup;
            cu_dup = contrainte_dup(cu);
            cu_dup->succ = list_cu, list_cu=cu_dup;
            lind_dup = contrainte_dup(lind);
            lind_dup->succ = list_ind, list_ind = lind_dup;
            nb_bounds ++;
          }
        }
      }
      *bound_inf= list_cl;
      *bound_sup = list_cu;
      *iterator = list_ind;
      *motif_up_bound =- vect_coeff(TCST,list_cl->vecteur) - vect_coeff(TCST,list_cu->vecteur) +1;
      *lowerbound = vect_coeff(TCST,list_cl->vecteur);
      *upperbound = vect_coeff(TCST,list_cu->vecteur)+1;
    }
    else if (!CONTRAINTE_UNDEFINED_P(bounds[lower][1]) && !CONTRAINTE_UNDEFINED_P(bounds[upper][1])) {
      /* case where loop bounds are numeric */
      *bound_inf= bounds[lower][1];
      *bound_sup = bounds[upper][1];
      *iterator =  bounds[ind][1];
      *motif_up_bound = - vect_coeff(TCST,bounds[lower][1]->vecteur)
        - vect_coeff(TCST,bounds[upper][1]->vecteur)+1;
      *upperbound = vect_coeff(TCST,bounds[upper][1]->vecteur)+1;
      *lowerbound = vect_coeff(TCST,bounds[lower][1]->vecteur);
    } else {
      /* Only bounds with several loop indices */
      /* printf("PB - Only bounds with several loop indices\n"); */
      *bound_inf= CONTRAINTE_UNDEFINED;
      *bound_sup = CONTRAINTE_UNDEFINED;
      *iterator = CONTRAINTE_UNDEFINED;
      *motif_up_bound = 1;
      *upperbound = 1;
      *lowerbound = 0;
    }
  }
  vect_rm( vars_to_eliminate);
}

References Ssysteme::base, BASE_NULLE, contrainte_dup(), contrainte_make(), CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, make_phi_entity(), NO_OFL_CTRL, Scontrainte::succ, Svecteur::succ, TCST, upperbound(), value_neg_p, value_pos_p, var_of, vect_add_elem(), vect_coeff(), vect_copy(), vect_erase_var(), vect_opposite_except(), vect_rm(), vect_size(), Scontrainte::vecteur, VECTEUR_NUL, and VECTEUR_NUL_P.

Referenced by xml_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

find_pattern()

static void find_pattern ( Psysteme  ps, Pvecteur  paving_indices, Pvecteur  formal_parameters, int  dim, Ppattern *  patt  )

static

Liste des variables a eliminer autres de les phi et les indices de boucles englobants et les parametres formels de la fonction. copie de la base + mise a zero des indices englobants

• projection selon les elem de ce vecteur

on classe toutes les contraintes ayant plus de 2 indices de boucles externes ensemble

case with 1 loop index in the loop bound constraints than 0

DEBUG printf("Liste des contraintes ajoutees PHI-%d: \n",dim); for (pt=*patt; pt != NULL; pt=pt->next) { vect_fprint(stdout, pt->diff, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->lower, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->upper, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->lind, (char * (*)(Variable)) entity_local_name); fprintf(stdout,"mult = %d\n", pt->cl_coeff); }

DEBUG pt =*patt; if (patt != NULL && pt != NULL) { printf("Pattern choisi : \n"); vect_fprint(stdout, pt->diff, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->lower, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->upper, (char * (*)(Variable)) entity_local_name); vect_fprint(stdout, pt->lind, (char * (*)(Variable)) entity_local_name); fprintf(stdout,"mult = %d\n", pt->cl_coeff); }

Definition at line 2139 of file xml_prettyprinter.c.

{
  Variable phi;
  Value v;
  Pvecteur pi;
  Pcontrainte c, next, cl, cu, lind;
  *patt = NULL;
  int lower =1;
  int upper =2;
  int ind =3;
  Pcontrainte bounds[4][4];
  int nb_bounds =0;
  int nb_lower = 0;
  int nb_upper = 0;
  int nb_indices=0;
  int i,j;
  Pbase vars_to_eliminate = BASE_NULLE;
  Pvecteur vdiff = VECTEUR_NUL,
    diff2 = VECTEUR_NUL;
  // DEBUG  Ppattern pt= NULL;
  Ppattern patt1=NULL;
  int mult=1;
  for (i=1; i<=3;i++)
    for (j=1; j<=3;j++)
      bounds[i][j]=CONTRAINTE_UNDEFINED;
 
  phi = (Variable) make_phi_entity(dim);
 
  /* Liste des  variables a eliminer autres de les phi et les indices de boucles englobants
     et les parametres formels de la fonction.
     copie de la base + mise a zero des indices englobants
     + projection selon les elem de ce vecteur
  */
  if (!SC_EMPTY_P(ps)) {
 
    Psysteme ps_dup=sc_dup(ps);
    vars_to_eliminate = vect_copy(ps->base);
    vect_erase_var(&vars_to_eliminate, phi);
 
    //printf("paving_indices:\n");
    //vect_fprint(stdout,paving_indices,(char * (*)(Variable))  entity_local_name);
 
    for (pi = paving_indices; !VECTEUR_NUL_P(pi); pi = pi->succ)
      vect_erase_var(&vars_to_eliminate, var_of(pi));
    //printf("formal_parameters:\n");
    // vect_fprint(stdout,formal_parameters,(char * (*)(Variable)) entity_local_name);
 
    for (pi = formal_parameters; !VECTEUR_NUL_P(pi); pi = pi->succ)
      vect_erase_var(&vars_to_eliminate, var_of(pi));
    //printf("vars_to_eliminate:\n");
    //vect_fprint(stdout,vars_to_eliminate,(char * (*)(Variable)) entity_local_name);
 
    sc_projection_along_variables_ofl_ctrl(&ps_dup,vars_to_eliminate , NO_OFL_CTRL);
 
    //printf("Systeme a partir duquel on genere les contraintes  du motif:\n");
    //sc_fprint(stdout,ps,entity_local_name);
 
    for(c = sc_inegalites(ps_dup), next=(c==NULL ? NULL : c->succ);
        c!=NULL;
        c=next, next=(c==NULL ? NULL : c->succ))
      {
        Pvecteur indices_in_vecteur = VECTEUR_NUL;
        vdiff = VECTEUR_NUL;
        v = vect_coeff(phi, c->vecteur);
        for (pi = paving_indices; !VECTEUR_NUL_P(pi); pi = pi->succ)
          {
            int coeff_index = vect_coeff(var_of(pi),c->vecteur);
            if (coeff_index)
              vect_add_elem(&indices_in_vecteur,var_of(pi), coeff_index);
          }
        /* on classe toutes les contraintes ayant plus de 2 indices de boucles
           externes ensemble */
        nb_indices=vect_size(indices_in_vecteur);
        nb_indices = (nb_indices >2) ? 2 : nb_indices;
 
        if (value_pos_p(v)) {
          c->succ = bounds[upper][nb_indices+1];
          bounds[upper][nb_indices+1] = c;
 
          //  printf(" bornes sup avec indices de boucles englobants :\n");
          //    vect_print(bounds[upper][nb_indices+1]->vecteur, (char * (*)(Variable)) entity_local_name);
          nb_upper ++;
        }
        else if (value_neg_p(v)) {
          c->succ = bounds[lower][nb_indices+1];
          bounds[lower][nb_indices+1] = c;
          //   printf(" bornes inf avec indices de boucles englobants :\n");
          //    vect_print(bounds[lower][nb_indices+1]->vecteur, (char * (*)(Variable)) entity_local_name);
          lind = contrainte_make(indices_in_vecteur);
          lind->succ = bounds[ind][nb_indices+1];
          bounds[ind][nb_indices+1] = lind;
          //   printf(" indices contenus dans la contrainte :\n");
          //    vect_print(bounds[ind][nb_indices+1]->vecteur, (char * (*)(Variable)) entity_local_name);
          nb_lower ++;
        }
      }
    // printf("Nb borne inf = %d, Nb borne sup = %d pour dimension %d;\n",nb_lower,nb_upper,dim);
 
 
    for (int nb_ind=2; nb_ind>=1; nb_ind--){
        /* case with 1 loop index in the loop bound constraints than 0 */
      if  (!CONTRAINTE_UNDEFINED_P(bounds[lower][nb_ind])) {
        for(cl = bounds[lower][nb_ind], lind= bounds[ind][nb_ind]; cl !=NULL; cl=cl->succ,lind=lind->succ)  {
          for(cu = bounds[upper][nb_ind]; cu !=NULL; cu =cu->succ) {
            Value cv1 = vect_coeff(phi, cl->vecteur);
            Value cv2 = vect_coeff(phi, cu->vecteur);
            if (value_abs(cv1)==value_abs(cv2)) {
              vdiff = vect_add(cu->vecteur,cl->vecteur);
              mult=value_abs(cv1);
            }
            else {
              vdiff = vect_cl2(value_abs(cv1),cu->vecteur,value_abs(cv2),cl->vecteur);
              mult=(int) value_abs(cv1 * cv2);
            }
            vect_chg_sgn(vdiff);
 
            // le +1 est ajoute dans l'expression apres division lorsque mult!=1
            if (mult==1)
              vect_add_elem(&vdiff,TCST,1);
            //  pattern = contrainte_make(vect_dup(vdiff));
 
            diff2=vect_dup(vdiff);
            for (pi = formal_parameters; !VECTEUR_NUL_P(pi); pi = pi->succ)
              vect_erase_var(&vdiff, var_of(pi));
 
            if (vect_dimension(vdiff)==0) {
              patt1= (Ppattern) malloc(sizeof(Spattern));
              patt1->diff = vect_dup(diff2);
              patt1->lower = vect_dup(cl->vecteur);
              patt1->upper = vect_dup(cu->vecteur);
              patt1->lind = vect_dup(lind->vecteur);
              patt1->cl_coeff=mult;
              patt1->unitp=(vect_dimension(diff2)==0 && vect_coeff(TCST, diff2)==1)?true:false;
 
              vect_chg_sgn(patt1->upper);
              for (pi = lind->vecteur; !VECTEUR_NUL_P(pi); pi = pi->succ) {
                vect_erase_var(&(patt1->lower), var_of(pi));
                vect_erase_var(&(patt1->upper), var_of(pi));
              }
              vect_erase_var(&(patt1->lower), phi);
              vect_erase_var(&(patt1->upper),phi);
              patt1->next = *patt, *patt=patt1;
              nb_bounds ++;
            }
            vect_rm(vdiff);
            vect_rm(diff2);
          }
        }
      }
    }
    /* DEBUG
    printf("Liste des contraintes ajoutees PHI-%d: \n",dim);
      for (pt=*patt; pt != NULL; pt=pt->next) {
      vect_fprint(stdout, pt->diff, (char * (*)(Variable)) entity_local_name);
      vect_fprint(stdout, pt->lower, (char * (*)(Variable)) entity_local_name);
      vect_fprint(stdout, pt->upper, (char * (*)(Variable)) entity_local_name);
      vect_fprint(stdout, pt->lind, (char * (*)(Variable)) entity_local_name);
      fprintf(stdout,"mult = %d\n", pt->cl_coeff);
      } */
 
    choose_pattern(patt);
     /* DEBUG
        pt =*patt;
    if (patt != NULL && pt != NULL) {
    printf("Pattern choisi : \n");
    vect_fprint(stdout, pt->diff, (char * (*)(Variable)) entity_local_name);
    vect_fprint(stdout, pt->lower, (char * (*)(Variable)) entity_local_name);
    vect_fprint(stdout, pt->upper, (char * (*)(Variable)) entity_local_name);
    vect_fprint(stdout, pt->lind, (char * (*)(Variable)) entity_local_name);
    fprintf(stdout,"mult = %d\n", pt->cl_coeff);
    } */
 
    base_rm( vars_to_eliminate);
    sc_rm(ps_dup);
  }
}

References Ssysteme::base, BASE_NULLE, base_rm, choose_pattern(), Spattern::cl_coeff, contrainte_make(), CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, Spattern::diff, int, Spattern::lind, Spattern::lower, make_phi_entity(), malloc(), Spattern::next, NO_OFL_CTRL, sc_dup(), sc_rm(), Scontrainte::succ, Svecteur::succ, TCST, Spattern::unitp, Spattern::upper, value_abs, value_neg_p, value_pos_p, var_of, vect_add(), vect_add_elem(), vect_chg_sgn(), vect_cl2(), vect_coeff(), vect_copy(), vect_dimension(), vect_dup(), vect_erase_var(), vect_rm(), vect_size(), Scontrainte::vecteur, VECTEUR_NUL, and VECTEUR_NUL_P.

Referenced by xml_Pattern_Paving().

Here is the call graph for this function:

Here is the caller graph for this function:

first_precondition_of_module()

static transformer first_precondition_of_module ( const char *module_name   __attribute__(unused), Psysteme *  ps  )

static

Definition at line 4090 of file xml_prettyprinter.c.

{
  statement st1 = get_current_module_statement();
  statement fst = statement_undefined;
  instruction inst = statement_instruction(st1);
  transformer t=transformer_undefined;
  *ps= SC_UNDEFINED;
  switch instruction_tag(inst)
    {
    case is_instruction_sequence:{
      list sts = sequence_statements(instruction_sequence(inst));
      if (sts !=NULL)
        fst = STATEMENT(CAR(sts));
      break;
    }
 
    default:
      fst = st1;
    }
  if ( fst!= statement_undefined) {
    t = (transformer)load_statement_precondition(fst);
    *ps = sc_dup((Psysteme) predicate_system(transformer_relation(t)));
  }
  return t;
}

References CAR, get_current_module_statement(), instruction_sequence, instruction_tag, is_instruction_sequence, load_statement_precondition(), predicate_system, sc_dup(), sequence_statements, STATEMENT, statement_instruction, statement_undefined, transformer_relation, and transformer_undefined.

Referenced by xml_Application(), xml_Boxes(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_array_index()

static int gen_array_index ( gen_array_t  ar, string  item  )

static

Definition at line 298 of file xml_prettyprinter.c.

                                                       {
  int i;
 
  for(i = 0; i<(int) gen_array_nitems(ar); i++){
    if(gen_array_item(ar, i) != NULL){
      if(same_string_p(item, *((string *)(gen_array_item(ar, i))))){
        return i;
      }
    }
  }
  return ITEM_NOT_IN_ARRAY;
}

References gen_array_item(), gen_array_nitems(), int, ITEM_NOT_IN_ARRAY, and same_string_p.

Referenced by xml_array_in_task(), xml_call_from_assignation(), xml_call_from_indice(), and xml_call_from_loopnest().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_print_xml_application()

static bool generic_print_xml_application ( const char *  module_name, bool  is_app  )

static

Get the READ and WRITE regions of the module

Definition at line 6118 of file xml_prettyprinter.c.

{
  FILE * out;
  entity module;
  string dir, filename;
  statement stat;
  string_buffer sb_result = string_buffer_make(true);
  int code_tag;
  string resource = is_app? DBR_SPEAR_APP_FILE : DBR_SPEAR_CODE_FILE;
 
  // globals...
  hash_entity_def_into_tasks = hash_table_make(hash_pointer,0);
 
  module = module_name_to_entity(module_name);
  string xml = db_build_file_resource_name
    (resource, module_name, is_app? ".app.xml": ".xml");
  dir = db_get_current_workspace_directory();
  filename = strdup(concatenate(dir, "/", xml, NULL));
  stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  make_statement_global_stack();
  set_current_module_entity(module);
  set_current_module_statement(stat);
  if(statement_undefined_p(stat)) {
    pips_internal_error("No statement for module %s", module_name);
  }
  set_proper_rw_effects((statement_effects)
                        db_get_memory_resource(DBR_PROPER_EFFECTS,
                                               module_name,true));
  set_cumulated_rw_effects((statement_effects)
                      db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                               module_name,true));
  init_cost_table();
  // set_complexity_map( (statement_mapping)
  //                  db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
 
  /* Get the READ and WRITE regions of the module */
  set_rw_effects((statement_effects)
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
 
  set_precondition_map((statement_mapping)
                       db_get_memory_resource(DBR_PRECONDITIONS,
                                              module_name,
                                              true));
 
  module_to_value_mappings(get_current_module_entity());
 
  debug_on("XMLPRETTYPRINTER_DEBUG_LEVEL");
  out = safe_fopen(filename, "w");
  code_tag = find_code_status(module_name);
  fprintf(out,"%s<!-- XML prettyprint for %s \"%s\" --> \n",
          is_app? "": "  ",
          is_app? "application": code_tag == code_is_a_te? "task": "box",
          module_name);
 
  if (is_app)
    def_to_task_set((entity_to_entity)
                    db_get_memory_resource(DBR_TASK_VARIABLE_CHANGED_BY,
                                           module_name, true));
  else
    def_to_task_init();
 
  fortran_appli = fortran_module_p(module);
 
  if (is_app)
  {
    pips_assert("application is a main", code_tag == code_is_a_main);
    xml_Application(module_name, code_tag, sb_result);
  }
  else
  {
    switch (code_tag)
    {
    case code_is_a_main:
    case code_is_a_box:
      // xml_Boxes(module_name, code_is_a_main, sb_result);
      xml_Boxes(module_name, code_tag, sb_result);
      break;
    case code_is_a_te:
      xml_Task(module_name, code_tag, sb_result);
      break;
    default:
      pips_internal_error("unexpected kind of code for xml_prettyprinter");
    }
  }
 
  pips_debug(1, "End XML prettyprinter for %s\n", module_name);
  debug_off();
 
  string sr = string_buffer_to_string(sb_result);
  fputs(sr, out);
  free(sr);
  safe_fclose(out, filename);
 
  string_buffer_free(&sb_result);
  hash_table_free(hash_entity_def_into_tasks), hash_entity_def_into_tasks = NULL;
  free(dir);
  free(filename);
 
  DB_PUT_FILE_RESOURCE(resource, module_name, xml);
  if (!is_app)
    DB_PUT_MEMORY_RESOURCE(DBR_TASK_VARIABLE_CHANGED_BY, module_name,
                           def_to_task_mapping);
 
  def_to_task_reset();
  free_statement_global_stack();
  reset_current_module_statement();
  reset_current_module_entity();
  reset_complexity_map();
  reset_precondition_map();
  reset_rw_effects();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
  free_value_mappings();
  return true;
}

References code_is_a_box, code_is_a_main, code_is_a_te, concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, def_to_task_init(), def_to_task_mapping, def_to_task_reset(), def_to_task_set(), find_code_status(), fortran_appli, fortran_module_p(), fprintf(), free(), free_statement_global_stack(), free_value_mappings(), get_current_module_entity(), hash_entity_def_into_tasks, hash_pointer, hash_table_free(), hash_table_make(), init_cost_table(), make_statement_global_stack(), module, module_name(), module_name_to_entity(), module_to_value_mappings(), out, pips_assert, pips_debug, pips_internal_error, reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), safe_fclose(), safe_fopen(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), statement_undefined_p, strdup(), string_buffer_free(), string_buffer_make(), string_buffer_to_string(), xml_Application(), xml_Boxes(), and xml_Task().

Referenced by print_xml_application(), print_xml_application_main(), print_xml_application_main_with_points_to(), and print_xml_application_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

indice_p()

static bool indice_p ( stack  indices, entity  v  )

static

Definition at line 4922 of file xml_prettyprinter.c.

{
  bool result=false;
  STACK_MAP_X(index,entity,
              {
                if (same_entity_p(index ,v)) result=true;
              }, indices,1);
  return result;
}

References indices, same_entity_p(), and STACK_MAP_X.

Referenced by xml_Chain_Graph().

Here is the call graph for this function:

Here is the caller graph for this function:

int_compare()

static int int_compare ( void const *  a, void const *  b  )

static

Definition at line 4162 of file xml_prettyprinter.c.

{
  int const*pa=a;
  int const*pb=b;
  return(*pb-*pa);
}

Referenced by tri_abc().

Here is the caller graph for this function:

logic_condition_filter()

static bool logic_condition_filter ( statement  s1, statement  sx, entity *  cond, expression *  lhs, expression *  rhs  )

static

Definition at line 4867 of file xml_prettyprinter.c.

{
  if ( !statement_undefined_p(sx) &&  instruction_test_p(statement_instruction(sx))) {
    test l = instruction_test(statement_instruction(sx));
    expression exp=test_condition(l);
    if (syntax_call_p(expression_syntax(exp))) {
      call oper=syntax_call(expression_syntax(exp));
      *cond=call_function(oper);
      if (ENTITY_LOGICAL_OPERATOR_P(call_function(oper))) {
        list largs_oper= call_arguments(oper);
        if (gen_length(largs_oper)>=2) {
          *lhs = EXPRESSION(CAR(largs_oper));
          *rhs = EXPRESSION(CAR(CDR(largs_oper)));
          return true;
        }
        else
          spear_warning(s1,"Change the test or Encapsulate it into a function",
                        "NON BINARY OPERATORS in conditional are not accepted outside task");
      }
      else  spear_warning(s1,"Change the test or Encapsulate it into a function",
                          "NON LOGICAL OPERATORS in conditional are not accepted outside task");
    }
    else
      spear_warning(s1,"Change the test or Encapsulate it into a function",
                    "The conditional is not a LOGICAL TEST");
  }
  return false;
}

References call_arguments, call_function, CAR, CDR, ENTITY_LOGICAL_OPERATOR_P, exp, EXPRESSION, expression_syntax, gen_length(), instruction_test, instruction_test_p, s1, spear_warning, statement_instruction, statement_undefined_p, syntax_call, syntax_call_p, and test_condition.

Referenced by xml_Call(), and xml_Chain_Graph().

Here is the call graph for this function:

Here is the caller graph for this function:

matrix_init()

static void matrix_init ( Pmatrix  mat, int  n, int  m  )

static

Definition at line 4117 of file xml_prettyprinter.c.

{
  int i,j;
  for (i=1;i<=n;i++) {
    for (j=1;j<=m;j++) {
      MATRIX_ELEM(mat,i,j)=0;
    }
  }
}

References MATRIX_ELEM.

Referenced by xml_Connection(), xml_ConstOffset(), xml_LoopOffset(), and xml_Transposition().

Here is the caller graph for this function:

memory_location_for_array_p()

static string memory_location_for_array_p ( const char *  sa )

static

Definition at line 3684 of file xml_prettyprinter.c.

{
  statement stat = get_current_module_statement();
  string result=NULL;
  int n=0;
 
  array_location_string = NULL;
  array_mem_string = (char *)malloc(strlen(sa)+5+1);
  (void)  strcpy(array_mem_string, sa);
  (void) strcat(array_mem_string,MEM_PREFIX);
  gen_recurse(stat, statement_domain, gen_true,find_memory_comment_on_array);
  if (array_location_string != NULL) {
    n= strcspn(array_location_string+strlen(sa)+5,":\n");
    result=(char *)malloc(n+1);
    strncpy(result,array_location_string+strlen(sa)+5,n);
    result[n]=(char) 0;
  }
  free(array_mem_string);
  return (result);
}

References array_location_string, array_mem_string, find_memory_comment_on_array(), free(), gen_recurse, gen_true(), get_current_module_statement(), malloc(), MEM_PREFIX, and statement_domain.

Referenced by xml_Array().

Here is the call graph for this function:

Here is the caller graph for this function:

motif_in_statement()

static void motif_in_statement ( statement  s )

static

Definition at line 3977 of file xml_prettyprinter.c.

{
  if (pragma_motif_p(s)) motif_in_statement_p= true;
}

References motif_in_statement_p, and pragma_motif_p().

Referenced by find_code_status(), xml_Loops(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_to_initial_name()

char* pointer_to_initial_name	(	char *	ts,
		_UNUSED_ char *	ste
	)

Prefix extraction int nbpref= strcspn(ste, ts); string pref_ts= malloc (sizeof (char) * (nbpref+1)); pref_ts = strncpy(pref_ts,ste,(int)nbpref); pref_ts[nbpref]='\0'; fprintf(stdout,"Prefix for %s in %s is %s\n",ts, ste,pref_ts );

Search entity to determine its type string newst = malloc (sizeof (char) * (nbpref+strlen(initial_ts))); newst = strcat(pref_ts,initial_ts); entity newent=gen_find_entity(newst);

Definition at line 2690 of file xml_prettyprinter.c.

{
  string ts_tmp = ts;
  string initial_ts =ts;
  /* Prefix extraction
  int nbpref= strcspn(ste, ts);
  string pref_ts= malloc (sizeof (char) * (nbpref+1));
  pref_ts = strncpy(pref_ts,ste,(int)nbpref);
  pref_ts[nbpref]='\0';
  fprintf(stdout,"Prefix for %s in %s is %s\n",ts, ste,pref_ts );
  */
  bool reduction_p=true;
  // Remove "_" on either side of intial entity name ts in case of pointer
  while (reduction_p && strchr(ts_tmp,'_')==ts_tmp)
    {
      string end_ts=strrchr(ts,'_');
      if (strlen(ts_tmp)-strlen(end_ts)-1>0)
        initial_ts = str_sub (ts,1,strlen(ts_tmp)-strlen(end_ts)-1);
      else reduction_p=false;
      ts_tmp=initial_ts;
    }
 
  /* Search entity to determine its type
  string newst = malloc (sizeof (char) * (nbpref+strlen(initial_ts)));
  newst = strcat(pref_ts,initial_ts); 
  entity newent=gen_find_entity(newst);
  */
   return(initial_ts);
}

References reduction_p(), and str_sub().

Referenced by words_points_to_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_current_statement()

static void pop_current_statement ( statement s   __attribute__(unused), nest_context_p  nest  )

static

if (debug) print_statement(s);

Definition at line 1287 of file xml_prettyprinter.c.

{
  /*   if (debug) print_statement(s);*/
  stack_pop(nest->current_stat);
}

References nest_context_t::current_stat, and stack_pop().

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_if()

static void pop_if ( test l   __attribute__(unused), nest_context_p  nest  )

static

Definition at line 1319 of file xml_prettyprinter.c.

{
  stack_pop(nest->testif);
 
}

References stack_pop(), and nest_context_t::testif.

Referenced by find_loops_and_calls_in_box().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_loop()

static void pop_loop ( _UNUSED_ loop  l, nest_context_p  nest  )

static

Definition at line 1304 of file xml_prettyprinter.c.

{
  stack_pop(nest->loops_for_call);
  stack_pop(nest->loop_indices);
}

References nest_context_t::loop_indices, nest_context_t::loops_for_call, and stack_pop().

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_test()

static void pop_test ( test t   __attribute__(unused), nest_context_p nest   __attribute__(unused)  )

static

encapsulation de l'ensemble des instructions appartenant au test

Definition at line 1374 of file xml_prettyprinter.c.

{
  /* encapsulation de l'ensemble des instructions appartenant au test*/
}

Referenced by search_nested_loops_and_calls().

Here is the caller graph for this function:

pragma_motif_p()

static bool pragma_motif_p ( statement  s )

static

Definition at line 3959 of file xml_prettyprinter.c.

{
  extensions es = statement_extensions(s);
  list exl=extensions_extension(es);
  string name="MOTIF";
  bool result=false;
  FOREACH(EXTENSION, ex, exl){
    if (extension_pragma_p(ex)) {
      pragma p = extension_pragma(ex);
      if(pragma_string_p(p)) {
        if(same_string_p(pragma_string(p),name))
          result= true;
      }
    }
  }
  return result;
}

References EXTENSION, extension_pragma, extension_pragma_p, extensions_extension, FOREACH, pragma_string, pragma_string_p, same_string_p, and statement_extensions.

Referenced by motif_in_statement(), and xml_Loops().

Here is the caller graph for this function:

print_call_precondition()

static void print_call_precondition ( Psysteme  prec, string_buffer  sb_result  )

static

Definition at line 5609 of file xml_prettyprinter.c.

{
  //  fprintf(stdout,"DEBUG - preconditions\n");
  // sc_fprint(stdout,prec, (get_variable_name_t) entity_local_name);
  
  Pcontrainte pc;
  Pvecteur pv;
 
  string_buffer_append_word("CallPreconditions", sb_result);
  global_margin++;
  for (pc = prec->egalites; pc!=NULL; pc=pc->succ) {
    pv = contrainte_vecteur(pc);
    if (vect_size(pv)<=2 && vect_dimension(pv)==1){
      Pvecteur pv2=vect_copy(pv);
      int coeff = - vect_coeff(TCST,pv2);
      vect_chg_coeff(&pv2,TCST,0);
      if (!VECTEUR_UNDEFINED_P(pv2) && !VECTEUR_NUL_P(pv2)) {
        entity etmp = (entity) pv2->var;
        if (!old_value_entity_p(etmp)) {
          entity ve=(entity) pv2->var;
          if (!value_undefined_p(entity_initial(ve)) && value_reference_p(entity_initial(ve))) {
            reference r = value_reference(entity_initial(ve)); 
            entity v = reference_variable(r);
            region reg = region_undefined; 
            add_margin(global_margin, sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "Precondition Param=", QUOTE,entity_user_name(v), QUOTE,
                                             " Field=", QUOTE, words_points_to_reference(r,true,reg), QUOTE,
                                             " Numeric=", QUOTE,  int2a(coeff), QUOTE, SLASH, CLOSEANGLE, NL, NULL)); 
          }
          else {        
            add_margin(global_margin, sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "Precondition Param=", QUOTE,entity_user_name(ve), QUOTE,
                                             " Numeric=", QUOTE,  int2a(coeff), QUOTE,SLASH, CLOSEANGLE, NL, NULL));
          }
        }
      }
      vect_rm(pv2);
    }
  }
  for (pc = prec->inegalites; pc!=NULL; pc=pc->succ) {
    pv = contrainte_vecteur(pc);
    if (vect_size(pv)<=2 && vect_dimension(pv)==1) {
      Pvecteur pv2 = vect_copy(pv);
      int coeff = - vect_coeff(TCST,pv2);
      vect_chg_coeff(&pv2,TCST,0);
      if (!VECTEUR_UNDEFINED_P(pv2) && !VECTEUR_NUL_P(pv2)) {
        entity etmp = (entity) pv2->var;
        if (!old_value_entity_p(etmp)) {
          entity ve = value_to_variable(etmp);
          int val = pv2->val;
          if (!value_undefined_p(entity_initial(ve)) && (value_reference_p(entity_initial(ve)))) {
            reference r = value_reference(entity_initial(ve));
            entity v = reference_variable(r);
            region reg = region_undefined; 
            add_margin(global_margin, sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "Precondition Param=", QUOTE,entity_user_name(v), QUOTE,
                                             " Field=", QUOTE, words_points_to_reference(r,true,reg), QUOTE,
                                             (val<=0) ? " MinNumeric=":" MaxNumeric=", QUOTE,  int2a(coeff), QUOTE, SLASH,CLOSEANGLE, NL, NULL));
          }
          else {        
            add_margin(global_margin, sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "Precondition Param=", QUOTE,entity_user_name(ve), QUOTE,
                                             (val<=0)?" MinNumeric=":" MaxNumeric=", QUOTE,  int2a(coeff), QUOTE, SLASH,CLOSEANGLE, NL, NULL));
 
          }
        }
      }
    }
  }
  global_margin--;
  string_buffer_append_word("/CallPreconditions", sb_result);
}

References add_margin(), CLOSEANGLE, concatenate(), contrainte_vecteur, Ssysteme::egalites, entity_initial, entity_user_name(), global_margin, if(), Ssysteme::inegalites, int2a(), NL, old_value_entity_p(), OPENANGLE, QUOTE, reference_variable, region, region_undefined, SLASH, string_buffer_append(), string_buffer_append_word(), Scontrainte::succ, TCST, Svecteur::val, value_reference, value_reference_p, value_to_variable(), value_undefined_p, Svecteur::var, vect_chg_coeff(), vect_coeff(), vect_copy(), vect_dimension(), vect_rm(), vect_size(), VECTEUR_NUL_P, VECTEUR_UNDEFINED_P, and words_points_to_reference().

Referenced by xml_Call().

Here is the call graph for this function:

Here is the caller graph for this function:

print_full_name_p()

static bool print_full_name_p ( )

static

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

Definition at line 1214 of file xml_prettyprinter.c.

{
  return false;
}

Referenced by xml_Region_Parameter(), and xml_TaskParameter().

Here is the caller graph for this function:

print_name_1_level_p()

static bool print_name_1_level_p ( )

static

Definition at line 1221 of file xml_prettyprinter.c.

{
  return true;
}

Referenced by xml_Chain_Graph().

Here is the caller graph for this function:

print_xml_application()

bool print_xml_application

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 6243 of file xml_prettyprinter.c.

{
  bool result = generic_print_xml_application(module_name, false);
  return result;
}

References generic_print_xml_application(), and module_name().

Here is the call graph for this function:

print_xml_application_main()

bool print_xml_application_main

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 6249 of file xml_prettyprinter.c.

{
  bool result = generic_print_xml_application(module_name, true);
  return result;
}

References generic_print_xml_application(), and module_name().

Here is the call graph for this function:

print_xml_application_main_with_points_to()

bool print_xml_application_main_with_points_to

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 6254 of file xml_prettyprinter.c.

{
  set_pt_to_list( (statement_points_to)
                   db_get_memory_resource(DBR_POINTS_TO, module_name, true) );
  bool result = generic_print_xml_application(module_name, true);
  reset_pt_to_list();
  return result;
}

References db_get_memory_resource(), generic_print_xml_application(), module_name(), reset_pt_to_list(), and set_pt_to_list().

Here is the call graph for this function:

print_xml_application_with_points_to()

bool print_xml_application_with_points_to

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 6234 of file xml_prettyprinter.c.

{
  set_pt_to_list( (statement_points_to)
                  db_get_memory_resource(DBR_POINTS_TO, module_name, true) );
  bool result = generic_print_xml_application(module_name, false);
  reset_pt_to_list();
  return result;
}

References db_get_memory_resource(), generic_print_xml_application(), module_name(), reset_pt_to_list(), and set_pt_to_list().

Here is the call graph for this function:

print_xml_code()

bool print_xml_code

(

const char *

module_name

)

Initiates xml pretty print modules.

Get the READ and WRITE regions of the module

save to file

Parameters

module_name

odule_name

Definition at line 1888 of file xml_prettyprinter.c.

{
  FILE * out;
  string ppt;
  entity module = module_name_to_entity(module_name);
  string xml = db_build_file_resource_name(DBR_XML_PRINTED_FILE,
                                           module_name, ".xml");
  string  dir = db_get_current_workspace_directory();
  string filename = strdup(concatenate(dir, "/", xml, NULL));
  statement stat=(statement) db_get_memory_resource(DBR_CODE,
                                                    module_name, true);
 
  init_cost_table();
  /* Get the READ and WRITE regions of the module */
  set_rw_effects((statement_effects)
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
 
  set_complexity_map( (statement_mapping)
                      db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
 
  if(statement_undefined_p(stat))
    {
      pips_internal_error("No statement for module %s", module_name);
    }
  set_current_module_entity(module);
  set_current_module_statement(stat);
 
  debug_on("XMLPRETTYPRINTER_DEBUG_LEVEL");
  pips_debug(1, "Spec validation before xml prettyprinter for %s\n",
             entity_name(module));
  if (valid_specification_p(module,stat)){
    pips_debug(1, "Spec is valid\n");
    pips_debug(1, "Begin XML prettyprinter for %s\n", entity_name(module));
    ppt = xml_code(module, stat);
    pips_debug(1, "end\n");
    debug_off();
    /* save to file */
    out = safe_fopen(filename, "w");
    fprintf(out,"%s",ppt);
    safe_fclose(out, filename);
    free(ppt);
  }
 
  free(dir);
  free(filename);
 
  DB_PUT_FILE_RESOURCE(DBR_XML_PRINTED_FILE, module_name, xml);
 
  reset_current_module_statement();
  reset_current_module_entity();
  reset_complexity_map();
  reset_rw_effects();
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_name, fprintf(), free(), init_cost_table(), module, module_name(), module_name_to_entity(), out, pips_debug, pips_internal_error, reset_complexity_map(), reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), safe_fclose(), safe_fopen(), set_complexity_map(), set_current_module_entity(), set_current_module_statement(), set_rw_effects(), statement_undefined_p, strdup(), valid_specification_p(), and xml_code().

Here is the call graph for this function:

print_xml_code_with_explicit_motif()

bool print_xml_code_with_explicit_motif

(

const char *

module_name

)

Initiates xml pretty print modules.

xml_prettyprinter.c

save to file

Parameters

module_name

odule_name

Definition at line 1162 of file xml_prettyprinter.c.

{
  FILE * out;
  string ppt, xml, dir, filename;
  entity module;
  statement stat;
  array_names = gen_array_make(0);
  array_dims = gen_array_make(0);
  xml = db_build_file_resource_name(DBR_XML_PRINTED_FILE, module_name, ".xml");
 
  global_module_name = module_name;
  module = module_name_to_entity(module_name);
  dir = db_get_current_workspace_directory();
  filename = strdup(concatenate(dir, "/", xml, NULL));
  stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  if(statement_undefined_p(stat))
    {
      pips_internal_error("No statement for module %s", module_name);
    }
  set_current_module_entity(module);
  set_current_module_statement(stat);
 
  debug_on("XMLPRETTYPRINTER_DEBUG_LEVEL");
  pips_debug(1, "Begin Claire prettyprinter for %s\n", entity_name(module));
  ppt = xml_code_string(module, stat);
  pips_debug(1, "end\n");
  debug_off();
 
  /* save to file */
  out = safe_fopen(filename, "w");
  fprintf(out, "%s", ppt);
  safe_fclose(out, filename);
 
  free(ppt);
  free(dir);
  free(filename);
 
  DB_PUT_FILE_RESOURCE(DBR_XML_PRINTED_FILE, module_name, xml);
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References array_dims, array_names, concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_name, fprintf(), free(), gen_array_make(), global_module_name, module, module_name(), module_name_to_entity(), out, pips_debug, pips_internal_error, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), statement_undefined_p, strdup(), and xml_code_string().

Here is the call graph for this function:

push_current_statement()

static void push_current_statement ( statement  s, nest_context_p  nest  )

static

Definition at line 1281 of file xml_prettyprinter.c.

{
  stack_push(s , nest->current_stat);
}

References nest_context_t::current_stat, and stack_push().

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

push_if()

static void push_if ( _UNUSED_ test  l, nest_context_p  nest  )

static

on sauve le statement associe au test

Definition at line 1311 of file xml_prettyprinter.c.

{
  /* on sauve le statement associe au test */
  statement sl = (statement) stack_head(nest->current_stat);
  stack_push(sl , nest->testif);
}

References nest_context_t::current_stat, stack_head(), stack_push(), and nest_context_t::testif.

Referenced by find_loops_and_calls_in_box().

Here is the call graph for this function:

Here is the caller graph for this function:

push_loop()

static void push_loop ( loop  l, nest_context_p  nest  )

static

on sauve le statement associe a la boucle courante

Definition at line 1295 of file xml_prettyprinter.c.

{
  /* on sauve le statement associe a la boucle courante */
  statement sl = (statement) stack_head(nest->current_stat);
  stack_push(sl , nest->loops_for_call);
  stack_push(loop_index(l) , nest->loop_indices);
}

References nest_context_t::current_stat, loop_index, nest_context_t::loop_indices, nest_context_t::loops_for_call, stack_head(), and stack_push().

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

push_test()

static bool push_test ( test t   __attribute__(unused), nest_context_p nest   __attribute__(unused)  )

static

encapsulation de l'ensemble des instructions appartenant au test

Definition at line 1366 of file xml_prettyprinter.c.

{
  /* encapsulation de l'ensemble des instructions appartenant au test*/
  return true;
}

Referenced by search_nested_loops_and_calls().

Here is the caller graph for this function:

region_range_nul_p()

static bool region_range_nul_p ( region  reg, Variable  phi  )

static

tatic bool string_in_list_p(string ts,list lr){ bool trouve=false; MAPL(tt, {trouve= trouve || strcmp(STRING(CAR(tt)),ts) == 0;}, lr); return trouve; }

Definition at line 2650 of file xml_prettyprinter.c.

{
  Pcontrainte pc;
  bool result=false;
  if(reg != region_undefined) {
    reference ref = effect_any_reference(reg);
    entity vreg = reference_variable(ref);
    if (array_entity_p(reference_variable(ref))) {
      if (gen_length(variable_dimensions(type_variable(entity_type(vreg)))) ==1) {
        Psysteme ps_reg = sc_dup(region_system(reg));
        if (!SC_UNDEFINED_P(ps_reg)) {
          for(pc = sc_egalites(ps_reg); pc!=NULL;pc= pc->succ)  {
            if (vect_coeff(phi, pc->vecteur) && (vect_size(pc->vecteur)==1 ))
              result=true;
          }
        }
      }
    }
  }
  return result;
}

References array_entity_p(), effect_any_reference, entity_type, gen_length(), ref, reference_variable, region_system, region_undefined, sc_dup(), Scontrainte::succ, type_variable, variable_dimensions, vect_coeff(), vect_size(), and Scontrainte::vecteur.

Referenced by words_points_to_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

same_callst_p()

static bool same_callst_p ( Pcallst  c1, Pcallst  c2  )

static

Definition at line 3154 of file xml_prettyprinter.c.

{
  return(same_entity_p(c1->func,c2->func) && (c1->stat_nb ==c2->stat_nb));
}

References callst::func, same_entity_p(), and callst::stat_nb.

Referenced by update_def_into_tasks_table().

Here is the call graph for this function:

Here is the caller graph for this function:

same_entities()

static void same_entities ( reference  r, expression_ctxt *  ctxt  )

static

Definition at line 3095 of file xml_prettyprinter.c.

{
  if (same_entity_p(reference_variable(r),ctxt->e))
    ctxt->entity_in_p = true;
}

References expression_ctxt::e, expression_ctxt::entity_in_p, reference_variable, and same_entity_p().

Referenced by entity_in_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

search_1r_function_call()

static void search_1r_function_call ( call  c )

static

Definition at line 1330 of file xml_prettyprinter.c.

{
  entity f = call_function(c);
  if  (ENTITY_ASSIGN_P(f) || entity_subroutine_p(f)|| entity_function_p(f))
    if (encapsulated_call ==call_undefined)
      encapsulated_call =c;
}

References call_function, call_undefined, encapsulated_call, ENTITY_ASSIGN_P, entity_function_p(), entity_subroutine_p(), and f().

Referenced by xml_Argument(), xml_Arguments(), xml_Call(), xml_Chain_Graph(), and xml_TaskParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

search_nested_loops_and_calls()

static void search_nested_loops_and_calls ( statement  stmp, nest_context_p  nest  )

static

Definition at line 1383 of file xml_prettyprinter.c.

{
  gen_context_multi_recurse(stmp,nest, loop_domain,push_loop,pop_loop,
                            statement_domain, push_current_statement,pop_current_statement,
                            test_domain, push_test, pop_test,
                            call_domain,call_selection,store_call_context,
                            NULL);
}

References call_domain, call_selection(), gen_context_multi_recurse(), loop_domain, pop_current_statement(), pop_loop(), pop_test(), push_current_statement(), push_loop(), push_test(), statement_domain, store_call_context(), and test_domain.

Referenced by xml_tasks().

Here is the call graph for this function:

Here is the caller graph for this function:

sequence_call()

static call sequence_call ( sequence  seq )

static

meaningful call

number of calls

Definition at line 838 of file xml_prettyprinter.c.

{
  call mc = call_undefined; /* meaningful call */
  int nc = 0; /* number of calls */
 
  MAP(STATEMENT, s, {
      if(continue_statement_p(s))
        ;
      else if(statement_call_p(s)) {
        mc = instruction_call(statement_instruction(s));
        nc++;
      }
      else {
        nc = 0;
        break;
      }
    }, sequence_statements(seq));
 
  if(nc!=1)
    mc = call_undefined;
 
  return mc;
}

References call_undefined, continue_statement_p(), instruction_call, MAP, sequence_statements, STATEMENT, statement_call_p(), and statement_instruction.

Referenced by xml_loop_from_loop(), and xml_loop_from_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

sequence_loop()

static loop sequence_loop ( sequence  seq )

static

meaningful loop

number of loops

Definition at line 862 of file xml_prettyprinter.c.

{
  loop ml = loop_undefined; /* meaningful loop */
  int nl = 0; /* number of loops */
 
  MAP(STATEMENT, s, {
      if(continue_statement_p(s))
        ;
      else if(statement_loop_p(s)) {
        ml = instruction_loop(statement_instruction(s));
        nl++;
      }
      else {
        nl = 0;
        break;
      }
    }, sequence_statements(seq));
 
  if(nl!=1)
    ml = loop_undefined;
 
  return ml;
}

References continue_statement_p(), instruction_loop, loop_undefined, MAP, sequence_statements, STATEMENT, statement_instruction, and statement_loop_p().

Referenced by xml_loop_from_loop(), and xml_loop_from_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_cast_and_addop_expression()

static expression skip_cast_and_addop_expression ( expression  exp )

static

Definition at line 4228 of file xml_prettyprinter.c.

{
  expression exp1=exp;
  if (syntax_cast_p(expression_syntax(exp)))
    exp1 = cast_expression(syntax_cast(expression_syntax(exp)));
  if (syntax_call_p(expression_syntax(exp1))) {
    call cl = syntax_call(expression_syntax(exp1));
    const char *fun = entity_local_name(call_function(cl));
    if (strcmp(fun, ADDRESS_OF_OPERATOR_NAME) == 0) {
      exp1 = EXPRESSION(CAR(call_arguments(cl)));
    }
  }
  return exp1;
}

References ADDRESS_OF_OPERATOR_NAME, call_arguments, call_function, CAR, cast_expression, entity_local_name(), exp, EXPRESSION, expression_syntax, syntax_call, syntax_call_p, syntax_cast, and syntax_cast_p.

Referenced by xml_Argument().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_cast_expression()

static expression skip_cast_expression ( expression  exp )

static

Definition at line 4210 of file xml_prettyprinter.c.

{
  expression exp1=exp;
  if (syntax_cast_p(expression_syntax(exp)))
    exp1 = cast_expression(syntax_cast(expression_syntax(exp)));
  return exp1;
}

References cast_expression, exp, expression_syntax, syntax_cast, and syntax_cast_p.

Referenced by xml_Argument().

Here is the caller graph for this function:

skip_field_and_cast_expression()

static expression skip_field_and_cast_expression ( expression  exp )

static

Definition at line 4218 of file xml_prettyprinter.c.

{
  expression exp1=exp;
  if (expression_field_p(exp))
    exp1= EXPRESSION(CAR(call_arguments(expression_call(exp))));
  if (syntax_cast_p(expression_syntax(exp1)))
    exp1 = cast_expression(syntax_cast(expression_syntax(exp1)));
  return exp1;
}

References call_arguments, CAR, cast_expression, exp, EXPRESSION, expression_call(), expression_field_p(), expression_syntax, syntax_cast, and syntax_cast_p.

Referenced by xml_Call(), and xml_Transposition().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_in_truebranch()

static void statement_in_truebranch ( statement  s )

static

Definition at line 4860 of file xml_prettyprinter.c.

{
  if (statement_number(test_statement_of_reference) == statement_number(s))
    statement_in_truebranch_p= true;
}

References statement_in_truebranch_p, statement_number, and test_statement_of_reference.

Referenced by xml_Call(), and xml_Chain_Graph().

Here is the caller graph for this function:

store_call_context()

static void store_call_context ( call c   __attribute__(unused), nest_context_p  nest  )

static

on sauve le statement associe au call

Definition at line 1349 of file xml_prettyprinter.c.

                                                    {
  /* on sauve le statement associe au call */
  statement statc = (statement)stack_head(nest->current_stat);
  //  if (instruction_call_p(statement_instruction(statc))) {
  stack sl = stack_copy(nest->loops_for_call);
  stack si = stack_copy(nest->loop_indices);
  stack statif = stack_copy(nest->testif);
  gen_array_append(nest->nested_loop_indices, si);
  gen_array_append(nest->nested_loops, sl);
  gen_array_append(nest->nested_call, statc);
  gen_array_append(nest->nested_if, statif);
  //  }
}

References nest_context_t::current_stat, gen_array_append(), nest_context_t::loop_indices, nest_context_t::loops_for_call, nest_context_t::nested_call, nest_context_t::nested_if, nest_context_t::nested_loop_indices, nest_context_t::nested_loops, stack_copy(), stack_head(), and nest_context_t::testif.

Referenced by find_loops_and_calls_in_box(), and search_nested_loops_and_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

store_local_array_declaration()

static void store_local_array_declaration ( statement  s )

static

Definition at line 3874 of file xml_prettyprinter.c.

{
  list ls;
  if (declaration_statement_p(s)) {
    ls=statement_declarations(s);
    local_declaration_list = gen_append(local_declaration_list,ls);
  }
}

References declaration_statement_p(), gen_append(), local_declaration_list, and statement_declarations.

Referenced by xml_LocalVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

str_sub()

char* str_sub	(	const char *	s,
		int	start,
		int	end
	)

Parameters

start	tart
end	nd

Definition at line 2673 of file xml_prettyprinter.c.

{
   char *new_s = NULL;
   if (s != NULL && start <= end)
   {
      new_s = malloc (sizeof (*new_s) * (end - start + 2));
      if (new_s != NULL) {
         int i;
         for (i = start; i <= end; i++) {
            new_s[i-start] = s[i];
         }
         new_s[i-start] = '\0';
      }
   }
   return new_s;
}

References end, malloc(), and start.

Referenced by pointer_to_initial_name().

Here is the call graph for this function:

Here is the caller graph for this function:

string_buffer_append_numeric()

static void string_buffer_append_numeric ( string  str, string_buffer  sb_result  )

static

Definition at line 2018 of file xml_prettyprinter.c.

                                                                             {
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,"Numeric",CLOSEANGLE,
                                   str,
                                   OPENANGLE,"/Numeric",CLOSEANGLE,
                                   NL, NULL));
}

References add_margin(), CLOSEANGLE, concatenate(), global_margin, NL, OPENANGLE, and string_buffer_append().

Referenced by xml_Argument(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), and xml_Pattern_Paving().

Here is the call graph for this function:

Here is the caller graph for this function:

string_buffer_append_symbolic()

static void string_buffer_append_symbolic ( string  str, string_buffer  sb_result  )

static

Definition at line 1997 of file xml_prettyprinter.c.

                                                                              {
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE, "Symbolic", CLOSEANGLE, NULL));
  string_buffer_append_xml_text(sb_result, str, false);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,"/Symbolic",CLOSEANGLE,
                                   NL, NULL));
}

References add_margin(), CLOSEANGLE, concatenate(), global_margin, NL, OPENANGLE, string_buffer_append(), and string_buffer_append_xml_text().

Referenced by xml_Bounds(), xml_Bounds_and_Stride(), and xml_Pattern_Paving().

Here is the call graph for this function:

Here is the caller graph for this function:

string_buffer_append_word()

static void string_buffer_append_word ( string  str, string_buffer  sb_result  )

static

Definition at line 1987 of file xml_prettyprinter.c.

{
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,NULL));
  string_buffer_append_xml_text(sb_result, str, false);
  string_buffer_append(sb_result,
                       concatenate(CLOSEANGLE, NL, NULL));
}

References add_margin(), CLOSEANGLE, concatenate(), global_margin, NL, OPENANGLE, string_buffer_append(), and string_buffer_append_xml_text().

Referenced by print_call_precondition(), xml_Application(), xml_Argument(), xml_Arguments(), xml_Array(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), xml_Boxes(), xml_Call(), xml_Chain_Graph(), xml_CodeSize(), xml_Connection(), xml_ConstOffset(), xml_FormalVariables(), xml_Full_Type(), xml_GlobalVariables(), xml_Library(), xml_LocalVariables(), xml_Loop(), xml_LoopOffset(), xml_Loops(), xml_Matrix(), xml_Pattern_Paving(), xml_Region_Parameter(), xml_Task(), xml_TaskParameter(), xml_TaskParameters(), xml_TaskReturnParameter(), xml_Transposition(), and xml_Type_Entity().

Here is the call graph for this function:

Here is the caller graph for this function:

string_parameter_p()

static bool string_parameter_p ( entity  e )

static

Definition at line 3996 of file xml_prettyprinter.c.

{
  const char * comm = entity_user_name(e);
  if (!string_undefined_p(comm) && strstr(comm,"\"")!=NULL)
    return (true);
  else return (false);
}

References entity_user_name(), and string_undefined_p.

Referenced by xml_Chain_Graph(), and xml_Compute_and_Need().

Here is the call graph for this function:

Here is the caller graph for this function:

task_complexity()

static string task_complexity ( statement  s )

static

Definition at line 1778 of file xml_prettyprinter.c.

{
  complexity stat_comp = load_statement_complexity(s);
  string r;
  if(stat_comp != (complexity) HASH_UNDEFINED_VALUE && !complexity_zero_p(stat_comp)) {
    cons *pc = CHAIN_SWORD(NIL, complexity_sprint(stat_comp, false,
                                                  true));
    r = words_to_string(pc);
  }
  else r = int2a(1);
  return  (r);
}

References CHAIN_SWORD, complexity_sprint(), complexity_zero_p(), HASH_UNDEFINED_VALUE, int2a(), load_statement_complexity(), NIL, and words_to_string().

Referenced by xml_task().

Here is the call graph for this function:

Here is the caller graph for this function:

this_entity_xmldeclaration()

static string this_entity_xmldeclaration ( entity  var )

static

Many possible combinations

Definition at line 364 of file xml_prettyprinter.c.

{
  string result = strdup("");
  string name = strdup(concatenate("A_", entity_local_name(var), NULL));
  type t = entity_type(var);
  pips_debug(2,"Entity name : %s\n",entity_name(var));
  /*  Many possible combinations */
 
  if (strstr(name,TYPEDEF_PREFIX) != NULL)
    pips_user_error("Structs not supported\n");
 
  switch (type_tag(t)) {
  case is_type_variable:
    {
      variable v = type_variable(t);
      string sd;
      sd = strdup(xml_dim_string(variable_dimensions(v), name));
      result = strdup(concatenate(result, sd, NULL));
      break;
    }
  case is_type_struct:
    {
      pips_user_error("Struct not allowed\n");
      break;
    }
  case is_type_union:
    {
      pips_user_error("Union not allowed\n");
      break;
    }
  case is_type_enum:
    {
      pips_user_error("Enum not allowed\n");
      break;
    }
  default:
    pips_user_error("Something not allowed here\n");
  }
 
  return result;
}

References concatenate(), entity_local_name(), entity_name, entity_type, is_type_enum, is_type_struct, is_type_union, is_type_variable, pips_debug, pips_user_error, strdup(), type_tag, type_variable, TYPEDEF_PREFIX, variable_dimensions, and xml_dim_string().

Referenced by xml_declarations_with_explicit_motif().

Here is the call graph for this function:

Here is the caller graph for this function:

tri_abc()

static void tri_abc ( int  a[12], int  dim, int  result[12]  )

static

Definition at line 4169 of file xml_prettyprinter.c.

{
  int a_copy[12];
  int i;
  memcpy(a_copy,a,(2*dim+1)*sizeof(int));
  qsort(&a_copy[1],dim,sizeof(int), int_compare);
  qsort(&a_copy[1+dim],dim,sizeof(int), int_compare);
  for (int k=0;k<=1;k++)
    for ( i=1; i<=dim; i++) {
      for (int j=1; j<=dim; j++)
        if (a_copy[i+dim*k]==a[j+dim*k])
          result[i+dim*k]=j;
    }
}

References int_compare().

Referenced by xml_Transposed_Matrix3_5D().

Here is the call graph for this function:

Here is the caller graph for this function:

two_string_buffer_append_symbolic()

static void two_string_buffer_append_symbolic ( string  str1, string  str2, string_buffer  sb_result  )

static

Definition at line 2007 of file xml_prettyprinter.c.

                                                                                                {
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,"Symbolic",CLOSEANGLE, NULL));
  string_buffer_append_xml_text(sb_result,str1,false);
  string_buffer_append_xml_text(sb_result,str2,false);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,"/Symbolic",CLOSEANGLE,
                                   NL, NULL));
}

References add_margin(), CLOSEANGLE, concatenate(), global_margin, NL, OPENANGLE, string_buffer_append(), and string_buffer_append_xml_text().

Referenced by xml_Pattern_Paving().

Here is the call graph for this function:

Here is the caller graph for this function:

type_and_size_of_var()

static void type_and_size_of_var ( entity  var, const char **  datatype, int *  size  )

static

UNUSED static bool vect_one_p(Pvecteur v) { return (!VECTEUR_NUL_P(v) && vect_size(v) == 1 && vect_coeff(TCST, v) ==1); }.

UNUSED static bool vect_zero_p(Pvecteur v) { return (VECTEUR_NUL_P(v) || (!VECTEUR_NUL_P(v) && vect_size(v) == 1 && value_zero_p(vect_coeff(TCST, v)))); }

Definition at line 1965 of file xml_prettyprinter.c.

{
  // type t = ultimate_type(entity_type(var));
  type t = entity_type(var);
  if (type_variable_p(t)) {
    basic b = variable_basic(type_variable(t));
    int e = SizeOfElements(b);
    if (e==-1)
      *size = 9999;
    else
      *size = e;
    *datatype =basic_to_string(b);
  }
}

References basic_to_string(), entity_type, SizeOfElements(), type_variable, type_variable_p, and variable_basic.

Referenced by xml_Array(), xml_Scalar(), and xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

update_def_into_tasks_table()

static void update_def_into_tasks_table ( entity  v, Pcallst  c1  )

static

Definition at line 3159 of file xml_prettyprinter.c.

{
  Pcallst ll= NULL,lc2;
  bool found=false;
  Pcallst ldef = (Pcallst) hash_get(hash_entity_def_into_tasks,(char *) v);
  if (ldef != (Pcallst) HASH_UNDEFINED_VALUE) {
    for(lc2=ldef;lc2 !=(Pcallst) HASH_UNDEFINED_VALUE && lc2 !=(Pcallst) NULL && !found; lc2=lc2->succ)
      {
        if (same_callst_p(c1,lc2))
          found=true;
      }
    if (!found)
      c1->succ=ldef, ll=c1;
    else ll =ldef;
  }
  else ll=c1;
  hash_del(hash_entity_def_into_tasks,(char *) v);
  hash_put(hash_entity_def_into_tasks,(char *) v,(char *)ll);
}

References hash_del(), hash_entity_def_into_tasks, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, same_callst_p(), and callst::succ.

Referenced by xml_Argument(), xml_AssignArgument(), and xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

valid_specification_p()

static bool valid_specification_p ( entity module   __attribute__(unused), statement stat   __attribute__(unused)  )

static

Definition at line 1878 of file xml_prettyprinter.c.

{ return true;
}

Referenced by print_xml_code().

Here is the caller graph for this function:

variable_p()

static bool variable_p ( entity  e )

static

Definition at line 187 of file xml_prettyprinter.c.

{
  storage s = entity_storage(e);
  return type_variable_p(entity_type(e)) &&
    (storage_ram_p(s) || storage_return_p(s));
}

References entity_storage, entity_type, storage_ram_p, storage_return_p, and type_variable_p.

Referenced by xml_code_string(), and xml_declarations().

Here is the caller graph for this function:

vars_read_and_written()

static void vars_read_and_written ( list  effects_list, Pvecteur *  vr, Pvecteur *  vw  )

static

UNUSED static void array_vars_read_or_written(list effects_list, Pvecteur *vl) { Pvecteur vin=VECTEUR_NUL; Pvecteur vout = VECTEUR_NUL; list pc; for (pc= effects_list;pc != NIL; pc = CDR(pc)){ effect e = EFFECT(CAR(pc)); reference r = effect_any_reference(e); if (store_effect_p(e) && array_entity_p(reference_variable(r))) { entity v = reference_variable(r); if (effect_read_p(e)) vect_add_elem(&vin,v,1); else vect_add_elem(&vout,v,1); } } vin = base_normalize(vin); vout = base_normalize(vout); vl = vect_substract(vin,vout); vl= base_normalize(*vl); vect_rm(vin); vect_rm(vout); }.

Definition at line 2526 of file xml_prettyprinter.c.

{
  list pc;
  for (pc= effects_list;pc != NIL; pc = CDR(pc)){
    effect e = EFFECT(CAR(pc));
    if (e!=(effect) 0 && effect_cell(e)!=0 && !effect_undefined_p(e)  && store_effect_p(e)) {
      reference r = effect_any_reference(e);
      entity v = reference_variable(r);
      if (effect_read_p(e))
        vect_add_elem(vr,v,1);
      else  vect_add_elem(vw,v,1);
    }
  }
  *vr = base_normalize(*vr);
  *vw = base_normalize(*vw);
}

References base_normalize(), CAR, CDR, EFFECT, effect_any_reference, effect_cell, effect_read_p, effect_undefined_p, NIL, reference_variable, store_effect_p(), and vect_add_elem().

Referenced by xml_Chain_Graph(), and xml_Compute_and_Need().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_to_string()

static string vect_to_string ( Pvecteur  pv )

static

Definition at line 1948 of file xml_prettyprinter.c.

                                          {
  return  expression_to_string(make_vecteur_expression(pv));
}

References expression_to_string(), and make_vecteur_expression().

Referenced by xml_Pattern_Paving(), and xml_Region_Range().

Here is the call graph for this function:

Here is the caller graph for this function:

words_points_to_reference()

static const char* words_points_to_reference ( reference  rv, bool  suffix_only_p, region  reg  )

static

Definition at line 2720 of file xml_prettyprinter.c.

{
  list pc = NIL;
  list pc1=NIL;
  int i;
  bool bp=false;
  entity vv = reference_variable(rv);
  type ct = entity_basic_concrete_type(vv);
  list lr=reference_indices(rv);
 
  if (!suffix_only_p)  {
    // Translate temporary constant entity name into user entity name
    string full_name= (string) entity_user_name(vv);
    string initial_name = pointer_to_initial_name(full_name,(string)entity_name(vv));
    pc = CHAIN_SWORD(pc, initial_name);
  }
  while(lr != NIL) {
    switch (type_tag(ct)) {
    case is_type_variable: {
 
      variable vt = type_variable(ct);
      basic bt = variable_basic(vt);
      list lt = variable_dimensions(vt);
 
      if (array_type_p(ct)) {
        expression ll = EXPRESSION(CAR(lr));
        entity re=entity_undefined;
        if (syntax_reference_p(expression_syntax(ll)))
          re=reference_variable(syntax_reference(expression_syntax(ll)));
        if (gen_length(lt) ==1 && !region_undefined_p(reg) && !entity_undefined_p(re) && region_range_nul_p(reg,(Variable)re)) {
          if (CDR(lr)!=NIL)  {
            pc = CHAIN_SWORD(pc,"->");
            bp=true;
          }
          else {
            pc1=NIL;
            pc1 = CHAIN_SWORD(pc1,"*");
            gen_nconc(pc1,pc);
            pc=pc1;
          }
          lr=CDR(lr);
        }
        else {
          for (i= 1; i<= (int) gen_length(lt) && lr!=NIL; i++) {
            pc = CHAIN_SWORD(pc,"[*]");
            lr=CDR(lr);
          }
        }
      }
 
      if (lr!=NIL) {
        if(basic_typedef_p(bt)) {
          entity e = basic_typedef(bt);
          ct= compute_basic_concrete_type(entity_type(e));
        }
        else if(basic_pointer_p(bt)) {
          pc = CHAIN_SWORD(pc, "->");
          lr=CDR(lr); // equivalent to [0]
          ct = compute_basic_concrete_type(basic_pointer(bt));
          bp=true;
        }
        else if(basic_derived_p(bt)) {
          ct = compute_basic_concrete_type(entity_type(basic_derived(bt)));
        }
        else  { // int, float, logical, overload, complex, string, bit ==> nothing to do
          if (lr ==NIL)
            printf(" additional basic type, PB \n");
          else {
            lr=CDR(lr);
          }
        }
      }
      break;
    }
 
    case is_type_struct: {
      if (!bp) pc = CHAIN_SWORD(pc, ".");
      bp=false;
      list fe = type_struct(ct); // list of type entities in struct
      expression exp= EXPRESSION(CAR(lr));
      syntax se = expression_syntax(exp);
      if (syntax_reference_p(se)) {
        entity re=reference_variable(syntax_reference(se));
        FOREACH(ENTITY, fee, fe){
          if (same_entity_p(fee,re))
            ct = compute_basic_concrete_type(entity_type(fee));
        }
        pc = CHAIN_SWORD(pc,expression_to_string(exp));
        lr = CDR(lr);
      }
      else printf("pb avec le STRUCT\n");
      break;
    }
    case is_type_union: {
      if (!bp) pc = CHAIN_SWORD(pc, ".");
      bp=false;
      list fe = type_union(ct); // list of type entities in union
      expression exp= EXPRESSION(CAR(lr));
      syntax se = expression_syntax(exp);
      if (syntax_reference_p(se)) {
        entity re=reference_variable(syntax_reference(se));
        FOREACH(ENTITY, fee, fe){
          if (same_entity_p(fee,re))
            ct = compute_basic_concrete_type(entity_type(fee));
        }
        pc = CHAIN_SWORD(pc, "{");
        pc = CHAIN_SWORD(pc,expression_to_string(exp));
        pc = CHAIN_SWORD(pc, "}");
        lr = CDR(lr);
      }
      else printf("pb avec le UNION\n");
      break;
    }
    case is_type_enum: {
      if (!bp) pc = CHAIN_SWORD(pc, ".");
      bp=false;
      list fe = type_enum(ct); // list of type entities in union
      expression exp= EXPRESSION(CAR(lr));
      syntax se = expression_syntax(exp);
      if (syntax_reference_p(se)) {
        entity re=reference_variable(syntax_reference(se));
        FOREACH(ENTITY, fee, fe){
          if (same_entity_p(fee,re))
            ct = compute_basic_concrete_type(entity_type(fee));
        }
        pc = CHAIN_SWORD(pc, "{");
        pc = CHAIN_SWORD(pc,expression_to_string(exp));
        pc = CHAIN_SWORD(pc, "}");
        lr = CDR(lr);
      }
      else printf("pb avec le ENUM\n");
      break;
    }
    default: // void(not here), unknown(not here), varargs (to be added?), functional (not here), statement(not here), area (not here)
      {
        printf("Not implemented\n");
        pc = CHAIN_SWORD(pc, expression_to_string(EXPRESSION(CAR(lr))));
        lr = CDR(lr);
      }
    }
  }
  return(strdup(list_to_string(pc)));
}

References array_type_p(), basic_derived, basic_derived_p, basic_pointer, basic_pointer_p, basic_typedef, basic_typedef_p, CAR, CDR, CHAIN_SWORD, compute_basic_concrete_type(), ENTITY, entity_basic_concrete_type(), entity_name, entity_type, entity_undefined, entity_undefined_p, entity_user_name(), exp, EXPRESSION, expression_syntax, expression_to_string(), FOREACH, full_name, gen_length(), gen_nconc(), int, is_type_enum, is_type_struct, is_type_union, is_type_variable, list_to_string(), NIL, pointer_to_initial_name(), printf(), reference_indices, reference_variable, region_range_nul_p(), region_undefined_p, same_entity_p(), strdup(), syntax_reference, syntax_reference_p, type_enum, type_struct, type_tag, type_union, type_variable, variable_basic, and variable_dimensions.

Referenced by print_call_precondition(), xml_Chain_Graph(), xml_Region_Parameter(), and xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_AccessFunction()

static void xml_AccessFunction ( string_buffer sb_result   __attribute__(unused) )

static

Definition at line 2059 of file xml_prettyprinter.c.

{
  //string_buffer_append_word("AccessFunction",sb_result);
  //string_buffer_append_word("/AccessFunction",sb_result);
}

Referenced by xml_Pattern_Paving().

Here is the caller graph for this function:

xml_Application()

static void xml_Application ( const char *  module_name, int  code_tag, string_buffer  sb_result  )

static

Definition at line 6049 of file xml_prettyprinter.c.

{
  entity module = module_name_to_entity(module_name);
  statement s = get_current_module_statement();
  Psysteme prec = SC_UNDEFINED;
  transformer t = first_precondition_of_module(module_name, &prec);
  Pvecteur vargs = VECTEUR_NUL;
 
  pips_assert("code is a main", code_tag == code_is_a_main);
 
  global_margin = 0;
  // <Application ...>
  string_buffer_append(sb_result, concatenate(
    OPENANGLE, "Application Name=", QUOTE, get_current_module_name(), QUOTE, BL,
    "Language=",QUOTE, (fortran_appli)? "FORTRAN": "C", QUOTE, BL,
    "PassingMode=", QUOTE,(fortran_appli)? "BYREFERENCE": "BYVALUE", QUOTE,
    CLOSEANGLE, NL, NULL));
 
  global_margin ++;
 
  //   IncludedFiles will be written here
  add_margin(global_margin, sb_result);
  string_buffer_append(sb_result, "<!-- Included Files -->" NL);
 
  //   <GlobalVariables>...</GlobalVariables>
  xml_GlobalVariables( t, prec, true, sb_result);
 
  //   Box/Task will be written here
  add_margin(global_margin, sb_result);
  string_buffer_append(sb_result, "<!-- Main Box -->" NL);
 
  //   <ApplicationGraph>
  add_margin(global_margin, sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "ApplicationGraph Name=", QUOTE, module_name, QUOTE,
                                   CLOSEANGLE,NL, NULL));
 
  //     <TaskRef>
  global_margin ++;
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "TaskRef Name=", QUOTE,entity_user_name(module), QUOTE,
                                   CLOSEANGLE,NL,NULL));
 
  cumulated_list = NIL;
  gen_recurse(s, statement_domain, gen_true, cumul_effects_of_statement);
  xml_Compute_and_Need(module,cumulated_list, vargs, sb_result);
 
  //     </TaskRef>
  string_buffer_append_word("/TaskRef", sb_result);
  global_margin --;
 
  //   </ApplicationGraph>
  string_buffer_append_word("/ApplicationGraph", sb_result);
  global_margin --;
 
  // </Application>
  string_buffer_append_word("/Application", sb_result);
 
  sc_free(prec);
}

References add_margin(), BL, CLOSEANGLE, code_is_a_main, concatenate(), cumul_effects_of_statement(), cumulated_list, entity_user_name(), first_precondition_of_module(), fortran_appli, gen_recurse, gen_true(), get_current_module_name(), get_current_module_statement(), global_margin, module, module_name(), module_name_to_entity(), NIL, NL, OPENANGLE, pips_assert, QUOTE, sc_free(), statement_domain, string_buffer_append(), string_buffer_append_word(), VECTEUR_NUL, xml_Compute_and_Need(), and xml_GlobalVariables().

Referenced by generic_print_xml_application().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Argument()

static void xml_Argument ( statement  s, entity  function, int  statnb, bool  assign_func, expression  exp0, entity  FormalName, Pvecteur  loop_indices, transformer  t, _UNUSED_ Psysteme  prec, string_buffer  sb_result  )

static

Scalar Argument

if (strncmp(aan, "\"", 1) == 0) quote_p = ""; else quote_p = QUOTE;

Array Argument

Save information to generate Task Graph

Definition at line 4529 of file xml_prettyprinter.c.

{
  list call_effect = load_proper_rw_effects_list(s);
  entity ActualName = entity_undefined;
  reference ActualRef = reference_undefined;
  syntax sr;
  effect efr = effect_undefined, efw = effect_undefined;
  ;
  intptr_t iexp;
  int rw_ef = 0;
  string aan = "";
  //  string quote_p = "";
  int valr = 0, min = 0, max = 0;
 
  expression exp1= skip_cast_and_addop_expression(exp0);
  //skip field, cast and address operator
  //expression exp2 = skip_field_and_cast_and_addop_expression(exp0);
  expression exp2 = skip_cast_expression(exp0);
  expression exp=exp1;
  push_statement_on_statement_global_stack(s);
  sr = expression_syntax(exp);
  if (syntax_reference_p(sr)) {
    ActualRef = syntax_reference(sr);
    ActualName = reference_variable(ActualRef);
    //aan = strdup(entity_user_name(ActualName));
    aan = expression_to_string(exp2);
    rw_ef = find_effect_actions_for_entity(call_effect, &efr, &efw, ActualName);
 
    if (rw_ef == 3) { // Aliasing checking
      // First, search the Call
      call c = call_undefined;
      if (instruction_call_p(statement_instruction(s))) {
        c = instruction_call(statement_instruction(s));
      } else {
        encapsulated_call = call_undefined;
        gen_recurse(s, call_domain, gen_true, search_1r_function_call);
        c = encapsulated_call;
      }
      if (c == call_undefined)
        pips_internal_error("Unexpected call in statement number %d \n",(int) statement_number(s));
 
      if (aliasing_p(c, ActualRef))
        spear_warning(s, "Check the IN PLACE condition",
                      "Array %s is read and written into the same function and "
                      "appears twice as actual argument in the Call",
                      entity_user_name(ActualName));
    }
  } else {
    // Actual Parameter could be  an expression
    aan = words_to_string(Words_Syntax(sr));
    rw_ef = 1;
  }
  string_buffer_append_word("Argument", sb_result);
  if (!array_argument_p(exp)) { /* Scalar Argument */
    bool tb = true;
    global_margin++;
    add_margin(global_margin, sb_result);
    /* if (strncmp(aan, "\"", 1) == 0)
      quote_p = "";
    else
    quote_p = QUOTE;*/
 
    if (!assign_func) {
      string_buffer_append( sb_result,
                            concatenate(OPENANGLE,
                                        "ScalarArgument ActualName=", QUOTE, NULL));
      string_buffer_append_xml_text(sb_result,aan,false);
      string_buffer_append( sb_result,
                            concatenate(QUOTE, BL,
                                        "FormalName=", QUOTE,
                                        (!entity_undefined_p(FormalName)) ? entity_user_name(FormalName) : "LocalExpression",
                                        QUOTE, BL,
                                        "AccessMode=", QUOTE,
                                        (rw_ef >= 2) ? ((rw_ef == 2) ? "DEF" : "DEF_USE") : "USE",
                                        QUOTE, CLOSEANGLE, NL, NULL));
    }
    
    else {
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "ScalarArgument ActualName=", QUOTE, NULL));
      string_buffer_append_xml_text(sb_result,aan,false);
      string_buffer_append(sb_result,
                           concatenate(QUOTE, BL,
                                       "AccessMode=", QUOTE,
                                       (rw_ef >= 2) ? ((rw_ef == 2) ? "DEF" : "DEF_USE") : "USE",
                                       QUOTE, CLOSEANGLE, NL, NULL));
    }
    if (expression_integer_value(exp, &iexp))
      string_buffer_append_numeric(int2a(iexp), sb_result);
    else if (value_constant_p(EvalExpression(exp))) {
      string exps = expression_to_string(exp);
      string_buffer_append_numeric(exps, sb_result);
    }
    else if ((tb = eval_linear_expression(exp1,t, &valr, &min, &max)) == true) {
      if (valr==min && valr==max)
        string_buffer_append_numeric(int2a(valr), sb_result);
      else {
        if (min != INT_MIN) {
          add_margin(global_margin, sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "MinNumeric", CLOSEANGLE, int2a(min), OPENANGLE,
                                           "/MinNumeric",
                                           CLOSEANGLE, NL, NULL));
        }
        if (max != INT_MAX) {
          add_margin(global_margin, sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "MaxNumeric", CLOSEANGLE, int2a(max), OPENANGLE,
                                           "/MaxNumeric",
                                           CLOSEANGLE, NL, NULL));
        }
      }
    }
    string_buffer_append_word("/ScalarArgument", sb_result);
    global_margin--;
    if (rw_ef >= 2) {
      Pcallst cst1 = (callst *)malloc(sizeof(callst));
      cst1->func = function;
      cst1->stat_nb = statnb;
      cst1->succ = (Pcallst)NULL;
      update_def_into_tasks_table(ActualName, cst1);
    }
  } else { /* Array Argument */
    int ActualArrayDim = variable_entity_dimension(ActualName);
    char *SActualArrayDim = strdup(i2a(ActualArrayDim));
    int FormalArrayDim = (entity_undefined_p(FormalName))
      ? 0
      : variable_entity_dimension(FormalName);
    list ActualArrayInd = reference_indices(ActualRef);
 
    global_margin++;
    add_margin(global_margin, sb_result);
    if (!assign_func) {
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "ArrayArgument ActualName=", QUOTE,NULL));
      string_buffer_append_xml_text(sb_result, (string) entity_user_name(ActualName),false);
      string_buffer_append(sb_result,
                           concatenate(QUOTE, BL,
                                       //Give Array access function indices "ArrayArgument ActualName=", QUOTE, expression_to_string(exp2), QUOTE, BL,
                                       "ActualDim=", QUOTE, SActualArrayDim, QUOTE, BL,
                                       "FormalName=", QUOTE,
                                       (!entity_undefined_p(FormalName)) ? entity_user_name(FormalName) : "LocalExpression",
                                       QUOTE, BL,
                                       "FormalDim=", QUOTE, i2a(FormalArrayDim), QUOTE, BL,
                                       "AccessMode=", QUOTE,
                                       (rw_ef >= 2) ? ((rw_ef == 2) ? "DEF" : "DEF_USE") : "USE",
                                       QUOTE, CLOSEANGLE, NL, NULL));
    }
    else {
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "ArrayArgument ActualName=", QUOTE, NULL));
      string_buffer_append_xml_text(sb_result, (string) entity_user_name(ActualName),false);
      string_buffer_append(sb_result,
                           concatenate(QUOTE, BL,
                                       // Give Array access function indices "ArrayArgument ActualName=", QUOTE, expression_to_string(exp2), QUOTE, BL,
                                       "ActualDim=", QUOTE, SActualArrayDim, QUOTE, BL,
                                       "AccessMode=", QUOTE, (rw_ef >= 2) ? ((rw_ef == 2) ? "DEF" : "DEF_USE") : "USE",
                                       QUOTE, CLOSEANGLE, NL, NULL));
    }
    /* Save information to generate Task Graph */
    if (rw_ef >= 2) {
      Pcallst cst1 = (callst *)malloc(sizeof(callst));
      cst1->func = function;
      cst1->stat_nb = statnb;
      cst1->succ = (Pcallst)NULL;
      update_def_into_tasks_table(ActualName, cst1);
    }
    free(SActualArrayDim);
    xml_Connection(ActualArrayInd, ActualArrayDim, FormalArrayDim, sb_result);
    xml_LoopOffset(ActualArrayInd, ActualArrayDim, loop_indices, sb_result);
    xml_ConstOffset(ActualArrayInd, ActualArrayDim, sb_result);
    global_margin--;
    string_buffer_append_word("/ArrayArgument", sb_result);
  }
  string_buffer_append_word("/Argument", sb_result);
  (void) pop_statement_global_stack();
}

References add_margin(), aliasing_p(), array_argument_p(), BL, call_domain, call_undefined, CLOSEANGLE, concatenate(), effect_undefined, encapsulated_call, entity_undefined, entity_undefined_p, entity_user_name(), eval_linear_expression(), EvalExpression(), exp, expression_integer_value(), expression_syntax, expression_to_string(), find_effect_actions_for_entity(), free(), callst::func, gen_recurse, gen_true(), global_margin, i2a(), instruction_call, instruction_call_p, int2a(), intptr_t, load_proper_rw_effects_list(), malloc(), max, min, NL, OPENANGLE, pips_internal_error, pop_statement_global_stack(), push_statement_on_statement_global_stack(), QUOTE, reference_indices, reference_undefined, reference_variable, search_1r_function_call(), skip_cast_and_addop_expression(), skip_cast_expression(), spear_warning, callst::stat_nb, statement_instruction, statement_number, strdup(), string_buffer_append(), string_buffer_append_numeric(), string_buffer_append_word(), string_buffer_append_xml_text(), callst::succ, syntax_reference, syntax_reference_p, update_def_into_tasks_table(), value_constant_p, variable_entity_dimension(), Words_Syntax(), words_to_string(), xml_Connection(), xml_ConstOffset(), and xml_LoopOffset().

Referenced by xml_Arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Arguments()

static void xml_Arguments ( statement  s, entity  function, int  statnb, bool  assign_func, Pvecteur  loop_indices, transformer  t, Psysteme  prec, string_buffer  sb_result  )

static

Definition at line 4806 of file xml_prettyprinter.c.

{
  entity FormalName= entity_undefined;
  intptr_t ith=0;
  call c = call_undefined, rhs_call= call_undefined;
  entity rhs_func=entity_undefined;
  expression lhs_exp;
  bool func_as_rhs_of_assign =false;
 
  if (instruction_call_p(statement_instruction(s))) {
    c = instruction_call(statement_instruction(s));
  }
  else {
    encapsulated_call =call_undefined;
    gen_recurse(s, call_domain, gen_true,search_1r_function_call);
    c =encapsulated_call;
  }
  if (c==call_undefined)
    pips_internal_error("Unexpected call in statement number %d \n",(int) statement_number(s));
 
  if (ENTITY_ASSIGN_P(function)) {
    list largs = call_arguments(c);
    if(gen_length(largs)==2) {
      POP(largs);
      expression rhs_exp = EXPRESSION(CAR(largs));
      syntax sr = expression_syntax(rhs_exp);
      if(syntax_call_p(sr)) {
        rhs_call = syntax_call(sr);
        rhs_func=call_function(rhs_call);
        func_as_rhs_of_assign = (entity_subroutine_p(rhs_func)|| entity_function_p(rhs_func)|| (io_intrinsic_p(rhs_func)));
      }
    }
  }
  string_buffer_append_word("Arguments",sb_result);
  global_margin++;
  call final_call = (func_as_rhs_of_assign)? rhs_call:c;
  entity final_func = (func_as_rhs_of_assign)? rhs_func:function;
  bool asb = (!assign_func || (assign_func && func_as_rhs_of_assign &&  !io_intrinsic_p(rhs_func)));
  FOREACH(EXPRESSION,exp,call_arguments(final_call)){
    ith ++;
    if (asb)
      FormalName = find_ith_formal_parameter(call_function(final_call),ith);
    else FormalName = entity_undefined;
    xml_Argument(s,final_func,statnb, (assign_func && !func_as_rhs_of_assign),exp,FormalName, loop_indices,t,prec,sb_result);
  }
  if (func_as_rhs_of_assign) {
    lhs_exp=EXPRESSION(CAR(call_arguments(c)));
    FormalName = reference_variable(syntax_reference(expression_syntax(lhs_exp)));
    xml_AssignArgument(s,final_func,statnb, assign_func,lhs_exp,FormalName, loop_indices,t, prec,sb_result);
  }
  global_margin--;
  string_buffer_append_word("/Arguments",sb_result);
}

References call_arguments, call_domain, call_function, call_undefined, CAR, encapsulated_call, ENTITY_ASSIGN_P, entity_function_p(), entity_subroutine_p(), entity_undefined, exp, EXPRESSION, expression_syntax, find_ith_formal_parameter(), FOREACH, gen_length(), gen_recurse, gen_true(), global_margin, instruction_call, instruction_call_p, intptr_t, io_intrinsic_p(), pips_internal_error, POP, reference_variable, search_1r_function_call(), statement_instruction, statement_number, string_buffer_append_word(), syntax_call, syntax_call_p, syntax_reference, xml_Argument(), and xml_AssignArgument().

Referenced by xml_Call().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Array()

static void xml_Array ( entity  var, transformer  t, Psysteme  prec, bool  formal_p, string_buffer  sb_result  )

static

Print XML Array DATA TYPE and DATA SIZE

Print XML Array Memory Location

Print XML Array DIMENSION

Print XML Array Bound

Print XML Array LAYOUT

Definition at line 3706 of file xml_prettyprinter.c.

{
  const char* datatype ="";
  list ld, ldim = variable_dimensions(type_variable(entity_type(var)));
  int i,j, size =0;
  int nb_dim = (int) gen_length(ldim);
  char* layout_up[nb_dim];
  char *layout_low[nb_dim];
  int no_dim=0;
 
  string spec_location = memory_location_for_array_p(entity_user_name(var));
 
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE, "Array Name=",QUOTE,NULL));
  string_buffer_append_xml_text(sb_result,(string) entity_user_name(var),false);
  string_buffer_append(sb_result,
                       concatenate(QUOTE, BL,
                                   "Type=", QUOTE,(entity_xml_parameter_p(var))? "CONTROL":"DATA",QUOTE,BL,
                                   "Allocation=", QUOTE,
                                   (heap_area_p(var) || stack_area_p(var)) ? "DYNAMIC": "STATIC", QUOTE,BL,
                                   "Kind=", QUOTE,   "VARIABLE",QUOTE,
                                   CLOSEANGLE,NL, NULL));
 
  /* Print XML Array DATA TYPE and DATA SIZE */
  type_and_size_of_var(var, &datatype,&size);
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "DataType Type=",QUOTE,datatype,QUOTE, BL,
                                   "Size=",QUOTE, int2a(size), QUOTE, "/"
                                   CLOSEANGLE,NL,NULL));
  /* Print XML Array Memory Location */
  if (spec_location!=NULL) {
    add_margin(global_margin,sb_result);
    string_buffer_append(sb_result,
                         concatenate(OPENANGLE,
                                     "ArrayLocation",CLOSEANGLE, spec_location,OPENANGLE,
                                     "/ArrayLocation",CLOSEANGLE,
                                     NL, NULL));
  }
  /* Print XML Array DIMENSION */
 
  if((int) gen_length(ldim) >0) {
    string_buffer_append_word("Dimensions",sb_result);
 
    for (ld = ldim ; !ENDP(ld); ld = CDR(ld)) {
      expression elow = dimension_lower(DIMENSION(CAR(ld)));
      expression eup = dimension_upper(DIMENSION(CAR(ld)));
      global_margin++;
      string_buffer_append_word("Dimension",sb_result);
      /* Print XML Array Bound */
      global_margin++;
      xml_Bounds(elow,eup,t,prec, formal_p, sb_result);
      global_margin--;
      string_buffer_append_word("/Dimension",sb_result);
      global_margin--;
      layout_low[no_dim] = expression_to_string(elow);
      layout_up[no_dim] = expression_to_string(eup);
      no_dim++;
    }
  }
 
  string_buffer_append_word("/Dimensions",sb_result);
 
  /* Print XML Array LAYOUT */
  string_buffer_append_word("Layout",sb_result);
  global_margin++;
  for (i =0; i<= no_dim-1; i++) {
    string_buffer_append_word("DimLayout",sb_result);
    global_margin++;
    string_buffer_append_word("Symbolic",sb_result);
    if (i==no_dim-1) {
      add_margin(global_margin,sb_result);
      string_buffer_append(sb_result,concatenate("1",NL,NULL));
    }
    else {
      add_margin(global_margin,sb_result);
      for (j=no_dim-1; j>=i+1; j--)
        {
          if (strcmp(layout_low[j],"0")==0)
            string_buffer_append(sb_result,
                                 concatenate("(",layout_up[j],"+1)",NULL));
          else
            string_buffer_append(sb_result,
                                 concatenate("(",layout_up[j],"-",
                                             layout_low[j],"+1)",NULL));
          if (j==i+1)
            string_buffer_append(sb_result,NL);
        }
    }
    string_buffer_append_word("/Symbolic",sb_result);
    global_margin--;
    string_buffer_append_word("/DimLayout",sb_result);
  }
  global_margin--;
  string_buffer_append_word("/Layout",sb_result);
  string_buffer_append_word("/Array",sb_result);
}

References add_margin(), BL, CAR, CDR, CLOSEANGLE, concatenate(), DIMENSION, dimension_lower, dimension_upper, ENDP, entity_type, entity_user_name(), entity_xml_parameter_p(), expression_to_string(), gen_length(), global_margin, heap_area_p(), int, int2a(), memory_location_for_array_p(), NL, OPENANGLE, QUOTE, stack_area_p(), string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), type_and_size_of_var(), type_variable, variable_dimensions, and xml_Bounds().

Referenced by xml_FormalVariables(), xml_GlobalVariables(), and xml_LocalVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_array_in_task()

static string xml_array_in_task ( reference  r, bool  first, int  task_number  )

static

XML name of the referenced array

iterator for dimensions of array

number of external loops

number of dimensions of referenced array

(int *) (gen_array_item(array_dims, gen_array_index(array_names, varname))));

number of internal loops

list of offsets for XML code

paving matrix for XML code 1st coeff: array dimension (row index) 2nd coeff: iteration dimension (column index)

fitting matrix for XML code 1st coeff: array dimension 2nd coeff: iteration dimension

initialization of the arrays

XML reference header

Fill in paving, fitting and offset matrices from index expressions.

generate offset list in XML code

fitting header

XML column-major storage of fitting matrix

Generation of paving XML code

Definition of the inner loop nest

FI->IH: if some columns are removed, the effective depth is unkown and must be computed here

result = strdup(concatenate(result, "inLoopNest = LOOPNEST(deep = ", int2a(MONMAX(gen_array_nitems(intern_indices_array), 1)), ",", NL, TAB, TAB, TAB, NULL));

see comment just below about null fitting matrices.

3 cases :

• the fitting matrix is null : must generate a (0,0) loop with dummy index
• some fitting matrix column is null : do not generate anything
• some fitting matrix column is not null : generate the corresponding loop bound and index name

Complete XML reference

Definition at line 561 of file xml_prettyprinter.c.

                                                                         {
  /* XML name of the referenced array */
  string varname = strdup(concatenate(XML_ARRAY_PREFIX,
                                      xml_entity_local_name(reference_variable(r)),
                                      NULL));
  /* iterator for dimensions of array */
  int indice_nr = 0;
  list indices = reference_indices(r);
  string result = "";
  /* number of external loops*/
  int extern_nb = gen_array_nitems(extern_indices_array);
 
  /* number of dimensions of referenced array */
  int index_of_array = gen_length(indices); /*((int *) (gen_array_item(array_dims, gen_array_index(array_names, varname))));*/
 
  /* number of internal loops*/
  int intern_nb = gen_array_nitems(intern_indices_array);
 
  /* list of offsets for XML code */
  string offset_array[index_of_array];
  /* paving matrix for XML code
     1st coeff: array dimension (row index)
     2nd coeff: iteration dimension (column index) */
  string paving_array[index_of_array][extern_nb];
 
  /* fitting matrix for XML code
     1st coeff: array dimension
     2nd coeff: iteration dimension*/
  string fitting_array[index_of_array][intern_nb];
  int i;
  int j;
  int depth = 0;
 
  bool null_fitting_p = true;
  string internal_index_declarations = strdup("");
  string fitting_declaration = strdup("");
  string fitting_declaration2 = strdup("");
 
  /* initialization of the arrays */
  for (i=0; i<index_of_array; i++)
    offset_array[i] = "0";
 
  for (i=0; i<index_of_array ; i++)
    for (j=0; j<extern_nb; j++)
      paving_array[i][j] = "0";
 
  for (i=0; i<index_of_array ; i++)
    for (j=0; j<intern_nb; j++)
      fitting_array[i][j] = "0";
 
  /* XML reference header */
  result = strdup(concatenate(result, "DATA(name = symbol!(\"", "T_", int2a(task_number),
                              "\" /+ \"", varname, "\"),", NL, TAB, TAB, NULL));
 
  result = strdup(concatenate(result, "darray = ", varname, "," NL, TAB, TAB, "accessMode = ", (first?"Wmode,":"Rmode,"),
                              NL, TAB, TAB, "offset = list<VARTYPE>(", NULL));
 
  /* Fill in paving, fitting and offset matrices from index expressions. */
  MAP(EXPRESSION, ind, {
      syntax sind = expression_syntax(ind);
      int iterator_nr;
      switch(syntax_tag(sind)){
      case is_syntax_reference:{
        reference ref = syntax_reference(sind);
        if((iterator_nr = gen_array_index(extern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
          paving_array[indice_nr][iterator_nr] = strdup("1");
        }
        else if((iterator_nr = gen_array_index(intern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
          fitting_array[indice_nr][iterator_nr] = strdup("1");
        }
 
        break;
      }
      case is_syntax_call:{
        call c = syntax_call(sind);
        xml_call_from_indice(c, &(offset_array[indice_nr]), paving_array[indice_nr], fitting_array[indice_nr]);
        break;
      }
      default:{
        pips_user_error("Only call and reference allowed in indices.\n");
        break;
      }
      }
      indice_nr++;
    }, indices);
 
 
  /* generate offset list in XML code */
  for(i=0; i<index_of_array - 1; i++){
    result=strdup(concatenate(result, "vartype!(", offset_array[i],"), ", NULL));
  }
  result = strdup(concatenate(result, "vartype!(", offset_array[i], "))," NL, NULL));
 
  /* fitting header */
  result = strdup(concatenate(result, TAB, TAB, "fitting = list<list[VARTYPE]>(", NULL));
 
  /* XML column-major storage of fitting matrix */
  for(i=0;i<intern_nb; i++){
    bool is_null_p = true;
    for(j = 0; j<index_of_array; j++){
      is_null_p = is_null_p && (same_string_p(fitting_array[j][i], "0"));
    }
    if(!is_null_p){
      null_fitting_p = false;
      fitting_declaration = strdup(concatenate(fitting_declaration, "list(", NULL));
      for(j = 0; j<index_of_array-1; j++){
        fitting_declaration = strdup(concatenate(fitting_declaration, "vartype!(", fitting_array[j][i], "), ", NULL));
      }
      fitting_declaration = strdup(concatenate(fitting_declaration,
                                               "vartype!(",
                                               fitting_array[j][i],
                                               ")), ",
                                               NULL));
    }
  }
 
  if(!null_fitting_p){
    fitting_declaration2 =
      strdup(concatenate(gen_strndup0(fitting_declaration,
                                      strlen(fitting_declaration) - 2),
                         "),", NL, TAB, TAB, TAB, NULL));
    result = strdup(concatenate(result, fitting_declaration2, NULL));
  }
 
  if(null_fitting_p){
    result = strdup(concatenate(result, "list()),", NL, TAB, TAB, NULL));
  }
 
  null_fitting_p = true;
  /* Generation of paving XML code*/
  result = strdup(concatenate(result, TAB, TAB, "paving = list<list[VARTYPE]>(", NULL));
 
  for(i=0;i<extern_nb-1; i++){
    result = strdup(concatenate(result, "list(", NULL));
    for(j = 0; j<index_of_array-1; j++){
      result = strdup(concatenate(result, "vartype!(", paving_array[j][i], "), ", NULL));
    }
    result = strdup(concatenate(result, "vartype!(", paving_array[j][i], ")),", NL, TAB, TAB, TAB, NULL));
  }
  result = strdup(concatenate(result, "list(", NULL));
  for(j = 0; j<index_of_array-1; j++){
    result = strdup(concatenate(result, "vartype!(", paving_array[j][i], "), ", NULL));
  }
  result = strdup(concatenate(result, "vartype!(", paving_array[j][i], "))),", NL, TAB, TAB, NULL));
 
#define MONMAX(a, b) ((a<b)?b:a)
 
  /* Definition of the inner loop nest */
  /* FI->IH: if some columns are removed, the effective depth is unkown and must be computed here */
  /* result = strdup(concatenate(result, "inLoopNest = LOOPNEST(deep = ", int2a(MONMAX(gen_array_nitems(intern_indices_array), 1)), ",", NL, TAB, TAB, TAB, NULL)); */
 
  for (j = 0; j<intern_nb; j++){
    bool is_null_p = true;
    for(i = 0; i < index_of_array; i++){
      is_null_p = is_null_p && (same_string_p(fitting_array[i][j], "0"));
    }
    if(!is_null_p){
      depth++;
    }
  }
  if(depth==0) depth = 1; /* see comment just below about null fitting matrices. */
  result = strdup(concatenate(result, "inLoopNest = LOOPNEST(deep = ", i2a(depth), ",", NL, TAB, TAB, TAB, NULL));
  result = strdup(concatenate(result, "upperBound = list<VARTYPE>(", NULL));
 
  /* 3 cases :
     - the fitting matrix is null : must generate a (0,0) loop with dummy index
     - some fitting matrix column is null : do not generate anything
     - some fitting matrix column is not null : generate the corresponding loop bound and index name
  */
 
  for (j = 0; j<intern_nb; j++){
    bool is_null_p = true;
    for(i = 0; i < index_of_array; i++){
      is_null_p = is_null_p && (same_string_p(fitting_array[i][j], "0"));
    }
    if(!is_null_p){
      null_fitting_p = false;
      result = strdup(concatenate(result,
                                  "vartype!(",
                                  *((string *)(gen_array_item(intern_upperbounds_array, j))),
                                  "), ",
                                  NULL));
      internal_index_declarations =
        strdup(concatenate(internal_index_declarations,
                           QUOTE,
                           *((string *)(gen_array_item(intern_indices_array, j))),
                           QUOTE,
                           ", ",
                           NULL));
    }
  }
  if(!null_fitting_p)
    {
      result = strdup(concatenate(gen_strndup0(result, strlen(result) - 2),
                                  "),", NULL));
      internal_index_declarations =
        strdup(concatenate(gen_strndup0(internal_index_declarations,
                                        strlen(internal_index_declarations) -2),
                           ")", NULL));
    }
 
 
 
  if(null_fitting_p){
    result = strdup(concatenate(result, "vartype!(1)),", NL, TAB, TAB, TAB, "names = list<string>(\"M_I\")", NULL));
  }
  else{
    result = strdup(concatenate(result, NL, TAB, "names = list<string>(", internal_index_declarations, NULL));
  }
 
  /* Complete XML reference */
  result = strdup(concatenate(result, "))", (first?")":","), NL, NULL));
  return result;
}

References concatenate(), depth, EXPRESSION, expression_syntax, extern_indices_array, gen_array_index(), gen_array_item(), gen_array_nitems(), gen_length(), gen_strndup0(), i2a(), indices, int2a(), intern_indices_array, intern_upperbounds_array, is_syntax_call, is_syntax_reference, ITEM_NOT_IN_ARRAY, MAP, NL, pips_user_error, QUOTE, ref, reference_indices, reference_variable, same_string_p, strdup(), syntax_call, syntax_reference, syntax_tag, TAB, XML_ARRAY_PREFIX, xml_call_from_indice(), and xml_entity_local_name().

Referenced by xml_call_from_assignation(), and xml_call_from_loopnest().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_AssignArgument()

static void xml_AssignArgument ( _UNUSED_ statement  s, entity  function, int  statnb, bool  assign_func, expression  exp, entity  FormalName, Pvecteur  loop_indices, transformer  t, _UNUSED_ Psysteme  prec, string_buffer  sb_result  )

static

Scalar Argument

if (strncmp(aan, "\"", 1) == 0) quote_p = ""; else quote_p = QUOTE;

Array Argument

Save information to generate Task Graph

Definition at line 4715 of file xml_prettyprinter.c.

{
  entity ActualName = entity_undefined;
  reference ActualRef = reference_undefined;
  syntax sr;
  intptr_t iexp;
  int rw_ef = 0;
  string aan = "";
  //  string quote_p = "";
  int valr = 0, min = 0, max = 0;
 
  sr = expression_syntax(exp);
  if (syntax_reference_p(sr)) {
    ActualRef = syntax_reference(sr);
    ActualName = reference_variable(ActualRef);
    aan = strdup(entity_user_name(ActualName));
    rw_ef = 2;
  } else
    printf("PB traduction AssignParameter\n");
  string_buffer_append_word("AssignArgument", sb_result);
  if (!array_argument_p(exp)) { /* Scalar Argument */
    global_margin++;
    add_margin(global_margin, sb_result);
    /* if (strncmp(aan, "\"", 1) == 0)
      quote_p = "";
    else
      quote_p = QUOTE;
    */
    string_buffer_append(sb_result,
                         concatenate(OPENANGLE,
                                     "ScalarArgument ActualName=", QUOTE, NULL));
    string_buffer_append_xml_text(sb_result, aan, false);
    string_buffer_append(sb_result,
                         concatenate(QUOTE, BL,
                                     "AccessMode=", QUOTE, "DEF", QUOTE,
                                     CLOSEANGLE, NL, NULL));
    if (expression_integer_value(exp, &iexp))
      string_buffer_append_numeric(int2a(iexp), sb_result);
    else if (value_constant_p(EvalExpression(exp))) {
      string exps = expression_to_string(exp);
      string_buffer_append_numeric(exps, sb_result);
    } else if (eval_linear_expression(exp, t, &valr, &min, &max)) {
      if (valr==min && valr==max)
        string_buffer_append_numeric(int2a(valr), sb_result);
    }
    string_buffer_append_word("/ScalarArgument", sb_result);
    global_margin--;
    Pcallst cst1 = (callst *)malloc(sizeof(callst));
    cst1->func = function;
    cst1->stat_nb = statnb;
    cst1->succ = (Pcallst)NULL;
    update_def_into_tasks_table(ActualName, cst1);
  } else { /* Array Argument */
    int ActualArrayDim = variable_entity_dimension(ActualName);
    char *SActualArrayDim = strdup(i2a(ActualArrayDim));
    int FormalArrayDim = (entity_undefined_p(FormalName))
      ? 0
      : variable_entity_dimension(FormalName);
    list ActualArrayInd = reference_indices(ActualRef);
    global_margin++;
    add_margin(global_margin, sb_result);
    string_buffer_append( sb_result,
                          concatenate(OPENANGLE,
                                      "ArrayArgument ActualName=", QUOTE, NULL));
    string_buffer_append_xml_text( sb_result, (string) entity_user_name(ActualName), false);
    string_buffer_append( sb_result,
                          concatenate(QUOTE, BL,
                                      "ActualDim=", QUOTE, SActualArrayDim, QUOTE, BL,
                                      "AccessMode=", QUOTE, (rw_ef >= 2) ? ((rw_ef == 2) ? "DEF" : "DEF_USE") : "USE", QUOTE,
                                      CLOSEANGLE, NL, NULL));
 
    /* Save information to generate Task Graph */
    Pcallst cst1 = (callst *)malloc(sizeof(callst));
    cst1->func = function;
    cst1->stat_nb = statnb;
    cst1->succ = (Pcallst)NULL;
    update_def_into_tasks_table(ActualName, cst1);
    free(SActualArrayDim);
    if (!assign_func)
      xml_Connection(ActualArrayInd, ActualArrayDim, FormalArrayDim, sb_result);
    xml_LoopOffset(ActualArrayInd, ActualArrayDim, loop_indices, sb_result);
    xml_ConstOffset(ActualArrayInd, ActualArrayDim, sb_result);
    global_margin--;
    string_buffer_append_word("/ArrayArgument", sb_result);
  }
  string_buffer_append_word("/AssignArgument", sb_result);
}

References add_margin(), array_argument_p(), BL, CLOSEANGLE, concatenate(), entity_undefined, entity_undefined_p, entity_user_name(), eval_linear_expression(), EvalExpression(), exp, expression_integer_value(), expression_syntax, expression_to_string(), free(), callst::func, global_margin, i2a(), int2a(), intptr_t, malloc(), max, min, NL, OPENANGLE, printf(), QUOTE, reference_indices, reference_undefined, reference_variable, callst::stat_nb, strdup(), string_buffer_append(), string_buffer_append_numeric(), string_buffer_append_word(), string_buffer_append_xml_text(), callst::succ, syntax_reference, syntax_reference_p, update_def_into_tasks_table(), value_constant_p, variable_entity_dimension(), xml_Connection(), xml_ConstOffset(), and xml_LoopOffset().

Referenced by xml_Arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Bounds()

static void xml_Bounds ( expression  elow, expression  eup, transformer  t, _UNUSED_ Psysteme  prec, bool  formal_p, string_buffer  sb_result  )

static

UNUSED static bool eval_linear_expression2( expression exp, Psysteme ps, int *val, int *min, int *max) { normalized norm= normalized_undefined; Pvecteur vexp,pv; bool result = true,result_exact = true,min_exact=true,max_exact=true; val = 0; min=0; max=0;.

fprintf(stdout,"Expression a evaluer : %s",words_to_string(words_expression(exp,NIL)));

if (expression_normalized(exp) == normalized_undefined) expression_normalized(exp)= NormalizeExpression(exp); norm = expression_normalized(exp); if (normalized_linear_p(norm) && !SC_UNDEFINED_P(ps)) { vexp = (Pvecteur)normalized_linear(norm); for (pv= vexp; pv != VECTEUR_NUL; pv=pv->succ) { Variable v = var_of(pv); if (v==TCST) { val += vect_coeff(TCST,vexp); min += vect_coeff(TCST,vexp); max += vect_coeff(TCST,vexp); } else { if(base_contains_variable_p(sc_base(ps), v)) { Value min1, max1; Psysteme ps1 = sc_dup(ps); bool feasible = sc_minmax_of_variable2(ps1, (Variable)v, &min1, &max1); if (feasible) { if (value_eq(min1,max1)) { val += vect_coeff(v,vexp) *min1; min+= vect_coeff(v,vexp) *min1; max+= vect_coeff(v,vexp) *max1; } else { result_exact=false; bool pb = (vect_coeff(v,vexp)>0); if (pb) { if (*min!=INT_MIN && min1!=INT_MIN && min1!=VALUE_MIN) min+= vect_coeff(v,vexp) *min1; else min_exact=false; if (*max!=INT_MAX && max1!=INT_MAX && max1!=VALUE_MAX) max+= vect_coeff(v,vexp) *max1; else max_exact=false; } else { if (*max!=INT_MIN && min1!=INT_MIN && min1!=VALUE_MIN) max+= vect_coeff(v,vexp) *min1; else max_exact=false; if (*min!=INT_MAX && max1!=INT_MAX && max1!=VALUE_MAX) min+= vect_coeff(v,vexp) *max1; else min_exact=false; } } } else // fprintf(stdout,"le systeme est non faisable\n"); result = false,min_exact=false,max_exact=false; } // sc_free(ps1); le systeme est desalloue par sc_minmax_of_variable else result = false,min_exact=false,max_exact=false; } } } else // fprintf(stdout,"Ce n'est pas une expression lineaire\n"); result = false,min_exact=false,max_exact=false; if (!result) *min=INT_MIN,*max =INT_MAX; if (!min_exact) *min=INT_MIN; if (!max_exact) *max=INT_MAX; if (!result_exact) result=false; fprintf(stdout,"Valeur trouvee : %d \n",*val); return result; }

Print XML Array LOWER BOUND

Print XML Array UPPER BOUND

Definition at line 3585 of file xml_prettyprinter.c.

                                                                                       {
  intptr_t low, up;
  int valr = 0;
  int min = 0, max = 0;
  bool tb = true;
  /* Print XML Array LOWER BOUND */
  string_buffer_append_word("LowerBound", sb_result);
  global_margin++;
  string_buffer_append_symbolic(expression_to_string(elow), sb_result);
  if (expression_integer_value(elow, &low))
    string_buffer_append_numeric(int2a(low), sb_result);
  else if (!formal_p && (tb = eval_linear_expression(elow, t, &valr, &min, &max)) == true) {
    if (valr == min && valr == max)
      string_buffer_append_numeric(int2a(valr), sb_result);
    else {
      if (min != INT_MIN) {
        add_margin(global_margin, sb_result);
        string_buffer_append(sb_result,
                             concatenate(OPENANGLE,
                                         "MinNumeric", CLOSEANGLE, int2a(min), OPENANGLE,
                                         "/MinNumeric",
                                         CLOSEANGLE, NL, NULL));
      }
      if (max != INT_MAX) {
        add_margin(global_margin, sb_result);
        string_buffer_append(sb_result,
                             concatenate(OPENANGLE,
                                         "MaxNumeric", CLOSEANGLE, int2a(max), OPENANGLE,
                                         "/MaxNumeric",
                                         CLOSEANGLE, NL, NULL));
      }
    }
  }
  global_margin--;
  string_buffer_append_word("/LowerBound", sb_result);
 
  /* Print XML Array UPPER BOUND */
  string_buffer_append_word("UpperBound", sb_result);
  global_margin++;
  string_buffer_append_symbolic(expression_to_string(eup), sb_result);
  if (expression_integer_value(eup, &up))
    string_buffer_append_numeric(int2a(up), sb_result);
  else if (!formal_p && (tb = eval_linear_expression(eup, t, &valr, &min, &max)) == true) {
    if (valr == min && valr == max)
      string_buffer_append_numeric(int2a(valr), sb_result);
    else {
      if (min != INT_MIN) {
        add_margin(global_margin, sb_result);
        string_buffer_append(sb_result,
                             concatenate(OPENANGLE,
                                         "MinNumeric", CLOSEANGLE, int2a(min), OPENANGLE,
                                         "/MinNumeric",
                                         CLOSEANGLE, NL, NULL));
      }
      if (max != INT_MAX) {
        add_margin(global_margin, sb_result);
        string_buffer_append(sb_result,
                             concatenate(OPENANGLE,
                                         "MaxNumeric", CLOSEANGLE, int2a(max), OPENANGLE,
                                         "/MaxNumeric",
                                         CLOSEANGLE, NL, NULL));
      }
    }
  }
  global_margin--;
  string_buffer_append_word("/UpperBound", sb_result);
}

References add_margin(), CLOSEANGLE, concatenate(), eval_linear_expression(), expression_integer_value(), expression_to_string(), global_margin, int2a(), intptr_t, max, min, NL, OPENANGLE, string_buffer_append(), string_buffer_append_numeric(), string_buffer_append_symbolic(), and string_buffer_append_word().

Referenced by xml_Array(), and xml_Bounds_and_Stride().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Bounds_and_Stride()

static void xml_Bounds_and_Stride ( expression  elow, expression  eup, expression  stride, transformer  t, Psysteme  prec, bool  formal_p, string_buffer  sb_result  )

static

Definition at line 3653 of file xml_prettyprinter.c.

{
  intptr_t inc;
  int  valr =0,min=0,max=0;
  xml_Bounds(elow, eup,t,prec,formal_p, sb_result);
  string_buffer_append_word("Stride",sb_result);
  global_margin++;
  string_buffer_append_symbolic(expression_to_string(stride),
                                sb_result);
  if (expression_integer_value(stride, &inc))
    string_buffer_append_numeric(int2a(inc),sb_result);
  else if (eval_linear_expression(stride,t,&valr,&min,&max)) {
    if (valr==min && valr==max)
      string_buffer_append_numeric(int2a(valr),sb_result);
  }
  global_margin--;
  string_buffer_append_word("/Stride",sb_result);
 
}

References eval_linear_expression(), expression_integer_value(), expression_to_string(), global_margin, int2a(), intptr_t, max, min, string_buffer_append_numeric(), string_buffer_append_symbolic(), string_buffer_append_word(), and xml_Bounds().

Referenced by xml_Loop().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Boxes()

static void xml_Boxes ( const char *  module_name, int  code_tag, string_buffer  sb_result  )

static

A

for validation

A

Search calls in Box

AGGREGATION TRANSFERED TO "tspear"

string_buffer_append_word("Tasks",sb_result); insert_xml_callees(module_name); string_buffer_append_word("/Tasks",sb_result);

Definition at line 5945 of file xml_prettyprinter.c.

{
  entity module = module_name_to_entity(module_name);
  statement stat = get_current_module_statement();
  string_buffer type_buffer = string_buffer_make(true);
  string string_types;
  Psysteme prec = SC_UNDEFINED;
  transformer t = first_precondition_of_module(module_name, &prec);
  nest_context_t nest;
  int st_nb1=0, st_sauv=0;
  Pvecteur pv=VECTEUR_NUL;
  push_statement_on_statement_global_stack(stat);
  nest.loops_for_call = stack_make(statement_domain,0,0);
  nest.loop_indices = stack_make(entity_domain,0,0);
  nest.current_stat = stack_make(statement_domain,0,0);
  nest.testif = stack_make(statement_domain,0,0);
  nest.nested_if=  gen_array_make(0);
  nest.nested_loops=  gen_array_make(0);
  nest.nested_loop_indices =  gen_array_make(0);
  nest.nested_call=  gen_array_make(0);
 
  global_margin++;
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "Box Name=", QUOTE,module_name,QUOTE,
                                   CLOSEANGLE,NL, NULL));
  global_margin++;
  global_application_variables=VECTEUR_NUL;
  local_application_variables=VECTEUR_NUL;
  if (!entity_main_module_p(module)) {
    xml_GlobalVariables(t,prec,true,sb_result);
    xml_LocalVariables(module,t,prec,sb_result);
    xml_FormalVariables(module,t,prec,sb_result);
  }
  else {
        xml_GlobalVariables(t,prec,false,sb_result);
        //string_buffer_append_word("GlobalVariables/",sb_result);
    xml_LocalVariables(module,t,prec,sb_result);
    string_buffer_append_word("FormalVariables/",sb_result);
  }
 
  /*CA*/
  vect_erase_var(&global_application_variables, TCST);
  vect_erase_var(&local_application_variables, TCST);
  string_buffer_append_word("GlobalReferencedTypes",type_buffer);
  global_margin++;
  for (pv = global_application_variables;pv!=NULL;pv=pv->succ) {
    xml_Type_Entity((entity)pv->var,type_buffer);
  }
  /* for validation */
  global_margin--;
  string_buffer_append_word("/GlobalReferencedTypes",type_buffer);
  string_buffer_append_word("LocalReferencedTypes",type_buffer);
  global_margin++;
 
  for (pv = local_application_variables;pv!=NULL;pv=pv->succ) {
    xml_Type_Entity((entity)pv->var,type_buffer);
  }
  global_margin--;
  string_buffer_append_word("/LocalReferencedTypes",type_buffer);
  string_types =string_buffer_to_string(type_buffer);
  string_buffer_append(sb_result,string_types);
  free(string_types);
 
  /*CA*/
  /* Search calls in Box */
  find_loops_and_calls_in_box(stat,&nest);
  int nb_call = (int)gen_array_nitems(nest.nested_call);
  for (int callnumber = 0; callnumber<nb_call; callnumber++) {
    statement st= gen_array_item(nest.nested_call,callnumber);
    st_nb1 = statement_number(st);
    // to deal with nested calls in the same instruction
    if (callnumber==0 || st_nb1!=st_sauv)
      xml_Call(module, code_tag, callnumber, &nest,sb_result);
    st_sauv=st_nb1;
  }
 
  // xml_BoxGraph(module,&nest,sb_result);
  xml_Chains(module, module_name,stat,&nest,sb_result);
  global_margin--;
  string_buffer_append_word("/Box",sb_result);
 
  /* AGGREGATION TRANSFERED TO "tspear"
   *
   * string_buffer_append_word("Tasks",sb_result);
   * insert_xml_callees(module_name);
   * string_buffer_append_word("/Tasks",sb_result);
   */
 
  global_margin--;
  gen_array_free(nest.nested_loops);
  gen_array_free(nest.nested_loop_indices);
  gen_array_free(nest.nested_call);
  gen_array_free(nest.nested_if);
  stack_free(&(nest.testif));
  stack_free(&(nest.loops_for_call));
  stack_free(&(nest.loop_indices));
  stack_free(&(nest.current_stat));
  pop_statement_global_stack();
  sc_free(prec);
}

References add_margin(), CLOSEANGLE, concatenate(), nest_context_t::current_stat, entity_domain, entity_main_module_p(), find_loops_and_calls_in_box(), first_precondition_of_module(), free(), gen_array_free(), gen_array_item(), gen_array_make(), gen_array_nitems(), get_current_module_statement(), global_application_variables, global_margin, int, local_application_variables, nest_context_t::loop_indices, nest_context_t::loops_for_call, module, module_name(), module_name_to_entity(), nest_context_t::nested_call, nest_context_t::nested_if, nest_context_t::nested_loop_indices, nest_context_t::nested_loops, NL, OPENANGLE, pop_statement_global_stack(), push_statement_on_statement_global_stack(), QUOTE, sc_free(), stack_free(), stack_make(), statement_domain, statement_number, string_buffer_append(), string_buffer_append_word(), string_buffer_make(), string_buffer_to_string(), Svecteur::succ, TCST, nest_context_t::testif, Svecteur::var, vect_erase_var(), VECTEUR_NUL, xml_Call(), xml_Chains(), xml_FormalVariables(), xml_GlobalVariables(), xml_LocalVariables(), and xml_Type_Entity().

Referenced by generic_print_xml_application().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Call()

static void xml_Call ( entity  module, int  code_tag, int  taskNumber, nest_context_p  nest, string_buffer  sb_result  )

static

Definition at line 5690 of file xml_prettyprinter.c.

{
  statement s = gen_array_item(nest->nested_call,taskNumber);
 push_statement_on_statement_global_stack(s);
   //  if (instruction_call_p(statement_instruction(s))) {
  stack st = gen_array_item(nest->nested_loops,taskNumber);
  stack statif = gen_array_item(nest->nested_if,taskNumber);
  transformer t = load_statement_precondition(s);
  Psysteme prec = sc_dup((Psysteme) predicate_system(transformer_relation(t)));
  call c = call_undefined;
  list pattern_region=NIL;
  Pvecteur paving_indices = VECTEUR_NUL;
  Pvecteur pattern_indices = VECTEUR_NUL;
  bool motif_in_te_p=false;
  bool func_as_rhs_of_assign =false;
  int nb_cond=0;
  entity cond, encapsulated_func,func ;
  expression lhs,rhs;
 
  if (instruction_call_p(statement_instruction(s))) {
    c = instruction_call(statement_instruction(s));
  }
  else {
    encapsulated_call =call_undefined;
    gen_recurse(s, call_domain, gen_true,search_1r_function_call);
    c =encapsulated_call;
  }
  if (c==call_undefined)
    pips_internal_error("Unexpected call in statement number %d \n",(int) statement_number(s));
 
  //used by statement_in_truebranch
  test_statement_of_reference=s;
  func= call_function(c);
  const char * strtmp = entity_user_name(func);
 
  if (ENTITY_ASSIGN_P(func) || !instruction_call_p(statement_instruction(s))) {
    pattern_region =load_proper_rw_effects_list(s);
  }
  else
    pattern_region = regions_dup(load_statement_local_regions(s));
 
  if (ENTITY_ASSIGN_P(func)) {
    list largs = call_arguments(c);
    expression lhs_exp = EXPRESSION(CAR(largs));
    lhs_exp = skip_field_and_cast_expression(lhs_exp);
    if (array_argument_p(lhs_exp)) // lhs not scalar
      spear_warning(s,"Please use only scalar variable on the left hand side of assignements not included in a MOTIF",
                    "Non scalar variable as LHS part of a LocalAssignment");
 
    FOREACH(EXPRESSION,expt,POP(largs)){
      expression arg_exp = skip_field_and_cast_expression(expt);
      if (array_argument_p(arg_exp))  // rhs not scalar
        spear_warning(s,"Please use only scalar variable on the right hand side of assignements not included in a MOTIF",
                      "Non scalar variable as RHS part of a LocalAssignment");
    }
    largs = call_arguments(c);
    if(gen_length(largs)>2)
      spear_warning(s,"Please use only one varaible on the right hand side of assignements not included in a MOTIF",
                    "More than 1 variable as RHS part of a LocalAssignment");
 
    if(gen_length(largs)==2) {
      POP(largs);
      expression rhs_exp = EXPRESSION(CAR(largs));
      syntax sr = expression_syntax(rhs_exp);
      if(syntax_call_p(sr)) {
        call rhs_call = syntax_call(sr);
        encapsulated_func=call_function(rhs_call);
        func_as_rhs_of_assign = (entity_subroutine_p(encapsulated_func)|| entity_function_p(encapsulated_func));
      }
      //spear_warning(s,"Please encapsulate assignments into TASK or into the existing MOTIF","LocalAssignment detected");
    }
  }
  if (statif != STACK_NULL) {
    STACK_MAP_X(sx, statement,
                {  if (logic_condition_filter(s,sx,&cond,&lhs,&rhs)) {
                    test l = instruction_test(statement_instruction(sx));
                   push_statement_on_statement_global_stack(sx);
                    statement_in_truebranch_p=false;
                    if (!statement_undefined_p(test_true(l)))
                      gen_recurse(test_true(l), statement_domain, gen_true,statement_in_truebranch);
                    add_margin(global_margin,sb_result);
 
                    string_buffer_append(sb_result,
                                         concatenate(OPENANGLE,
                                                     "CallCondition Branch=",
                                                     QUOTE, (statement_in_truebranch_p ? "TRUE":"FALSE"),
                                                     QUOTE, BL,
                                                     "Test=", QUOTE, NULL));
                    string_buffer_append_xml_text(sb_result,(string)entity_user_name(cond),false);
                    string_buffer_append(sb_result,
                                         concatenate(QUOTE, BL,
                                                     "LHS=",QUOTE, NULL));
                    string_buffer_append_xml_text(sb_result,expression_to_string(lhs),false);
                    string_buffer_append(sb_result,
                                         concatenate(QUOTE, BL, "RHS=",QUOTE, NULL));
                    string_buffer_append_xml_text(sb_result, expression_to_string(rhs), false);
                    string_buffer_append(sb_result,
                                         concatenate(QUOTE,BL,
                                                     "StNumber=",QUOTE,int2a(statement_number(sx)),QUOTE,
                                                     CLOSEANGLE,NL, NULL));
                     // For special character :  string_buffer_append_xml_text(buffer_cond,exps,false);
                    global_margin++;nb_cond++;
                    (void) pop_statement_global_stack();
                  }
                },
                statif, 0);
  }
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "Call Name=",
                                   QUOTE,
                                   ENTITY_ASSIGN_P(func) ? (
                                                            (func_as_rhs_of_assign) ? entity_user_name(encapsulated_func):
                                                            "LocalAssignment")
                                   : entity_user_name(func),
                                   QUOTE,BL,
                                   "StNumber=",QUOTE,int2a(statement_number(s)),QUOTE,
                                   CLOSEANGLE,NL, NULL)); 
  global_margin++;
  print_call_precondition(prec, sb_result);
  //  only detect  Opengpu 2D and 3D 4D and 5D cornerturns
  if (strstr(strtmp,"cornerturn_5D")!=NULL)
    xml_Transposition(s,c,5,sb_result,0);
  else if (strstr(strtmp,"cornerturn_4D")!=NULL)
    xml_Transposition(s,c,4,sb_result,0);
  else if (strstr(strtmp,"cornerturn_3D")!=NULL)
    xml_Transposition(s,c,3,sb_result,0);
  else
    if (strstr(strtmp,"cornerturn_2D")!=NULL)
      xml_Transposition(s,c,2,sb_result,0);
 
  if (strstr(strtmp,"transpose_5D")!=NULL)
    xml_Transposition(s,c,5,sb_result,1);
  else if (strstr(strtmp,"transpose_4D")!=NULL)
    xml_Transposition(s,c,4,sb_result,1);
  else if (strstr(strtmp,"transpose_3D")!=NULL)
    xml_Transposition(s,c,3,sb_result,1);
  else
    if (strstr(strtmp,"transpose_2D")!=NULL)
      xml_Transposition(s,c,2,sb_result,1);
  xml_Region_Parameter(pattern_region, sb_result);
  xml_Loops(st,true,&pattern_region,&paving_indices, &pattern_indices,motif_in_te_p, sb_result);
  if (ENTITY_ASSIGN_P(func) && !func_as_rhs_of_assign)
    xml_TaskParameters(s,true,code_tag, module,pattern_region,paving_indices,sb_result);
  else // it may be an assignment but with a (non intrinsic) function  at the RHS
    xml_Arguments(s,func,statement_number(s),ENTITY_ASSIGN_P(func), paving_indices, t, prec,sb_result);
  global_margin--;
  string_buffer_append_word("/Call",sb_result);
 
  if (statif != STACK_NULL) {
    for (int tp=1;tp<=nb_cond;tp++) {
      global_margin--;
      string_buffer_append_word("/CallCondition",sb_result);
    }
  }
  pop_statement_global_stack();
  sc_free(prec);
}

References add_margin(), array_argument_p(), BL, call_arguments, call_domain, call_function, call_undefined, CAR, CLOSEANGLE, concatenate(), encapsulated_call, ENTITY_ASSIGN_P, entity_function_p(), entity_subroutine_p(), entity_user_name(), EXPRESSION, expression_syntax, expression_to_string(), FOREACH, gen_array_item(), gen_length(), gen_recurse, gen_true(), global_margin, instruction_call, instruction_call_p, instruction_test, int2a(), load_proper_rw_effects_list(), load_statement_local_regions(), load_statement_precondition(), logic_condition_filter(), module, nest_context_t::nested_call, nest_context_t::nested_if, nest_context_t::nested_loops, NIL, NL, OPENANGLE, pattern_indices, pips_internal_error, POP, pop_statement_global_stack(), predicate_system, print_call_precondition(), push_statement_on_statement_global_stack(), QUOTE, regions_dup(), sc_dup(), sc_free(), search_1r_function_call(), skip_field_and_cast_expression(), spear_warning, STACK_MAP_X, STACK_NULL, statement_domain, statement_in_truebranch(), statement_in_truebranch_p, statement_instruction, statement_number, statement_undefined_p, string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), syntax_call, syntax_call_p, test_statement_of_reference, test_true, transformer_relation, VECTEUR_NUL, xml_Arguments(), xml_Loops(), xml_Region_Parameter(), xml_TaskParameters(), and xml_Transposition().

Referenced by xml_Boxes().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_call_from_assignation()

static string xml_call_from_assignation ( call  c, int  task_number, bool *  input_provided  )

static

All arguments of this call are in Rmode (inputs of the task)

This function is called recursively

Definition at line 438 of file xml_prettyprinter.c.

                                                                                       {
  /* All arguments of this call are in Rmode (inputs of the task) */
  /* This function is called recursively */
  list arguments = call_arguments(c);
  syntax syn;
  string result = "";
 
  MAP(EXPRESSION, expr, {
      syn = expression_syntax(expr);
      switch(syntax_tag(syn)){
      case is_syntax_call:{
        result = strdup(concatenate(result, xml_call_from_assignation(syntax_call(syn), task_number, input_provided), NULL));
        break;
      }
      case is_syntax_reference:{
        reference ref = syntax_reference(syn);
    string svar = xml_entity_local_name(reference_variable(ref));
        string varname = strdup(concatenate("A_", svar, NULL));
    free(svar);
        if(gen_array_index(array_names, varname) != ITEM_NOT_IN_ARRAY){
          result = strdup(concatenate(result, xml_array_in_task(ref, false, task_number), NULL));
          *input_provided = true;
        }
        break;
      }
      default:{
        pips_user_error("only call and references allowed here\n");
      }
      }
    }, arguments);
  return result;
}

References array_names, call_arguments, concatenate(), EXPRESSION, expression_syntax, free(), gen_array_index(), is_syntax_call, is_syntax_reference, ITEM_NOT_IN_ARRAY, MAP, pips_user_error, ref, reference_variable, strdup(), syntax_call, syntax_reference, syntax_tag, xml_array_in_task(), and xml_entity_local_name().

Referenced by xml_call_from_loopnest().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_call_from_indice()

static void xml_call_from_indice ( call  c, string *  offset_array, string  paving_array[], string  fitting_array[]  )

static

Definition at line 471 of file xml_prettyprinter.c.

                                                                                                              {
  entity called = call_function(c);
  string funname = xml_entity_local_name(called);
  list arguments = call_arguments(c);
  syntax args[2];
  int i = 0;
  int iterator_nr;
  if(gen_length(arguments)==2){
    if(same_string_p(funname, "+") || same_string_p(funname, "-") || same_string_p(funname, "*")){
      MAP(EXPRESSION, arg, {
          args[i] = expression_syntax(arg);
          i++;
        }, arguments);
      if(same_string_p(funname, "+")){
        if(syntax_tag(args[0]) == is_syntax_call){
          xml_call_from_indice(syntax_call(args[0]), offset_array, paving_array, fitting_array);
        }
        if(syntax_tag(args[1]) == is_syntax_call){
          xml_call_from_indice(syntax_call(args[1]), offset_array, paving_array, fitting_array);
        }
        if(syntax_tag(args[0]) == is_syntax_reference){
          reference ref = syntax_reference(args[0]);
          if((iterator_nr = gen_array_index(extern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
            paving_array[iterator_nr] = strdup("1");
          }
          else if((iterator_nr = gen_array_index(intern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
            fitting_array[iterator_nr] = strdup("1");
          }
        }
        if(syntax_tag(args[1]) == is_syntax_reference){
          reference ref = syntax_reference(args[1]);
          if((iterator_nr = gen_array_index(extern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
            paving_array[iterator_nr] = strdup("1");
          }
          else if((iterator_nr = gen_array_index(intern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
            fitting_array[iterator_nr] = strdup("1");
          }
        }
      }
      else if(same_string_p(funname, "-")){
        if(syntax_tag(args[1]) == is_syntax_call && gen_length(call_arguments(syntax_call(args[1])))==0){
          if(syntax_tag(args[0]) == is_syntax_reference){
            reference ref = syntax_reference(args[0]);
            if((iterator_nr = gen_array_index(extern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
              paving_array[iterator_nr] = strdup("1");
            }
            else if((iterator_nr = gen_array_index(intern_indices_array, xml_entity_local_name(reference_variable(ref)))) != ITEM_NOT_IN_ARRAY){
              fitting_array[iterator_nr] = strdup("1");
            }
          }
          if(syntax_tag(args[0]) == is_syntax_call){
            xml_call_from_indice(syntax_call(args[0]), offset_array, paving_array, fitting_array);
          }
          xml_call_from_indice(syntax_call(args[1]), offset_array, paving_array, fitting_array);
        }
        else {
          pips_user_error("APOTRES doesn't allow negative coefficients in paving and fitting matrices\n");
        }
      }
      else if(same_string_p(funname, "*")){
        if(syntax_tag(args[0]) != is_syntax_call || syntax_tag(args[1]) != is_syntax_reference || gen_length(call_arguments(syntax_call(args[0])))!=0 ){
          pips_user_error("Only scalar * reference are allowed here. Please develop expressions.\n");
        }
        else {
          int intern_nr = gen_array_index(intern_indices_array, xml_entity_local_name(reference_variable(syntax_reference(args[1]))));
          int extern_nr = gen_array_index(extern_indices_array, xml_entity_local_name(reference_variable(syntax_reference(args[1]))));
          string mult =  strdup(xml_entity_local_name(call_function(syntax_call(args[0]))));
          if(extern_nr != ITEM_NOT_IN_ARRAY){
            paving_array[extern_nr] = mult;
          }
          else if(intern_nr != ITEM_NOT_IN_ARRAY){
            fitting_array[intern_nr] = strdup(mult);
          }
        }
      }
    }
    else{
      pips_user_error("only linear expression of indices allowed\n");
    }
  }
  else if(gen_length(arguments) == 0){
    *offset_array = funname;
  }
  else{
    pips_user_error("only +, -, * and constants allowed\n");
  }
}

References call_arguments, call_function, EXPRESSION, expression_syntax, extern_indices_array, gen_array_index(), gen_length(), intern_indices_array, is_syntax_call, is_syntax_reference, ITEM_NOT_IN_ARRAY, MAP, pips_user_error, ref, reference_variable, same_string_p, strdup(), syntax_call, syntax_reference, syntax_tag, and xml_entity_local_name().

Referenced by xml_array_in_task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_call_from_loopnest()

static string xml_call_from_loopnest ( call  c, int  task_number  )

static

Definition at line 776 of file xml_prettyprinter.c.

                                                             {
  entity called = call_function(c);
  list arguments = call_arguments(c);
  syntax s;
  string result = "";
  string first_result = "";
  bool first = true;
  bool input_provided = false, output_provided = false;
  string name = strdup(xml_entity_local_name(called));
 
  if(!same_string_p(name, "="))
    pips_user_error("Only assignation allowed here.\n");
 
  FOREACH(EXPRESSION, e, arguments){
    s = expression_syntax(e);
    switch(syntax_tag(s)){
    case is_syntax_call:{
      if(first)
        pips_user_error("Call not allowed in left-hand side argument of assignation.\n");
      else
        result = strdup(concatenate(result, xml_call_from_assignation(syntax_call(s), task_number, &input_provided), NULL));
      break;
    }
    case is_syntax_reference:
    {
      reference r = syntax_reference(s);
      string varname = strdup(concatenate("A_",
        xml_entity_local_name(reference_variable(r)), NULL));
      if (gen_array_index(array_names, varname) != ITEM_NOT_IN_ARRAY)
      {
        if(first){
          first_result = xml_array_in_task(r, first, task_number);
          output_provided = true;
        }
        else{
          result = strdup(concatenate(result,
             xml_array_in_task(r, first, task_number), NULL));
          input_provided = true;
        }
      }
      break;
    }
    default:
      pips_internal_error("unhandled case");
    }
    first = false;
  }
 
  if(!input_provided){
    result = strdup(concatenate("data = list<DATA>(dummyDATA, ", result, first_result, NULL));
  }
  else{
    result = strdup(concatenate("data = list<DATA>(", result, first_result, NULL));
  }
  if(!output_provided){
    result = strdup(concatenate(result, " dummyDATA)", NULL));
  }
  result = strdup(concatenate(result, TAB, ")", NL, NULL));
  return result;
}

References array_names, call_arguments, call_function, concatenate(), EXPRESSION, expression_syntax, FOREACH, gen_array_index(), is_syntax_call, is_syntax_reference, ITEM_NOT_IN_ARRAY, NL, pips_internal_error, pips_user_error, reference_variable, same_string_p, strdup(), syntax_call, syntax_reference, syntax_tag, TAB, xml_array_in_task(), xml_call_from_assignation(), and xml_entity_local_name().

Referenced by xml_loop_from_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Chain_Graph()

static void xml_Chain_Graph ( entity  module, statement  mod_stat, graph  mod_graph, nest_context_p  nest, string_buffer  sb_result  )

static

Definition at line 4932 of file xml_prettyprinter.c.

{
  cons *pv1, *ps, *pc;
  string_buffer buff_computed_by_func1 = string_buffer_make(true);
  string_buffer buff_needed_from_func1 = string_buffer_make(true);
  string_buffer buff_cumul_needed = string_buffer_make(true);
  string_buffer buffer_cond = string_buffer_make(true);
  string string_temp, stn1="", stn2="";
  bool new_temp=false, empty_buff_computed_by_func1=true,new_cond=false;
  bool new_temp2=false, empty_buff_needed_from_func1=true;
  bool empty_buff_cumul_needed=true;
  int taskNumber=0;
  stack statif=STACK_NULL;
  entity func1=entity_undefined;
  entity func2=entity_undefined;
  entity cond;
  expression lhs,rhs;
  statement sc;
  int nb_cond=0;
  int stat_kind1=-1,stat_kind2=-1;
  Pvecteur written_cumul = VECTEUR_UNDEFINED, vr= VECTEUR_UNDEFINED,vw= VECTEUR_UNDEFINED;
  list cumulated_effects_list=NIL, local_effects=NIL;
  string st_nb1, st_nb2;
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "BoxGraph Name=", QUOTE,entity_user_name(module), QUOTE,
                                   CLOSEANGLE,NL, NULL));
  global_margin++;
 
  // COMPUTATION of the cumulated proper effects for the 2 following lists of NEEDS and COMPUTES
  cumulated_list = NIL;
  gen_recurse(mod_stat, statement_domain, gen_true, cumul_and_update_effects_of_statement);
  cumulated_effects_list= cumulated_list;
  vars_read_and_written(cumulated_effects_list,&vr,&vw);
 
  ifdebug(8) {
    print_ordering_to_statement( );
  }
  gen_sort_list(graph_vertices(mod_graph), (gen_cmp_func_t)vertex_sort_callback);
  for ( pv1 = graph_vertices(mod_graph); !ENDP(pv1); pv1 = CDR(pv1) ) {
    vertex v1 = VERTEX(CAR(pv1));
    statement s1 = vertex_to_statement( v1 );
    Pvecteur vread_func1= vect_new(TCST,1);
    Pvecteur vwritten_func1 = vect_new(TCST,1); // only 1 "xml COMPUTES information" per reference for each call statement S1
    Pvecteur vread_in_condition= vect_new(TCST,1);
    buffer_cond = string_buffer_make(true);
    buff_computed_by_func1 = string_buffer_make(true);
    gen_sort_list(vertex_successors(v1), (gen_cmp_func_t)successor_sort_callback);
    new_temp=false;
    taskNumber=-1;
    new_cond=false;
    func1=entity_undefined;
    statif = STACK_NULL;
    stack indices= STACK_NULL;;
    //  Recovery of conditions on/in statement s1, if any
    for (int callnumber = 0; callnumber<(int)gen_array_nitems(nest->nested_call); callnumber++) {
      statement s3 = gen_array_item(nest->nested_call,callnumber);
      if (statement_number(s3) == statement_number(s1))
        taskNumber=callnumber;
    }
    if (taskNumber>=0) {
      sc = gen_array_item(nest->nested_call,taskNumber);
      indices = gen_array_item(nest->nested_loop_indices,taskNumber);
      local_effects=regions_dup(load_statement_local_regions(sc));
      statif = gen_array_item(nest->nested_if,taskNumber);
    }
    // Conditional information around the dependencies
    if (statif != STACK_NULL) {
      test_statement_of_reference=s1;
      nb_cond=0; // to restore alignment
      global_margin++;
      STACK_MAP_X(sx, statement,
                  {  if (logic_condition_filter(s1,sx,&cond,&lhs,&rhs)) {
                      test l = instruction_test(statement_instruction(sx));
                      push_statement_on_statement_global_stack(sx);
                      statement_in_truebranch_p=false;
                      if (!statement_undefined_p(test_true(l)))
                        gen_recurse(test_true(l), statement_domain, gen_true,statement_in_truebranch);
                      add_margin(global_margin,buffer_cond);
                      //DEBUG -   printf("Condition Branch=%s Test=\n", (statement_in_truebranch_p ? "TRUE":"FALSE"),(string)entity_user_name(cond));
                      string_buffer_append(buffer_cond,
                                           concatenate(OPENANGLE,
                                                       "Condition Branch=",
                                                       QUOTE, (statement_in_truebranch_p ? "TRUE":"FALSE"),
                                                       QUOTE,  BL,
                                                       "Test=", QUOTE, NULL));
                      string_buffer_append_xml_text(buffer_cond,(string)entity_user_name(cond),false);
                      string_buffer_append(buffer_cond,
                                           concatenate(QUOTE,  BL,
                                                       "LHS=",QUOTE, expression_to_string(lhs), QUOTE,  BL,
                                                       "RHS=",QUOTE, expression_to_string(rhs), QUOTE, BL,
                                                       "StNumber=",QUOTE,int2a(statement_number(sx)),QUOTE,
                                                       CLOSEANGLE,NL, NULL));
                      // For special character :  string_buffer_append_xml_text(buffer_cond,exps,false);
                      global_margin++;nb_cond++;
 
                      { // usefull to add the READ effects on variables referenced into condition
                        list l = load_proper_rw_effects_list(sx);
                        if (!ENDP(l) && !list_undefined_p(l)) {
                          
                          for (list pc = l; pc != NIL; pc = CDR(pc)) {
                            effect e = EFFECT(CAR(pc));
                            reference r = effect_any_reference(e);
                            action ac = effect_action(e);
                            entity v = reference_variable(r);
                            if (store_effect_p(e)
                                && !effects_package_entity_p(v) && !std_file_entity_p(v) && !variable_heap_p(v)
                                // local effect = read and no written effect in the function
                                && action_read_p(ac) && vect_coeff(v,vw)==0 &&
                                !(entity_static_variable_p(v) && !top_level_entity_p(v))) {
                                vect_add_elem(&vread_in_condition,(Variable)v,statement_number(sx));
                            }
                          }
                          }
                      }
                      
                      (void) pop_statement_global_stack();
                    }
                  },
                  statif, 0);
      global_margin--;
      if (nb_cond>0) new_cond=true;
    }
 
    // Scan dependences from Call statement S1 to all Call Statement S2
    for ( ps = vertex_successors(v1); !ENDP(ps); ps = CDR(ps) ) {
      successor su = SUCCESSOR(CAR(ps));
      vertex v2 = successor_vertex(su);
      statement s2 = vertex_to_statement( v2 );
      dg_arc_label dal = (dg_arc_label) successor_arc_label(su);
      list cl = dg_arc_label_conflicts(dal);
      int nb_conflicts = gen_length(cl);
      vread_func1 = vect_new(TCST,1);
      buff_needed_from_func1 = string_buffer_make(true);
      new_temp2=false;
      empty_buff_needed_from_func1=true;
      if(get_bool_property("PRETTYPRINT_MEMORY_EFFECTS_ONLY")) {
        FOREACH(CONFLICT, c, cl) {
          effect efsrc = conflict_source(c);
          if(!store_effect_p(efsrc))
            nb_conflicts--;
        }
      }
      if(nb_conflicts==0)
        continue;
      if ( nb_conflicts > 1 ) { //SORT
        gen_array_t conflicts_array = gen_array_make( 20 );
        list_to_array( dg_arc_label_conflicts(dal), conflicts_array );
        qsort( gen_array_pointer( conflicts_array ),
               gen_array_nitems( conflicts_array ),
               sizeof(void *),
               (gen_cmp_func_t) conflicts_sort_callback);
        list conflicts_list = NIL;
        GEN_ARRAY_FOREACH(conflict, s, conflicts_array)
          conflicts_list = CONS(conflict, s, conflicts_list);
        gen_array_free(conflicts_array);
        dg_arc_label_conflicts(dal)=conflicts_list;
      }
 
      stat_kind1=-1, stat_kind2=-1;
      dependencies_filter(s1,&stat_kind1);
      dependencies_filter(s2,&stat_kind2);
      if ((( 0<=stat_kind1 && stat_kind1 <=1)
           && ( 0<=stat_kind2 && stat_kind2 <=1) && !(statement_number(s2) == statement_number(s1)))
          || ((stat_kind1==2 || stat_kind1==3) && ( 0<=stat_kind2 && stat_kind2 <=1) )
          || ((stat_kind2==2 || stat_kind2==3) && ( 0<=stat_kind1 && stat_kind1 <=1))) {
        st_nb1=int2a(statement_number(s1));
        st_nb2=int2a(statement_number(s2));
        // DEBUG - printf( "\t\tdependence %s - %s  between %s  and  %s \n",stn1,stn2, st_nb1,st_nb2  );
        switch(stat_kind1) {
        case 1: {
          func1 = call_function(instruction_call(statement_instruction(s1)));
          stn1 = strdup(entity_user_name(func1));
          break;
        }
        case 2: {
          stn1 = strdup("DeclarationInstruction");
          break;
        }
        case 0:  {
          expression rhs_exp = EXPRESSION(CAR(CDR( call_arguments(instruction_call(statement_instruction(s1))))));
          syntax sr = expression_syntax(rhs_exp);
          if(syntax_call_p(sr)) {
            call rhs_call = syntax_call(sr);
            func2=call_function(rhs_call);
            if ((entity_subroutine_p(func2)|| entity_function_p(func2)))
              stn1= (string) entity_local_name(call_function(rhs_call));
            else
              stn1 =  strdup("LocalAssignment");
          }
          else
            stn1 =  strdup("LocalAssignment");
          break;
        }
        case 3:  {
          stn1 =  strdup("TestInstruction");
          break;
        }
        default:
          break;
        }
        switch(stat_kind2) {
        case 1: {
          func2 = call_function(instruction_call(statement_instruction(s2)));
          stn2 = strdup(entity_user_name(func2));
          break;
        }
        case 2: {
          stn2 = strdup("DeclarationInstruction");
          break;
        }
        case 0: {
          expression rhs_exp = EXPRESSION(CAR(CDR(call_arguments(instruction_call(statement_instruction(s2))))));
          syntax sr = expression_syntax(rhs_exp);
          if(syntax_call_p(sr)) {
            call rhs_call = syntax_call(sr);
            func2=call_function(rhs_call);
            if ((entity_subroutine_p(func2)|| entity_function_p(func2)))
              stn2= (string) entity_local_name(call_function(rhs_call));
            else
              stn2 =  strdup("LocalAssignment");
          }
          else
            stn2 =  strdup("LocalAssignment");
          break;
          break;
        }
        case 3: {
          stn2 =  strdup("TestInstruction");
          break;
        }
        default:
          break;
        }
        // Create the header for dependencies for TASKREF func1
        if (!new_temp){
          global_margin ++;
          add_margin(global_margin,buff_computed_by_func1);
          string_buffer_append(buff_computed_by_func1,
                               concatenate(OPENANGLE,
                                           (stat_kind1>=0 && stat_kind1<=1)?"TaskRef Name=" :"Instruction Name=",QUOTE,stn1,QUOTE, BL,
                                           "StNumber=",QUOTE,st_nb1,QUOTE,
                                           CLOSEANGLE,NL,
                                           NULL));
          new_temp=true;
          empty_buff_computed_by_func1=true;
        }
        if (!new_temp2){
          add_margin(global_margin,buff_needed_from_func1);
          string_buffer_append(buff_needed_from_func1,
                               concatenate(OPENANGLE,
                                           (stat_kind2>=0 && stat_kind2<=1)?"TaskRef Name=" :"Instruction Name=",QUOTE,stn2,QUOTE, BL,
                                           "StNumber=",QUOTE,st_nb2,QUOTE,
                                           CLOSEANGLE,NL,
                                           NULL));
          new_temp2=true;
          empty_buff_needed_from_func1=true;
        }
        // Scan all dependences  from Call statement S1 to Call Statement S2
        for ( pc = dg_arc_label_conflicts(dal); !ENDP(pc); pc = CDR(pc) ) {
          conflict c = CONFLICT(CAR(pc));
          effect efsrc = conflict_source(c);
          effect efsrs = conflict_sink(c);
          action acc = effect_action(efsrc);
          action acs = effect_action(efsrs);
          reference rc = effect_any_reference(efsrc);
          reference rs = effect_any_reference(efsrs);
          entity vc =  reference_variable(rc);
          entity vs =  reference_variable(rs);
 
          // DEBUG-
          // if (( 0<=stat_kind1 && stat_kind1 <=3) && ( 0<=stat_kind2 && stat_kind2 <=3))
          // printf( "\t\tdependence %s (%s)- %s(%s) for %s - %s \n",stn1,st_nb1,stn2,st_nb2, entity_user_name(vc), entity_user_name(vs) );
 
          if (store_effect_p(efsrc) 
              && !effects_package_entity_p(vc) && !std_file_entity_p(vc)
              && !effects_package_entity_p(vs) && !std_file_entity_p(vs) 
              && !string_parameter_p(vs) && !string_parameter_p(vc)
              // && !variable_heap_p(vc) && !variable_heap_p(vs)
              ) {
 
            if (action_write_p(acc) && action_read_p(acs) && vect_coeff(vc,vwritten_func1)==0
                ) {
              //DEBUG- printf( "\t\t%s COMPUTES %s read by %s(%s)\n",stn1, entity_user_name(vc),stn2,st_nb2 );
              global_margin++;
              add_margin(global_margin,buff_computed_by_func1);
              string_buffer_append(buff_computed_by_func1,
                                   concatenate(OPENANGLE,
                                               "Computes ",(array_entity_p(vc))?"ArrayName=": "ScalarName=",
                                               QUOTE,NULL));
             string_buffer_append_xml_text(buff_computed_by_func1,
                                           (string) ((print_name_1_level_p() || reference_undefined_p(rc))?
                                                     entity_user_name(vc):words_points_to_reference(rc,false,region_undefined)),
                                           false);
             string_buffer_append(buff_computed_by_func1,
                                   concatenate(QUOTE, BL,
                                               "ReadBy=",QUOTE,stn2,QUOTE, BL,
                                               "StNumber=",QUOTE,st_nb2,QUOTE,
                                               "/",CLOSEANGLE,NL,
                                               NULL));
              global_margin--;
              empty_buff_computed_by_func1=false;
              vect_add_elem(&vwritten_func1,(Variable)vc,1);
              vect_add_elem(&written_cumul,(Variable)vc,1);
            }
            if (action_write_p(acc) && action_read_p(acs)) {
              if (vect_coeff(vc,vread_func1)==0 ) {
                //DEBUG- printf( "\t\t%s NEEDS %s DefinedBy by %s (%s)\n",stn2, entity_user_name(vc),stn1, st_nb1);
 
                global_margin++;
                add_margin(global_margin,buff_needed_from_func1);
                string_buffer_append(buff_needed_from_func1,
                                     concatenate(OPENANGLE,
                                                 "Needs ",(array_entity_p(vc))?"ArrayName=": "ScalarName=",
                                                 QUOTE, NULL));
                string_buffer_append_xml_text(buff_needed_from_func1,
                                              (string) ((print_name_1_level_p() || reference_undefined_p(rc)) ?
                                                        entity_user_name(vc):words_points_to_reference(rc,false,region_undefined)),
                                              false);
                string_buffer_append(buff_needed_from_func1,
                                     concatenate(QUOTE, BL,
                                                 "DefinedBy=",QUOTE,stn1,QUOTE,BL,
                                                 "StNumber=",QUOTE,st_nb1,QUOTE,
                                                 "/",CLOSEANGLE,NL,NULL));
                global_margin--;
                empty_buff_needed_from_func1=false;
                if (!entity_undefined_p(func1))
                  def_to_task_store(vc, func1);
                vect_add_elem(&vread_func1,(Variable)vc,1);
              }
            }
 
            if (action_write_p(acc) && action_write_p(acs) && !same_string_p(stn1,stn2))
              spear_warning(s1,"Check the dependencies before mapping",
                            "Elements of Array  %s written into two different functions %s and %s",
                            (print_name_1_level_p() || reference_undefined_p(rc)) ?
                            entity_user_name(vc):words_points_to_reference(rc,false,region_undefined), stn1,stn2);
 
            //   ADD R-W Dependances
            if (action_write_p(acs) && action_read_p(acc)) {
              //DEBUG- printf( "\t\t%s COMPUTES %s read by %s(%s)\n",stn1, entity_user_name(vc),stn2,st_nb2 );
              global_margin++;
              add_margin(global_margin,buff_computed_by_func1);
              string_buffer_append(buff_computed_by_func1,
                                   concatenate(OPENANGLE,
                                               "Reads ",(array_entity_p(vc))?"ArrayName=": "ScalarName=",
                                               QUOTE,NULL));
              string_buffer_append_xml_text(buff_computed_by_func1,
                                            (string) ((print_name_1_level_p() || reference_undefined_p(rc))?
                                                      entity_user_name(vc):words_points_to_reference(rc,false,region_undefined)),
                                            false);
              string_buffer_append(buff_computed_by_func1,
                                   concatenate(QUOTE, BL,
                                               "WrittenAfterBy=",QUOTE,stn2,QUOTE, BL,
                                               "StNumber=",QUOTE,st_nb2,QUOTE,
                                               "/",CLOSEANGLE,NL,
                                               NULL));
              global_margin--;
              empty_buff_computed_by_func1=false;
            }
          }
        }  // end scanning dependencies
      } // end dependency filter
 
      if (new_temp2) {
        string_buffer_append_word((stat_kind2>=0 && stat_kind2<=1)?"/TaskRef":"/Instruction",buff_needed_from_func1); 
        if  (!empty_buff_needed_from_func1) {
          string_temp =string_buffer_to_string(buff_needed_from_func1);
          string_buffer_append(buff_cumul_needed,string_temp);
          empty_buff_cumul_needed=false;
          string_buffer_free(&buff_needed_from_func1);
        }
        new_temp2=false;
        empty_buff_needed_from_func1=true;
      }
    } // end scan func2
 
    if (new_temp) {
      string_buffer_append_word((stat_kind1>=0 && stat_kind1<=1)?"/TaskRef":"/Instruction",buff_computed_by_func1);
      global_margin--;
    }
    if (new_cond && !new_temp) {
      global_margin--;
    }
    if (!empty_buff_computed_by_func1) {
      if (statif != STACK_NULL) {
        for (int tp=1;tp<=nb_cond;tp++) {
          string_buffer_append_word("/Condition",buff_computed_by_func1);
          global_margin--;
        }
        string_temp =string_buffer_to_string(buffer_cond);
        string_buffer_append(sb_result,string_temp);
      }
      string_temp =string_buffer_to_string(buff_computed_by_func1);
      string_buffer_append(sb_result,string_temp);
 
      string_temp=NULL;
      new_temp=false;
      empty_buff_computed_by_func1=true;
    }
    else  {
      string_buffer_free(&buff_computed_by_func1);
      //  string_buffer_free(&buffer_cond);
    }
 
    // Add Read effects on variable written outside the function and Read by the local statement (in local_effects=local regions)
    if (taskNumber>=0) {
      call c1=call_undefined;
      if (instruction_call_p(statement_instruction(s1))) {
        c1 = instruction_call(statement_instruction(s1));
      }
      else { // The call is encapsulated
        encapsulated_call =call_undefined;
        gen_recurse(s1, call_domain, gen_true,search_1r_function_call);
        c1 =encapsulated_call;
      }
      if (c1!=call_undefined) {
        //      pips_internal_error("Unexpected call in statement number %d \n",(int) statement_number(s1));
 
        sc = gen_array_item(nest->nested_call,taskNumber);
        indices = gen_array_item(nest->nested_loop_indices,taskNumber);
        statif = gen_array_item(nest->nested_if,taskNumber);
 
      
        func1 = call_function(c1);
        const char *temp = (ENTITY_ASSIGN_P(func1))?"LocalAssignment":entity_user_name(func1);
        stn1 = strdup(temp);
        st_nb1=int2a(statement_number(s1));
        for (pc= local_effects;!ENDP(pc); pc = CDR(pc)){
          effect e2 = EFFECT(CAR(pc));
          reference r2 = effect_any_reference(e2);
          action ac2 = effect_action(e2);
          entity v2 =  reference_variable(r2);
          Pcallst t=hash_get(hash_entity_def_into_tasks,(char *) v2);
          bool b=(t!=(Pcallst) HASH_UNDEFINED_VALUE);
 
          if ( store_effect_p(e2) && action_read_p(ac2)
               && !effects_package_entity_p(v2) && !std_file_entity_p(v2) && !variable_heap_p(v2)
               // variable written outside the function
               &&  (vect_coeff(v2,vwritten_func1)==0 || (vect_coeff(v2,vwritten_func1)!=0 &&b ))
               // only if not yet mentioned in the dependencies list or in the local_effects list
               &&  vect_coeff(v2,vread_func1)==0
               && !(entity_static_variable_p(v2) && !top_level_entity_p(v2))
               && vect_coeff(v2,written_cumul)==0 && !(indice_p(indices,v2))
               && !string_parameter_p(v2)//  && (b && t->stat_nb<statement_number(s1))
               ) {      
 
            // Conditional information around the dependencies
            string_temp =string_buffer_to_string(buffer_cond);
            string_buffer_append(sb_result,string_temp);
 
 
            global_margin++;
            add_margin(global_margin,sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "TaskRef Name=",QUOTE, stn1,QUOTE, BL,
                                             "StNumber=",QUOTE,st_nb1,QUOTE,
                                             CLOSEANGLE,NL,
                                             NULL));
            global_margin++;
            add_margin(global_margin,sb_result);
            string_buffer_append(sb_result,
                                 concatenate(OPENANGLE,
                                             "Needs ",(array_entity_p(v2))?"ArrayName=": "ScalarName=",
                                             QUOTE, NULL));
            string_buffer_append_xml_text(sb_result,
                                          (string) ((print_name_1_level_p() || reference_undefined_p(r2))?
                                                    entity_user_name(v2):words_points_to_reference(r2,false,region_undefined)),
                                          false);
            string_buffer_append(sb_result,
                                 concatenate(QUOTE, BL,
                                             "DefinedBy=",QUOTE,
                                             //(b && t->stat_nb<statement_number(s1))?
                                             // - v2 has been updated into a non-call instruction or into a call nested into other instructions.
                                             // - v2 has been updated IN_PLACE
                                             // - v2 has been updated into a callee
                                             // ((t->stat_nb<statement_number(s1)) ? entity_user_name(t->func):"IN_PLACE"):
                                             //((t->stat_nb==statement_number(s1)) ?"IN_PLACE":
                                             //(!(entity_undefined_p(t->func)) ? entity_user_name(t->func) : "NestedCall")
                                             //)
                                             //:
                                             "IN_VALUE",QUOTE,BL,
                                             "StNumber=",QUOTE,(b)?int2a(t->stat_nb):int2a(0),QUOTE,
                                             "/",CLOSEANGLE,NL,NULL));
 
            vect_add_elem(&vread_func1,(Variable)v2,1); 
            global_margin--; 
            string_buffer_append_word("/TaskRef",sb_result);
            global_margin--;
 
            if (statif != STACK_NULL) {
              for (int tp=1;tp<=nb_cond;tp++) {
                string_buffer_append_word("/Condition",sb_result);
                global_margin--;
              }
            }
          }
        }
      }
      {//begin
        vect_chg_coeff(&vread_in_condition, TCST,0);
        for (Pvecteur pv= vread_in_condition;!VECTEUR_UNDEFINED_P(pv); pv = pv->succ){
          entity ent = (entity)pv->var;
         global_margin++;
          add_margin(global_margin,sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "Instruction Name=",QUOTE, "TestInstruction",QUOTE, BL,
                                           "StNumber=",QUOTE,int2a(pv->val),QUOTE,
                                           CLOSEANGLE,NL,
                                           NULL));
          global_margin++;
          add_margin(global_margin,sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "Needs ","ScalarName=",
                                           QUOTE, NULL));
          string_buffer_append_xml_text(sb_result,
                                        (string) entity_user_name(ent),
                                        false);
          string_buffer_append(sb_result,
                               concatenate(QUOTE, BL,
                                           "DefinedBy=",QUOTE,
                                           "IN_VALUE",QUOTE,
                                           //BL, "StNumber=",QUOTE,int2a(0),QUOTE,
                                           "/",CLOSEANGLE,NL,NULL));
            
          global_margin--; 
          string_buffer_append_word("/Instruction",sb_result);
          global_margin--;
 
           
        }
      }//end 
      vect_rm(vread_func1);
      vect_rm(vwritten_func1);
      vect_rm(vread_in_condition);
      string_buffer_free(&buffer_cond);
    }
  } // end toutes les func1
  if  (!empty_buff_cumul_needed) {
    string_temp =string_buffer_to_string(buff_cumul_needed);
    string_buffer_append(sb_result,string_temp);
    string_buffer_free(&buff_cumul_needed);
  }
  //  ADD Write effects on variables that are not used in the function
  //printf("ADD Write effects on variables that are not used in the function\n");
 
  for (pc= cumulated_effects_list;pc != NIL; pc = CDR(pc)){
    effect e = EFFECT(CAR(pc));
    reference r = effect_any_reference(e);
    action ac = effect_action(e);
    entity v =  reference_variable(r);
    if ( store_effect_p(e)
         && !effects_package_entity_p(v) && !std_file_entity_p(v) && !variable_heap_p(v)
         &&!action_read_p(ac) &&  vect_coeff(v,vw) // Write effects in the cumulated effects list
         && !(entity_static_variable_p(v) && !top_level_entity_p(v))
         && vect_coeff(v,written_cumul)==0) {
      Pcallst ct2,ct1=hash_get(hash_entity_def_into_tasks,(char *) v);
      for(ct2=ct1;ct2 !=(Pcallst) HASH_UNDEFINED_VALUE && ct2 !=(Pcallst) NULL; ct2=ct2->succ)
        {
          print_reference(r);
          string temp =strdup(int2a(ct2->stat_nb));
 
          {
            taskNumber=-1;
            statif = STACK_NULL;
            for (int callnumber = 0; callnumber<(int)gen_array_nitems(nest->nested_call); callnumber++) {
              statement s3 = gen_array_item(nest->nested_call,callnumber);
              if (statement_number(s3) == ct2->stat_nb)
                taskNumber=callnumber;
            }
            if (taskNumber>=0) { 
              sc = gen_array_item(nest->nested_call,taskNumber);
              statif = gen_array_item(nest->nested_if,taskNumber);
            }
            // Conditional information around the dependencies
            if (statif != STACK_NULL) {     
              test_statement_of_reference=sc;
              nb_cond=0; // to restore alignment
              global_margin++;    
              STACK_MAP_X(sx, statement,
                          {  if (logic_condition_filter(sc,sx,&cond,&lhs,&rhs)) {
                              test l = instruction_test(statement_instruction(sx));
                              push_statement_on_statement_global_stack(sx);
                              statement_in_truebranch_p=false;
                              if (!statement_undefined_p(test_true(l)))
                                gen_recurse(test_true(l), statement_domain, gen_true,statement_in_truebranch);
                              add_margin(global_margin,sb_result);
                              //DEBUG -   printf("Condition Branch=%s Test=\n", (statement_in_truebranch_p ? "TRUE":"FALSE"),(string)entity_user_name(cond));    
                              string_buffer_append(sb_result,
                                                   concatenate(OPENANGLE,
                                                               "Condition Branch=", 
                                                               QUOTE, (statement_in_truebranch_p ? "TRUE":"FALSE"),
                                                               QUOTE,  BL,
                                                               "Test=", QUOTE, NULL));
                              string_buffer_append_xml_text(sb_result,(string)entity_user_name(cond),false);
                              string_buffer_append(sb_result,
                                                   concatenate(QUOTE, BL, "LHS=",QUOTE, NULL));
                              string_buffer_append_xml_text(sb_result,expression_to_string(lhs), false);
                              string_buffer_append(sb_result,
                                                   concatenate(QUOTE, BL, "RHS=",QUOTE, NULL));
                              string_buffer_append_xml_text(sb_result,expression_to_string(rhs), false);
                              string_buffer_append(sb_result,
                                                   concatenate(QUOTE, BL,
                                                               "StNumber=",QUOTE,int2a(statement_number(sx)),QUOTE,
                                                               CLOSEANGLE,NL, NULL));
                              // For special character :  string_buffer_append_xml_text(buffer_cond,exps,false);
                              global_margin++;nb_cond++;
                              (void) pop_statement_global_stack();
                            }
                          },
                          statif, 0);
              global_margin--;  
              if (nb_cond>0) new_cond=true;
            }
         
            {
              global_margin++;
              add_margin(global_margin,sb_result);
              string_buffer_append(sb_result,
                                   concatenate(OPENANGLE,"TaskRef Name=",QUOTE,
                                               (!entity_undefined_p(ct2->func)) ?
                                               (ENTITY_ASSIGN_P(ct2->func)?"LocalAssignment":entity_user_name(ct2->func)):
                                               // Variable assigned in an instruction that is not a Call; in a loop, a nested call,...
                                               "NestedCall", QUOTE,
                                               BL,"StNumber=",QUOTE,temp,QUOTE,
                                               CLOSEANGLE,NL,
                                               NULL));
              global_margin++;
              add_margin(global_margin,sb_result);
              string_buffer_append(sb_result,
                                   concatenate(OPENANGLE,
                                               "Computes ",(array_entity_p(v))?"ArrayName=": "ScalarName=",
                                               QUOTE,NULL));
             string_buffer_append_xml_text(sb_result,
                                           (string) ((print_name_1_level_p() || reference_undefined_p(r))?
                                                     entity_user_name(v):words_points_to_reference(r,false,region_undefined)),
                                           false);
            string_buffer_append(sb_result,
                                   concatenate(QUOTE,"/", CLOSEANGLE,NL, NULL));
               vect_add_elem(&written_cumul,(Variable)v,1);
              global_margin--;
              string_buffer_append_word("/TaskRef",sb_result);
              global_margin--;
            }
            if (statif != STACK_NULL) {
              for (int tp=1;tp<=nb_cond;tp++) {
                string_buffer_append_word("/Condition",sb_result);
                global_margin--;
              }
            }
          }
        }
    }
  }
  global_margin--;
  string_buffer_append_word("/BoxGraph",sb_result);
  vect_rm(written_cumul);
  vect_rm(vr);
  vect_rm(vw);
}

References action_read_p, action_write_p, add_margin(), array_entity_p(), BL, call_arguments, call_domain, call_function, call_undefined, CAR, CDR, CLOSEANGLE, concatenate(), CONFLICT, conflict_sink, conflict_source, conflicts_sort_callback(), CONS, cumul_and_update_effects_of_statement(), cumulated_list, def_to_task_store(), dependencies_filter(), dg_arc_label_conflicts, EFFECT, effect_action, effect_any_reference, effects_package_entity_p(), encapsulated_call, ENDP, ENTITY_ASSIGN_P, entity_function_p(), entity_local_name(), entity_static_variable_p(), entity_subroutine_p(), entity_undefined, entity_undefined_p, entity_user_name(), EXPRESSION, expression_syntax, expression_to_string(), FOREACH, callst::func, GEN_ARRAY_FOREACH, gen_array_free(), gen_array_item(), gen_array_make(), gen_array_nitems(), gen_array_pointer(), gen_length(), gen_recurse, gen_sort_list(), gen_true(), get_bool_property(), global_margin, graph_vertices, hash_entity_def_into_tasks, hash_get(), HASH_UNDEFINED_VALUE, ifdebug, indice_p(), indices, instruction_call, instruction_call_p, instruction_test, int, int2a(), list_to_array(), list_undefined_p, load_proper_rw_effects_list(), load_statement_local_regions(), logic_condition_filter(), mod_stat, module, nest_context_t::nested_call, nest_context_t::nested_if, nest_context_t::nested_loop_indices, NIL, NL, OPENANGLE, pop_statement_global_stack(), print_name_1_level_p(), print_ordering_to_statement(), print_reference(), push_statement_on_statement_global_stack(), QUOTE, reference_undefined_p, reference_variable, region_undefined, regions_dup(), s1, same_string_p, search_1r_function_call(), spear_warning, STACK_MAP_X, STACK_NULL, callst::stat_nb, statement_domain, statement_in_truebranch(), statement_in_truebranch_p, statement_instruction, statement_number, statement_undefined_p, std_file_entity_p(), store_effect_p(), strdup(), string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), string_buffer_free(), string_buffer_make(), string_buffer_to_string(), string_parameter_p(), callst::succ, SUCCESSOR, successor_arc_label, successor_sort_callback(), successor_vertex, syntax_call, syntax_call_p, TCST, test_statement_of_reference, test_true, top_level_entity_p(), variable_heap_p(), vars_read_and_written(), vect_add_elem(), vect_chg_coeff(), vect_coeff(), vect_new(), vect_rm(), VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, VERTEX, vertex_sort_callback(), vertex_successors, vertex_to_statement(), and words_points_to_reference().

Referenced by xml_Chains().

Here is the caller graph for this function:

xml_Chains()

static void xml_Chains ( entity  module, const char *  mod_name, statement  mod_stat, nest_context_p  nest, string_buffer  sb_result  )

static

Definition at line 5598 of file xml_prettyprinter.c.

{
  set_ordering_to_statement(mod_stat);
  dg = (graph) db_get_memory_resource(DBR_DG, mod_name, true);
  xml_Chain_Graph(module,mod_stat,dg,nest,sb_result);
  // reset_current_module_statement();
  //  reset_current_module_entity();
  reset_ordering_to_statement();
}

References db_get_memory_resource(), dg, mod_stat, module, reset_ordering_to_statement(), set_ordering_to_statement(), and xml_Chain_Graph().

Referenced by xml_Boxes().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_code()

static string xml_code ( entity  module, statement  stat  )

static

Creates string for xml pretty printer.

This string divides in declarations (array decl.) and tasks which are loopnests with an instruction at the core.

ifdebug(2) { printf("%s", result2); }

Definition at line 1860 of file xml_prettyprinter.c.

{
  string_buffer result=string_buffer_make(true);
  string result2;
 
  string_buffer_append(result,concatenate(OPENANGLE, "module name=", QUOTE,get_current_module_name(), QUOTE, CLOSEANGLE, NL, NULL ));
  xml_declarations(module,result);
  xml_tasks(stat,result);
 
  string_buffer_append(result,concatenate(OPENANGLE, SLASH, "module", CLOSEANGLE, NL, NULL ));
  result2=string_buffer_to_string(result);
  /* ifdebug(2)
     {
     printf("%s", result2);
     } */
  return result2;
}

References CLOSEANGLE, concatenate(), get_current_module_name(), module, NL, OPENANGLE, QUOTE, SLASH, string_buffer_append(), string_buffer_make(), string_buffer_to_string(), xml_declarations(), and xml_tasks().

Referenced by print_xml_code().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_code_string()

static string xml_code_string ( entity  module, statement  stat  )

static

Creates string for xml pretty printer.

This string divides in declarations (array decl.) and tasks which are loopnest with an instruction at the core.

Definition at line 1135 of file xml_prettyprinter.c.

{
  string decls="", tasks="", result="";
 
  ifdebug(2)
    {
      printf("Module statement: \n");
      print_statement(stat);
      printf("and declarations: \n");
      print_entities(statement_declarations(stat));
    }
 
  decls       = xml_declarations_with_explicit_motif(module, variable_p, "", true);
  tasks       = xml_tasks_with_motif(stat);
  result = strdup(concatenate(decls, NL, tasks, NL, NULL));
  ifdebug(2)
    {
      printf("%s", result);
    }
  return result;
}

References concatenate(), ifdebug, module, NL, print_entities(), print_statement(), printf(), statement_declarations, strdup(), variable_p(), xml_declarations_with_explicit_motif(), and xml_tasks_with_motif().

Referenced by print_xml_code_with_explicit_motif().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_CodeSize()

static void xml_CodeSize ( string_buffer  sb_result )

static

Definition at line 2071 of file xml_prettyprinter.c.

{
  string_buffer_append_word("CodeSize",sb_result);
  string_buffer_append_word("/CodeSize",sb_result);
}

References string_buffer_append_word().

Referenced by xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Compute_and_Need()

static void xml_Compute_and_Need ( entity  func, list  effects_list, Pvecteur  vargs, string_buffer  sb_result  )

static

Definition at line 5850 of file xml_prettyprinter.c.

{
  string_buffer buffer_needs = string_buffer_make(true);
  string string_needs = "";
  Pvecteur vr = VECTEUR_NUL,vw = VECTEUR_NUL;
  list pc;
  Pvecteur va2 = vect_dup(vargs);
 
  vars_read_and_written(effects_list,&vr,&vw);
 
  for (pc= effects_list;pc != NIL; pc = CDR(pc)){
    effect e = EFFECT(CAR(pc));
    reference r = effect_any_reference(e);
    action ac = effect_action(e);
    entity v = reference_variable(r);
    // get last function which modified v, if any...
    entity t = def_to_task_get(v);
    if ( store_effect_p(e)
         && !effects_package_entity_p(v) && !std_file_entity_p(v) && !variable_heap_p(v)
         // To avoid the multiple references to the same user array (Array of struct,  Read-Written arrays, ..)
         && action_read_p(ac) && vect_coeff(v,vr) && ((vect_coeff(v,vw) && (t != NULL)) || !vect_coeff(v,vw) )
         // to avoid private variables
         && !(entity_static_variable_p(v) && !top_level_entity_p(v))
         && !string_parameter_p(v)) {
      vect_chg_coeff(&vr,v,0);
      global_margin++;
      add_margin(global_margin,buffer_needs);
      string_buffer_append(buffer_needs,
                           concatenate(OPENANGLE,
                                       "Needs ",(array_entity_p(v))?"ArrayName=": "ScalarName=",
                                       QUOTE,NULL));
      string_buffer_append_xml_text(buffer_needs,(string) entity_user_name(v),false);
      string_buffer_append(buffer_needs,
                           concatenate(QUOTE, BL,
                                       "DefinedBy=",QUOTE,
                                       (t != NULL) ? entity_local_name(t): "IN_VALUE",QUOTE,"/",
                                       CLOSEANGLE,NL,NULL));
      global_margin--;
    }
  }
  for (pc= effects_list;pc != NIL; pc = CDR(pc)){
    effect e = EFFECT(CAR(pc));
    reference r = effect_any_reference(e);
    action ac = effect_action(e);
    entity v =  reference_variable(r);
    if ( store_effect_p(e) && !effects_package_entity_p(v) && !std_file_entity_p(v) && !variable_heap_p(v)
         // to avoid private variables and the multiple references to the same user array (Array of struct, ..)
         &&!action_read_p(ac) &&  vect_coeff(v,vw)
         && !(entity_static_variable_p(v) && !top_level_entity_p(v))) {
      vect_chg_coeff(&vw,v,0);
      global_margin++;
      add_margin(global_margin,sb_result);
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "Computes ",(array_entity_p(v))?"ArrayName=": "ScalarName=",
                                       QUOTE,NULL));
      string_buffer_append_xml_text(sb_result,(string) entity_user_name(v),false);
     string_buffer_append(sb_result,
                           concatenate(QUOTE,"/", CLOSEANGLE,NL,NULL));
      def_to_task_store(v, func);
      global_margin--;
    }
  }
 
  vect_rm(va2);
  string_needs =string_buffer_to_string(buffer_needs);
  string_buffer_append(sb_result,string_needs);
  free(string_needs);
  string_needs=NULL;
}

References action_read_p, add_margin(), array_entity_p(), BL, CAR, CDR, CLOSEANGLE, concatenate(), def_to_task_get(), def_to_task_store(), EFFECT, effect_action, effect_any_reference, effects_package_entity_p(), entity_local_name(), entity_static_variable_p(), entity_user_name(), free(), global_margin, NIL, NL, OPENANGLE, QUOTE, reference_variable, std_file_entity_p(), store_effect_p(), string_buffer_append(), string_buffer_append_xml_text(), string_buffer_make(), string_buffer_to_string(), string_parameter_p(), top_level_entity_p(), variable_heap_p(), vars_read_and_written(), vect_chg_coeff(), vect_coeff(), vect_dup(), vect_rm(), and VECTEUR_NUL.

Referenced by xml_Application().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Connection()

static void xml_Connection ( list  ActualArrayInd, int  ActualArrayDim, int  FormalArrayDim, string_buffer  sb_result  )

static

Definition at line 4432 of file xml_prettyprinter.c.

{
  Pmatrix mat;
  int i,j;
  Pvecteur pv;
  string_buffer_append_word("Connection",sb_result);
  mat = matrix_new(ActualArrayDim,FormalArrayDim);
  matrix_init(mat,ActualArrayDim,FormalArrayDim);
  if (fortran_appli) {
    for (i=1;i<=ActualArrayDim && i<= FormalArrayDim;i++)
      MATRIX_ELEM(mat,i,i)=1;
  }
  else
    for (i=ActualArrayDim, j=FormalArrayDim;i>=1 && j>=1;i=i-1,j=j-1)
      MATRIX_ELEM(mat,i,j)=1;
  // Normalise les expressions lors du premier parcours
  // Utile aussi a  xml_LoopOffset
  MAP(EXPRESSION, e , {
      if (expression_normalized(e) == normalized_undefined)
        expression_normalized(e)= NormalizeExpression(e);
      pv = (Pvecteur)normalized_linear(expression_normalized(e));
      pv = pv;
    },
    ActualArrayInd);
 
  xml_Matrix(mat,ActualArrayDim,FormalArrayDim,sb_result);
  string_buffer_append_word("/Connection",sb_result);
}

References EXPRESSION, expression_normalized, fortran_appli, MAP, MATRIX_ELEM, matrix_init(), matrix_new(), normalized_linear, normalized_undefined, NormalizeExpression(), string_buffer_append_word(), and xml_Matrix().

Referenced by xml_Argument(), and xml_AssignArgument().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_ConstOffset()

static void xml_ConstOffset ( list  ActualArrayInd, int  ActualArrayDim, string_buffer  sb_result  )

static

Definition at line 4486 of file xml_prettyprinter.c.

{
  Pmatrix mat;
  Pvecteur pv;
  int i=1;
  string_buffer_append_word("ConstOffset",sb_result);
  mat = matrix_new(ActualArrayDim,1);
  matrix_init(mat,ActualArrayDim,1);
  MAP(EXPRESSION, e , {
      if (expression_normalized(e) == normalized_undefined)
        expression_normalized(e)= NormalizeExpression(e);
      pv = (Pvecteur)normalized_linear(expression_normalized(e));
      MATRIX_ELEM(mat,i,1)=vect_coeff(TCST,pv);
      i++;
    },
    ActualArrayInd);
 
  xml_Matrix(mat,ActualArrayDim,1,sb_result);
  string_buffer_append_word("/ConstOffset",sb_result);
}

References EXPRESSION, expression_normalized, MAP, MATRIX_ELEM, matrix_init(), matrix_new(), normalized_linear, normalized_undefined, NormalizeExpression(), string_buffer_append_word(), TCST, vect_coeff(), and xml_Matrix().

Referenced by xml_Argument(), and xml_AssignArgument().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_data()

static void xml_data ( int  taskNumber, statement  s, stack  indices, string_buffer  result  )

static

Definition at line 1760 of file xml_prettyprinter.c.

{
 
  list  l_regions = regions_dup(load_statement_local_regions(s));
  string_buffer_append(result,concatenate(TAB,SPACE, OPENANGLE, "dataList", CLOSEANGLE, NL,NULL));
  /*
    ifdebug(2) {
    fprintf(stderr, "\n list of regions ");
    print_regions(l_regions);
    fprintf(stderr, "\n for the statement");
    print_statement(s);
    }
  */
  xml_references(taskNumber, l_regions, indices, result);
  string_buffer_append(result,concatenate(TAB,SPACE,OPENANGLE, SLASH, "dataList", CLOSEANGLE,NL,NULL));
  regions_free(l_regions);
}

References CLOSEANGLE, concatenate(), indices, load_statement_local_regions(), NL, OPENANGLE, regions_dup(), regions_free(), SLASH, SPACE, string_buffer_append(), TAB, and xml_references().

Referenced by xml_task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_declarations()

static void xml_declarations ( entity  module, string_buffer  result  )

static

Definition at line 1227 of file xml_prettyprinter.c.

{
  list dim;
  list ldecl = code_declarations(value_code(entity_initial(module)));
  list ld;
 
  entity var = entity_undefined;
  for(ld = ldecl; !ENDP(ld); ld = CDR(ld)){
 
    //printf("inside for");
    var = ENTITY(CAR(ld));
    //printf("Entity Name in the List : %s  ",entity_name(var));
 
    if (variable_p(var) && ( variable_entity_dimension(var) > 0))
      {
        // int nb_dim = variable_entity_dimension(var);
        //printf("inside p, %d",nb_dim);
 
        string_buffer_append(result,
                             concatenate(TAB, OPENANGLE, "array name =", QUOTE, XML_ARRAY_PREFIX,entity_user_name(var),QUOTE,
                                         " dataType = ", QUOTE,
                                         "INTEGER", QUOTE,CLOSEANGLE
                                         , XML_RL, NULL));
        string_buffer_append(result,
                             concatenate(OPENANGLE,"dimensions",CLOSEANGLE
                                         , XML_RL,NULL));
 
        for (dim = variable_dimensions(type_variable(entity_type(var))); !ENDP(dim); dim = CDR(dim)) {
 
          intptr_t low;
          intptr_t  up;
          expression elow = dimension_lower(DIMENSION(CAR(dim)));
          expression eup = dimension_upper(DIMENSION(CAR(dim)));
          if (expression_integer_value(elow, &low) && expression_integer_value(eup, &up)){
            string_buffer_append(result,
                                 concatenate( TAB,OPENANGLE, "range min =", QUOTE,  int2a(low), QUOTE, NULL));
            string_buffer_append(result,
                                 concatenate(" max =", QUOTE,  int2a(up-low+1),QUOTE, SLASH, CLOSEANGLE, XML_RL, NULL));
          }
          else pips_user_error("Array dimensions must be integer\n");
 
        }
 
        string_buffer_append(result,
                             concatenate(OPENANGLE, SLASH, "dimensions", CLOSEANGLE,NL ,NULL));
        string_buffer_append(result,
                             concatenate(TAB, OPENANGLE, SLASH, "array", CLOSEANGLE, NL, NULL));
 
      }
  }
}

References CAR, CDR, CLOSEANGLE, code_declarations, concatenate(), DIMENSION, dimension_lower, dimension_upper, ENDP, ENTITY, entity_initial, entity_type, entity_undefined, entity_user_name(), expression_integer_value(), int2a(), intptr_t, module, NL, OPENANGLE, pips_user_error, QUOTE, SLASH, string_buffer_append(), TAB, type_variable, value_code, variable_dimensions, variable_entity_dimension(), variable_p(), XML_ARRAY_PREFIX, and XML_RL.

Referenced by xml_code().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_declarations_with_explicit_motif()

static string xml_declarations_with_explicit_motif ( entity  module, bool(*)(entity)  consider_this_entity, string  separator, bool  lastsep  )

static

Definition at line 407 of file xml_prettyprinter.c.

{
  string result = strdup("");
  code c;
  bool first = true;
 
  pips_assert("it is a code", value_code_p(entity_initial(module)));
 
  c = value_code(entity_initial(module));
  MAP(ENTITY, var,
      {
        debug(2, "\n Prettyprinter declaration for variable :",xml_entity_local_name(var));
        if (consider_this_entity(var))
          {
            string old = strdup(result);
            string svar = strdup(this_entity_xmldeclaration(var));
            result = strdup(concatenate(old, !first && !lastsep? separator: "",
                                        svar, lastsep? separator: "", NULL));
            free(old);
            free(svar);
            first = false;
          }
      },code_declarations(c));
  return result;
}

References code_declarations, concatenate(), debug(), ENTITY, entity_initial, free(), MAP, module, pips_assert, strdup(), this_entity_xmldeclaration(), value_code, value_code_p, and xml_entity_local_name().

Referenced by xml_code_string().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_dim_string()

static string xml_dim_string ( list  ldim, string  name  )

static

Definition at line 311 of file xml_prettyprinter.c.

{
  string result = "";
  int nbdim = 0;
  string origins = "origins = list<integer>(";
  string dimensions = "dimSizes = list<integer>(";
  string deuxpoints = " :: ";
  string data_array = "DATA_ARRAY(";
  string data_decl = "name = symbol!(";
  string dimstring = "dim = ";
  string datatype = "dataType = INTEGER)";
  string name4p = name;
  string * namep = malloc(sizeof(string));
  int * nbdimptr = malloc(sizeof(int));
  *namep = name4p;
  if (ldim)
    {
      result = strdup(concatenate(name, deuxpoints, data_array, data_decl, QUOTE, name, QUOTE, CLOSEPAREN, COMMA, NL, NULL));
      result = strdup(concatenate(result, TAB, dimstring, NULL));
      MAP(DIMENSION, dim, {
          expression elow = dimension_lower(dim);
          expression eup = dimension_upper(dim);
 
          intptr_t low;
          intptr_t up;
          nbdim++;
          if (expression_integer_value(elow, &low)){
            if(nbdim != 1)
              origins = strdup(concatenate(origins, COMMA ,int2a(low), NULL));
            else
              origins = strdup(concatenate(origins, int2a(low), NULL));
          }
          else pips_user_error("Array origins must be integer\n");
 
          if (expression_integer_value(eup, &up)){
            if(nbdim != 1)
              dimensions = strdup(concatenate(dimensions, COMMA ,int2a(up-low+1), NULL));
            else
              dimensions = strdup(concatenate(dimensions, int2a(up-low+1), NULL));
          }
          else pips_user_error("Array dimensions must be integer\n");
        }, ldim);
      *nbdimptr = nbdim;
      gen_array_append(array_dims, nbdimptr);
      gen_array_append(array_names, namep);
      result = strdup(concatenate(result, int2a(nbdim), COMMA, NL, NULL));
      result = strdup(concatenate(result, TAB, origins, CLOSEPAREN, COMMA, NL, NULL));
      result = strdup(concatenate(result, TAB, dimensions, CLOSEPAREN, COMMA, NL, NULL));
      result = strdup(concatenate(result, TAB, datatype, NL, NL, NULL));
    }
  return result;
}

References array_dims, array_names, CLOSEPAREN, COMMA, concatenate(), DIMENSION, dimension_lower, dimension_upper, expression_integer_value(), gen_array_append(), int2a(), intptr_t, malloc(), MAP, NL, pips_user_error, QUOTE, strdup(), and TAB.

Referenced by this_entity_xmldeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_entity_local_name()

static string xml_entity_local_name ( entity  var )

static

Delete all the prefixes

switch to upper cases...

Definition at line 196 of file xml_prettyprinter.c.

{
  const char* name;
 
  if (current_module_is_a_function() &&
      var != get_current_module_entity() &&
      same_string_p(entity_local_name(var),
                    entity_local_name(get_current_module_entity())))
    name = RESULT_NAME;
  else
    {
      name = entity_local_name(var);
 
      /* Delete all the prefixes */
 
      if (strstr(name,STRUCT_PREFIX) != NULL)
        name = strstr(name,STRUCT_PREFIX) + 1;
      if (strstr(name,UNION_PREFIX) != NULL)
        name = strstr(name,UNION_PREFIX) + 1;
      if (strstr(name,ENUM_PREFIX) != NULL)
        name = strstr(name,ENUM_PREFIX) + 1;
      if (strstr(name,TYPEDEF_PREFIX) != NULL)
        name = strstr(name,TYPEDEF_PREFIX) + 1;
      if (strstr(name,MEMBER_SEP_STRING) != NULL)
        name = strstr(name,MEMBER_SEP_STRING) + 1;
    }
 
  /* switch to upper cases... */
  char *rname=strupper(strdup(name),name);
  return rname;
}

References current_module_is_a_function, entity_local_name(), ENUM_PREFIX, get_current_module_entity(), MEMBER_SEP_STRING, RESULT_NAME, same_string_p, strdup(), STRUCT_PREFIX, strupper(), TYPEDEF_PREFIX, and UNION_PREFIX.

Referenced by xml_array_in_task(), xml_call_from_assignation(), xml_call_from_indice(), xml_call_from_loopnest(), xml_declarations_with_explicit_motif(), xml_loop_from_loop(), xml_loop_from_sequence(), and xml_reference_with_explicit_motif().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_expression()

static string xml_expression ( expression  e )

static

forward declaration

Definition at line 262 of file xml_prettyprinter.c.

{
  string result = string_undefined;
  syntax s = expression_syntax(e);
 
  switch (syntax_tag(s))
    {
    case is_syntax_reference:
      result = xml_reference_with_explicit_motif(syntax_reference(s));
      break;
    case is_syntax_call: {
      value ev = EvalExpression(e);
      constant ec = value_constant(ev);
      int eiv = 0;
 
      if(!value_constant_p(ev)) {
        pips_user_error("Constant expected for XML loop bounds.\n");
      }
      if(!constant_int_p(ec)) {
        pips_user_error("Integer constant expected for XML loop bounds.\n");
      }
      eiv = constant_int(ec);
      result = strdup(i2a(eiv));
      break;
    }
    default:
      pips_internal_error("unexpected syntax tag");
    }
  return result;
}

References constant_int, constant_int_p, EvalExpression(), expression_syntax, i2a(), is_syntax_call, is_syntax_reference, pips_internal_error, pips_user_error, strdup(), string_undefined, syntax_reference, syntax_tag, value_constant, value_constant_p, and xml_reference_with_explicit_motif().

Referenced by xml_loop_from_loop(), xml_loop_from_sequence(), and xml_reference_with_explicit_motif().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_FormalVariables()

static void xml_FormalVariables ( entity  module, transformer  t, Psysteme  prec, string_buffer  sb_result  )

static

Definition at line 3934 of file xml_prettyprinter.c.

{
  // gen_length(functional_results(type_functional(entity_type(module))))
  int FormalParameterNumber = (int) gen_length(module_formal_parameters(module));
  entity FormalArrayName = entity_undefined;
  int ith ;
  if(FormalParameterNumber >=1) {
    string_buffer_append_word("FormalVariables",sb_result);
    global_margin++;
 
    for (ith=1;ith<=FormalParameterNumber;ith++) {
      FormalArrayName = find_ith_formal_parameter(module,ith);
      if (type_variable_p(entity_type(FormalArrayName))
          &&  (storage_formal_p(entity_storage(FormalArrayName)))) {
        if (variable_entity_dimension(FormalArrayName)>0)
          xml_Array(FormalArrayName,t, prec, true, sb_result);
        else xml_Scalar(FormalArrayName,prec,sb_result);
      }
    }
    global_margin--;
    string_buffer_append_word("/FormalVariables",sb_result);
  }
  else string_buffer_append_word("FormalVariables/",sb_result);
}

References entity_storage, entity_type, entity_undefined, find_ith_formal_parameter(), gen_length(), global_margin, int, module, module_formal_parameters(), storage_formal_p, string_buffer_append_word(), type_variable_p, variable_entity_dimension(), xml_Array(), and xml_Scalar().

Referenced by xml_Boxes(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Full_Type()

static void xml_Full_Type ( type  pt, int  max_step, string_buffer  type_result  )

static

Definition at line 2866 of file xml_prettyprinter.c.

{
  if (max_step>=0) {
    switch (type_tag(pt)) {
    case is_type_variable: {
      variable vt1 = type_variable(pt);
      basic bt1 = variable_basic(vt1);
      list lt1 = variable_dimensions(vt1);
      //DEBUG- if ((int)gen_length(lt1)>0)      printf("ARRAY_DIMENSION= %d ", (int)gen_length(lt1));
 
      global_margin++;
 
      if ((int)gen_length(lt1)>0) {
        add_margin(global_margin,type_result);
        string_buffer_append(type_result,
                             concatenate(OPENANGLE,
                                         "ArrayType Dimension = ",QUOTE,i2a((int)gen_length(lt1)),QUOTE,
                                         CLOSEANGLE,NL,NULL));
      }
      if(basic_typedef_p(bt1)) {
        entity e1 = basic_typedef(bt1);
        //DEBUG- printf("TYPEDEF %s \n",basic_to_string(bt1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result,
                             concatenate(OPENANGLE,
                                         "Typedef Name= ",QUOTE,basic_to_string(bt1),QUOTE,CLOSEANGLE,NL,NULL));
        xml_Full_Type(entity_type(e1),max_step-1,type_result);
        string_buffer_append_word("/Typedef",type_result);
      }
      else if(basic_pointer_p(bt1)) {
        type pt1 = basic_pointer(bt1);
        //DEBUG- printf("POINTER %s\n",basic_to_string(bt1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result, concatenate(
          OPENANGLE, "Pointer Name = ", QUOTE, basic_to_string(bt1), QUOTE,
          CLOSEANGLE,NL,NULL));
        xml_Full_Type(pt1,max_step-1,type_result);
        string_buffer_append_word("/Pointer",type_result);
      }
      else if(basic_derived_p(bt1)) {
        entity e1 = basic_derived(bt1);
        //DEBUG- printf("DERIVED  %s \n", basic_to_string(bt1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result, concatenate(OPENANGLE,
                                         "Derived Name= ",QUOTE,basic_to_string(bt1),QUOTE,CLOSEANGLE,NL, NULL));
        xml_Full_Type(entity_type(e1),max_step-1,type_result);
        string_buffer_append_word("/Derived",type_result);
      }
      else  { // int, float, logical, overload, complex, string, bit ==> nothing to do
        add_margin(global_margin,type_result);
        string_buffer_append(type_result,
                             concatenate(OPENANGLE,"Basic",CLOSEANGLE,
                                         basic_to_string(bt1),
                                         OPENANGLE,"/Basic",CLOSEANGLE,NL, NULL));
        //DEBUG- printf("BASIC  %s \n", basic_to_string(bt1));
      }
      if ((int)gen_length(lt1)>0)
        string_buffer_append_word("/ArrayType",type_result);
      global_margin--;
      break;
    }
 
    case is_type_struct: {
      list fe1 = type_struct(pt);
      global_margin++;
      string_buffer_append_word("Struct",type_result);
      FOREACH(ENTITY, fee1, fe1){
        global_margin++;
        //DEBUG- printf("field %s \n",entity_user_name(fee1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result, concatenate(
          OPENANGLE, "Field Name= ",QUOTE,entity_user_name(fee1),QUOTE,BL,
          CLOSEANGLE,NL,NULL));
        xml_Full_Type(entity_type(fee1),max_step-1,type_result);
        string_buffer_append_word("/Field",type_result);
        global_margin--;
      }
      string_buffer_append_word("/Struct",type_result);
      global_margin--;
      break;
    }
    case is_type_union: {
      list fe1 = type_union(pt);
      global_margin++;
      string_buffer_append_word("Union",type_result);
      FOREACH(ENTITY, fee1, fe1){
        global_margin++;
        //DEBUG- printf("field %s \n",entity_user_name(fee1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result,
                             concatenate(OPENANGLE,"Field Name= ",QUOTE,entity_user_name(fee1),QUOTE,BL,CLOSEANGLE,NL,NULL));
        xml_Full_Type(entity_type(fee1),max_step-1,type_result);
        string_buffer_append_word("/Field",type_result);
        global_margin--;
      }
      string_buffer_append_word("/Union",type_result);
      global_margin--;
      break;
    }
    case is_type_enum: {
      list fe1 = type_enum(pt);
      global_margin++;
      string_buffer_append_word("Enum",type_result);
      FOREACH(ENTITY, fee1, fe1){
        global_margin++;
        //DEBUG- printf("field %s \n",entity_user_name(fee1));
        add_margin(global_margin,type_result);
        string_buffer_append(type_result,
                             concatenate(OPENANGLE,"Field Name= ",QUOTE,entity_user_name(fee1),QUOTE,BL,CLOSEANGLE,NL,NULL));
        xml_Full_Type(entity_type(fee1),max_step-1,type_result);
        string_buffer_append_word("/Field",type_result);
        global_margin--;
      }
      string_buffer_append_word("/Enum",type_result);
      global_margin--;
      break;
    }
    default: // void(not here), unknown(not here), varargs (to be added?), functional (not here), statement(not here), area (not here)
      {  //printf("Not implemented\n");
        max_step=-1;
      }
      return;
    }
  }
}

References add_margin(), basic_derived, basic_derived_p, basic_pointer, basic_pointer_p, basic_to_string(), basic_typedef, basic_typedef_p, BL, CLOSEANGLE, concatenate(), ENTITY, entity_type, entity_user_name(), FOREACH, gen_length(), global_margin, i2a(), is_type_enum, is_type_struct, is_type_union, is_type_variable, NL, OPENANGLE, QUOTE, string_buffer_append(), string_buffer_append_word(), type_enum, type_struct, type_tag, type_union, type_variable, variable_basic, and variable_dimensions.

Referenced by xml_Type_Entity().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_GlobalVariables()

static void xml_GlobalVariables ( transformer  t, Psysteme  prec, bool  printp, string_buffer  sb_result  )

static

Definition at line 3831 of file xml_prettyprinter.c.

{
  list ldecl;
  int nb_dim=0;
 
  Pvecteur v_already_seen=VECTEUR_NUL;
  statement s = get_current_module_statement();
  cumulated_list = NIL;
  gen_recurse(s, statement_domain, gen_true, cumul_effects_of_statement);
 
  ldecl = statement_declarations(s);
  MAP(ENTITY,var, {
      vect_add_elem(&v_already_seen,var,1);
    },ldecl);
  if((int) gen_length( cumulated_list) >0) {
    string_buffer_append_word("GlobalVariables",sb_result);
    global_margin++;
    MAP(EFFECT,ef, {
        reference ref = effect_any_reference(ef);
        entity v = reference_variable(ref);
        if (type_variable_p(entity_type(v))
            && !effects_package_entity_p(v) && !std_file_entity_p(v) && !variable_heap_p(v)
            &&  (storage_ram_p(entity_storage(v)))
            && top_level_entity_p(v)
            && !storage_formal_p(entity_storage(v))
            && !vect_coeff(v,v_already_seen)) {
          vect_add_elem(&v_already_seen,v,1);
          if (printp) {
            if ((nb_dim = variable_entity_dimension(v))>0)
              xml_Array(v,t,prec,false,sb_result);
            else xml_Scalar(v,prec,sb_result);
          }
        }
      }, cumulated_list);
    global_application_variables=vect_copy(v_already_seen);
    vect_rm(v_already_seen);
    global_margin--;
    string_buffer_append_word("/GlobalVariables",sb_result);
  }
  else
    string_buffer_append_word("GlobalVariables/",sb_result);
}

References cumul_effects_of_statement(), cumulated_list, EFFECT, effect_any_reference, effects_package_entity_p(), ENTITY, entity_storage, entity_type, gen_length(), gen_recurse, gen_true(), get_current_module_statement(), global_application_variables, global_margin, MAP, NIL, ref, reference_variable, statement_declarations, statement_domain, std_file_entity_p(), storage_formal_p, storage_ram_p, string_buffer_append_word(), top_level_entity_p(), type_variable_p, variable_entity_dimension(), variable_heap_p(), vect_add_elem(), vect_coeff(), vect_copy(), vect_rm(), VECTEUR_NUL, xml_Array(), and xml_Scalar().

Referenced by xml_Application(), xml_Boxes(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Library()

static void xml_Library ( string_buffer  sb_result )

static

Definition at line 2040 of file xml_prettyprinter.c.

{
  string_buffer_append_word("Library",sb_result);
  string_buffer_append_word("/Library",sb_result);
}

References string_buffer_append_word().

Referenced by xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_LocalVariables()

static void xml_LocalVariables ( entity  module, transformer  t, Psysteme  prec, string_buffer  sb_result  )

static

Definition at line 3882 of file xml_prettyprinter.c.

{
  list ldecl;
  int nb_dim=0;
  Pvecteur pv_dec= vect_new(TCST,1);
  statement s = get_current_module_statement();
  if (fortran_appli)
    ldecl = code_declarations(value_code(entity_initial(module)));
  else
    ldecl = statement_declarations(s);
 
  if((int) gen_length(ldecl) >0) {
    string_buffer_append_word("LocalVariables",sb_result);
    global_margin++;
    MAP(ENTITY,var, {
        if (type_variable_p(entity_type(var))
            //&& ((nb_dim = variable_entity_dimension(var))>0)
            &&  !(storage_formal_p(entity_storage(var)))) {
          if ((nb_dim = variable_entity_dimension(var))>0)
            xml_Array(var,t, prec,false,sb_result);
          else xml_Scalar(var,prec,sb_result);
          vect_add_elem(&pv_dec,(Variable)var,1);
        }
      },ldecl);
    local_declaration_list =NIL;
    gen_recurse(s,statement_domain,gen_true,store_local_array_declaration);
    //    printf("list tableaux locaux pour module %s\n",entity_user_name(module));
    //    MAP(ENTITY,var, {
    //  printf("Entity = %s\n",entity_user_name(var));
    //      },local_declaration_list);
 
    MAP(ENTITY,var, {
        if (type_variable_p(entity_type(var))
            // && (variable_entity_dimension(var)>0)
            &&  !(storage_formal_p(entity_storage(var)))
            && !vect_coeff(var,pv_dec)) {
          if ((nb_dim = variable_entity_dimension(var))>0)
            xml_Array(var,t, prec,false,sb_result);
          else xml_Scalar(var,prec,sb_result);
          vect_add_elem(&pv_dec,(Variable)var,1);
        }
      },local_declaration_list);
 
    global_margin--;
    string_buffer_append_word("/LocalVariables",sb_result);
    local_application_variables=vect_copy(pv_dec);
  }
  else
    string_buffer_append_word("LocalVariables/",sb_result);
  vect_rm(pv_dec);
}

References code_declarations, ENTITY, entity_initial, entity_storage, entity_type, fortran_appli, gen_length(), gen_recurse, gen_true(), get_current_module_statement(), global_margin, local_application_variables, local_declaration_list, MAP, module, NIL, statement_declarations, statement_domain, storage_formal_p, store_local_array_declaration(), string_buffer_append_word(), TCST, type_variable_p, value_code, variable_entity_dimension(), vect_add_elem(), vect_coeff(), vect_copy(), vect_new(), vect_rm(), xml_Array(), and xml_Scalar().

Referenced by xml_Boxes(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_loop()

static void xml_loop ( stack  st, string_buffer  result  )

static

Definition at line 1420 of file xml_prettyprinter.c.

{
  string_buffer_append(result,concatenate(TAB,SPACE, OPENANGLE, "outLoop", CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, OPENANGLE, "loopNest", CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, SPACE, OPENANGLE, "bounds", CLOSEANGLE, NL, NULL));
 
  STACK_MAP_X(s, statement,
              {
                loop l = instruction_loop(statement_instruction(s));
                expression el =range_lower(loop_range(l));
                expression eu =range_upper(loop_range(l));
                expression new_eu= expression_plusplus(eu);
 
                string_buffer_append(result,
                                     concatenate(TAB,SPACE,SPACE,SPACE,SPACE,OPENANGLE,"bound idx =",QUOTE,entity_user_name(loop_index(l)),QUOTE,NULL));
                string_buffer_append(result,
                                     concatenate(SPACE, "lower =",QUOTE,expression_to_string(el),QUOTE,NULL));
                string_buffer_append(result,
                                     concatenate(SPACE, "upper =", QUOTE, expression_to_string(new_eu),QUOTE, SLASH, CLOSEANGLE,NL,NULL));
              },
              st, 0);
 
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, SPACE,  OPENANGLE,SLASH "bounds", CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, OPENANGLE,SLASH, "loopNest", CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE,  OPENANGLE, SLASH, "openLoop", CLOSEANGLE, NL, NULL));
}

References CLOSEANGLE, concatenate(), entity_user_name(), expression_plusplus(), expression_to_string(), instruction_loop, loop_index, loop_range, NL, OPENANGLE, QUOTE, range_lower, range_upper, SLASH, SPACE, STACK_MAP_X, statement_instruction, string_buffer_append(), and TAB.

Referenced by xml_task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Loop()

static void xml_Loop ( statement  s, string_buffer  sb_result  )

static

Definition at line 4004 of file xml_prettyprinter.c.

{
  loop l = instruction_loop(statement_instruction(s));
  transformer t = load_statement_precondition(s);
  Psysteme prec = sc_dup((Psysteme) predicate_system(transformer_relation(t)));
  expression el =range_lower(loop_range(l));
  expression eu =range_upper(loop_range(l));
  expression stride = range_increment(loop_range(l));
  entity index =loop_index(l);
 
  push_statement_on_statement_global_stack(s);
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "Loop Index=",QUOTE, NULL));
  string_buffer_append_xml_text(sb_result, (string) entity_user_name(index),false);
  string_buffer_append(sb_result,
                       concatenate(QUOTE, BL,
                                   "ExecutionMode=",QUOTE,
                                   (execution_parallel_p(loop_execution(l)))? "PARALLEL":"SEQUENTIAL", QUOTE,
                                   CLOSEANGLE,NL,NULL));
  xml_Bounds_and_Stride(el,eu,stride,t,prec, false,sb_result);
  string_buffer_append_word("/Loop",sb_result);
  pop_statement_global_stack();
 sc_free(prec);
}

References add_margin(), BL, CLOSEANGLE, concatenate(), entity_user_name(), execution_parallel_p, global_margin, instruction_loop, load_statement_precondition(), loop_execution, loop_index, loop_range, NL, OPENANGLE, pop_statement_global_stack(), predicate_system, push_statement_on_statement_global_stack(), QUOTE, range_increment, range_lower, range_upper, sc_dup(), sc_free(), statement_instruction, string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), transformer_relation, and xml_Bounds_and_Stride().

Referenced by xml_Loops().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_loop_from_loop()

static call xml_loop_from_loop ( loop  l, string *  result, int  task_number  )

static

printf("%i %i\n", u, low);

Definition at line 886 of file xml_prettyprinter.c.

                                                                        {
 
  string * up = malloc(sizeof(string));
  string * xml_name = malloc(sizeof(string));
  statement s = loop_body(l);
  instruction i = statement_instruction(s);
  int u, low;
  expression incr_e = range_increment(loop_range(l));
  syntax incr_s = expression_syntax(incr_e);
 
  if(!syntax_call_p(incr_s) ||
     strcmp( entity_local_name(call_function(syntax_call(incr_s))), "1") != 0 ) {
    pips_user_error("Loop increments must be constant \"1\".\n");
  }
 
  u = atoi(xml_expression(range_upper(loop_range(l))));
  low = atoi(xml_expression(range_lower(loop_range(l))));
  /*  printf("%i %i\n", u, low); */
  *up = strdup(int2a(u - low+1));
  //*up = xml_expression(range_upper(loop_range(l)) - range_lower(loop_range(l)) + 1);
  *xml_name = xml_entity_local_name(loop_index(l));
  if( (*xml_name)[0] == 'M'){
    gen_array_append(intern_indices_array, xml_name);
    gen_array_append(intern_upperbounds_array, up);
  }
  else{
    gen_array_append(extern_indices_array, xml_name);
    gen_array_append(extern_upperbounds_array, up);
  }
 
  switch(instruction_tag(i)){
  case is_instruction_loop:{
    loop l = instruction_loop(i);
    return xml_loop_from_loop(l, result, task_number);
    break;
  }
  case is_instruction_call: {
    call c = instruction_call(i);
    return c;
  }
  case is_instruction_sequence:
  {
    call c = sequence_call(instruction_sequence(i));
    loop l = sequence_loop(instruction_sequence(i));
    if (!call_undefined_p(c))
      return c;
    if (!loop_undefined_p(l))
      return xml_loop_from_loop(l, result, task_number);
    pips_user_error("A sequence should only contain a call or a loop");
  }
  default:
    pips_user_error("Only loops and calls allowed in a loop.");
  }
  return call_undefined;
}

References call_function, call_undefined, call_undefined_p, entity_local_name(), expression_syntax, extern_indices_array, extern_upperbounds_array, gen_array_append(), instruction_call, instruction_loop, instruction_sequence, instruction_tag, int2a(), intern_indices_array, intern_upperbounds_array, is_instruction_call, is_instruction_loop, is_instruction_sequence, loop_body, loop_index, loop_range, loop_undefined_p, malloc(), pips_user_error, range_increment, range_lower, range_upper, sequence_call(), sequence_loop(), statement_instruction, strdup(), syntax_call, syntax_call_p, xml_entity_local_name(), and xml_expression().

Referenced by xml_loop_from_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_loop_from_sequence()

static string xml_loop_from_sequence ( loop  l, int  task_number  )

static

We enter a loop nest.

The first loop must be an extern loop.

Initialize result string with the declaration of the task

(re-)initialize task-scoped arrays

The sequence should contain only one meaningful call

External loop nest depth

add external upperbounds

add external indices names

Definition at line 944 of file xml_prettyprinter.c.

                                                             {
  statement s = loop_body(l);
  call c= call_undefined;
  int i;
  string * taskname = (string *)(malloc(sizeof(string)));
  expression incr_e = range_increment(loop_range(l));
  syntax incr_s = expression_syntax(incr_e);
 
 
  /* Initialize result string with the declaration of the task */
  string result;
 
  instruction ins = statement_instruction(s);
  string * name = malloc(sizeof(string));
  string * up = malloc(sizeof(string));
  int u, low;
  if(!syntax_call_p(incr_s) ||
     strcmp( entity_local_name(call_function(syntax_call(incr_s))), "1") != 0 ) {
    pips_user_error("Loop increments must be constant \"1\".\n");
  }
 
 
  *taskname = strdup(concatenate("T_", int2a(task_number), NULL));
  result = strdup(concatenate(*taskname,
                              " :: TASK(unitSpentTime = vartype!(1),"
                              NL, TAB, "exLoopNest = LOOPNEST(deep = ", NULL));
  gen_array_append(tasks_names, taskname);
  /* (re-)initialize task-scoped arrays*/
  extern_indices_array = gen_array_make(0);
  intern_indices_array = gen_array_make(0);
  extern_upperbounds_array = gen_array_make(0);
  intern_upperbounds_array = gen_array_make(0);
 
  *name = xml_entity_local_name(loop_index(l));
  u = atoi(xml_expression(range_upper(loop_range(l))));
  low = atoi(xml_expression(range_lower(loop_range(l))));
  *up = strdup(int2a(u - low+1));
  //*up = xml_expression(range_upper(loop_range(l)) - range_lower(loop_range(l)) + 1);
 
  if((*name)[0] == 'M'){
    pips_user_error("At least one extern loop is needed.\n");
  }
  else{
    gen_array_append(extern_indices_array, name);
    gen_array_append(extern_upperbounds_array, up);
  }
 
 
  switch(instruction_tag(ins)){
  case is_instruction_loop:{
    loop l = instruction_loop(ins);
    c = xml_loop_from_loop(l, &result, task_number);
    break;
  }
  case is_instruction_call:
    {
      c = instruction_call(ins);
    }
    break;
  case is_instruction_sequence:
    /* The sequence should contain only one meaningful call */
    if(!call_undefined_p(c=sequence_call(instruction_sequence(ins))))
      break;
    if(!loop_undefined_p(l=sequence_loop(instruction_sequence(ins)))) {
      c = xml_loop_from_loop(l, &result, task_number);
      break;
    }
    pips_user_error("Sequence should contain one loop or one call");
    break;
  default:
    pips_user_error("Only loops and one significant call allowed in a loop.");
  }
 
  /* External loop nest depth */
  result = strdup(concatenate(result, int2a(gen_array_nitems(extern_upperbounds_array)), ",", NL, TAB, TAB, NULL));
 
  /* add external upperbounds */
  result = strdup(concatenate(result, "upperBound = list<VARTYPE>(", NULL));
 
  for(i=0; i< ((int) gen_array_nitems(extern_upperbounds_array)) - 1; i++){
    result = strdup(concatenate(result, "vartype!(", *((string *)(gen_array_item(extern_upperbounds_array, i))), "), ", NULL));
  }
  result = strdup(concatenate(result, "vartype!(",*((string *)(gen_array_item(extern_upperbounds_array, i))), ")),",NL, TAB, TAB, NULL));
 
  /* add external indices names*/
  result = strdup(concatenate(result, "names = list<string>(", NULL));
  for(i=0; i<((int) gen_array_nitems(extern_indices_array)) - 1; i++){
    result = strdup(concatenate(result, QUOTE, *((string *)(gen_array_item(extern_indices_array, i))), QUOTE ", ", NULL));
  }
  result = strdup(concatenate(result, QUOTE, *((string *)(gen_array_item(extern_indices_array, i))), QUOTE, ")),", NL, TAB, NULL));
 
  result = strdup(concatenate(result, xml_call_from_loopnest(c, task_number), NULL));
 
  gen_array_free(extern_indices_array);
  gen_array_free(intern_indices_array);
  gen_array_free(extern_upperbounds_array);
  gen_array_free(intern_upperbounds_array);
  result = strdup(concatenate(result, NL, NULL));
  return result;
}

References call_function, call_undefined, call_undefined_p, concatenate(), entity_local_name(), expression_syntax, extern_indices_array, extern_upperbounds_array, gen_array_append(), gen_array_free(), gen_array_item(), gen_array_make(), gen_array_nitems(), instruction_call, instruction_loop, instruction_sequence, instruction_tag, int, int2a(), intern_indices_array, intern_upperbounds_array, is_instruction_call, is_instruction_loop, is_instruction_sequence, loop_body, loop_index, loop_range, loop_undefined_p, malloc(), NL, pips_user_error, QUOTE, range_increment, range_lower, range_upper, sequence_call(), sequence_loop(), statement_instruction, strdup(), syntax_call, syntax_call_p, TAB, tasks_names, xml_call_from_loopnest(), xml_entity_local_name(), xml_expression(), and xml_loop_from_loop().

Referenced by xml_statement_from_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_LoopOffset()

static void xml_LoopOffset ( list  ActualArrayInd, int  ActualArrayDim, Pvecteur  loop_indices, string_buffer  sb_result  )

static

Definition at line 4461 of file xml_prettyprinter.c.

{
  Pmatrix mat;
  Pvecteur loop_indices2 = vect_reversal(loop_indices);
  int nestloop_dim = vect_size(loop_indices2);
  Pvecteur pv, pv2;
  int i,j;
 
  string_buffer_append_word("LoopOffset",sb_result);
  mat = matrix_new(ActualArrayDim,nestloop_dim);
  matrix_init(mat,ActualArrayDim,nestloop_dim);
  i=1;
  MAP(EXPRESSION, e , {
      pv = (Pvecteur)normalized_linear(expression_normalized(e));
      for (pv2 = loop_indices2, j=1; !VECTEUR_NUL_P(pv2);pv2=pv2->succ,j++)
        MATRIX_ELEM(mat,i,j)=vect_coeff(pv2->var,pv);
      i++;
    },
    ActualArrayInd);
 
  xml_Matrix(mat,ActualArrayDim,nestloop_dim,sb_result);
  string_buffer_append_word("/LoopOffset",sb_result);
}

References EXPRESSION, expression_normalized, MAP, MATRIX_ELEM, matrix_init(), matrix_new(), normalized_linear, string_buffer_append_word(), Svecteur::succ, Svecteur::var, vect_coeff(), vect_reversal(), vect_size(), VECTEUR_NUL_P, and xml_Matrix().

Referenced by xml_Argument(), and xml_AssignArgument().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Loops()

static void xml_Loops ( stack  st, bool  call_external_loop_p, list *  pattern_region, Pvecteur *  paving_indices, Pvecteur *  pattern_indices, bool  motif_in_te_p, string_buffer  sb_result  )

static

Definition at line 4031 of file xml_prettyprinter.c.

{
  bool in_motif_p=!call_external_loop_p && !motif_in_te_p;
  bool motif_on_loop_p=false;
  // Boucles externes a la TE
  if (call_external_loop_p)
    string_buffer_append_word("ExternalLoops",sb_result);
  else
    // Boucles externes au motif dans la TE
    string_buffer_append_word("Loops",sb_result);
 
  // if comment MOTIF is on the loop, the pattern_region is the loop region
  // if comment MOTIF is on a statement inside the sequence of the loop body
  // the cumulated regions of the loop body are taken
  // if comment MOTIF is outside the loop nest, the pattern_region is the call region
  global_margin++;
  if (st != STACK_NULL) {
    STACK_MAP_X(s, statement,
                {
                  loop l = instruction_loop(statement_instruction(s));
                  //string comm = statement_comments(s);
                  entity index =loop_index(l);
                  push_statement_on_statement_global_stack(s);
                  if (!in_motif_p) {
                    // Test : Motif is in the loop body  or not
                    motif_in_statement_p=false;
                    gen_recurse(loop_body(l), statement_domain, gen_true,motif_in_statement);
                    //motif_on_loop_p = !string_undefined_p(comm) && strstr(comm,"MOTIF")!=NULL;
                    motif_on_loop_p = pragma_motif_p(s);
 
                    if (motif_on_loop_p) {      // comment MOTIF  is on the Loop
                      *pattern_region = regions_dup(load_statement_local_regions(s));
                      vect_add_elem (pattern_indices,(Variable) index ,VALUE_ONE);
                    }
                    else if (motif_in_statement_p) {
                      // cumulated regions on the sequence of the loop body instructions are needed
                      *pattern_region = regions_dup(load_statement_local_regions(loop_body(l)));
                    }
                    in_motif_p =   (!call_external_loop_p && !motif_in_te_p) //Par default on englobe si TE
                      || in_motif_p        // on etait deja dans le motif
                      || motif_on_loop_p  // on vient de trouver un Motif sur la boucle
                      || (motif_in_te_p && !motif_on_loop_p && !motif_in_statement_p);
                    // motif externe au nid de boucles (cas des motif au milieu d'une sequence)
                  }
                  if (!in_motif_p) {
                    vect_add_elem (paving_indices,(Variable) index ,VALUE_ONE);
                    xml_Loop(s, sb_result);
                  }
                  (void) pop_statement_global_stack();
                },
                st, 0);
  }
  global_margin--;
  if (call_external_loop_p)
    string_buffer_append_word("/ExternalLoops",sb_result);
  else
    string_buffer_append_word("/Loops",sb_result);
}

References gen_recurse, gen_true(), global_margin, instruction_loop, load_statement_local_regions(), loop_body, loop_index, motif_in_statement(), motif_in_statement_p, pattern_indices, pop_statement_global_stack(), pragma_motif_p(), push_statement_on_statement_global_stack(), regions_dup(), STACK_MAP_X, STACK_NULL, statement_domain, statement_instruction, string_buffer_append_word(), VALUE_ONE, vect_add_elem(), and xml_Loop().

Referenced by xml_Call(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Matrix()

static void xml_Matrix ( Pmatrix  mat, int  n, int  m, string_buffer  sb_result  )

static

Definition at line 4127 of file xml_prettyprinter.c.

{
  string srow, scolumn;
  int i,j;
  // cas des nids de boucles vides
  if (n==0 && m!=0) m=0;
  if (m==0 && n!=0) n=0;
  srow =strdup(i2a(n));
  scolumn=strdup(i2a(m));
 
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "Matrix NbRows=", QUOTE,srow,QUOTE,BL,
                                   "NbColumns=", QUOTE, scolumn,QUOTE, BL,
                                   CLOSEANGLE,NL, NULL));
  for (i=1;i<=n;i++) {
    add_margin(global_margin,sb_result);
    string_buffer_append(sb_result,
                         concatenate(OPENANGLE,
                                     "Row", CLOSEANGLE,BL, NULL));
    for (j=1;j<=m;j++) {
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,"c", CLOSEANGLE,
                                       i2a(MATRIX_ELEM(mat,i,j)),
                                       OPENANGLE, "/c", CLOSEANGLE,
                                       BL, NULL));
    }
    string_buffer_append(sb_result,
                         concatenate(OPENANGLE,
                                     "/Row", CLOSEANGLE, NL, NULL));
  }
  string_buffer_append_word("/Matrix",sb_result);
}

References add_margin(), BL, CLOSEANGLE, concatenate(), global_margin, i2a(), MATRIX_ELEM, NL, OPENANGLE, QUOTE, strdup(), string_buffer_append(), and string_buffer_append_word().

Referenced by xml_Connection(), xml_ConstOffset(), xml_LoopOffset(), and xml_Transposition().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_ParameterUseToArrayBound()

static void xml_ParameterUseToArrayBound ( entity  var, string_buffer  sb_result  )

static

Definition at line 3109 of file xml_prettyprinter.c.

{
  string sdim;
  entity FormalArrayName, mod = get_current_module_entity();
  int ith, FormalParameterNumber = (int) gen_length(module_formal_parameters(mod));
  global_margin++;
  for (ith=1;ith<=FormalParameterNumber;ith++) {
    FormalArrayName = find_ith_formal_parameter(mod,ith);
    if (type_variable_p(entity_type(FormalArrayName))
        && ( variable_entity_dimension(FormalArrayName)>0)) {
      list ld, ldim = variable_dimensions(type_variable(entity_type(FormalArrayName)));
      int dim;
      for (ld = ldim, dim =1 ; !ENDP(ld); ld = CDR(ld), dim++) {
        expression elow = dimension_lower(DIMENSION(CAR(ld)));
        expression eup = dimension_upper(DIMENSION(CAR(ld)));
        //const char * low= words_to_string(words_syntax(expression_syntax(elow),NIL));
        //const char * up = words_to_string(words_syntax(expression_syntax(eup),NIL));
        //const char * sv = entity_local_name(var);
        //if ((strstr(low,sv)!=NULL) || (strstr(up,sv)!=NULL)) {
        if (entity_in_expression_p(elow,var) || entity_in_expression_p(eup,var)) {
          sdim= strdup(i2a(variable_entity_dimension(FormalArrayName)-dim+1));
          add_margin(global_margin,sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "TaskParameterUsedFor"," ArrayName=", QUOTE, NULL));
          string_buffer_append_xml_text(sb_result, (string) entity_user_name(FormalArrayName),false);
          string_buffer_append(sb_result,
                               concatenate(QUOTE, BL,
                                           //QUOTE,words_points_to_reference(FormalArrayName),QUOTE, BL,
                                           "Dim=", QUOTE,sdim,QUOTE,"/", CLOSEANGLE, NL, NULL));
        }
      }
    }
  }
  global_margin--;
}

References add_margin(), BL, CAR, CDR, CLOSEANGLE, concatenate(), DIMENSION, dimension_lower, dimension_upper, ENDP, entity_in_expression_p(), entity_type, entity_user_name(), find_ith_formal_parameter(), gen_length(), get_current_module_entity(), global_margin, i2a(), int, module_formal_parameters(), NL, OPENANGLE, QUOTE, strdup(), string_buffer_append(), string_buffer_append_xml_text(), type_variable, type_variable_p, variable_dimensions, and variable_entity_dimension().

Referenced by xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Pattern_Paving()

static void xml_Pattern_Paving ( region  reg, entity  var, bool  effet_read, Pvecteur  formal_parameters, Pvecteur  paving_indices, string_buffer  sb_result  )

static

phi = (Variable) make_phi_entity(i); if(!SC_UNDEFINED_P(ps_reg) && base_contains_variable_p(sc_base(ps_reg),phi)) { ps1 = sc_dup(ps_reg); feasible = sc_minmax_of_variable(ps1, (Variable)phi, &min, &max); if (feasible){ if (min!=VALUE_MIN) voffset = vect_new(TCST,min); if (min==max) uniqp=1; } }

PRINT PATTERN and PAVING

Definition at line 2316 of file xml_prettyprinter.c.

{
  string_buffer buffer_pattern = string_buffer_make(true);
  string_buffer buffer_paving = string_buffer_make(true);
  string string_paving = "";
  string string_pattern =  "";
  Pvecteur voffset;
 
  if(reg != region_undefined) {
    reference ref = effect_any_reference(reg);
    entity vreg = reference_variable(ref);
    if ( array_entity_p(reference_variable(ref)) && same_entity_p(vreg,var) && region_read_p(reg)== effet_read) {
      Psysteme ps_reg = sc_dup(region_system(reg));
      Pvecteur iterat= VECTEUR_NUL;
      Pvecteur iterator = VECTEUR_NUL;
      Ppattern patt=NULL;
      Pvecteur vpattern=VECTEUR_NUL;
      int dim = (int) gen_length(variable_dimensions(type_variable(entity_type(var))));
      int i ;
      int val =0;
      int inc =0;
      dimension vreg_dim = dimension_undefined;
      int mult=1;
      if (!SC_UNDEFINED_P(ps_reg))
        sc_transform_eg_in_ineg(ps_reg);
      add_margin(global_margin,buffer_pattern);
      string_buffer_append(buffer_pattern,
                           concatenate(OPENANGLE,
                                       "Pattern AccessMode=",
                                       QUOTE,(effet_read)? "USE":"DEF",QUOTE,CLOSEANGLE,NL,NULL));
      add_margin(global_margin,buffer_paving);
      string_buffer_append(buffer_paving,
                           concatenate(OPENANGLE,
                                       "Pavage AccessMode=",
                                       QUOTE,(effet_read)? "USE":"DEF",QUOTE,CLOSEANGLE,NL,NULL));
      global_margin++;
      // pour chaque dimension : generer en meme temps le pattern et le pavage
      for(i=1; i<=dim; i++) {
        int uniqp=0;
        voffset =vect_new(TCST,0);
        patt = NULL;
        //      printf("find pattern for entity %s [dim=%d]\n",entity_local_name(var),i);
        //     sc_fprint(stdout,ps_reg,(char * (*)(Variable)) entity_local_name);
        //      printf("paving_indices:\n");
        //      vect_fprint(stdout,paving_indices,(char * (*)(Variable))  entity_local_name);
 
        //find_pattern(ps_reg, paving_indices, formal_parameters, i, &bound_inf, &bound_up, &pattern_up_bound, &iterator, &mult);
        find_pattern(ps_reg, paving_indices, formal_parameters, i, &patt);
        if (patt !=NULL) {
          vpattern=patt->diff;
          iterator= patt->lind;
          mult = patt->cl_coeff;
          uniqp=patt->unitp;
          voffset = patt->lower;
        }
        else
          {
            vpattern=VECTEUR_NUL;
            iterator = VECTEUR_NUL;
          }
 
        //      printf("pattern_bound:\n");
        //if (!VECTEUR_NUL_P(vpattern))
        //  vect_fprint(stdout,vpattern,(char * (*)(Variable))  entity_local_name);
        /*      phi = (Variable) make_phi_entity(i);
        if(!SC_UNDEFINED_P(ps_reg) && base_contains_variable_p(sc_base(ps_reg),phi)) {
          ps1 = sc_dup(ps_reg);
          feasible = sc_minmax_of_variable(ps1, (Variable)phi, &min, &max);
          if (feasible){
            if (min!=VALUE_MIN)
              voffset = vect_new(TCST,min);
            //  if (min==max)
            // uniqp=1;
          }
        }
        */
 
        if (!uniqp) {
          if (VECTEUR_NUL_P(vpattern)) { // if we cannot deduce pattern length from region, array dim size is taken
            list ldim = variable_dimensions(type_variable(entity_type(vreg)));
            vreg_dim = find_ith_dimension(ldim,i);
            normalized ndim = NORMALIZE_EXPRESSION(dimension_upper(vreg_dim));
            vpattern = vect_dup((Pvecteur) normalized_linear(ndim));
            if (vpattern != VECTEUR_NUL)
              vect_add_elem(&vpattern,TCST,1);
          }
        }
        /* PRINT PATTERN and PAVING */
        //      if ((vect_zero_p(voffset)  && (!VECTEUR_NUL_P(vpattern) && vect_one_p(vpattern)))
        //      || (uniqp && vect_zero_p(voffset)))
        if (!VECTEUR_NUL_P(vpattern) && uniqp && vect_dimension(voffset)==0 && vect_coeff(TCST,voffset)==0)
          string_buffer_append_word("DimUnitPattern/",buffer_pattern);
        else {
          add_margin(global_margin,buffer_pattern);
          // A completer - choisir un indice pour le motif ?
          string_buffer_append(buffer_pattern,
                               concatenate(OPENANGLE,
                                           "DimPattern Index=",QUOTE, QUOTE,CLOSEANGLE,NL,NULL));
 
          global_margin++;
          string_buffer_append_word("Offset",buffer_pattern);
          string_buffer_append_symbolic(vect_to_string(voffset),
                                        buffer_pattern);
          if (vect_dimension(voffset)==0)
            string_buffer_append_numeric(vect_to_string(voffset),
                                         buffer_pattern);
          string_buffer_append_word("/Offset",buffer_pattern);
 
          string_buffer_append_word("Length",buffer_pattern);
 
          // The upper bound is not a complex expression
          if (uniqp) {
            string_buffer_append_symbolic(int2a(1),buffer_pattern);
            string_buffer_append_numeric(int2a(1),buffer_pattern);
          }
          else {
            if (vpattern != VECTEUR_NUL) {
              if (mult==1)
                string_buffer_append_symbolic(vect_to_string(vpattern),buffer_pattern);
              else {
                add_margin(global_margin,buffer_pattern);
                string_buffer_append(buffer_pattern,
                                     concatenate(OPENANGLE,"Symbolic",CLOSEANGLE,
                                                 "(",NULL));
                string_buffer_append_xml_text(buffer_pattern,vect_to_string(vpattern),false);
                string_buffer_append(buffer_pattern,
                                     concatenate(")",
                                                 "/",i2a(mult),"+1",
                                                 OPENANGLE,"/Symbolic",CLOSEANGLE,
                                                 NL, NULL));
              }
              
            }
            else //vpattern == VECTEUR_NUL
              two_string_buffer_append_symbolic(expression_to_string(dimension_upper(vreg_dim)), "+1",
                                                buffer_pattern);
            if ((vpattern != VECTEUR_NUL) && vect_dimension(vpattern)==0)
              string_buffer_append_numeric(vect_to_string(vpattern),
                                           buffer_pattern);
          }
          string_buffer_append_word("/Length",buffer_pattern);
 
          string_buffer_append_word("Stride",buffer_pattern);
          val =1;
          string_buffer_append_symbolic(int2a(val),buffer_pattern);
          string_buffer_append_numeric(int2a(val),buffer_pattern);
          string_buffer_append_word("/Stride",buffer_pattern);
          global_margin--;
          string_buffer_append_word("/DimPattern",buffer_pattern);
        }
        if (!VECTEUR_UNDEFINED_P(iterator) &&!VECTEUR_NUL_P(iterator)) {
          string_buffer_append_word("DimPavage",buffer_paving);
          for (iterat = paving_indices; !VECTEUR_NUL_P(iterat); iterat = iterat->succ) {
            if ((inc = vect_coeff(var_of(iterat),iterator)) !=0) {
              add_margin(global_margin,buffer_paving);
              string_buffer_append(buffer_paving,
                                   concatenate(OPENANGLE,
                                               "RefLoopIndex Name=",
                                               QUOTE,entity_user_name(var_of(iterat)),QUOTE, BL,
                                               "Inc=", QUOTE,
                                               int2a(inc),QUOTE,"/", CLOSEANGLE,NL,NULL));
            }
          }
          string_buffer_append_word("/DimPavage",buffer_paving);
        }
        else
          string_buffer_append_word("DimPavage/",buffer_paving);
      }
      global_margin--;
      string_buffer_append_word("/Pattern",buffer_pattern);
      string_buffer_append_word("/Pavage",buffer_paving);
      string_pattern = string_buffer_to_string(buffer_pattern);
      string_paving = string_buffer_to_string(buffer_paving);
      string_buffer_append(sb_result, string_pattern);
      free(string_pattern);
      string_pattern=NULL;
      string_buffer_append(sb_result, string_paving);
      free(string_paving);
      string_paving=NULL;
      xml_AccessFunction(sb_result);
      sc_free(ps_reg);
    }
  }
}

References add_margin(), array_entity_p(), BL, Spattern::cl_coeff, CLOSEANGLE, concatenate(), Spattern::diff, dimension_undefined, dimension_upper, effect_any_reference, entity_type, entity_user_name(), expression_to_string(), find_ith_dimension(), find_pattern(), free(), gen_length(), global_margin, i2a(), int, int2a(), Spattern::lind, Spattern::lower, NL, NORMALIZE_EXPRESSION, normalized_linear, OPENANGLE, QUOTE, ref, reference_variable, region_read_p, region_system, region_undefined, same_entity_p(), sc_dup(), sc_free(), sc_transform_eg_in_ineg(), string_buffer_append(), string_buffer_append_numeric(), string_buffer_append_symbolic(), string_buffer_append_word(), string_buffer_append_xml_text(), string_buffer_make(), string_buffer_to_string(), Svecteur::succ, TCST, two_string_buffer_append_symbolic(), type_variable, Spattern::unitp, var_of, variable_dimensions, vect_add_elem(), vect_coeff(), vect_dimension(), vect_dup(), vect_new(), vect_to_string(), VECTEUR_NUL, VECTEUR_NUL_P, VECTEUR_UNDEFINED_P, and xml_AccessFunction().

Referenced by xml_TaskParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_reference()

static void xml_reference ( int taskNumber   __attribute__(unused), reference  r, bool  wmode, string_buffer  result  )

static

Definition at line 1449 of file xml_prettyprinter.c.

{
 
  const char* varname = entity_user_name(reference_variable(r));
  string_buffer_append
    (result,
     concatenate(SPACE, QUOTE, XML_ARRAY_PREFIX, varname, QUOTE, SPACE, "accessMode =", QUOTE,
                 (wmode?"W":"R"),QUOTE, CLOSEANGLE,NL,
                 NULL));
}

References CLOSEANGLE, concatenate(), entity_user_name(), NL, QUOTE, reference_variable, SPACE, string_buffer_append(), and XML_ARRAY_PREFIX.

Referenced by xml_references().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_reference_with_explicit_motif()

static string xml_reference_with_explicit_motif ( reference  r )

static

Attention with Fortran: the indices are reversed.

Definition at line 242 of file xml_prettyprinter.c.

{
  string result = strdup(EMPTY), old, svar;
  MAP(EXPRESSION, e,
      {
        string s = strdup(xml_expression(e));
        old = result;
        result = strdup(concatenate(old, OPENBRACKET, s, CLOSEBRACKET, NULL));
        free(old);
        free(s);
      }, reference_indices(r));
 
  old = result;
  svar = xml_entity_local_name(reference_variable(r));
  result = strdup(concatenate(svar, old, NULL));
  free(old);
  free(svar);
  return result;
}

References CLOSEBRACKET, concatenate(), EMPTY, EXPRESSION, free(), MAP, OPENBRACKET, reference_indices, reference_variable, strdup(), xml_entity_local_name(), and xml_expression().

Referenced by xml_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_references()

static void xml_references ( int  taskNumber, list  l_regions, stack  indices, string_buffer  result  )

static

Read array references first

Definition at line 1725 of file xml_prettyprinter.c.

{
  list lr;
  bool atleast_one_read_ref = false;
  bool atleast_one_written_ref = false;
  /*   Read array references first */
  for ( lr = l_regions; !ENDP(lr); lr = CDR(lr))
    {
      region re = REGION(CAR(lr));
      reference ref = effect_any_reference(re);
      if (array_entity_p(reference_variable(ref)) && region_read_p(re)) {
        atleast_one_read_ref = true;
        string_buffer_append(result,concatenate(TAB, SPACE, SPACE, OPENANGLE,  "data darray=",NULL));
        xml_reference(taskNumber, ref,  region_write_p(re), result);
        xml_tiling(taskNumber, ref,re, indices, result);
      }
    }
  if (!atleast_one_read_ref)
    string_buffer_append(result,concatenate(TAB,SPACE, SPACE, "dummyDATA",
                                            NL,NULL));
  for ( lr = l_regions; !ENDP(lr); lr = CDR(lr))
    {
      region re = REGION(CAR(lr));
      reference ref = effect_any_reference(re);
      if (array_entity_p(reference_variable(ref)) && region_write_p(re)) {
        atleast_one_written_ref = true;
        string_buffer_append(result,concatenate(TAB, SPACE, SPACE, OPENANGLE, "data darray=",NULL));
        xml_reference(taskNumber, ref,  region_write_p(re), result);
        xml_tiling(taskNumber, ref,re, indices, result);
      }
    }
  if (!atleast_one_written_ref)
    string_buffer_append(result,concatenate(TAB,SPACE, SPACE,"dummyDATA",NL,NULL));
}

References array_entity_p(), CAR, CDR, concatenate(), effect_any_reference, ENDP, indices, NL, OPENANGLE, ref, reference_variable, region, REGION, region_read_p, region_write_p, SPACE, string_buffer_append(), TAB, xml_reference(), and xml_tiling().

Referenced by xml_data().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Region_Parameter()

static void xml_Region_Parameter ( list  pattern_region, string_buffer  sb_result  )

static

Definition at line 3013 of file xml_prettyprinter.c.

{
  list lr;
  list lrr = NIL, lrw=NIL;
  bool effet_read = true;
  reference ref;
  region reg;
  entity v;
 
  string_buffer_append_word("ReferencedParameters",sb_result);
  global_margin++;
 
  for ( lr = pattern_region; !ENDP(lr); lr = CDR(lr))
    {
      reg = REGION(CAR(lr));
      ref = effect_any_reference(reg);
      v = reference_variable(ref);
      if (store_effect_p(reg) && array_entity_p(reference_variable(ref)) && !variable_heap_p(v)
          && !(entity_static_variable_p(v) && !top_level_entity_p(v))) {
        string ts = strdup(entity_user_name(v));
        
        //      string temp2 = pointer_to_initial_name(ts);
         
        effet_read = region_read_p(reg);
        //      if ((effet_read && !string_in_list_p(ts,lrr)) || (!effet_read && !string_in_list_p(ts,lrw))) {
          if (effet_read)
            lrr = gen_nconc(lrr,CONS(STRING,ts,NIL));
          else lrw = gen_nconc(lrw,CONS(STRING,ts,NIL));
          add_margin(global_margin,sb_result);
          string_buffer_append(sb_result,
                               concatenate(OPENANGLE,
                                           "ReferencedParameter"," Name=",
                                           QUOTE,NULL));
          string_buffer_append_xml_text(sb_result,
                                        (string)((print_full_name_p() || reference_undefined_p(ref))? entity_user_name(v):words_points_to_reference(ref,false,reg)),
                                        false);
          string_buffer_append(sb_result,
                               concatenate(QUOTE, BL,"Range=",QUOTE,NULL));
          xml_Region_Range(reg, sb_result);
 
          string_buffer_append(sb_result,
                               concatenate(QUOTE, BL,
                                           "Type=", QUOTE,(entity_xml_parameter_p(v))? "CONTROL":"DATA",QUOTE,BL,
                                           "AccessMode=", QUOTE, (effet_read)? "USE":"DEF",QUOTE,BL,
                                           "ArrayP=", QUOTE, (array_entity_p(v))?"TRUE":"FALSE",QUOTE, BL,
                                           "Kind=", QUOTE,  "VARIABLE",QUOTE,"/",
                                           CLOSEANGLE
                                           NL, NULL));
         
          //    }
      }
    }
  global_margin--;
  string_buffer_append_word("/ReferencedParameters",sb_result);
  gen_free_list(lrr);
  gen_free_list(lrw);
}

References add_margin(), array_entity_p(), BL, CAR, CDR, CLOSEANGLE, concatenate(), CONS, effect_any_reference, ENDP, entity_static_variable_p(), entity_user_name(), entity_xml_parameter_p(), gen_free_list(), gen_nconc(), global_margin, NIL, NL, OPENANGLE, print_full_name_p(), QUOTE, ref, reference_undefined_p, reference_variable, region, REGION, region_read_p, store_effect_p(), strdup(), STRING, string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), top_level_entity_p(), variable_heap_p(), words_points_to_reference(), and xml_Region_Range().

Referenced by xml_Call(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Region_Range()

static void xml_Region_Range ( region  reg, string_buffer  sb_result  )

static

on peut ameliorer les resultats en projetant les egalites portant sur les variables autres que les PHI

Definition at line 2543 of file xml_prettyprinter.c.

{
  Variable phi;
  int i;
  Pcontrainte pc;
  if(reg != region_undefined) {
    reference ref = effect_any_reference(reg);
    entity vreg = reference_variable(ref);
    if (array_entity_p(reference_variable(ref))) {
      int dim = (int) gen_length(variable_dimensions(type_variable(entity_type(vreg))));
      Psysteme ps_reg = sc_dup(region_system(reg));
      /* on peut ameliorer les resultats en projetant
         les egalites portant sur les variables autres que les PHI */
      /*
        Pvecteur vva = VECTEUR_NUL;
        Variable va;
        for(pc = sc_egalites(ps_reg); pc!=NULL;pc= pc->succ)
        {
        va = vect_one_coeff_if_any(pc->vecteur);
        if (va!= NULL && strcmp(variable_name(va),"PHI")==0 ) vect_add_elem(&vva,va,1);
        }
        sc_projection_along_variables_ofl_ctrl(&ps_reg,vva , NO_OFL_CTRL);
      */
      if (!SC_UNDEFINED_P(ps_reg)) {
        sc_transform_eg_in_ineg(ps_reg);
        for (i=1;i<=dim;i++) {
          string_buffer sbi_result=string_buffer_make(true);
          string_buffer sbu_result=string_buffer_make(true);
          string string_sbi, string_sbu;
          int fub = 0;
          int fib = 0;
          phi = (Variable) make_phi_entity(i);
          string_buffer_append(sbi_result,
                               concatenate("[", NULL));
          string_buffer_append(sbu_result,
                               concatenate(";",NULL));
          for(pc = sc_inegalites(ps_reg); pc!=NULL;pc= pc->succ)
            {
              int vc = vect_coeff(phi, pc->vecteur);
              Pvecteur vvc = vect_dup(pc->vecteur);
              string sb= NULL;
              string scst;
              if (value_pos_p(vc)) { // borne sup
                vect_erase_var(&vvc,phi);
                vect_chg_sgn(vvc);
                sb = vect_to_string(vvc);
                if (vc-1)
                  scst =strdup(i2a(vc));
                if (fub++)
                  if  (vc-1)
                    string_buffer_append(sbu_result,
                                         concatenate(",(",sb, NULL));
                  else  string_buffer_append(sbu_result,
                                             concatenate(",",sb, NULL));
                else
                  if  (vc-1)
                    string_buffer_append(sbu_result,
                                         concatenate("(",sb, NULL));
                  else string_buffer_append(sbu_result,
                                            concatenate(sb, NULL));
                if (vc-1)
                  string_buffer_append(sbu_result,
                                       concatenate(")/",scst, NULL));
              }
              else if (value_neg_p(vc)) {
                vect_erase_var(&vvc,phi);
                sb = vect_to_string(vvc);
                if (vc+1) scst =strdup(i2a(-1*vc));
                if (fib++)
                  if (vc+1)
                    string_buffer_append(sbi_result,
                                         concatenate(",(",sb, NULL));
                  else string_buffer_append(sbi_result,
                                            concatenate(",",sb, NULL));
                else
                  if (vc+1)
                    string_buffer_append(sbi_result,
                                         concatenate("(",sb, NULL));
                  else   string_buffer_append(sbi_result,
                                              concatenate(sb, NULL));
                if (vc+1)
                  string_buffer_append(sbi_result,
                                       concatenate(")/",scst, NULL));
              }
            }
          string_buffer_append(sbu_result,
                               concatenate("]",NULL));
          string_sbi = string_buffer_to_string(sbi_result);
          string_sbu = string_buffer_to_string(sbu_result);
          string_buffer_append(sb_result,string_sbi);
          string_buffer_append(sb_result,string_sbu);
        }
        sc_rm(ps_reg);
      }
    }
  }
}

References array_entity_p(), concatenate(), effect_any_reference, entity_type, gen_length(), i2a(), int, make_phi_entity(), ref, reference_variable, region_system, region_undefined, sc_dup(), sc_rm(), sc_transform_eg_in_ineg(), strdup(), string_buffer_append(), string_buffer_make(), string_buffer_to_string(), Scontrainte::succ, type_variable, value_neg_p, value_pos_p, variable_dimensions, vect_chg_sgn(), vect_coeff(), vect_dup(), vect_erase_var(), vect_to_string(), and Scontrainte::vecteur.

Referenced by xml_Region_Parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Regions()

static void xml_Regions ( string_buffer sb_result   __attribute__(unused) )

static

Definition at line 2065 of file xml_prettyprinter.c.

{
  // string_buffer_append_word("Regions",sb_result);
  // string_buffer_append_word("/Regions",sb_result);
}

Referenced by xml_Task().

Here is the caller graph for this function:

xml_Returns()

static void xml_Returns ( string_buffer sb_result   __attribute__(unused) )

static

Definition at line 2046 of file xml_prettyprinter.c.

{
  //string_buffer_append_word("Returns",sb_result);
  //string_buffer_append_word("/Returns",sb_result);
}

Referenced by xml_Task().

Here is the caller graph for this function:

xml_Scalar()

static void xml_Scalar ( entity  var, _UNUSED_ Psysteme  prec, string_buffer  sb_result  )

static

Print XML Array DATA TYPE and DATA SIZE

Definition at line 3806 of file xml_prettyprinter.c.

{
  const char* datatype ="";
  int  size =0;
 
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE, "Scalar Name=", QUOTE,NULL));
  string_buffer_append_xml_text(sb_result, (string) entity_user_name(var),false);
  string_buffer_append(sb_result,
                       concatenate(QUOTE, BL,
                                   "Type=", QUOTE,(entity_xml_parameter_p(var))? "CONTROL":"DATA",QUOTE,BL,
                                   "Allocation=", QUOTE,
                                   (heap_area_p(var) || stack_area_p(var)) ? "DYNAMIC": "STATIC", QUOTE,BL,
                                   "Kind=", QUOTE,"VARIABLE",QUOTE, NULL));
  /* Print XML Array DATA TYPE and DATA SIZE */
  type_and_size_of_var(var, &datatype,&size);
  //add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(BL,
                                   "DataType=",QUOTE,datatype,QUOTE, BL,
                                   "Size=",QUOTE, int2a(size), QUOTE, "/"
                                   CLOSEANGLE,NL,NULL));
}

References add_margin(), BL, CLOSEANGLE, concatenate(), entity_user_name(), entity_xml_parameter_p(), global_margin, heap_area_p(), int2a(), NL, OPENANGLE, QUOTE, stack_area_p(), string_buffer_append(), string_buffer_append_xml_text(), and type_and_size_of_var().

Referenced by xml_FormalVariables(), xml_GlobalVariables(), and xml_LocalVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_sequence_from_task()

static string xml_sequence_from_task ( sequence  seq )

static

Concatentates each task to the final result.

The validity of the task is not checked in this function but it is into xml_statementement_from_sequence and subsequent functions.

Definition at line 1076 of file xml_prettyprinter.c.

                                                  {
  string result = "";
  int task_number = 0;
  MAP(STATEMENT, s,
      {
        string oldresult = strdup(result);
        string current = strdup(xml_statement_from_sequence(s, task_number));
 
        if(strlen(current)==0) {
          free(current);
          result = oldresult;
        }
        else {
          result = strdup(concatenate(oldresult, current, NULL));
          free(current);
          free(oldresult);
          task_number++;
        }
      }, sequence_statements(seq));
  return result;
}

References concatenate(), current, free(), MAP, sequence_statements, STATEMENT, strdup(), and xml_statement_from_sequence().

Referenced by xml_tasks_with_motif().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_statement_from_sequence()

static string xml_statement_from_sequence ( statement  s, int  task_number  )

static

We are here at the highest level of statements.

The statements are either loopnests or a RETURN instruction. Any other possibility pips_user_errors the prettyprinter.

RETURN should only be allowed as the last statement in the sequence

Definition at line 1048 of file xml_prettyprinter.c.

                                                                       {
  string result = "";
  instruction i = statement_instruction(s);
 
  switch(instruction_tag(i)){
  case is_instruction_loop:{
    loop l = instruction_loop(i);
    result = xml_loop_from_sequence(l, task_number);
    break;
  }
  case is_instruction_call:{
    /* RETURN should only be allowed as the last statement in the sequence */
    if(!return_statement_p(s) && !continue_statement_p(s))
      pips_user_error("Only RETURN and CONTINUE allowed here.\n");
    break;
  }
  default:{
    pips_user_error("Only loops and calls allowed here.\n");
  }
  }
 
  return result;
}

References continue_statement_p(), instruction_loop, instruction_tag, is_instruction_call, is_instruction_loop, pips_user_error, return_statement_p(), statement_instruction, and xml_loop_from_sequence().

Referenced by xml_sequence_from_task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Task()

static void xml_Task ( const char *  module_name, int  code_tag, string_buffer  sb_result  )

static

On ne traite qu'une TE : un seul nid de boucles

Definition at line 4355 of file xml_prettyprinter.c.

{
  nest_context_t task_loopnest;
  task_loopnest.loops_for_call = stack_make(statement_domain,0,0);
  task_loopnest.loop_indices = stack_make(entity_domain,0,0);
  task_loopnest.current_stat = stack_make(statement_domain,0,0);
  task_loopnest.testif = stack_make(statement_domain,0,0);
  task_loopnest.nested_loops=  gen_array_make(0);
  task_loopnest.nested_loop_indices =  gen_array_make(0);
  task_loopnest.nested_call=  gen_array_make(0);
  task_loopnest.nested_if=  gen_array_make(0);
  stack nested_loops;
  list pattern_region =NIL;
  Pvecteur paving_indices = VECTEUR_NUL;
  Pvecteur pattern_indices = VECTEUR_NUL;
  bool motif_in_te_p = false;
  entity module = module_name_to_entity(module_name);
  Psysteme prec;
  transformer t;
  statement stat_module=(statement) db_get_memory_resource(DBR_CODE,
                                                           module_name, true);
  push_statement_on_statement_global_stack(stat_module);
  reset_rw_effects();
  set_rw_effects
    ((statement_effects)
     db_get_memory_resource(DBR_REGIONS, module_name, true));
 
  push_current_module_statement(stat_module);
  t = first_precondition_of_module(module_name,&prec);
  global_margin++;
  add_margin(global_margin,sb_result);
  string_buffer_append(sb_result,
                       concatenate(OPENANGLE,
                                   "Task Name=",QUOTE,
                                   module_name,QUOTE,CLOSEANGLE,NL, NULL));
  global_margin++;
 
  find_loops_and_calls_in_box(stat_module,&task_loopnest);
  pattern_region = regions_dup(load_statement_local_regions(stat_module));
 
  xml_Library(sb_result);
  xml_Returns(sb_result);
  xml_Timecosts(sb_result);
  xml_GlobalVariables(t,prec,true,sb_result);
  xml_LocalVariables(module,t, prec,sb_result);
  xml_FormalVariables(module,t,prec,sb_result);
  /*  On ne traite qu'une TE : un seul nid de boucles */
  nested_loops = gen_array_item(task_loopnest.nested_loops,0);
  xml_Region_Parameter(pattern_region, sb_result);
  gen_recurse(stat_module, statement_domain, gen_true,motif_in_statement);
  motif_in_te_p = motif_in_statement_p;
  xml_Loops(nested_loops,false,&pattern_region,&paving_indices, &pattern_indices, motif_in_te_p, sb_result);
  xml_TaskParameters(stat_module, false,code_tag, module,pattern_region,paving_indices,sb_result);
  xml_Regions(sb_result);
  xml_CodeSize(sb_result);
  global_margin--;
  string_buffer_append_word("/Task",sb_result);
  global_margin--;
 
  pop_current_module_statement();
  gen_array_free(task_loopnest.nested_loops);
  gen_array_free(task_loopnest.nested_loop_indices);
  gen_array_free(task_loopnest.nested_call);
  gen_array_free(task_loopnest.nested_if);
  stack_free(&(task_loopnest.testif));
  stack_free(&(task_loopnest.loops_for_call));
  stack_free(&(task_loopnest.loop_indices));
  stack_free(&(task_loopnest.current_stat));
  pop_statement_global_stack();
  regions_free(pattern_region);
  sc_rm(prec);
}

References add_margin(), CLOSEANGLE, concatenate(), nest_context_t::current_stat, db_get_memory_resource(), entity_domain, find_loops_and_calls_in_box(), first_precondition_of_module(), gen_array_free(), gen_array_item(), gen_array_make(), gen_recurse, gen_true(), global_margin, load_statement_local_regions(), nest_context_t::loop_indices, nest_context_t::loops_for_call, module, module_name(), module_name_to_entity(), motif_in_statement(), motif_in_statement_p, nest_context_t::nested_call, nest_context_t::nested_if, nest_context_t::nested_loop_indices, nest_context_t::nested_loops, NIL, NL, OPENANGLE, pattern_indices, pop_current_module_statement(), pop_statement_global_stack(), push_current_module_statement(), push_statement_on_statement_global_stack(), QUOTE, regions_dup(), regions_free(), reset_rw_effects(), sc_rm(), set_rw_effects(), stack_free(), stack_make(), statement_domain, string_buffer_append(), string_buffer_append_word(), nest_context_t::testif, VECTEUR_NUL, xml_CodeSize(), xml_FormalVariables(), xml_GlobalVariables(), xml_Library(), xml_LocalVariables(), xml_Loops(), xml_Region_Parameter(), xml_Regions(), xml_Returns(), xml_TaskParameters(), and xml_Timecosts().

Referenced by generic_print_xml_application().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_task()

static void xml_task ( int  taskNumber, nest_context_p  nest, string_buffer  result  )

static

Definition at line 1790 of file xml_prettyprinter.c.

{
 
  statement s = gen_array_item(nest->nested_call,taskNumber);
  stack st = gen_array_item(nest->nested_loops,taskNumber);
  stack sindices = gen_array_item(nest->nested_loop_indices,taskNumber);
 
  string_buffer_append(result, concatenate(NL,TAB,OPENANGLE,"task name =", QUOTE, XML_TASK_PREFIX,int2a(taskNumber),QUOTE, CLOSEANGLE, NL, NULL));
  string_buffer_append(result, concatenate(TAB, SPACE, OPENANGLE, "unitSpentTime", CLOSEANGLE,task_complexity(s),NULL));
  string_buffer_append(result, concatenate(OPENANGLE,SLASH,"unitSpentTime",CLOSEANGLE,NL,NULL));
 
  xml_loop(st, result);
  xml_data (taskNumber, s,sindices, result);
  string_buffer_append(result, concatenate(TAB,OPENANGLE,SLASH,"task",CLOSEANGLE, NL, NULL));
}

References CLOSEANGLE, concatenate(), gen_array_item(), int2a(), nest_context_t::nested_call, nest_context_t::nested_loop_indices, nest_context_t::nested_loops, NL, OPENANGLE, QUOTE, SLASH, SPACE, string_buffer_append(), TAB, task_complexity(), xml_data(), xml_loop(), and XML_TASK_PREFIX.

Referenced by xml_tasks().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_TaskParameter()

static void xml_TaskParameter ( bool  assign_function, _UNUSED_ entity  function, int  statnb, bool  is_not_main_p, entity  var, Pvecteur  formal_parameters, list  pattern_region, Pvecteur  paving_indices, string_buffer  sb_result, string_buffer  buffer_assign  )

static

Definition at line 3217 of file xml_prettyprinter.c.

{
  bool effet_read = true;
  region rwr = region_undefined;
  region rre = region_undefined;
  const char* datatype ="";
  int size=0, rw_ef=0, prems=0;
  reference ref = reference_undefined;
  region reg = region_undefined;
  entity v = entity_undefined;
  list pc = list_undefined;
  bool  pavp=true, RW_effet=false;
 
  // rappel : les regions contiennent les effects sur les scalaires
  // - Pour les fonctions, on ecrit les parametres formels dans l'ordre.
  // - Pour le MAIN, ordre des regions:
  if (assign_function){
    reg = REGION(CAR(pattern_region));
    ref = effect_any_reference(reg);
    v = reference_variable(ref);
    pavp = true;
    effet_read = region_read_p(reg);
    rw_ef=(!effet_read)?2:1;
  }
  else {
    if  (!is_not_main_p) {
      reg = REGION(CAR(pattern_region));
      ref = effect_any_reference(reg);
      v = reference_variable(ref);
      pavp =(vect_coeff(v,paving_indices) == 0);
      effet_read = region_read_p(reg);
    }
    else { // c'est une fonction -->  impression selon l'ordre des parametres formels
      // recherche des regions du parametre formel
      rw_ef= find_effect_actions_for_entity(pattern_region,&rre, &rwr,var);
      // choix de l'affichage des regions write en premier lorsque R&W existent
      if (rwr != region_undefined)
        reg=rwr, effet_read=false;
      else reg= rre, effet_read=true;
      if (reg != region_undefined) {
        ref = effect_any_reference(reg);
        v = reference_variable(ref);
      }
      else  // cas ou il n'y a pas d'effet sur le parametre formel,
        //  mais il fait partie de la liste des parametres de la fonction
        v = var, effet_read = true;
 
      // La liste des effects de la fonction a ete completee dans le TaskParameters
      // On recherche le premier effect sur la variable pour en deduire l'info Use OU Def dans la fonction
      if((rw_ef>=3) && (int)gen_length(cumulated_list) >0) {
        for (pc= cumulated_list;pc != NIL && prems ==0; pc = CDR(pc)){
          effect e = EFFECT(CAR(pc));
          reference r = effect_any_reference(e);
          if (store_effect_p(e) && array_entity_p(reference_variable(r)) && (same_entity_p(v,reference_variable(r))) ) {
            prems=(effect_read_p(e)) ? 1:2;
          }
        }
        //  printf("DEBUG - DEF_USE detection %s \n",(prems)? ((prems==1)?"USE":"DEF"):"Erreur pas d'effets sur cette variable");
      }
    }
  }
 
  RW_effet=((!is_not_main_p || assign_function) && !effet_read) || (is_not_main_p && (rw_ef==2 || prems==2));
  if (pavp) {
    type_and_size_of_var(v, &datatype,&size);
 
    if (assign_function && RW_effet && same_entity_p(var,v)) {
      add_margin(global_margin,buffer_assign);
      string_buffer_append(buffer_assign,
                           concatenate(OPENANGLE,
                                       "AssignParameter"," Name=",
                                       QUOTE, NULL));
      string_buffer_append_xml_text(buffer_assign,
                                    (string) ((print_full_name_p() || reference_undefined_p(ref)) ?
                                                            entity_user_name(v):words_points_to_reference(ref, false,region_undefined)),
                                    false);
      string_buffer_append(buffer_assign,
                           concatenate(QUOTE, BL,
                                        "Type=", QUOTE,(entity_xml_parameter_p(v))? "CONTROL":"DATA",QUOTE,BL,
                                       "DataType=",QUOTE,datatype,QUOTE,BL,
                                       "AccessMode=", QUOTE, RW_effet ? "DEF":"USE",QUOTE,BL,
                                       "ArrayP=", QUOTE, (array_entity_p(v))?"TRUE":"FALSE",QUOTE, BL,
                                       "Kind=", QUOTE,  "VARIABLE",QUOTE,
                                       CLOSEANGLE,
                                       NL, NULL));
 
      global_margin++;
      xml_Pattern_Paving(reg,v, effet_read, formal_parameters,
                         paving_indices, buffer_assign);
      if (rw_ef>=3)
        xml_Pattern_Paving(rre,v, true, formal_parameters,
                           paving_indices, buffer_assign);
      global_margin--;
      string_buffer_append_word("/AssignParameter",buffer_assign);
 
    }
    else {
      add_margin(global_margin,sb_result);
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "TaskParameter",
                                       // " Name=", QUOTE,entity_user_name(v),QUOTE, BL,
                                       " Name=", QUOTE, NULL));
      // For the task/function parameter, only one region is taken to represent all the struct fields if any.
      string_buffer_append_xml_text(sb_result,
                                    (string) ((print_full_name_p() || reference_undefined_p(ref) || is_not_main_p)?
                                              entity_user_name(v):words_points_to_reference(ref,false,region_undefined)),
                                    false);
      string_buffer_append(sb_result,
                           concatenate(QUOTE, BL,
                                       "Type=", QUOTE,(entity_xml_parameter_p(v))? "CONTROL":"DATA",QUOTE,BL,
                                       "DataType=",QUOTE,datatype,QUOTE,BL,
                                       "AccessMode=", QUOTE, RW_effet ? "DEF":"USE",QUOTE,BL,
                                       "ArrayP=", QUOTE, (array_entity_p(v))?"TRUE":"FALSE",QUOTE, BL,
                                       "Kind=", QUOTE,  "VARIABLE",QUOTE,
                                       CLOSEANGLE,
                                       NL, NULL));
      xml_ParameterUseToArrayBound(var,sb_result);
      global_margin++;
      xml_Pattern_Paving(reg,v, effet_read, formal_parameters,
                         paving_indices, sb_result);
      if (rw_ef>=3)
        xml_Pattern_Paving(rre,v, true, formal_parameters,
                           paving_indices, sb_result);
      global_margin--;
      string_buffer_append_word("/TaskParameter",sb_result);
    }
    if (assign_function && rw_ef>=2 && statnb>0) {
      Pcallst cst1=(callst *) malloc(sizeof(callst));
      entity assign_ent = gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                                  ASSIGN_OPERATOR_NAME),
                                             entity_domain);
      cst1->func = assign_ent;
      cst1->stat_nb= statnb;
      cst1->succ = (Pcallst)NULL;
      update_def_into_tasks_table(v ,cst1);
    }
  }
}

References add_margin(), array_entity_p(), ASSIGN_OPERATOR_NAME, BL, CAR, CDR, CLOSEANGLE, concatenate(), cumulated_list, EFFECT, effect_any_reference, effect_read_p, entity_domain, entity_undefined, entity_user_name(), entity_xml_parameter_p(), find_effect_actions_for_entity(), callst::func, gen_find_tabulated(), gen_length(), global_margin, list_undefined, make_entity_fullname(), malloc(), NIL, NL, OPENANGLE, print_full_name_p(), QUOTE, ref, reference_undefined, reference_undefined_p, reference_variable, region, REGION, region_read_p, region_undefined, same_entity_p(), callst::stat_nb, store_effect_p(), string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), callst::succ, TOP_LEVEL_MODULE_NAME, type_and_size_of_var(), update_def_into_tasks_table(), vect_coeff(), words_points_to_reference(), xml_ParameterUseToArrayBound(), and xml_Pattern_Paving().

Referenced by xml_TaskParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_TaskParameters()

static void xml_TaskParameters ( statement  stat, bool  assign_function, int  code_tag, entity  module, list  pattern_region, Pvecteur  paving_indices, string_buffer  sb_result  )

static

Definition at line 3391 of file xml_prettyprinter.c.

{
  string_buffer buffer_assign = string_buffer_make(true);
  string string_temp = "";
  list lr=NIL;
  call c=call_undefined;
  int ith;
  entity FormalName = entity_undefined;
  Pvecteur formal_parameters = VECTEUR_NUL;
  int FormalParameterNumber = (int) gen_length(module_formal_parameters(module));
 
  string_buffer_append_word("TaskParameters",sb_result);
  global_margin++;
 
  if (assign_function){
    if (instruction_call_p(statement_instruction(stat))) {
      c = instruction_call(statement_instruction(stat));
    }
    else {
      encapsulated_call =call_undefined;
      gen_recurse(stat, call_domain, gen_true,search_1r_function_call);
      c =encapsulated_call;
    }
    if (c==call_undefined)
      pips_internal_error("Unexpected call in statement number %d \n",(int) statement_number(stat));
 
    expression lhs_exp=EXPRESSION(CAR(call_arguments(c)));
    syntax lhs_syn= expression_syntax(lhs_exp);
    if (syntax_reference_p(lhs_syn))
      FormalName = reference_variable(syntax_reference(lhs_syn));
    else FormalName = entity_undefined;
 
    for (lr = pattern_region; !ENDP(lr); lr = CDR(lr)) {
      effect efs = REGION(CAR(lr));
      reference rs = effect_any_reference(efs);
      entity vs =  reference_variable(rs);
 
      if (store_effect_p(efs) &&
          !effects_package_entity_p(vs) && !std_file_entity_p(vs) && !variable_heap_p(vs))
        xml_TaskParameter(assign_function,module, statement_number(stat),false,FormalName,
                          formal_parameters,lr,paving_indices,sb_result, buffer_assign);
    }
  }
  else {
    // Formal parameters list
    for (ith=1;ith<=FormalParameterNumber;ith++) {
      FormalName = find_ith_formal_parameter(module,ith);
      vect_add_elem (&formal_parameters,(Variable) FormalName,VALUE_ONE);
    }
 
    if (code_tag != code_is_a_main) {
      // Formal parameters of functions are printed in the function argument order
      for (ith=1;ith<=FormalParameterNumber;ith++) {
        FormalName = find_ith_formal_parameter(module,ith);
 
        xml_TaskParameter(assign_function,module, statement_number(stat),true,FormalName,
                          formal_parameters,pattern_region,paving_indices,sb_result, buffer_assign);
      }
    }
    else   {
      for (lr = pattern_region; !ENDP(lr); lr = CDR(lr)) {
        if (store_effect_p(REGION(CAR(lr))))
          xml_TaskParameter(assign_function,module, statement_number(stat), false,FormalName,
                            formal_parameters,lr,paving_indices,sb_result, buffer_assign);
      }
    }
    xml_TaskReturnParameter(module, statement_number(stat),sb_result);
  }
 
  if (assign_function && !string_buffer_empty_p(buffer_assign)) {
    string_temp =string_buffer_to_string(buffer_assign);
    string_buffer_append(sb_result,string_temp);
  }
  string_temp=NULL;
  global_margin--;
  string_buffer_append_word("/TaskParameters",sb_result);
}

References call_arguments, call_domain, call_undefined, CAR, CDR, code_is_a_main, effect_any_reference, effects_package_entity_p(), encapsulated_call, ENDP, entity_undefined, EXPRESSION, expression_syntax, find_ith_formal_parameter(), gen_length(), gen_recurse, gen_true(), global_margin, instruction_call, instruction_call_p, int, module, module_formal_parameters(), NIL, pips_internal_error, reference_variable, REGION, search_1r_function_call(), statement_instruction, statement_number, std_file_entity_p(), store_effect_p(), string_buffer_append(), string_buffer_append_word(), string_buffer_empty_p(), string_buffer_make(), string_buffer_to_string(), syntax_reference, syntax_reference_p, VALUE_ONE, variable_heap_p(), vect_add_elem(), VECTEUR_NUL, xml_TaskParameter(), and xml_TaskReturnParameter().

Referenced by xml_Call(), and xml_Task().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_TaskReturnParameter()

static void xml_TaskReturnParameter ( entity  function, _UNUSED_ int  statnb, string_buffer  sb_result  )

static

Definition at line 3186 of file xml_prettyprinter.c.

{
  const char* datatype ="";
 
  if (type_functional_p(entity_type(function))) {
    type tp=functional_result(type_functional(entity_type(function)));
    if (type_variable_p(tp)) {
      variable v=type_variable(tp);
      basic b = variable_basic(v);
      //int e = SizeOfElements(b);
      // int size = (e==-1) ? 9999:e;
      datatype =basic_to_string(b);
 
      add_margin(global_margin,sb_result);
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,
                                       "AssignParameter",
                                       " Name= ",QUOTE, "RETURN",QUOTE,BL,
                                       "DataType=",QUOTE,datatype,QUOTE,BL,
                                       "AccessMode=", QUOTE,"DEF",QUOTE,BL,
                                       "ArrayP=", QUOTE, (variable_dimensions(v) != NIL)?"TRUE":"FALSE",QUOTE, BL,
                                       "Kind=", QUOTE,  "VARIABLE",QUOTE,
                                       CLOSEANGLE,
                                       NL, NULL));
      string_buffer_append_word("/AssignParameter",sb_result);
 
    }
  }
}

References add_margin(), basic_to_string(), BL, CLOSEANGLE, concatenate(), entity_type, functional_result, global_margin, NIL, NL, OPENANGLE, QUOTE, string_buffer_append(), string_buffer_append_word(), type_functional, type_functional_p, type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by xml_TaskParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_tasks()

static void xml_tasks ( statement  stat, string_buffer  result  )

static

ifdebug(2) print_call_selection(&nest);

Definition at line 1806 of file xml_prettyprinter.c.

                                                            {
 
  const char*  module_name = get_current_module_name();
  nest_context_t nest;
  int taskNumber =0;
  nest.loops_for_call = stack_make(statement_domain,0,0);
  nest.loop_indices = stack_make(entity_domain,0,0);
  nest.current_stat = stack_make(statement_domain,0,0);
  nest.nested_loops=  gen_array_make(0);
  nest.nested_loop_indices =  gen_array_make(0);
  nest.nested_call=  gen_array_make(0);
 
  string_buffer_append(result,concatenate(NL,SPACE,OPENANGLE,"tasks",CLOSEANGLE,NL, NULL));
 
  if(statement_undefined_p(stat)) {
    pips_internal_error("statement error");
  }
 
  search_nested_loops_and_calls(stat,&nest);
  /* ifdebug(2)  print_call_selection(&nest); */
 
  for (taskNumber = 0; taskNumber<(int) gen_array_nitems(nest.nested_call); taskNumber++)
 
    xml_task(taskNumber, &nest,result);
  string_buffer_append(result,concatenate(SPACE,OPENANGLE, SLASH, "tasks", CLOSEANGLE, NL,NULL));
  string_buffer_append(result,
                       concatenate(SPACE, OPENANGLE,
                                   "application name = ",
                                   QUOTE, module_name, QUOTE, CLOSEANGLE
                                   NL, NULL));
 
  for(taskNumber = 0; taskNumber<(int) gen_array_nitems(nest.nested_call)-1; taskNumber++)
    string_buffer_append(result,concatenate(TAB, OPENANGLE, "taskref ref = ", QUOTE, XML_TASK_PREFIX,
                                            int2a(taskNumber),QUOTE, SLASH,  CLOSEANGLE, NL, NULL));
 
  string_buffer_append(result,concatenate(TAB, OPENANGLE, "taskref ref = ", QUOTE, XML_TASK_PREFIX,
                                          int2a(taskNumber),QUOTE, SLASH,  CLOSEANGLE, NL, NULL));
 
  string_buffer_append(result,concatenate(SPACE, OPENANGLE, SLASH, "application",CLOSEANGLE, NL, NULL));
 
  gen_array_free(nest.nested_loops);
  gen_array_free(nest.nested_loop_indices);
  gen_array_free(nest.nested_call);
  stack_free(&(nest.loops_for_call));
  stack_free(&(nest.loop_indices));
  stack_free(&(nest.current_stat));
 
}

References CLOSEANGLE, concatenate(), nest_context_t::current_stat, entity_domain, gen_array_free(), gen_array_make(), gen_array_nitems(), get_current_module_name(), int, int2a(), nest_context_t::loop_indices, nest_context_t::loops_for_call, module_name(), nest_context_t::nested_call, nest_context_t::nested_loop_indices, nest_context_t::nested_loops, NL, OPENANGLE, pips_internal_error, QUOTE, search_nested_loops_and_calls(), SLASH, SPACE, stack_free(), stack_make(), statement_domain, statement_undefined_p, string_buffer_append(), TAB, xml_task(), and XML_TASK_PREFIX.

Referenced by xml_code().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_tasks_with_motif()

static string xml_tasks_with_motif ( statement  stat )

static

Manages tasks.

The code is very defensive and hangs if sth not predicted happens. Here basically we begin the code in itself and thus $stat is obligatory a sequence.

Definition at line 1101 of file xml_prettyprinter.c.

                                                  {
  int j;
  instruction i;
  string result = "tasks\n";
  if(statement_undefined_p(stat))
    {
      pips_internal_error("statement error");
    }
  i = statement_instruction(stat);
  tasks_names = gen_array_make(0);
  switch(instruction_tag(i)){
  case is_instruction_sequence:{
    sequence seq = instruction_sequence(i);
    result = xml_sequence_from_task(seq);
    break;
  }
  default:{
    pips_user_error("Only a sequence can be here");
  }
  }
  result = strdup(concatenate(result, NL, NL, "PRES:APPLICATION := APPLICATION(name = symbol!(", QUOTE, global_module_name, QUOTE, "), ", NL, TAB,NULL));
  result = strdup(concatenate(result, "tasks = list<TASK>(", NULL));
  for(j = 0; j<(int) gen_array_nitems(tasks_names) - 1; j++){
    result = strdup(concatenate(result, *((string *)(gen_array_item(tasks_names, j))), ", ", NULL));
  }
  result = strdup(concatenate(result, *((string *)(gen_array_item(tasks_names, j))), "))", NULL));
 
  return result;
}

References concatenate(), gen_array_item(), gen_array_make(), gen_array_nitems(), global_module_name, instruction_sequence, instruction_tag, int, is_instruction_sequence, NL, pips_internal_error, pips_user_error, QUOTE, statement_instruction, statement_undefined_p, strdup(), TAB, tasks_names, and xml_sequence_from_task().

Referenced by xml_code_string().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_tiling()

static void xml_tiling ( int  taskNumber, reference  ref, region  reg, stack  indices, string_buffer  result  )

static

Definition at line 1594 of file xml_prettyprinter.c.

{
  fprintf(stderr,"XML");
  Psysteme ps_reg = sc_dup(region_system(reg));
  entity var = reference_variable(ref);
  int dim = (int) gen_length(variable_dimensions(type_variable(entity_type(var))));
  int i, j ;
  string_buffer buffer_bound = string_buffer_make(true);
  string_buffer buffer_offset = string_buffer_make(true);
  string_buffer buffer_fitting = string_buffer_make(true);
  string_buffer buffer_paving = string_buffer_make(true);
  string string_bound = "";
  string string_offset = "";
  string string_paving = "";
  string string_fitting =  "";
  Pvecteur iterat, pi= VECTEUR_NUL;
  Pcontrainte bound_inf = CONTRAINTE_UNDEFINED;
  Pcontrainte bound_up = CONTRAINTE_UNDEFINED;
  Pcontrainte iterator = CONTRAINTE_UNDEFINED;
  int motif_up_bound =0;
  int lowerbound = 0;
  int upperbound = 0;
  int dim_indices= stack_size(indices);
  int pav_matrix[10][10], fit_matrix[10][10];
 
  for (i=1; i<=9;i++)
    for (j=1;j<=9;j++)
      pav_matrix[i][j]=0, fit_matrix[i][j]=0;
 
  STACK_MAP_X(index,entity,
              {
                vect_add_elem (&pi,(Variable) index ,VALUE_ONE);
              }, indices,1);
 
  for(i=1; i<=dim ; i++) {
    Psysteme ps = sc_dup(ps_reg);
    sc_transform_eg_in_ineg(ps);
 
    find_motif(ps, pi, i,  dim, &bound_inf, &bound_up, &iterator,
               &motif_up_bound, &lowerbound, &upperbound);
    string_buffer_append(buffer_offset,
                         concatenate(TAB,TAB,OPENANGLE,"offset val =", QUOTE,
                                     (CONTRAINTE_UNDEFINED_P(bound_inf))? "0" :
                                     int2a(vect_coeff(TCST,bound_inf->vecteur)),
                                     QUOTE, SLASH, CLOSEANGLE,NL,NULL));
    if (!CONTRAINTE_UNDEFINED_P(iterator)) {
      for (iterat = pi, j=1; !VECTEUR_NUL_P(iterat); iterat = iterat->succ, j++)
        pav_matrix[i][j]= vect_coeff(var_of(iterat),iterator->vecteur);
    }
    if (!CONTRAINTE_UNDEFINED_P(bound_inf))
      fit_matrix[i][i]= (motif_up_bound >1) ? 1:0;
 
    string_buffer_append(buffer_bound,
                         concatenate(TAB,TAB, OPENANGLE, "bound idx=",
                                     QUOTE, XML_MOTIF_PREFIX, int2a(taskNumber),"_",
                                     entity_user_name(var), "_",int2a(i),QUOTE, SPACE,
                                     "lower =" QUOTE,int2a(lowerbound),QUOTE,
                                     SPACE, "upper =", QUOTE, int2a(upperbound),
                                     QUOTE, SLASH, CLOSEANGLE,
                                     NL,NULL));
  }
 
  for (j=1; j<=dim_indices ; j++){
    string_buffer_append(buffer_paving,concatenate(TAB,TAB, OPENANGLE,"row",
                                                   CLOSEANGLE,NULL));
    for(i=1; i<=dim ; i++)
      string_buffer_append(buffer_paving,
                           concatenate(OPENANGLE, "cell val =", QUOTE,
                                       int2a( pav_matrix[i][j]),QUOTE, SLASH,
                                       CLOSEANGLE,NULL));
    string_buffer_append(buffer_paving,concatenate(OPENANGLE,SLASH, "row",
                                                   CLOSEANGLE,NL,NULL));
  }
  for(i=1; i<=dim ; i++) {
    string_buffer_append(buffer_fitting,concatenate(TAB, TAB,OPENANGLE,"row",
                                                    CLOSEANGLE,NULL));
    for(j=1; j<=dim ; j++)
      string_buffer_append(buffer_fitting, concatenate(OPENANGLE, "cell val =", QUOTE,
                                                       int2a( fit_matrix[i][j]),
                                                       QUOTE, SLASH,
                                                       CLOSEANGLE,NULL));
 
    string_buffer_append(buffer_fitting,concatenate(OPENANGLE,SLASH, "row",
                                                    CLOSEANGLE,NL,NULL));
  }
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,"origin",
                                          CLOSEANGLE,NL,NULL));
  string_offset =string_buffer_to_string(buffer_offset);
  string_buffer_append(result,string_offset);
  free(string_offset);
  string_offset=NULL;
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,SLASH,"origin",
                                          CLOSEANGLE,NL,NULL));
 
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,"fitting",
                                          CLOSEANGLE,NL,NULL));
  string_fitting =string_buffer_to_string(buffer_fitting);
  string_buffer_append(result,string_fitting);
  free(string_fitting);
  string_fitting=NULL;
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,SLASH,"fitting",
                                          CLOSEANGLE,NL,NULL));
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,"paving",
                                          CLOSEANGLE,NL,NULL));
  string_paving =string_buffer_to_string(buffer_paving);
  string_buffer_append(result,string_paving);
  free(string_paving);
  string_paving=NULL;
  string_buffer_append(result,concatenate(TAB,SPACE,SPACE,OPENANGLE,SLASH,"paving",
                                          CLOSEANGLE,NL,NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, OPENANGLE, "inLoop",
                                          CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, OPENANGLE, "loopNest",
                                          CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, SPACE, OPENANGLE, "bounds",
                                          CLOSEANGLE, NL, NULL));
  string_bound =string_buffer_to_string(buffer_bound);
  string_buffer_append(result,string_bound);
  free(string_bound);
  string_bound=NULL;
 
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, SPACE,OPENANGLE,
                                          SLASH "bounds", CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE, SPACE, OPENANGLE,SLASH, "loopNest",
                                          CLOSEANGLE, NL, NULL));
  string_buffer_append(result,concatenate(TAB,SPACE,  OPENANGLE, SLASH, "inLoop",
                                          CLOSEANGLE, NL, NULL));
 
 
}

References CLOSEANGLE, concatenate(), CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, entity_type, entity_user_name(), find_motif(), fprintf(), free(), gen_length(), indices, int, int2a(), NL, OPENANGLE, QUOTE, ref, reference_variable, region_system, sc_dup(), sc_transform_eg_in_ineg(), SLASH, SPACE, STACK_MAP_X, stack_size(), string_buffer_append(), string_buffer_make(), string_buffer_to_string(), Svecteur::succ, TAB, TCST, type_variable, upperbound(), VALUE_ONE, var_of, variable_dimensions, vect_add_elem(), vect_coeff(), Scontrainte::vecteur, VECTEUR_NUL, VECTEUR_NUL_P, and XML_MOTIF_PREFIX.

Referenced by xml_references().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Timecosts()

static void xml_Timecosts ( string_buffer sb_result   __attribute__(unused) )

static

Definition at line 2052 of file xml_prettyprinter.c.

{
  //string_buffer_append_word("Timecosts",sb_result);
  // string_buffer_append_word("/Timecosts",sb_result);
}

Referenced by xml_Task().

Here is the caller graph for this function:

xml_Transposed_Matrix2D()

static void xml_Transposed_Matrix2D ( Pmatrix  mat )

static

Definition at line 4185 of file xml_prettyprinter.c.

{
  MATRIX_ELEM(mat,1,1)=0;
  MATRIX_ELEM(mat,1,2)=1;
  MATRIX_ELEM(mat,2,1)=1;
  MATRIX_ELEM(mat,2,2)=0;
}

References MATRIX_ELEM.

Referenced by xml_Transposition().

Here is the caller graph for this function:

xml_Transposed_Matrix3_5D()

static void xml_Transposed_Matrix3_5D ( Pmatrix  mat, int  a[12], int  ArrayDim1, _UNUSED_ int  ArrayDim2  )

static

Definition at line 4193 of file xml_prettyprinter.c.

{
 
  int i,j,n;
  int result[]={0,0,0,0,0,0,0,0,0,0,0,0};
  tri_abc(a,ArrayDim1,result);
  for (i=1; i<= ArrayDim1; i++) {
    n = result[i+ArrayDim1];
    for (j=1;j<=ArrayDim1;j++) {
      if (result[j]==n)
        MATRIX_ELEM(mat,i,j)=1;
    }
  }
}

References MATRIX_ELEM, and tri_abc().

Referenced by xml_Transposition().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Transposition()

static void xml_Transposition ( statement  s, call  c, int  d, string_buffer  sb_result, int  version  )

static

Definition at line 4266 of file xml_prettyprinter.c.

{
  int tab[]={0,0,0,0,0,0,0,0,0,0,0,0};
  int i;
  expression arg1=expression_undefined,arg2=expression_undefined;
  value v;
  list args = call_arguments(c);
  Pmatrix mat = NULL;
 
  if ((version==0)  && (int) gen_length(args)==3+3*d) {
    for (i=1; i<=d; i++) {
      arg1= EXPRESSION(CAR(args));
      POP(args);
    }
    for (i=1;i<=2*d;i++){
      arg2= EXPRESSION(CAR(args));
      v = EvalExpression(arg2);
      if (value_constant_p(v) && constant_int_p(value_constant(v))) {
        tab[i] = constant_int(value_constant(v));
      }
      POP(args);
    }
    POP(args);
    arg1= EXPRESSION(CAR(args));
    POP(args);
    arg2= EXPRESSION(CAR(args));
 
    if (d>2 && d<=5) {
      mat = matrix_new(d,d);
      matrix_init(mat,mat->number_of_lines,mat->number_of_columns);
      xml_Transposed_Matrix3_5D(mat,tab, mat->number_of_lines,mat->number_of_columns) ;
    }
    else if (d==2) {
      mat = matrix_new(2,2);
      matrix_init(mat,mat->number_of_lines,mat->number_of_columns);
      xml_Transposed_Matrix2D(mat);
    }
  }
  else if ((version==1)  && (int) gen_length(args)==3+2*d) {
    int j;
    mat = matrix_new(d,d);
    matrix_init(mat,mat->number_of_lines,mat->number_of_columns);
    for (i=1; i<= d; i++) {
      arg1= EXPRESSION(CAR(args));
      v = EvalExpression(arg1);
      if (value_constant_p(v) && constant_int_p(value_constant(v))) {
        j= constant_int(value_constant(v));
        if (0<=j && j<=d-1)
          MATRIX_ELEM(mat,i,j+1)=1;
      }
      POP(args);
    }
    for (i=1; i<= d; i++)
      POP(args); // strides
    POP(args); // size
    arg1= EXPRESSION(CAR(args));
    POP(args);
    arg2= EXPRESSION(CAR(args));
  }
  else {
    spear_warning(s, "Change the arguments to be consistent with the prototype ",
                  "The prototype of the function %s is not correct ",
                  entity_user_name(call_function(c)));
  }
  // case with array field reference
  if (arg1 != expression_undefined && arg2 != expression_undefined) {
    arg1 = skip_field_and_cast_expression(arg1);
    arg2 = skip_field_and_cast_expression(arg2);
    if (array_argument_p(arg1) && array_argument_p(arg2)) {
      reference r1 = syntax_reference(expression_syntax(arg1));
      reference r2 = syntax_reference(expression_syntax(arg2));
      string_buffer_append_word("Transposition",sb_result);
      global_margin++;
      add_margin(global_margin,sb_result);
      string_buffer_append(sb_result,
                           concatenate(OPENANGLE,"TransposParameters ", "OUT=", QUOTE,NULL));
      string_buffer_append_xml_text(sb_result, (string) entity_user_name(reference_variable(r1)),false);
      string_buffer_append(sb_result,
                           concatenate(QUOTE,BL,
                                       "IN=", QUOTE,entity_user_name(reference_variable(r2)),QUOTE,"/",
                                       CLOSEANGLE,NL,NULL));
      xml_Matrix(mat,mat->number_of_lines,mat->number_of_columns,sb_result);
      matrix_free(mat);
      global_margin--;
      string_buffer_append_word("/Transposition",sb_result);
    }
  }
}

References add_margin(), array_argument_p(), BL, call_arguments, call_function, CAR, CLOSEANGLE, concatenate(), constant_int, constant_int_p, entity_user_name(), EvalExpression(), EXPRESSION, expression_syntax, expression_undefined, gen_length(), global_margin, MATRIX_ELEM, matrix_free, matrix_init(), matrix_new(), NL, Pmatrix::number_of_columns, Pmatrix::number_of_lines, OPENANGLE, POP, QUOTE, reference_variable, skip_field_and_cast_expression(), spear_warning, string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), syntax_reference, value_constant, value_constant_p, xml_Matrix(), xml_Transposed_Matrix2D(), and xml_Transposed_Matrix3_5D().

Referenced by xml_Call().

Here is the call graph for this function:

Here is the caller graph for this function:

xml_Type_Entity()

static void xml_Type_Entity ( entity  vv, string_buffer  type_buffer  )

static

Definition at line 2992 of file xml_prettyprinter.c.

{
  int max_step = (int) maximal_type_depth(entity_type(vv));
  if (max_step <=30) {
    // if (!io_entity_p(vv) && !ENTITY_STDOUT_P(vv) && !ENTITY_STDIN_P(vv) && !ENTITY_STDERR_P(vv)) {
    if (!effects_package_entity_p(vv) && !std_file_entity_p(vv) && !variable_heap_p(vv)) {
      type ct = entity_type(vv);
      global_margin++;
      add_margin(global_margin,type_buffer);
      string_buffer_append(type_buffer,
                           concatenate(OPENANGLE,
                                       "Reference Name= ",QUOTE,NULL));
      string_buffer_append_xml_text(type_buffer, (string) entity_user_name(vv),false);
      string_buffer_append(type_buffer, concatenate(QUOTE,CLOSEANGLE,NL,NULL));
      xml_Full_Type(ct,max_step,type_buffer);
     string_buffer_append_word("/Reference",type_buffer);
      global_margin--;
    }
  }
}

References add_margin(), CLOSEANGLE, concatenate(), effects_package_entity_p(), entity_type, entity_user_name(), global_margin, int, maximal_type_depth(), NL, OPENANGLE, QUOTE, std_file_entity_p(), string_buffer_append(), string_buffer_append_word(), string_buffer_append_xml_text(), variable_heap_p(), and xml_Full_Type().

Referenced by xml_Boxes().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

array_dims

gen_array_t array_dims

static

Definition at line 294 of file xml_prettyprinter.c.

Referenced by print_xml_code_with_explicit_motif(), and xml_dim_string().

array_location_string

string array_location_string

static

Definition at line 134 of file xml_prettyprinter.c.

Referenced by find_memory_comment_on_array(), and memory_location_for_array_p().

array_mem_string

string array_mem_string

static

Definition at line 135 of file xml_prettyprinter.c.

Referenced by find_memory_comment_on_array(), and memory_location_for_array_p().

array_names

gen_array_t array_names

static

Definition at line 293 of file xml_prettyprinter.c.

Referenced by print_xml_code_with_explicit_motif(), xml_call_from_assignation(), xml_call_from_loopnest(), and xml_dim_string().

box_in_statement_p

bool box_in_statement_p = false

static

Definition at line 126 of file xml_prettyprinter.c.

Referenced by box_in_statement(), and find_code_status().

cumulated_list

list cumulated_list = NIL

static

Definition at line 129 of file xml_prettyprinter.c.

Referenced by cumul_and_update_effects_of_statement(), cumul_effects_of_statement(), xml_Application(), xml_Chain_Graph(), xml_GlobalVariables(), and xml_TaskParameter().

def_to_task_mapping

entity_to_entity def_to_task_mapping = entity_to_entity_undefined

static

Definition at line 145 of file xml_prettyprinter.c.

Referenced by def_to_task_get(), def_to_task_init(), def_to_task_reset(), def_to_task_set(), def_to_task_store(), and generic_print_xml_application().

encapsulated_call

call encapsulated_call = call_undefined

static

Definition at line 132 of file xml_prettyprinter.c.

Referenced by search_1r_function_call(), xml_Argument(), xml_Arguments(), xml_Call(), xml_Chain_Graph(), and xml_TaskParameters().

extern_indices_array

gen_array_t extern_indices_array

static

array containing extern loop indices names

Definition at line 105 of file xml_prettyprinter.c.

Referenced by xml_array_in_task(), xml_call_from_indice(), xml_loop_from_loop(), and xml_loop_from_sequence().

extern_upperbounds_array

gen_array_t extern_upperbounds_array

static

array containing extern upperbounds

Definition at line 109 of file xml_prettyprinter.c.

Referenced by xml_loop_from_loop(), and xml_loop_from_sequence().

fortran_appli

bool fortran_appli = true

static

Definition at line 125 of file xml_prettyprinter.c.

Referenced by generic_print_xml_application(), xml_Application(), xml_Connection(), and xml_LocalVariables().

global_application_variables

Pvecteur global_application_variables = VECTEUR_NUL

static

Definition at line 136 of file xml_prettyprinter.c.

Referenced by xml_Boxes(), and xml_GlobalVariables().

global_margin

int global_margin =0

static

Definition at line 123 of file xml_prettyprinter.c.

Referenced by print_call_precondition(), string_buffer_append_numeric(), string_buffer_append_symbolic(), string_buffer_append_word(), two_string_buffer_append_symbolic(), xml_Application(), xml_Argument(), xml_Arguments(), xml_Array(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), xml_Boxes(), xml_Call(), xml_Chain_Graph(), xml_Compute_and_Need(), xml_FormalVariables(), xml_Full_Type(), xml_GlobalVariables(), xml_LocalVariables(), xml_Loop(), xml_Loops(), xml_Matrix(), xml_ParameterUseToArrayBound(), xml_Pattern_Paving(), xml_Region_Parameter(), xml_Scalar(), xml_Task(), xml_TaskParameter(), xml_TaskParameters(), xml_TaskReturnParameter(), xml_Transposition(), and xml_Type_Entity().

global_module_name

static const char * global_module_name

static

Definition at line 115 of file xml_prettyprinter.c.

Referenced by print_xml_code_with_explicit_motif(), and xml_tasks_with_motif().

hash_entity_def_into_tasks

hash_table hash_entity_def_into_tasks = hash_table_undefined

static

Definition at line 120 of file xml_prettyprinter.c.

Referenced by add_def_into_tasks_table(), generic_print_xml_application(), update_def_into_tasks_table(), and xml_Chain_Graph().

intern_indices_array

gen_array_t intern_indices_array

static

array containing intern loop indices (name : "M_")

Definition at line 107 of file xml_prettyprinter.c.

Referenced by xml_array_in_task(), xml_call_from_indice(), xml_loop_from_loop(), and xml_loop_from_sequence().

intern_upperbounds_array

gen_array_t intern_upperbounds_array

static

array containing intern upperbounds

Definition at line 111 of file xml_prettyprinter.c.

Referenced by xml_array_in_task(), xml_loop_from_loop(), and xml_loop_from_sequence().

local_application_variables

Pvecteur local_application_variables = VECTEUR_NUL

static

Definition at line 137 of file xml_prettyprinter.c.

Referenced by xml_Boxes(), and xml_LocalVariables().

local_declaration_list

list local_declaration_list = NIL

static

Definition at line 131 of file xml_prettyprinter.c.

Referenced by store_local_array_declaration(), and xml_LocalVariables().

motif_in_statement_p

bool motif_in_statement_p = false

static

Definition at line 127 of file xml_prettyprinter.c.

Referenced by find_code_status(), motif_in_statement(), xml_Loops(), and xml_Task().

statement_in_truebranch_p

bool statement_in_truebranch_p = false

static

Definition at line 128 of file xml_prettyprinter.c.

Referenced by statement_in_truebranch(), xml_Call(), and xml_Chain_Graph().

tasks_names

gen_array_t tasks_names

static

array containing the tasks names

Definition at line 113 of file xml_prettyprinter.c.

Referenced by xml_loop_from_sequence(), and xml_tasks_with_motif().

test_statement_of_reference

statement test_statement_of_reference

static

Definition at line 130 of file xml_prettyprinter.c.

Referenced by statement_in_truebranch(), xml_Call(), and xml_Chain_Graph().