rename isl_{map,set}_add to isl_{map,set}_add_basic_{map,set}

diff --git a/include/isl_map.h b/include/isl_map.h
index e6bfd04..f2d7945 100644 (file)
--- a/include/isl_map.h
+++ b/include/isl_map.h
@@ -259,7 +259,8 @@ __isl_give isl_map *isl_map_empty(__isl_take isl_dim *dim);
 struct isl_map *isl_map_empty_like(struct isl_map *model);
 struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model);
 struct isl_map *isl_map_dup(struct isl_map *map);
-struct isl_map *isl_map_add(struct isl_map *map, struct isl_basic_map *bmap);
+__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
+                                               __isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_identity(__isl_take isl_dim *set_dim);
 struct isl_map *isl_map_identity_like(struct isl_map *model);
 struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model);

diff --git a/include/isl_set.h b/include/isl_set.h
index 16d78cb..ea06e7e 100644 (file)
--- a/include/isl_set.h
+++ b/include/isl_set.h
@@ -193,7 +193,8 @@ __isl_give isl_set *isl_set_empty(__isl_take isl_dim *dim);
 struct isl_set *isl_set_empty_like(struct isl_set *set);
 __isl_give isl_set *isl_set_universe(__isl_take isl_dim *dim);
 __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model);
-struct isl_set *isl_set_add(struct isl_set *set, struct isl_basic_set *bset);
+__isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
+                                               __isl_take isl_basic_set *bset);
 struct isl_set *isl_set_finalize(struct isl_set *set);
 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
 void isl_set_free(__isl_take isl_set *set);

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index 290e043..77dcc2a 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -318,7 +318,7 @@ error:
        return NULL;
 }
 
-static struct isl_set *isl_set_add_equality(struct isl_set *set, isl_int *c)
+static struct isl_set *isl_set_add_basic_set_equality(struct isl_set *set, isl_int *c)
 {
        int i;
 
@@ -592,7 +592,7 @@ static struct isl_mat *initial_facet_constraint(struct isl_set *set,
 
        while (bounds->n_row > 1) {
                slice = isl_set_copy(set);
-               slice = isl_set_add_equality(slice, bounds->row[0]);
+               slice = isl_set_add_basic_set_equality(slice, bounds->row[0]);
                face = isl_set_affine_hull(slice);
                if (!face)
                        goto error;
@@ -1397,8 +1397,8 @@ static struct isl_basic_set *convex_hull_pair_pointed(
        bset1 = homogeneous_map(bset1, isl_mat_copy(T2));
        bset2 = homogeneous_map(bset2, T2);
        set = isl_set_alloc_dim(isl_basic_set_get_dim(bset1), 2, 0);
-       set = isl_set_add(set, bset1);
-       set = isl_set_add(set, bset2);
+       set = isl_set_add_basic_set(set, bset1);
+       set = isl_set_add_basic_set(set, bset2);
        hull = uset_convex_hull(set);
        hull = isl_basic_set_preimage(hull, T);
         
@@ -1438,8 +1438,8 @@ static struct isl_basic_set *convex_hull_pair(struct isl_basic_set *bset1,
        if (lin->n_eq < isl_basic_set_total_dim(lin)) {
                struct isl_set *set;
                set = isl_set_alloc_dim(isl_basic_set_get_dim(bset1), 2, 0);
-               set = isl_set_add(set, bset1);
-               set = isl_set_add(set, bset2);
+               set = isl_set_add_basic_set(set, bset1);
+               set = isl_set_add_basic_set(set, bset2);
                return modulo_lineality(set, lin);
        }
        isl_basic_set_free(lin);
@@ -1516,7 +1516,7 @@ static struct isl_basic_set *uset_combined_lineality_space(struct isl_set *set)
 
        lin = isl_set_alloc_dim(isl_set_get_dim(set), set->n, 0);
        for (i = 0; i < set->n; ++i)
-               lin = isl_set_add(lin,
+               lin = isl_set_add_basic_set(lin,
                    isl_basic_set_lineality_space(isl_basic_set_copy(set->p[i])));
        isl_set_free(set);
        return isl_set_affine_hull(lin);
@@ -1558,7 +1558,7 @@ static struct isl_basic_set *uset_convex_hull_unbounded(struct isl_set *set)
                        break;
                }
                if (t->n_eq < isl_basic_set_total_dim(t)) {
-                       set = isl_set_add(set, convex_hull);
+                       set = isl_set_add_basic_set(set, convex_hull);
                        return modulo_lineality(set, t);
                }
                isl_basic_set_free(t);

diff --git a/isl_map.c b/isl_map.c
index 3cc76a4..eab41d9 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -1567,7 +1567,7 @@ struct isl_set *isl_set_dup(struct isl_set *set)
        if (!dup)
                return NULL;
        for (i = 0; i < set->n; ++i)
-               dup = isl_set_add(dup, isl_basic_set_copy(set->p[i]));
+               dup = isl_set_add_basic_set(dup, isl_basic_set_copy(set->p[i]));
        return dup;
 }
 
@@ -1583,7 +1583,7 @@ struct isl_set *isl_set_from_basic_set(struct isl_basic_set *bset)
                isl_basic_set_free(bset);
                return NULL;
        }
-       return isl_set_add(set, bset);
+       return isl_set_add_basic_set(set, bset);
 }
 
 struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap)
@@ -1598,12 +1598,13 @@ struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap)
                isl_basic_map_free(bmap);
                return NULL;
        }
-       return isl_map_add(map, bmap);
+       return isl_map_add_basic_map(map, bmap);
 }
 
-struct isl_set *isl_set_add(struct isl_set *set, struct isl_basic_set *bset)
+__isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
+                                               __isl_take isl_basic_set *bset)
 {
-       return (struct isl_set *)isl_map_add((struct isl_map *)set,
+       return (struct isl_set *)isl_map_add_basic_map((struct isl_map *)set,
                                                (struct isl_basic_map *)bset);
 }
 
@@ -1917,7 +1918,7 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2)
                        if (isl_basic_map_is_empty(part))
                                isl_basic_map_free(part);
                        else
-                               result = isl_map_add(result, part);
+                               result = isl_map_add_basic_map(result, part);
                        if (!result)
                                goto error;
                }
@@ -2227,7 +2228,7 @@ struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
                        if (isl_basic_map_is_empty(part))
                                isl_basic_map_free(part);
                        else
-                               result = isl_map_add(result, part);
+                               result = isl_map_add_basic_map(result, part);
                        if (!result)
                                goto error;
                }
@@ -2488,10 +2489,10 @@ static __isl_give isl_map *map_lex_lte(__isl_take isl_dim *dims, int equal)
        map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
 
        for (i = 0; i < dim; ++i)
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_less_at(isl_dim_copy(dims), i));
        if (equal)
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_equal(isl_dim_copy(dims), dim));
 
        isl_dim_free(dims);
@@ -2520,10 +2521,10 @@ static __isl_give isl_map *map_lex_gte(__isl_take isl_dim *dims, int equal)
        map = isl_map_alloc_dim(isl_dim_copy(dims), dim + equal, ISL_MAP_DISJOINT);
 
        for (i = 0; i < dim; ++i)
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_more_at(isl_dim_copy(dims), i));
        if (equal)
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_equal(isl_dim_copy(dims), dim));
 
        isl_dim_free(dims);
@@ -3064,7 +3065,7 @@ struct isl_map *isl_map_universe(struct isl_dim *dim)
        if (!dim)
                return NULL;
        map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
-       map = isl_map_add(map, isl_basic_map_universe(dim));
+       map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
        return map;
 }
 
@@ -3074,7 +3075,7 @@ struct isl_set *isl_set_universe(struct isl_dim *dim)
        if (!dim)
                return NULL;
        set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
-       set = isl_set_add(set, isl_basic_set_universe(dim));
+       set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
        return set;
 }
 
@@ -3094,11 +3095,12 @@ struct isl_map *isl_map_dup(struct isl_map *map)
                return NULL;
        dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
        for (i = 0; i < map->n; ++i)
-               dup = isl_map_add(dup, isl_basic_map_copy(map->p[i]));
+               dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
        return dup;
 }
 
-struct isl_map *isl_map_add(struct isl_map *map, struct isl_basic_map *bmap)
+__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
+                                               __isl_take isl_basic_map *bmap)
 {
        if (!bmap || !map)
                goto error;
@@ -4111,13 +4113,13 @@ struct isl_map *isl_map_union_disjoint(
        if (!map)
                goto error;
        for (i = 0; i < map1->n; ++i) {
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_copy(map1->p[i]));
                if (!map)
                        goto error;
        }
        for (i = 0; i < map2->n; ++i) {
-               map = isl_map_add(map,
+               map = isl_map_add_basic_map(map,
                                  isl_basic_map_copy(map2->p[i]));
                if (!map)
                        goto error;
@@ -4176,7 +4178,7 @@ struct isl_map *isl_map_intersect_range(
                goto error;
        for (i = 0; i < map->n; ++i)
                for (j = 0; j < set->n; ++j) {
-                       result = isl_map_add(result,
+                       result = isl_map_add_basic_map(result,
                            isl_basic_map_intersect_range(
                                isl_basic_map_copy(map->p[i]),
                                isl_basic_set_copy(set->p[j])));
@@ -4231,7 +4233,7 @@ struct isl_map *isl_map_apply_range(
                goto error;
        for (i = 0; i < map1->n; ++i)
                for (j = 0; j < map2->n; ++j) {
-                       result = isl_map_add(result,
+                       result = isl_map_add_basic_map(result,
                            isl_basic_map_apply_range(
                                isl_basic_map_copy(map1->p[i]),
                                isl_basic_map_copy(map2->p[j])));
@@ -4301,7 +4303,7 @@ struct isl_set *isl_map_deltas(struct isl_map *map)
        if (!result)
                goto error;
        for (i = 0; i < map->n; ++i)
-               result = isl_set_add(result,
+               result = isl_set_add_basic_set(result,
                          isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
        isl_map_free(map);
        return result;
@@ -4360,7 +4362,7 @@ struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
 static struct isl_map *map_identity(struct isl_dim *dim)
 {
        struct isl_map *map = isl_map_alloc_dim(dim, 1, ISL_MAP_DISJOINT);
-       return isl_map_add(map, basic_map_identity(isl_dim_copy(dim)));
+       return isl_map_add_basic_map(map, basic_map_identity(isl_dim_copy(dim)));
 }
 
 struct isl_map *isl_map_identity(struct isl_dim *set_dim)
@@ -4646,8 +4648,8 @@ struct isl_map *isl_basic_map_union(
        map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
        if (!map)
                goto error;
-       map = isl_map_add(map, bmap1);
-       map = isl_map_add(map, bmap2);
+       map = isl_map_add_basic_map(map, bmap1);
+       map = isl_map_add_basic_map(map, bmap2);
        return map;
 error:
        isl_basic_map_free(bmap1);
@@ -5596,7 +5598,7 @@ struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
                        if (isl_basic_map_is_empty(part))
                                isl_basic_map_free(part);
                        else
-                               result = isl_map_add(result, part);
+                               result = isl_map_add_basic_map(result, part);
                        if (!result)
                                goto error;
                }

diff --git a/isl_map_piplib.c b/isl_map_piplib.c
index 08a3104..65a9f67 100644 (file)
--- a/isl_map_piplib.c
+++ b/isl_map_piplib.c
@@ -231,7 +231,7 @@ static struct isl_map *scan_quast_r(struct scan_data *data, PipQuast *q,
                        if (add_equality(data->ctx, bmap, data->pos, j,
                                                l->vector) < 0)
                                goto error;
-               map = isl_map_add(map, isl_basic_map_copy(bmap));
+               map = isl_map_add_basic_map(map, isl_basic_map_copy(bmap));
                if (isl_basic_map_free_equality(bmap, n_out))
                        goto error;
        } else if (data->rest) {
@@ -240,7 +240,7 @@ static struct isl_map *scan_quast_r(struct scan_data *data, PipQuast *q,
                bset = isl_basic_set_drop_dims(bset, n_in, n_out);
                if (!bset)
                        goto error;
-               *data->rest = isl_set_add(*data->rest, bset);
+               *data->rest = isl_set_add_basic_set(*data->rest, bset);
        }
 
        if (isl_basic_map_free_inequality(bmap, 2*(bmap->n_div - old_n_div)))

diff --git a/isl_tab_pip.c b/isl_tab_pip.c
index 35a34ff..e89c843 100644 (file)
--- a/isl_tab_pip.c
+++ b/isl_tab_pip.c
@@ -532,7 +532,7 @@ static void sol_map_add_empty(struct isl_sol_map *sol,
        sol->empty = isl_set_grow(sol->empty, 1);
        bset = isl_basic_set_simplify(bset);
        bset = isl_basic_set_finalize(bset);
-       sol->empty = isl_set_add(sol->empty, isl_basic_set_copy(bset));
+       sol->empty = isl_set_add_basic_set(sol->empty, isl_basic_set_copy(bset));
        if (!sol->empty)
                goto error;
        isl_basic_set_free(bset);
@@ -642,7 +642,7 @@ static void sol_map_add(struct isl_sol_map *sol,
        bmap = isl_basic_map_simplify(bmap);
        bmap = isl_basic_map_finalize(bmap);
        sol->map = isl_map_grow(sol->map, 1);
-       sol->map = isl_map_add(sol->map, bmap);
+       sol->map = isl_map_add_basic_map(sol->map, bmap);
        if (!sol->map)
                goto error;
        isl_basic_set_free(dom);