25 #include "pips_config.h"
55 #define min(a,b) (((a)<(b))?(a):(b))
56 #define max(a,b) (((a)>(b))?(a):(b))
98 effect ge = (*effect_dup_func)(eff);
148 bool add_anywhere_write_effect_p =
false;
149 bool add_anywhere_read_effect_p =
false;
152 for(c_eff = l_eff; !
ENDP(c_eff);
POP(c_eff)) {
157 bool ignore_this_effect =
false;
160 pips_debug(4,
"current effect for entity \"\%s\":\n",
172 ignore_this_effect =
true;
205 ignore_this_effect =
true;
223 pips_debug(5,
"Local pointer \"%s\" is not initialized!\n",
226 add_anywhere_write_effect_p =
true;
228 add_anywhere_read_effect_p =
true;
229 ignore_this_effect =
true;
233 pips_debug(5,
"Local pointer \"%s\" can be ignored\n",
235 ignore_this_effect =
true;
238 pips_debug(5,
"dynamic or pointed var ignored (%s)\n",
240 ignore_this_effect =
true;
246 if(value_passing_p) {
251 ignore_this_effect =
true;
259 ignore_this_effect =
true;
268 if (! ignore_this_effect) {
273 pips_debug(4,
"effect preserved for variable \"\%s\": \n",
280 pips_debug(4,
"effect removed for variable \"\%s\": \n\t %s\n",
286 if(add_anywhere_write_effect_p)
288 if(add_anywhere_read_effect_p)
302 size_of_array(
entity a,
int n)
309 if ((size_nm1 = size_of_array(a, n-1)) != (
Pvecteur) NULL)
354 pips_assert(
"offset_of_reference", nindices == 0 || nindices >= n);
364 for (idim = 1; idim <= n; idim++) {
365 bool non_computable =
false;
383 Pvecteur s = size_of_array(a, idim-1);
386 non_computable =
true;
389 if (! non_computable)
398 non_computable =
true;
435 global_effect_translation(
440 list l_com_ent, l_tmp, l_new_eff =
NIL;
443 int eff_ent_size, total_size, eff_ent_begin_offset, eff_ent_end_offset;
447 pips_debug(5,
"target function: %s (local name: %s)\n",
473 for( l_tmp = l_com_ent; !
ENDP(l_tmp) && !found; l_tmp =
CDR(l_tmp) )
494 pips_debug(5,
"common not declared in caller,\n"
495 "\t using %s declarations instead\n",
503 eff_ent_end_offset = eff_ent_begin_offset + eff_ent_size - 1;
505 pips_debug(6,
"\n\t eff_ent: size = %d, offset_begin = %d,"
506 " offset_end = %d \n",
507 eff_ent_size, eff_ent_begin_offset, eff_ent_end_offset);
510 for(total_size = 0; !
ENDP(l_com_ent) && (total_size < eff_ent_size);
511 l_com_ent =
CDR(l_com_ent))
521 int new_ent_begin_offset =
523 int new_ent_end_offset = new_ent_begin_offset + new_ent_size - 1;
526 "offset_begin = %d, offset_end = %d \n",
527 new_ent_size, new_ent_begin_offset, new_ent_end_offset);
529 if ((new_ent_begin_offset <= eff_ent_end_offset) &&
530 (eff_ent_begin_offset <= new_ent_end_offset ))
539 if ((new_ent_begin_offset >= eff_ent_begin_offset) &&
540 (new_ent_end_offset <= eff_ent_end_offset))
559 total_size +=
min (eff_ent_begin_offset,new_ent_end_offset)
560 -
max(eff_ent_begin_offset, new_ent_begin_offset) + 1;
607 if (formal_ndims >= real_ndims)
612 for (ipc = 1, pc = real_args; pc !=
NIL; pc =
CDR(pc), ipc++) {
630 fprintf(stderr,
"\nBinding equations: ");
638 size_formal = size_of_array(formal_var, formal_ndims);
639 size_real = size_of_array(real_var, formal_ndims);
640 offset = offset_of_reference(real_ref, formal_ndims);
642 fprintf(stderr,
"size of formal: ");
644 fprintf(stderr,
"size of real: ");
651 fprintf(stderr,
"offset: could not be computed\n");
658 bad_reshaping =
true;
659 if (size_formal != NULL && size_real != NULL &&
offset != (
Pvecteur) -1)
671 sc_add_ineg(equations, ct);
674 fprintf(stderr,
"contrainte: ");
676 fprintf(stderr,
"\nsysteme a prouver: ");
680 bad_reshaping =
false;
683 debug(5,
"translate_array_effect",
684 "Test feasability for normalized system\n");
685 bad_reshaping = sc_faisabilite(equations);
686 debug(5,
"translate_array_effect",
687 "Test feasability for normalized system: %s\n",
691 debug(5,
"translate_array_effect",
692 "System could not be normalized\n");
697 if (! bad_reshaping) {
701 for (i = 1; i <= formal_ndims; i++) {
709 for (i = formal_ndims+1; i <= real_ndims; i++) {
718 for (i = formal_ndims+1; i <= real_ndims; i++) {
729 pips_debug(5,
"good reshaping between %s and %s\n",
734 "bad reshaping between %s and %s\n",
790 pips_debug(8,
"Array formal variable: translating.\n");
791 real_effect = translate_array_effect(called_func, real_args,
792 real_ref, formal_effect);
849 pips_assert(
"expression is a reference or read effect",
861 le = global_effect_translation (e,
881 fprintf(stderr,
"%d formal arguments for module %s:\n",
887 "insufficient number of actual arguments.\n",
893 fprintf(stderr,
"%d formal arguments for module%s:\n",
900 "too many actual arguments.\n",
933 for (pc = args, ipc = 1; !
ENDP(pc) && ipc<=n_formals; pc =
CDR(pc), ipc++)
961 translate_effect(func, args, real_ref, formal_effect);
992 (
"\nmodule %s called by module %s:\n\twrite"
993 " effect on non-variable actual"
994 " parameter thru %d%s formal parameter %s\n",
1001 (
"\nmodule %s called by module %s:\n\t"
1002 "possible write effect on non-variable "
1003 "actual parameter thru %d%s "
1004 "formal parameter %s\n",
1020 pips_debug(3,
"effects on statics and globals\n");
1027 le =
gen_nconc(global_effect_translation
1064 if (!
ENDP(l_sum_eff))
1070 pips_debug(8,
"begin for real arg %s, of type %s and effects :\n",
1073 (*effects_prettyprint_func)(l_sum_eff);
1096 pips_debug(8,
"pointer type real arg reference\n");
1100 bool exact_translation_p;
1105 &exact_translation_p);
1137 pips_debug(8,
"real arg reference is not a pointer and is not a partially indexed array -> NIL \n");
1144 bool read_p =
false;
1145 bool write_p =
false;
1176 bool anywhere_w_p =
false;
1177 bool anywhere_r_p =
false;
1181 pips_debug(6,
"addressing operator case \n");
1187 (arg1, &l_eff1,
true);
1203 "result is already anywhere\n");
1211 anywhere_r_p =
true;
1213 anywhere_w_p =
true;
1220 bool exact_translation_p;
1225 &exact_translation_p);
1235 anywhere_r_p =
true;
1237 anywhere_w_p =
true;
1251 bool anywhere_w_p =
false;
1252 bool anywhere_r_p =
false;
1257 (real_arg, &l_eff1,
true);
1268 pips_debug(6,
"no need to translate, result is already anywhere\n");
1277 anywhere_r_p =
true;
1279 anywhere_w_p =
true;
1287 n_eff = (*effect_dup_func)(eff1);
1303 (*effect_add_expression_dimension_func)(n_eff, ind);
1314 pips_debug(6,
"dereferencing operator case \n");
1329 (real_arg, &l_real_eff,
true);
1332 bool anywhere_w_p =
false;
1333 bool anywhere_r_p =
false;
1342 pips_debug(6,
"no need to translate, result is already anywhere\n");
1351 bool exact_translation_p;
1356 effect init_eff = (*effect_dup_func)(eff);
1364 &n_eff_ref, &n_eff_d,
1365 &exact_translation_p);
1369 anywhere_r_p =
true;
1371 anywhere_w_p =
true;
1390 pips_debug(8,
"real arg reference is not a pointer and is not a partially indexed array -> NIL \n");
1427 (l_sum_eff, cast_exp,
context));
1429 else if (!
ENDP(l_sum_eff))
1435 bool read_p =
false, write_p =
false;
1439 else read_p =
false;
1441 tag t = write_p ? (read_p ?
'x' :
'w') :
'r';
1512 pips_debug(8,
"begin for real arg %s, and effect :\n",
1523 pips_debug(5,
"effect on the value of the formal parameter -> NIL\n");
1530 pips_debug(5,
"type of real argument expression : %s\n",
1554 pips_debug(8,
"pointer type real arg reference\n");
1558 pips_debug(8,
"effect on the pointed area : \n");
1563 new_eff = (* reference_to_effect_func)(new_ref,
1570 (*effect_add_expression_dimension_func)(new_eff, eff_ind_exp);
1576 pips_debug(8,
"real arg reference is not a pointer and is not a partially indexed array -> NIL \n");
1609 (*effect_add_expression_dimension_func)
1610 (real_arg_eff, eff_ind_exp);
1674 (*effect_add_expression_dimension_func)
1675 (n_eff, eff_ind_exp);
1728 (*effect_add_expression_dimension_func)
1729 (n_eff, eff_ind_exp);
1768 (*effect_add_expression_dimension_func)(n_eff, ind);
1844 bool param_varargs_p =
false;
1869 param_varargs_p =
true;
1874 if (param_varargs_p)
1890 pips_debug(8,
"effect on formal parameter skipped : %s\n",
1895 bool force_may_p =
true;
1897 pips_debug(8,
"effect on global entity %s kept.\n",
1918 pips_debug(8,
"effects on global variables :\n");
1919 (* effects_prettyprint_func)(pel);
1930 pips_debug(8,
"effects on actual parameters added :\n");
1931 (* effects_prettyprint_func)(pel);
1939 pips_debug(5,
"Generating r/w effects on variables pointed by actual parameters\n");
1956 for(ce = func_sdfi; !
ENDP(ce);
POP(ce))
1997 (*effects_prettyprint_func)(pel);
2019 #define make_translated_effect(entity,action,approximation)\
2020 make_effect(make_cell(is_cell_reference, make_reference((entity), NIL)),\
2021 copy_action(action),\
2022 make_approximation(approximation, UU),\
2023 make_descriptor_none())
2036 real_simple_effects_forward_translation(
2069 effect fef = make_translated_effect
2073 l_fwd_translated =
CONS(
EFFECT, fef, l_fwd_translated);
2084 return l_fwd_translated;
2090 common_simple_effects_forward_translation(
2108 global_effect_translation
2114 return l_fwd_translated;
2128 pips_debug(4,
"forward translation of %s call to %s\n",
2132 lr = real_simple_effects_forward_translation(
callee, real_args, l_eff);
2133 lc = common_simple_effects_forward_translation(
callee, l_eff);
2167 pips_user_warning(
"Nested function calls are ignored. Consider splitting the code before running PIPS\n");
2186 bool general_case =
true;
2196 (arg1, &l_eff_real,
true);
2221 pips_debug(5,
"array element or sub-array case\n");
2227 general_case =
false;
2251 pips_debug_effect(5,
"matching access paths, considered effect is : \n", eff_orig);
2257 int i_max = general_case? nb_phi_real : nb_phi_real-1;
2258 for(
int i = 1; i<= i_max; i++,
POP(l_inds_orig));
2290 pips_debug(5,
"Other intrinsic case : entering general case \n");
2317 (real_exp, &l_eff_real,
true);
2319 if (!
ENDP(l_eff_real))
2334 && nb_phi_orig >= nb_phi_real)
2343 pips_debug_effect(5,
"matching access paths, considered effect is : \n", eff_orig);
2349 bool exact_translation_p;
2355 &n_eff_ref, &n_eff_d,
2356 &exact_translation_p);
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
action copy_action(action p)
ACTION.
descriptor make_descriptor(enum descriptor_utype tag, void *val)
void free_effect(effect p)
cell make_cell(enum cell_utype tag, void *val)
approximation make_approximation(enum approximation_utype tag, void *val)
approximation copy_approximation(approximation p)
APPROXIMATION.
approximation make_approximation_may(void)
effect make_effect(cell a1, action a2, approximation a3, descriptor a4)
descriptor copy_descriptor(descriptor p)
DESCRIPTOR.
cell make_cell_preference(preference _field_)
void free_reference(reference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
preference make_preference(reference a1)
struct paramStruct params
static reference ref
Current stmt (an integer)
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
void dump_arguments(cons *args)
entity_name is a macro, hence the code replication
void const char const char const int
#define CONTRAINTE_UNDEFINED
Pcontrainte contrainte_make(Pvecteur pv)
Pcontrainte contrainte_make(Pvecteur pv): allocation et initialisation d'une contrainte avec un vecte...
#define pips_debug_effects(level, message, l_eff)
#define pips_debug_effect(level, message, eff)
for debug
list generic_proper_effects_of_complex_address_expression(expression, list *, int)
effect make_anywhere_effect(action)
string vect_debug_entity_name(entity)
list(* effect_to_store_independent_effect_list_func)(effect, bool)
type simple_effect_reference_type(reference)
list generic_proper_effects_of_expression(expression)
effect(* effect_dup_func)(effect eff)
list c_actual_argument_to_may_summary_effects(expression, tag)
list effect_to_list(effect)
list generic_effect_generate_all_accessible_paths_effects(effect, type, tag)
bool effects_same_action_p(effect, effect)
list generic_proper_effects_of_expressions(list)
#define make_sdfi_effect(e)
copies an effect with no subcript expression
list EffectsMustUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect))
list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a l...
bool path_preceding_p(effect, effect, transformer, bool, bool *)
void simple_effect_descriptor_interprocedural_translation(effect)
void simple_cell_reference_with_address_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
list c_simple_effects_on_formal_parameter_backward_translation(list, expression, transformer)
void simple_effect_change_ith_dimension_expression(effect, expression, int)
list effect_to_sdfi_list(effect)
list effects_dynamic_elim(list)
void simple_effects_translation_init(entity, list, bool)
interprocedural.c
list fortran_summary_to_proper_effects(entity, list, list)
list c_simple_effects_on_actual_parameter_forward_translation(entity, expression, entity, list, transformer)
effect translate_effect_to_sdfi_effect(effect)
effect reference_to_simple_effect(reference, action, bool)
unary_operators.c
list summary_to_proper_effects(entity, list, list)
list simple_effects_backward_translation(entity, list, list, transformer)
list summary_effect_to_proper_effect(call, effect)
string effect_to_string(effect)
void check_user_call_site(entity, list)
void simple_cell_reference_with_value_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
list words_effect(effect)
list c_summary_effect_to_proper_effects(effect, expression)
list make_unknown_subscript(int)
list c_summary_to_proper_effects(entity, list, list)
list simple_effects_forward_translation(entity, list, list, transformer)
void simple_effects_translation_end(void)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
#define effect_approximation_tag(eff)
#define make_reference_simple_effect(reference, action, approximation)
#define effect_write_p(eff)
#define effect_read_p(eff)
#define effect_scalar_p(eff) entity_scalar_p(effect_entity(eff))
#define effect_exact_p(eff)
#define effect_variable(e)
For COMPATIBILITY purpose only - DO NOT USE anymore.
#define effect_action_tag(eff)
#define make_simple_effect(reference, action, approximation)
bool basic_concrete_types_compatible_for_effects_interprocedural_translation_p(type, type)
tests if the actual argument type and the formal argument type are compatible with the current state ...
entity effect_entity(effect)
cproto-generated files
action make_action_write_memory(void)
To ease the extension of action with action_kind.
bool store_effect_p(effect)
bool anywhere_effect_p(effect)
Is it an anywhere effect? ANYMMODULE:ANYWHERE
action make_action_read_memory(void)
bool types_compatible_for_effects_interprocedural_translation_p(type, type)
tests if the actual argument type and the formal argument type are compatible with the current state ...
bool any_anywhere_effect_p(effect)
Is it a typed or untyped anywhere effect?
#define effect_undefined_p(x)
#define approximation_tag(x)
#define action_write_p(x)
#define effect_descriptor(x)
#define descriptor_undefined
#define effect_approximation(x)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
void gen_full_free_list(list l)
static int array_size(dim)
ARRAY_SIZE returns the number of elements in the array whose dimension list is DIM.
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
list gen_last(list l)
Return the last element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
gen_chunk gen_nth(int n, const list l)
to be used as ENTITY(gen_nth(3, l))...
#define list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
static void term(Pproblem XX, int s, Value k, int x)
void vect_fprint(FILE *f, Pvecteur v, get_variable_name_t variable_name)
void vect_fprint(FILE * f, Pvecteur v, char * (*variable_name)()): impression d'un vecteur creux v su...
bool vect_equal(Pvecteur v1, Pvecteur v2)
bool vect_equal(Pvecteur v1, Pvecteur v2): test a egalite de deux vecteurs
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define user_warning(fn,...)
int get_debug_level(void)
GET_DEBUG_LEVEL returns the current debugging level.
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
string bool_to_string(bool)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
void print_expressions(list le)
string expression_to_string(expression e)
#define SUBSTRING_FUNCTION_NAME
#define ENTITY_ASSIGN_P(e)
#define ENTITY_DEREFERENCING_P(e)
#define PLUS_OPERATOR_NAME
#define NORMALIZE_EXPRESSION(e)
#define ENTITY_POINT_TO_P(e)
#define ENTITY_FIELD_P(e)
C data structure and pointer management.
#define ENTITY_MALLOC_SYSTEM_P(e)
#define ENTITY_ADDRESS_OF_P(e)
bool dynamic_area_p(entity aire)
bool stack_area_p(entity aire)
bool heap_area_p(entity aire)
bool entity_special_area_p(entity e)
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
bool intrinsic_entity_p(entity e)
bool same_entity_p(entity e1, entity e2)
predicates on entities
bool c_module_p(entity m)
Test if a module "m" is written in C.
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
bool effects_package_entity_p(entity e)
checks if an entity is an IO_EFFECTS_PACKAGE_NAME, a MALLOC_EFFECTS_NAME or a RAND_EFFECTS_PACKAGE_NA...
expression entity_ith_bounds(entity e, int i)
FIND_MODULE returns entity.
const char * module_local_name(entity e)
Returns the module local user name.
bool parameter_passing_by_reference_p(entity f)
bool top_level_entity_p(entity e)
Check if the scope of entity e is global.
entity find_ith_formal_parameter(entity the_fnct, int rank)
This function gives back the ith formal parameter, which is found in the declarations of a call or a ...
const char * entity_module_name(entity e)
See comments about module_name().
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
Pvecteur vect_product(Pvecteur *pv1, Pvecteur *pv2)
returns a Pvecteur equal to (*pv1) * (*pv2) if this product is linear or NULL otherwise.
value EvalExpression(expression e)
Evaluate statically an expression.
bool reference_with_unbounded_indices_p(reference r)
indices can be constant or unbounded: they are store independent.
list make_unbounded_subscripts(int d)
FI: this piece of code must have been duplicated somewhere else in an effect library.
expression make_unbounded_expression()
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
bool expression_reference_p(expression e)
Test if an expression is a reference.
bool expression_equal_integer_p(expression exp, int i)
================================================================
bool unbounded_expression_p(expression e)
bool reference_with_constant_indices_p(reference r)
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
list module_formal_parameters(entity func)
list module_formal_parameters(entity func) input : an entity representing a function.
dimension entity_ith_dimension(entity, int)
Another semantics would be: is this reference r to e a kill for e? In general, this cannot be answere...
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
bool entity_scalar_p(entity)
The concrete type of e is a scalar type.
expression reference_ith_index(reference, int)
functions for references
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
bool pointer_type_p(type)
Check for scalar pointers.
size_t type_depth(type)
Number of steps to access the lowest leave of type t without dereferencing.
bool formal_parameter_p(entity)
int NumberOfDimension(entity)
bool ith_parameter_p(entity, entity, int)
returns true if v is the ith formal parameter of function f
type reference_to_type(reference)
bool self_initialization_p(entity)
Check if a variable is initialized by itself as "int a = a;" is legal C code according to gcc.
bool entity_integer_scalar_p(entity)
for variables (like I), not constants (like 1)! use integer_constant_p() for constants
entity find_ith_parameter(entity, int)
string type_to_string(const type)
type.c
#define type_functional_p(x)
#define value_undefined_p(x)
#define syntax_reference_p(x)
#define transformer_undefined
#define storage_formal_p(x)
#define parameter_type(x)
#define value_constant(x)
#define syntax_reference(x)
#define normalized_linear_p(x)
#define reference_variable(x)
#define type_functional(x)
#define dimension_lower(x)
#define entity_storage(x)
@ is_syntax_sizeofexpression
#define value_constant_p(x)
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define type_undefined_p(x)
#define entity_undefined_p(x)
#define constant_int_p(x)
#define functional_parameters(x)
#define PARAMETER(x)
PARAMETER.
#define dimension_upper(x)
#define reference_indices(x)
#define type_varargs_p(x)
#define variable_dimensions(x)
#define call_arguments(x)
#define value_expression_p(x)
#define normalized_linear(x)
#define expression_syntax(x)
#define type_variable_p(x)
#define value_expression(x)
#define entity_initial(x)
void sc_creer_base(Psysteme ps)
void sc_creer_base(Psysteme ps): initialisation des parametres dimension et base d'un systeme lineair...
void sc_rm(Psysteme ps)
void sc_rm(Psysteme ps): liberation de l'espace memoire occupe par le systeme de contraintes ps;
void sc_add_egalite(Psysteme p, Pcontrainte e)
void sc_add_egalite(Psysteme p, Pcontrainte e): macro ajoutant une egalite e a un systeme p; la base ...
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
bool sc_empty_p(Psysteme sc)
bool sc_empty_p(Psysteme sc): check if the set associated to sc is the constant sc_empty or not.
void sc_fprint(FILE *fp, Psysteme ps, get_variable_name_t nom_var)
void sc_fprint(FILE * f, Psysteme ps, char * (*nom_var)()): cette fonction imprime dans le fichier po...
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
Psysteme sc_normalize(Psysteme ps)
Psysteme sc_normalize(Psysteme ps): normalisation d'un systeme d'equation et d'inequations lineaires ...
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
string words_to_string(cons *lw)
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
char *(* get_variable_name_t)(Variable)
struct Svecteur * Pvecteur
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
Pvecteur vect_new(Variable var, Value coeff)
Pvecteur vect_new(Variable var,Value coeff): allocation d'un vecteur colineaire au vecteur de base va...
void vect_rm(Pvecteur v)
void vect_rm(Pvecteur v): desallocation des couples de v;
Pvecteur vect_add(Pvecteur v1, Pvecteur v2)
package vecteur - operations binaires
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2)
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2): allocation d'un vecteur v dont la valeur est la di...
Pvecteur vect_cl(Pvecteur v, Value lambda, Pvecteur u)
void vect_add_elem(Pvecteur *pvect, Variable var, Value val)
void vect_add_elem(Pvecteur * pvect, Variable var, Value val): addition d'un vecteur colineaire au ve...