From 9cd730ef094ea40e0e7c91fecd5cd53280f78bfc Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Mon, 29 Sep 2008 12:07:31 +0200 Subject: [PATCH] Rename CloogConstraints to CloogConstraintSet --- include/cloog/clast.h | 2 +- include/cloog/constraints.h | 44 +++++++++++++------------- include/cloog/domain.h | 2 +- include/cloog/polylib/matrix.h | 4 +-- source/clast.c | 70 +++++++++++++++++++++--------------------- source/polylib/domain.c | 2 +- source/polylib/matrix.c | 48 ++++++++++++++--------------- 7 files changed, 86 insertions(+), 86 deletions(-) diff --git a/include/cloog/clast.h b/include/cloog/clast.h index d98bc05..b739bcf 100644 --- a/include/cloog/clast.h +++ b/include/cloog/clast.h @@ -122,7 +122,7 @@ void free_clast_stmt(struct clast_stmt *s); int clast_expr_equal(struct clast_expr *e1, struct clast_expr *e2); -struct clast_expr *clast_bound_from_constraint(CloogConstraints *constraints, +struct clast_expr *clast_bound_from_constraint(CloogConstraintSet *constraints, int line_num, int level, CloogNames *names); diff --git a/include/cloog/constraints.h b/include/cloog/constraints.h index 6f58e31..dd945de 100644 --- a/include/cloog/constraints.h +++ b/include/cloog/constraints.h @@ -44,8 +44,8 @@ extern "C" #ifdef CLOOG_POLYLIB #include #else -struct cloogconstraints; -typedef struct cloogconstraints CloogConstraints; +struct cloogconstraintset; +typedef struct cloogconstraintset CloogConstraintSet; struct cloogequalities; typedef struct cloogequalities CloogEqualities; #endif @@ -58,40 +58,40 @@ CloogEqualities *cloog_equal_alloc(int n, int nb_levels, int nb_parameters); void cloog_equal_free(CloogEqualities *equal); int cloog_equal_count(CloogEqualities *equal); -CloogConstraints *cloog_equal_constraints(CloogEqualities *equal); +CloogConstraintSet *cloog_equal_constraints(CloogEqualities *equal); int cloog_equal_type(CloogEqualities *equal, int level); void cloog_equal_add(CloogEqualities *equal, - CloogConstraints *constraints, + CloogConstraintSet *constraints, int level, int line, int nb_par); void cloog_equal_del(CloogEqualities *equal, int level); /****************************************************************************** * Processing functions * ******************************************************************************/ -void cloog_constraints_normalize(CloogConstraints *, int); -void cloog_constraints_free(CloogConstraints *); -int cloog_constraints_contain_level(CloogConstraints *constraints, +void cloog_constraint_set_normalize(CloogConstraintSet *, int); +void cloog_constraint_set_free(CloogConstraintSet *); +int cloog_constraint_set_contains_level(CloogConstraintSet *constraints, int level, int nb_parameters); -int cloog_constraints_defining_equality(CloogConstraints *constraints, +int cloog_constraint_set_defining_equality(CloogConstraintSet *constraints, int level); -int cloog_constraints_defining_inequalities(CloogConstraints *constraints, +int cloog_constraint_set_defining_inequalities(CloogConstraintSet *constraints, int level, int *lower, int nb_parameters); -int cloog_constraints_total_dimension(CloogConstraints *constraints); -CloogConstraints *cloog_constraints_copy(CloogConstraints *); -CloogConstraints *cloog_constraints_simplify(CloogConstraints *, CloogEqualities *, int, int); -int cloog_constraints_count(CloogConstraints *constraints); -int cloog_constraint_involves(CloogConstraints *constraints, int c, int v); -int cloog_constraint_is_lower_bound(CloogConstraints *constraints, int c, int v); -int cloog_constraint_is_upper_bound(CloogConstraints *constraints, int c, int v); -int cloog_constraint_is_equality(CloogConstraints *constraints, int c); -void cloog_constraint_constant_get(CloogConstraints *constraints, +int cloog_constraint_set_total_dimension(CloogConstraintSet *constraints); +CloogConstraintSet *cloog_constraint_set_copy(CloogConstraintSet *); +CloogConstraintSet *cloog_constraint_set_simplify(CloogConstraintSet *, CloogEqualities *, int, int); +int cloog_constraint_set_count(CloogConstraintSet *constraints); +int cloog_constraint_involves(CloogConstraintSet *constraints, int c, int v); +int cloog_constraint_is_lower_bound(CloogConstraintSet *constraints, int c, int v); +int cloog_constraint_is_upper_bound(CloogConstraintSet *constraints, int c, int v); +int cloog_constraint_is_equality(CloogConstraintSet *constraints, int c); +void cloog_constraint_constant_get(CloogConstraintSet *constraints, int c, cloog_int_t *val); -void cloog_constraint_coefficient_get(CloogConstraints *constraints, +void cloog_constraint_coefficient_get(CloogConstraintSet *constraints, int c, int var, cloog_int_t *val); -void cloog_constraint_coefficient_set(CloogConstraints *constraints, +void cloog_constraint_coefficient_set(CloogConstraintSet *constraints, int c, int var, cloog_int_t val); -void cloog_constraint_clear(CloogConstraints *constraints, int c); -void cloog_constraint_copy(CloogConstraints *constraints, int c, +void cloog_constraint_clear(CloogConstraintSet *constraints, int c); +void cloog_constraint_copy(CloogConstraintSet *constraints, int c, cloog_int_t *dst); #if defined(__cplusplus) diff --git a/include/cloog/domain.h b/include/cloog/domain.h index dea36ed..d2f41cc 100644 --- a/include/cloog/domain.h +++ b/include/cloog/domain.h @@ -107,7 +107,7 @@ CloogScattering *cloog_scattering_read(FILE *foo, /****************************************************************************** * Processing functions * ******************************************************************************/ -CloogConstraints *cloog_domain_constraints(CloogDomain *); +CloogConstraintSet *cloog_domain_constraints(CloogDomain *); int cloog_domain_isempty(CloogDomain *) ; CloogDomain * cloog_domain_universe(unsigned dim, CloogOptions *options); CloogDomain * cloog_domain_project(CloogDomain *, int, int) ; diff --git a/include/cloog/polylib/matrix.h b/include/cloog/polylib/matrix.h index 7b4c143..4e27473 100644 --- a/include/cloog/polylib/matrix.h +++ b/include/cloog/polylib/matrix.h @@ -19,10 +19,10 @@ extern "C" */ typedef Matrix CloogMatrix; -typedef Matrix CloogConstraints; +typedef Matrix CloogConstraintSet; struct cloogequalities { - CloogConstraints *constraints; + CloogConstraintSet *constraints; int *types; }; typedef struct cloogequalities CloogEqualities; diff --git a/source/clast.c b/source/clast.c index 8bfd401..749abd9 100644 --- a/source/clast.c +++ b/source/clast.c @@ -33,22 +33,22 @@ static int clast_binary_cmp(struct clast_binary *b1, struct clast_binary *b2); static int clast_reduction_cmp(struct clast_reduction *r1, struct clast_reduction *r2); -static int clast_equal_add(CloogEqualities *equal, CloogConstraints *constraints, +static int clast_equal_add(CloogEqualities *equal, CloogConstraintSet *constraints, int level, int line, CloogInfos *infos); static struct clast_stmt * clast_equal(CloogInfos *infos); static struct clast_stmt * clast_equal_cpp(int level, CloogInfos *infos); -static struct clast_expr *clast_minmax(CloogConstraints *constraints, +static struct clast_expr *clast_minmax(CloogConstraintSet *constraints, int level, int max, int guard, CloogInfos *infos); -static void insert_guard(CloogConstraints *constraints, int level, +static void insert_guard(CloogConstraintSet *constraints, int level, struct clast_stmt ***next, CloogInfos *infos); -static void insert_modulo_guard(CloogConstraints *constraints, int upper, +static void insert_modulo_guard(CloogConstraintSet *constraints, int upper, int lower, int level, struct clast_stmt ***next, CloogInfos *infos); -static void insert_equation(CloogConstraints *constraints, int upper, int lower, +static void insert_equation(CloogConstraintSet *constraints, int upper, int lower, int level, struct clast_stmt ***next, CloogInfos *infos); -static void insert_for(CloogConstraints *constraints, int level, +static void insert_for(CloogConstraintSet *constraints, int level, struct clast_stmt ***next, CloogInfos *infos); static void insert_scalar(CloogLoop *loop, int level, int *scalar, struct clast_stmt ***next, CloogInfos *infos); @@ -426,7 +426,7 @@ static int clast_equal_allow(CloogEqualities *equal, int level, int line, * - line is the line number in matrix of the constraint we want to study, * - the infos structure gives the user all options on code printing and more. */ -static int clast_equal_add(CloogEqualities *equal, CloogConstraints *constraints, +static int clast_equal_add(CloogEqualities *equal, CloogConstraintSet *constraints, int level, int line, CloogInfos *infos) { cloog_equal_add(equal, constraints, level, line, infos->names->nb_parameters); @@ -453,7 +453,7 @@ static struct clast_stmt * clast_equal(CloogInfos *infos) struct clast_stmt *a = NULL; struct clast_stmt **next = &a; CloogEqualities *equal = infos->equal; - CloogConstraints *constraints = cloog_equal_constraints(equal); + CloogConstraintSet *constraints = cloog_equal_constraints(equal); /* It is not necessary to print here the scattering iterators since they * never appear in the statement bodies. @@ -493,7 +493,7 @@ static struct clast_stmt * clast_equal_cpp(int level, CloogInfos *infos) struct clast_stmt *a = NULL; struct clast_stmt **next = &a; CloogEqualities *equal = infos->equal; - CloogConstraints *constraints = cloog_equal_constraints(equal); + CloogConstraintSet *constraints = cloog_equal_constraints(equal); cloog_int_init(one); @@ -531,7 +531,7 @@ static struct clast_stmt * clast_equal_cpp(int level, CloogInfos *infos) * - November 2nd 2001: first version. * - June 27th 2003: 64 bits version ready. */ -struct clast_expr *clast_bound_from_constraint(CloogConstraints *constraints, +struct clast_expr *clast_bound_from_constraint(CloogConstraintSet *constraints, int line_num, int level, CloogNames *names) { @@ -541,7 +541,7 @@ struct clast_expr *clast_bound_from_constraint(CloogConstraints *constraints, struct clast_expr *e = NULL; struct cloog_vec *line_vector; - len = cloog_constraints_total_dimension(constraints) + 2; + len = cloog_constraint_set_total_dimension(constraints) + 2; line_vector = cloog_vec_alloc(len); line = line_vector->p; cloog_constraint_copy(constraints, line_num, line+1); @@ -695,13 +695,13 @@ struct clast_expr *clast_bound_from_constraint(CloogConstraints *constraints, ** * - November 2nd 2001: first version. */ -static struct clast_expr *clast_minmax(CloogConstraints *constraints, +static struct clast_expr *clast_minmax(CloogConstraintSet *constraints, int level, int max, int guard, CloogInfos *infos) { int i, n; struct clast_reduction *r; - for (i = 0, n = 0; i < cloog_constraints_count(constraints); i++) + for (i = 0, n = 0; i < cloog_constraint_set_count(constraints); i++) if (((max && cloog_constraint_is_lower_bound(constraints, i, level-1)) || (!max && cloog_constraint_is_upper_bound(constraints, i, level-1))) && (!guard || !cloog_constraint_involves(constraints, i, guard-1)) && @@ -711,7 +711,7 @@ static struct clast_expr *clast_minmax(CloogConstraints *constraints, return NULL; r = new_clast_reduction(max ? clast_red_max : clast_red_min, n); - for (i = 0, n = 0; i < cloog_constraints_count(constraints); i++) + for (i = 0, n = 0; i < cloog_constraint_set_count(constraints); i++) if (((max && cloog_constraint_is_lower_bound(constraints, i, level-1)) || (!max && cloog_constraint_is_upper_bound(constraints, i, level-1))) && (!guard || !cloog_constraint_involves(constraints, i, guard-1)) && @@ -751,13 +751,13 @@ static struct clast_expr *clast_minmax(CloogConstraints *constraints, * domain unions, now it should be fixed directly in * cloog_loop_simplify). */ -static void insert_guard(CloogConstraints *constraints, int level, +static void insert_guard(CloogConstraintSet *constraints, int level, struct clast_stmt ***next, CloogInfos *infos) { int i, j, l, guarded, minmax=-1, nb_and = 0, nb_iter ; int total_dim; char * name; - CloogConstraints *copy; + CloogConstraintSet *copy; struct clast_guard *g; cloog_int_t one; @@ -767,20 +767,20 @@ static void insert_guard(CloogConstraints *constraints, int level, cloog_int_init(one); cloog_int_set_si(one, 1); - total_dim = cloog_constraints_total_dimension(constraints); + total_dim = cloog_constraint_set_total_dimension(constraints); g = new_clast_guard(2 * total_dim); /* Well, it looks complicated because I wanted to have a particular, more * readable, ordering, obviously this function may be far much simpler ! */ - copy = cloog_constraints_copy(constraints); + copy = cloog_constraint_set_copy(constraints); nb_iter = total_dim - infos->names->nb_parameters; nb_and = 0 ; /* We search for guard parts. */ for (i = 1; i <= total_dim; i++) - for (j = 0; j< cloog_constraints_count(copy); j++) + for (j = 0; j< cloog_constraint_set_count(copy); j++) if (cloog_constraint_involves(copy, j, i-1) && (!cloog_constraint_involves(copy, j, level-1) || (nb_iter < level))) { struct clast_term *t; @@ -822,12 +822,12 @@ static void insert_guard(CloogConstraints *constraints, int level, if (minmax == -1) continue; - for (l = j + 1; l < cloog_constraints_count(copy); l++) + for (l = j + 1; l < cloog_constraint_set_count(copy); l++) if (((minmax == 1) && cloog_constraint_is_lower_bound(copy, l, i-1)) || ((minmax == 0) && cloog_constraint_is_upper_bound(copy, l, i-1))) cloog_constraint_clear(copy, l); } - cloog_constraints_free(copy); + cloog_constraint_set_free(copy); g->n = nb_and; if (nb_and) { @@ -903,14 +903,14 @@ static void Euclid(cloog_int_t a, cloog_int_t b, * the number of parameters in matrix (nb_par), and the arrays of iterator * names and parameters (iters and params). */ -static void insert_modulo_guard(CloogConstraints *constraints, int upper, +static void insert_modulo_guard(CloogConstraintSet *constraints, int upper, int lower, int level, struct clast_stmt ***next, CloogInfos *infos) { int i, j, k, nb_elts = 0, len, len2, nb_iter, in_stride = 0, nb_par; struct cloog_vec *line_vector, *line_vector2; cloog_int_t *line, *line2, val, val2, x, y, g; - CloogConstraints *equal_constraints = cloog_equal_constraints(infos->equal); + CloogConstraintSet *equal_constraints = cloog_equal_constraints(infos->equal); cloog_int_init(val); cloog_constraint_coefficient_get(constraints, upper, level-1, &val); @@ -919,8 +919,8 @@ static void insert_modulo_guard(CloogConstraints *constraints, int upper, return; } - len = cloog_constraints_total_dimension(constraints) + 2; - len2 = cloog_constraints_total_dimension(equal_constraints) + 2; + len = cloog_constraint_set_total_dimension(constraints) + 2; + len2 = cloog_constraint_set_total_dimension(equal_constraints) + 2; nb_par = infos->names->nb_parameters; nb_iter = len - 2 - nb_par; @@ -1120,7 +1120,7 @@ static void insert_modulo_guard(CloogConstraints *constraints, int upper, * - July 14th 2003: (debug) no more print the constant in the modulo guard when * it was previously included in a stride calculation. */ -static void insert_equation(CloogConstraints *constraints, int upper, int lower, +static void insert_equation(CloogConstraintSet *constraints, int upper, int lower, int level, struct clast_stmt ***next, CloogInfos *infos) { struct clast_expr *e; @@ -1176,7 +1176,7 @@ static void insert_equation(CloogConstraints *constraints, int upper, int lower, * - March 6th 2003: infinite domain support. * - June 29th 2003: non-unit strides support. */ -static void insert_for(CloogConstraints *constraints, int level, +static void insert_for(CloogConstraintSet *constraints, int level, struct clast_stmt ***next, CloogInfos *infos) { char * iterator ; @@ -1340,7 +1340,7 @@ static void insert_loop(CloogLoop * loop, int level, int scalar, struct clast_stmt ***next, CloogInfos *infos) { int i, j, equality=0, scalar_level; - CloogConstraints *constraints, *temp; + CloogConstraintSet *constraints, *temp; struct clast_stmt **top = *next; /* It can happen that loop be NULL when an input polyhedron is empty. */ @@ -1351,10 +1351,10 @@ static void insert_loop(CloogLoop * loop, int level, int scalar, * thus we normalize it, we also simplify it with the equalities. */ temp = cloog_domain_constraints(loop->domain); - cloog_constraints_normalize(temp,level); - constraints = cloog_constraints_simplify(temp,infos->equal,level, + cloog_constraint_set_normalize(temp,level); + constraints = cloog_constraint_set_simplify(temp,infos->equal,level, infos->names->nb_parameters); - cloog_constraints_free(temp); + cloog_constraint_set_free(temp); cloog_int_set(infos->stride[level-1], loop->stride); /* First of all we have to print the guard. */ @@ -1364,15 +1364,15 @@ static void insert_loop(CloogLoop * loop, int level, int scalar, scalar_level = scalar ; insert_scalar(loop,level,&scalar, next, infos); - if (cloog_constraints_contain_level(constraints, level, + if (cloog_constraint_set_contains_level(constraints, level, infos->names->nb_parameters)) { /* We scan all the constraints to know in which case we are : * [[if] equation] or [for]. */ - if ((i = cloog_constraints_defining_equality(constraints, level)) != -1) { + if ((i = cloog_constraint_set_defining_equality(constraints, level)) != -1) { insert_equation(constraints, i, -1, level, next, infos); equality = 1 ; - } else if ((i = cloog_constraints_defining_inequalities(constraints, + } else if ((i = cloog_constraint_set_defining_inequalities(constraints, level, &j, infos->names->nb_parameters)) != -1) { insert_equation(constraints, i, j, level, next, infos); } else @@ -1387,7 +1387,7 @@ static void insert_loop(CloogLoop * loop, int level, int scalar, insert_loop(loop->inner, level+1,scalar, next, infos); cloog_equal_del(infos->equal,level); - cloog_constraints_free(constraints); + cloog_constraint_set_free(constraints); /* Go to the next loop on the same level. */ while (*top) diff --git a/source/polylib/domain.c b/source/polylib/domain.c index de596ee..7c40cd0 100644 --- a/source/polylib/domain.c +++ b/source/polylib/domain.c @@ -144,7 +144,7 @@ CloogMatrix * cloog_domain_domain2matrix(CloogDomain * domain) return cloog_matrix_matrix(Polyhedron2Constraints(domain->polyhedron)); } -CloogConstraints *cloog_domain_constraints(CloogDomain *domain) +CloogConstraintSet *cloog_domain_constraints(CloogDomain *domain) { return cloog_domain_domain2matrix(domain); } diff --git a/source/polylib/matrix.c b/source/polylib/matrix.c index ff24afe..2b3e8b8 100644 --- a/source/polylib/matrix.c +++ b/source/polylib/matrix.c @@ -115,12 +115,12 @@ void cloog_matrix_free(CloogMatrix * matrix) Matrix_Free(matrix) ; } -void cloog_constraints_free(CloogConstraints *constraints) +void cloog_constraint_set_free(CloogConstraintSet *constraints) { cloog_matrix_free(constraints); } -int cloog_constraints_contain_level(CloogConstraints *constraints, +int cloog_constraint_set_contains_level(CloogConstraintSet *constraints, int level, int nb_parameters) { return constraints->NbColumns - 2 - nb_parameters >= level; @@ -133,7 +133,7 @@ int cloog_constraints_contain_level(CloogConstraints *constraints, * PolyLib can give more than one equality, we use just the first one * (this is a PolyLib problem, but all equalities are equivalent). */ -int cloog_constraints_defining_equality(CloogConstraints *matrix, int level) +int cloog_constraint_set_defining_equality(CloogConstraintSet *matrix, int level) { int i; @@ -176,7 +176,7 @@ static int Vector_Opposite(Value *p1, Value *p2, unsigned len) * guards corresponding to the other constraints, and this has not * been implemented yet. */ -int cloog_constraints_defining_inequalities(CloogConstraints *matrix, +int cloog_constraint_set_defining_inequalities(CloogConstraintSet *matrix, int level, int *lower, int nb_par) { int i, j, k; @@ -236,7 +236,7 @@ int cloog_constraints_defining_inequalities(CloogConstraints *matrix, return -1; } -int cloog_constraints_total_dimension(CloogConstraints *constraints) +int cloog_constraint_set_total_dimension(CloogConstraintSet *constraints) { return constraints->NbColumns - 2; } @@ -404,7 +404,7 @@ int cloog_equal_count(CloogEqualities *equal) return equal->constraints->NbRows; } -CloogConstraints *cloog_equal_constraints(CloogEqualities *equal) +CloogConstraintSet *cloog_equal_constraints(CloogEqualities *equal) { return equal->constraints; } @@ -436,7 +436,7 @@ CloogConstraints *cloog_equal_constraints(CloogEqualities *equal) * ONE_TIME_LOOP is -1, an invalid read was possible. * - October 19th 2005: Removal of the once-time-loop specific processing. */ -static int cloog_constraint_equal_type(CloogConstraints *constraints, +static int cloog_constraint_equal_type(CloogConstraintSet *constraints, int level, int line) { int i, one=0 ; @@ -559,7 +559,7 @@ static void cloog_equal_update(CloogEqualities *equal, int level, int nb_par) * - July 2nd 2002: first version. * - October 19th 2005: Addition of the once-time-loop specific processing. */ -void cloog_equal_add(CloogEqualities *equal, CloogConstraints *matrix, +void cloog_equal_add(CloogEqualities *equal, CloogConstraintSet *matrix, int level, int line, int nb_par) { int i ; @@ -665,7 +665,7 @@ void cloog_equal_del(CloogEqualities *equal, int level) ******************************************************************************/ /** - * Function cloog_constraints_normalize: + * Function cloog_constraint_set_normalize: * This function will modify the constraint system in such a way that when * there is an equality depending on the element at level 'level', there are * no more (in)equalities depending on this element. For instance, try @@ -684,7 +684,7 @@ void cloog_equal_del(CloogEqualities *equal, int level) * - November 4th 2005: Complete rewriting, simpler and faster. It is no more an * adaptation from URGent. */ -void cloog_constraints_normalize(CloogConstraints *matrix, int level) +void cloog_constraint_set_normalize(CloogConstraintSet *matrix, int level) { int ref, i, j ; Value factor_i, factor_ref, temp_i, temp_ref, gcd ; @@ -743,12 +743,12 @@ void cloog_constraints_normalize(CloogConstraints *matrix, int level) /** - * cloog_constraints_copy function: + * cloog_constraint_set_copy function: * this functions builds and returns a "hard copy" (not a pointer copy) of a * CloogMatrix data structure. * - October 26th 2005: first version. */ -CloogConstraints *cloog_constraints_copy(CloogConstraints *matrix) +CloogConstraintSet *cloog_constraint_set_copy(CloogConstraintSet *matrix) { int i, j ; CloogMatrix * copy ; @@ -886,7 +886,7 @@ Value *cloog_equal_vector_simplify(CloogEqualities *equal, Value *vector, /** - * cloog_constraints_simplify function: + * cloog_constraint_set_simplify function: * this function simplify all constraints inside the matrix "matrix" thanks to * an equality matrix "equal" that gives for some elements of the affine * constraint an equality with other elements, preferably constants. @@ -900,7 +900,7 @@ Value *cloog_equal_vector_simplify(CloogEqualities *equal, Value *vector, ** * - November 4th 2005: first version. */ -CloogConstraints *cloog_constraints_simplify(CloogConstraints *matrix, +CloogConstraintSet *cloog_constraint_set_simplify(CloogConstraintSet *matrix, CloogEqualities *equal, int level, int nb_par) { int i, j, k ; Value * vector ; @@ -943,7 +943,7 @@ CloogConstraints *cloog_constraints_simplify(CloogConstraints *matrix, } -int cloog_constraints_count(CloogConstraints *constraints) +int cloog_constraint_set_count(CloogConstraintSet *constraints) { return constraints->NbRows; } @@ -951,27 +951,27 @@ int cloog_constraints_count(CloogConstraints *constraints) /** * Return true if constraint c involves variable v (zero-based). */ -int cloog_constraint_involves(CloogConstraints *constraints, int c, int v) +int cloog_constraint_involves(CloogConstraintSet *constraints, int c, int v) { return value_notzero_p(constraints->p[c][1+v]); } -int cloog_constraint_is_lower_bound(CloogConstraints *constraints, int c, int v) +int cloog_constraint_is_lower_bound(CloogConstraintSet *constraints, int c, int v) { return value_pos_p(constraints->p[c][1+v]); } -int cloog_constraint_is_upper_bound(CloogConstraints *constraints, int c, int v) +int cloog_constraint_is_upper_bound(CloogConstraintSet *constraints, int c, int v) { return value_neg_p(constraints->p[c][1+v]); } -int cloog_constraint_is_equality(CloogConstraints *constraints, int c) +int cloog_constraint_is_equality(CloogConstraintSet *constraints, int c) { return value_zero_p(constraints->p[c][0]); } -void cloog_constraint_clear(CloogConstraints *constraints, int c) +void cloog_constraint_clear(CloogConstraintSet *constraints, int c) { int k; @@ -979,19 +979,19 @@ void cloog_constraint_clear(CloogConstraints *constraints, int c) value_set_si(constraints->p[c][k], 0); } -void cloog_constraint_coefficient_get(CloogConstraints *constraints, +void cloog_constraint_coefficient_get(CloogConstraintSet *constraints, int c, int var, Value *val) { value_assign(*val, constraints->p[c][1+var]); } -void cloog_constraint_coefficient_set(CloogConstraints *constraints, +void cloog_constraint_coefficient_set(CloogConstraintSet *constraints, int c, int var, Value val) { value_assign(constraints->p[c][1+var], val); } -void cloog_constraint_constant_get(CloogConstraints *constraints, +void cloog_constraint_constant_get(CloogConstraintSet *constraints, int c, Value *val) { value_assign(*val, constraints->p[c][constraints->NbColumns-1]); @@ -1002,7 +1002,7 @@ void cloog_constraint_constant_get(CloogConstraints *constraints, * i.e., first the coefficients of the variables, then the coefficients * of the parameters and finally the constant. */ -void cloog_constraint_copy(CloogConstraints *constraints, int c, Value *dst) +void cloog_constraint_copy(CloogConstraintSet *constraints, int c, Value *dst) { Vector_Copy(constraints->p[c]+1, dst, constraints->NbColumns-1); } -- 2.11.4.GIT