rename F_ and FL_ macros to ISL_F_ and ISL_FL_ to avoid name clashes

diff --git a/include/isl_ctx.h.in b/include/isl_ctx.h.in
index 112b27f..7f717ca 100644 (file)
--- a/include/isl_ctx.h.in
+++ b/include/isl_ctx.h.in
@@ -54,15 +54,15 @@ struct isl_ctx {
 
 /* Some helper macros */
 
-#define FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
-#define FL_SET(l, f)    ((l) |= (f))
-#define FL_CLR(l, f)    ((l) &= ~(f))
-#define FL_ISSET(l, f)  ((l) & (f))
-
-#define F_INIT(p, f)    FL_INIT((p)->flags, f)  /* Structure element flags. */
-#define F_SET(p, f)     FL_SET((p)->flags, f)
-#define F_CLR(p, f)     FL_CLR((p)->flags, f)
-#define F_ISSET(p, f)   FL_ISSET((p)->flags, f)
+#define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
+#define ISL_FL_SET(l, f)    ((l) |= (f))
+#define ISL_FL_CLR(l, f)    ((l) &= ~(f))
+#define ISL_FL_ISSET(l, f)  ((l) & (f))
+
+#define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
+#define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
+#define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
+#define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
 
 #define isl_alloc(ctx,type,size)       (type *)malloc(size)
 #define isl_calloc(ctx,type,size)      (type *)calloc(1, size)

diff --git a/isl_affine_hull.c b/isl_affine_hull.c
index 0abe945..a8d6a03 100644 (file)
--- a/isl_affine_hull.c
+++ b/isl_affine_hull.c
@@ -19,13 +19,13 @@ struct isl_basic_map *isl_basic_map_implicit_equalities(
        if (!bmap)
                return bmap;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                return bmap;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_NO_IMPLICIT))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NO_IMPLICIT))
                return bmap;
 
        ctx = bmap->ctx;
-       rational = F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
+       rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
        isl_int_init(opt);
        isl_int_init(opt_denom);
        if (!rational)
@@ -53,7 +53,7 @@ struct isl_basic_map *isl_basic_map_implicit_equalities(
        isl_int_clear(opt_denom);
        isl_int_clear(opt);
 
-       F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
        return bmap;
 error:
        isl_int_clear(opt);
@@ -348,19 +348,19 @@ static struct isl_basic_set *equalities_in_underlying_set(
        dim = isl_basic_set_n_dim(bset);
        for (i = 0; i < dim; ++i) {
                struct isl_basic_set *point;
-               if (F_ISSET(hull, ISL_BASIC_SET_EMPTY))
+               if (ISL_F_ISSET(hull, ISL_BASIC_SET_EMPTY))
                        break;
                for (j = 0; j < hull->n_eq; ++j) {
                        point = outside_point(ctx, bset, hull->eq[j], 1);
                        if (!point)
                                goto error;
-                       if (!F_ISSET(point, ISL_BASIC_SET_EMPTY))
+                       if (!ISL_F_ISSET(point, ISL_BASIC_SET_EMPTY))
                                break;
                        isl_basic_set_free(point);
                        point = outside_point(ctx, bset, hull->eq[j], 0);
                        if (!point)
                                goto error;
-                       if (!F_ISSET(point, ISL_BASIC_SET_EMPTY))
+                       if (!ISL_F_ISSET(point, ISL_BASIC_SET_EMPTY))
                                break;
                        isl_basic_set_free(point);
                }
@@ -393,11 +393,11 @@ struct isl_basic_map *isl_basic_map_detect_equalities(
                return NULL;
        if (bmap->n_ineq == 0)
                return bmap;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                return bmap;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
                return bmap;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
                return isl_basic_map_implicit_equalities(bmap);
 
        hull = equalities_in_underlying_set(isl_basic_map_copy(bmap));
@@ -413,7 +413,7 @@ struct isl_basic_map *isl_basic_map_detect_equalities(
                                1 + isl_basic_set_total_dim(hull));
        }
        isl_basic_set_free(hull);
-       F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
        bmap = isl_basic_map_simplify(bmap);
        return isl_basic_map_finalize(bmap);
 error:
@@ -436,7 +436,7 @@ struct isl_basic_map *isl_basic_map_affine_hull(struct isl_basic_map *bmap)
        if (bmap->n_ineq == 0)
                return bmap;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
                bmap = isl_basic_map_cow(bmap);
                isl_basic_map_free_inequality(bmap, bmap->n_ineq);
                return bmap;

diff --git a/isl_constraint.c b/isl_constraint.c
index 8668341..89dbfe7 100644 (file)
--- a/isl_constraint.c
+++ b/isl_constraint.c
@@ -303,7 +303,7 @@ struct isl_constraint *isl_constraint_negate(struct isl_constraint *constraint)
        total = isl_basic_map_total_dim(constraint->bmap);
        isl_seq_neg(constraint->line[0], constraint->line[0], 1 + total);
        isl_int_sub_ui(constraint->line[0][0], constraint->line[0][0], 1);
-       F_CLR(constraint->bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(constraint->bmap, ISL_BASIC_MAP_NORMALIZED);
        return constraint;
 error:
        isl_constraint_free(constraint);

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index 780c1a0..d978108 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -91,9 +91,9 @@ struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap)
        if (!bmap)
                return NULL;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                return bmap;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_NO_REDUNDANT))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NO_REDUNDANT))
                return bmap;
 
        ctx = bmap->ctx;
@@ -107,7 +107,7 @@ struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap)
                                bmap->ineq[bmap->n_ineq], &opt_n, &opt_d);
                if (redundant == -1)
                        goto error;
-               if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+               if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                        break;
                bmap->n_ineq++;
                swap_ineq(bmap, i, bmap->n_ineq-1);
@@ -117,7 +117,7 @@ struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap)
        isl_int_clear(opt_n);
        isl_int_clear(opt_d);
 
-       F_SET(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
        return bmap;
 error:
        isl_int_clear(opt_n);
@@ -150,7 +150,7 @@ static int uset_is_bound(struct isl_ctx *ctx, struct isl_set *set,
        for (j = 0; j < set->n; ++j) {
                enum isl_lp_result res;
 
-               if (F_ISSET(set->p[j], ISL_BASIC_SET_EMPTY))
+               if (ISL_F_ISSET(set->p[j], ISL_BASIC_SET_EMPTY))
                        continue;
 
                res = isl_solve_lp((struct isl_basic_map*)set->p[j],
@@ -283,14 +283,14 @@ static struct isl_basic_set *isl_basic_set_set_rational(
        if (!bset)
                return NULL;
 
-       if (F_ISSET(bset, ISL_BASIC_MAP_RATIONAL))
+       if (ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL))
                return bset;
 
        bset = isl_basic_set_cow(bset);
        if (!bset)
                return NULL;
 
-       F_SET(bset, ISL_BASIC_MAP_RATIONAL);
+       ISL_F_SET(bset, ISL_BASIC_MAP_RATIONAL);
 
        return isl_basic_set_finalize(bset);
 }
@@ -320,7 +320,7 @@ static struct isl_basic_set *isl_basic_set_add_equality(struct isl_ctx *ctx,
        unsigned total;
        unsigned dim;
 
-       if (F_ISSET(bset, ISL_BASIC_SET_EMPTY))
+       if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
                return bset;
 
        isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
@@ -1177,7 +1177,7 @@ struct isl_basic_map *isl_map_convex_hull(struct isl_map *map)
 
        convex_hull = isl_basic_map_overlying_set(bset, model);
 
-       F_CLR(convex_hull, ISL_BASIC_MAP_RATIONAL);
+       ISL_F_CLR(convex_hull, ISL_BASIC_MAP_RATIONAL);
        return convex_hull;
 error:
        isl_set_free(set);

diff --git a/isl_equalities.c b/isl_equalities.c
index 2126271..2b3ed9c 100644 (file)
--- a/isl_equalities.c
+++ b/isl_equalities.c
@@ -563,7 +563,7 @@ struct isl_basic_set *isl_basic_set_remove_equalities(
                return NULL;
        isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
        bset = isl_basic_set_gauss(bset, NULL);
-       if (F_ISSET(bset, ISL_BASIC_SET_EMPTY))
+       if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
                return bset;
        bset = compress_variables(bset->ctx, bset, T, T2);
        return bset;

diff --git a/isl_map.c b/isl_map.c
index 2cc5855..0aa529b 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -354,7 +354,7 @@ static void dup_constraints(
                int j = isl_basic_map_alloc_div(dst);
                isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
        }
-       F_SET(dst, ISL_BASIC_SET_FINAL);
+       ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
 }
 
 struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
@@ -386,7 +386,7 @@ struct isl_basic_set *isl_basic_set_copy(struct isl_basic_set *bset)
        if (!bset)
                return NULL;
 
-       if (F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
+       if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
                bset->ref++;
                return bset;
        }
@@ -407,7 +407,7 @@ struct isl_basic_map *isl_basic_map_copy(struct isl_basic_map *bmap)
        if (!bmap)
                return NULL;
 
-       if (F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
+       if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
                bmap->ref++;
                return bmap;
        }
@@ -468,7 +468,7 @@ int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
                isl_seq_clr(bmap->eq[bmap->n_eq] +
                      1 + isl_basic_map_total_dim(bmap),
                      bmap->extra - bmap->n_div);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
        return bmap->n_eq++;
 }
 
@@ -519,9 +519,9 @@ void isl_basic_map_inequality_to_equality(
        bmap->n_eq++;
        bmap->n_ineq--;
        bmap->ineq++;
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
-       F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
 }
 
 int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
@@ -532,10 +532,10 @@ int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
        ctx = bmap->ctx;
        isl_assert(ctx, (bmap->ineq - bmap->eq) + bmap->n_ineq < bmap->c_size,
                        return -1);
-       F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
-       F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-       F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
        isl_seq_clr(bmap->ineq[bmap->n_ineq] +
                      1 + isl_basic_map_total_dim(bmap),
                      bmap->extra - bmap->n_div);
@@ -572,7 +572,7 @@ int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
                t = bmap->ineq[pos];
                bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
                bmap->ineq[bmap->n_ineq - 1] = t;
-               F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+               ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        }
        bmap->n_ineq--;
        return 0;
@@ -591,7 +591,7 @@ int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
        isl_seq_clr(bmap->div[bmap->n_div] +
                      1 + 1 + isl_basic_map_total_dim(bmap),
                      bmap->extra - bmap->n_div);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
        return bmap->n_div++;
 }
 
@@ -808,7 +808,7 @@ struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base,
        ext = add_constraints(ext, base, 0, 0);
        if (ext) {
                ext->flags = flags;
-               F_CLR(ext, ISL_BASIC_SET_FINAL);
+               ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
        }
 
        return ext;
@@ -877,7 +877,7 @@ struct isl_basic_map *isl_basic_map_cow(struct isl_basic_map *bmap)
                bmap->ref--;
                bmap = isl_basic_map_dup(bmap);
        }
-       F_CLR(bmap, ISL_BASIC_SET_FINAL);
+       ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
        return bmap;
 }
 
@@ -951,7 +951,7 @@ struct isl_basic_set *isl_basic_set_swap_vars(
 
        isl_blk_free(bset->ctx, blk);
 
-       F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+       ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
        return bset;
 
 error:
@@ -973,7 +973,7 @@ struct isl_set *isl_set_swap_vars(struct isl_set *set, unsigned n)
                        return NULL;
                }
        }
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 }
 
@@ -995,7 +995,7 @@ struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap)
        }
        isl_int_set_si(bmap->eq[i][0], 1);
        isl_seq_clr(bmap->eq[i]+1, total);
-       F_SET(bmap, ISL_BASIC_MAP_EMPTY);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
        return isl_basic_map_finalize(bmap);
 error:
        isl_basic_map_free(bmap);
@@ -1024,7 +1024,7 @@ static void swap_div(struct isl_basic_map *bmap, int a, int b)
 
        for (i = 0; i < bmap->n_div; ++i)
                isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b]);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 }
 
 /* Eliminate the specified n dimensions starting at first from the
@@ -1320,7 +1320,7 @@ int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
        isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
        isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
        isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        return 0;
 }
 
@@ -1610,9 +1610,9 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2)
                isl_assert(map1->ctx,
                            isl_dim_equal(map1->dim, map2->dim), goto error);
 
-       if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
-           F_ISSET(map2, ISL_MAP_DISJOINT))
-               FL_SET(flags, ISL_MAP_DISJOINT);
+       if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+           ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+               ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
        result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
                                map1->n * map2->n, flags);
@@ -2334,8 +2334,8 @@ struct isl_set *isl_map_range(struct isl_map *map)
                if (!set->p[i])
                        goto error;
        }
-       F_CLR(set, ISL_MAP_DISJOINT);
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_MAP_DISJOINT);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 error:
        isl_map_free(map);
@@ -2570,7 +2570,7 @@ struct isl_map *isl_map_add(struct isl_map *map, struct isl_basic_map *bmap)
        isl_assert(map->ctx, map->n < map->size, goto error);
        map->p[map->n] = bmap;
        map->n++;
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 error:
        if (map)
@@ -2698,7 +2698,7 @@ struct isl_map *isl_map_fix_si(struct isl_map *map,
                if (!map->p[i])
                        goto error;
        }
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 error:
        isl_map_free(map);
@@ -2776,7 +2776,7 @@ struct isl_map *isl_map_reverse(struct isl_map *map)
                if (!map->p[i])
                        goto error;
        }
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 error:
        isl_map_free(map);
@@ -2853,7 +2853,7 @@ struct isl_map *isl_map_compute_divs(struct isl_map *map)
        for (i = 1 ; i < map->n; ++i) {
                struct isl_map *r2;
                r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
-               if (F_ISSET(map, ISL_MAP_DISJOINT))
+               if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
                        res = isl_map_union_disjoint(res, r2);
                else
                        res = isl_map_union(res, r2);
@@ -2896,8 +2896,8 @@ struct isl_set *isl_map_domain(struct isl_map *map)
                if (!set->p[i])
                        goto error;
        }
-       F_CLR(set, ISL_MAP_DISJOINT);
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_MAP_DISJOINT);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 error:
        isl_map_free(map);
@@ -2925,9 +2925,9 @@ struct isl_map *isl_map_union_disjoint(
 
        isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
 
-       if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
-           F_ISSET(map2, ISL_MAP_DISJOINT))
-               FL_SET(flags, ISL_MAP_DISJOINT);
+       if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+           ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+               ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
        map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
                                map1->n + map2->n, flags);
@@ -2961,7 +2961,7 @@ struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2)
        if (!map1)
                return NULL;
        if (map1->n > 1)
-               F_CLR(map1, ISL_MAP_DISJOINT);
+               ISL_F_CLR(map1, ISL_MAP_DISJOINT);
        return map1;
 }
 
@@ -2989,9 +2989,9 @@ struct isl_map *isl_map_intersect_range(
        if (!map || !set)
                goto error;
 
-       if (F_ISSET(map, ISL_MAP_DISJOINT) &&
-           F_ISSET(set, ISL_MAP_DISJOINT))
-               FL_SET(flags, ISL_MAP_DISJOINT);
+       if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
+           ISL_F_ISSET(set, ISL_MAP_DISJOINT))
+               ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
        result = isl_map_alloc_dim(isl_dim_copy(map->dim),
                                        map->n * set->n, flags);
@@ -3067,7 +3067,7 @@ struct isl_map *isl_map_apply_range(
        isl_map_free(map1);
        isl_map_free(map2);
        if (result && result->n <= 1)
-               F_SET(result, ISL_MAP_DISJOINT);
+               ISL_F_SET(result, ISL_MAP_DISJOINT);
        return result;
 error:
        isl_map_free(map1);
@@ -3389,13 +3389,13 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap)
        if (!bmap)
                return -1;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                return 1;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
                struct isl_basic_map *copy = isl_basic_map_copy(bmap);
                copy = isl_basic_map_convex_hull(copy);
-               empty = F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
+               empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
                isl_basic_map_free(copy);
                return empty;
        }
@@ -3557,7 +3557,7 @@ struct isl_map *isl_map_align_divs(struct isl_map *map)
        for (i = 1; i < map->n; ++i)
                map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
 
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 }
 
@@ -3614,8 +3614,8 @@ static struct isl_map *subtract(struct isl_map *map, struct isl_basic_map *bmap)
        if (!map)
                goto error;
 
-       if (F_ISSET(map, ISL_MAP_DISJOINT))
-               FL_SET(flags, ISL_MAP_DISJOINT);
+       if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
+               ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
        max = map->n * (2 * bmap->n_eq + bmap->n_ineq);
        rest = isl_map_alloc_dim(isl_dim_copy(map->dim), max, flags);
@@ -3745,11 +3745,11 @@ struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
                return NULL;
 
        for (i = map->n-1; i >= 0; --i) {
-               if (!F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
+               if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
                        continue;
                isl_basic_map_free(map->p[i]);
                if (i != map->n-1) {
-                       F_CLR(map, ISL_MAP_NORMALIZED);
+                       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
                        map->p[i] = map->p[map->n-1];
                }
                map->n--;
@@ -3770,7 +3770,7 @@ struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
        if (!map || map->n == 0)
                return NULL;
        bmap = map->p[map->n-1];
-       isl_assert(map->ctx, F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
+       isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
        return isl_basic_map_copy(bmap);
 }
 
@@ -3794,7 +3794,7 @@ struct isl_map *isl_map_drop_basic_map(struct isl_map *map,
                        goto error;
                isl_basic_map_free(map->p[i]);
                if (i != map->n-1) {
-                       F_CLR(map, ISL_SET_NORMALIZED);
+                       ISL_F_CLR(map, ISL_SET_NORMALIZED);
                        map->p[i] = map->p[map->n-1];
                }
                map->n--;
@@ -4100,11 +4100,11 @@ struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
 {
        if (!bmap)
                return NULL;
-       if (F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
                return bmap;
        bmap = isl_basic_map_convex_hull(bmap);
        bmap = isl_basic_map_sort_constraints(bmap);
-       F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
        return bmap;
 }
 
@@ -4128,12 +4128,12 @@ static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1,
                return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
        if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
                return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
-       if (F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
-           F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
+           ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
                return 0;
-       if (F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY))
                return 1;
-       if (F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
+       if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
                return -1;
        if (bmap1->n_eq != bmap2->n_eq)
                return bmap1->n_eq - bmap2->n_eq;
@@ -4185,7 +4185,7 @@ struct isl_map *isl_map_normalize(struct isl_map *map)
 
        if (!map)
                return NULL;
-       if (F_ISSET(map, ISL_MAP_NORMALIZED))
+       if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED))
                return map;
        for (i = 0; i < map->n; ++i) {
                bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
@@ -4195,7 +4195,7 @@ struct isl_map *isl_map_normalize(struct isl_map *map)
                map->p[i] = bmap;
        }
        qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
-       F_SET(map, ISL_MAP_NORMALIZED);
+       ISL_F_SET(map, ISL_MAP_NORMALIZED);
        map = isl_map_remove_empty_parts(map);
        if (!map)
                return NULL;
@@ -4399,9 +4399,9 @@ struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2)
        isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
                                         map2->dim, isl_dim_param), goto error);
 
-       if (F_ISSET(map1, ISL_MAP_DISJOINT) &&
-           F_ISSET(map2, ISL_MAP_DISJOINT))
-               FL_SET(flags, ISL_MAP_DISJOINT);
+       if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
+           ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
+               ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
        result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
                                                   isl_dim_copy(map2->dim)),

diff --git a/isl_map_simplify.c b/isl_map_simplify.c
index 93c799b..fb2c5fc 100644 (file)
--- a/isl_map_simplify.c
+++ b/isl_map_simplify.c
@@ -69,7 +69,7 @@ struct isl_basic_set *isl_basic_set_drop_dims(
        if (!bset->dim)
                goto error;
 
-       F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+       ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
        bset = isl_basic_set_simplify(bset);
        return isl_basic_set_finalize(bset);
 error:
@@ -102,7 +102,7 @@ struct isl_set *isl_set_drop_dims(
                        goto error;
        }
 
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 error:
        isl_set_free(set);
@@ -152,7 +152,7 @@ struct isl_basic_map *isl_basic_map_drop(struct isl_basic_map *bmap,
        if (!bmap->dim)
                goto error;
 
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        bmap = isl_basic_map_simplify(bmap);
        return isl_basic_map_finalize(bmap);
 error:
@@ -190,7 +190,7 @@ struct isl_map *isl_map_drop(struct isl_map *map,
                if (!map->p[i])
                        goto error;
        }
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
 
        return map;
 error:
@@ -244,7 +244,7 @@ static struct isl_basic_map *isl_basic_map_drop_div(
 
                bmap->div[bmap->n_div - 1] = t;
        }
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        isl_basic_map_free_div(bmap, 1);
 
        return bmap;
@@ -270,7 +270,7 @@ static struct isl_basic_map *normalize_constraints(struct isl_basic_map *bmap)
                        isl_basic_map_drop_equality(bmap, i);
                        continue;
                }
-               if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+               if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
                        isl_int_gcd(gcd, gcd, bmap->eq[i][0]);
                if (isl_int_is_one(gcd))
                        continue;
@@ -291,7 +291,7 @@ static struct isl_basic_map *normalize_constraints(struct isl_basic_map *bmap)
                        isl_basic_map_drop_inequality(bmap, i);
                        continue;
                }
-               if (F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+               if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
                        isl_int_gcd(gcd, gcd, bmap->ineq[i][0]);
                if (isl_int_is_one(gcd))
                        continue;
@@ -390,7 +390,7 @@ static struct isl_basic_map *eliminate_divs_ineq(
                        continue;
                *progress = 1;
                bmap = isl_basic_map_eliminate_vars(bmap, (off-1)+d, 1);
-               if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+               if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                        break;
                bmap = isl_basic_map_drop_div(bmap, d);
                if (!bmap)
@@ -426,7 +426,7 @@ static void eliminate_var_using_equality(struct isl_basic_map *bmap,
                if (progress)
                        *progress = 1;
                isl_seq_elim(bmap->ineq[k], eq, 1+pos, 1+total, NULL);
-               F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+               ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        }
 
        for (k = 0; k < bmap->n_div; ++k) {
@@ -445,7 +445,7 @@ static void eliminate_var_using_equality(struct isl_basic_map *bmap,
                else
                        isl_seq_elim(bmap->div[k]+1, eq,
                                        1+pos, 1+total, &bmap->div[k][0]);
-               F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+               ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        }
 }
 
@@ -490,7 +490,7 @@ struct isl_basic_map *isl_basic_map_gauss(
                        isl_int_set_si(bmap->div[div][1+1+last_var], 0);
                        isl_int_set(bmap->div[div][0],
                                    bmap->eq[done][1+last_var]);
-                       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+                       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
                }
        }
        if (done == bmap->n_eq)
@@ -690,7 +690,7 @@ static struct isl_basic_map *normalize_divs(
        if (bmap->n_eq == 0)
                return bmap;
 
-       if (F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS))
+       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS))
                return bmap;
 
        total = isl_dim_total(bmap->dim);
@@ -810,7 +810,7 @@ static struct isl_basic_map *normalize_divs(
 
        *progress = 1;
 done:
-       F_SET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+       ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 
        return bmap;
 error:
@@ -986,7 +986,7 @@ struct isl_basic_map *isl_basic_map_finalize(struct isl_basic_map *bmap)
        bmap = remove_redundant_divs(bmap);
        if (!bmap)
                return NULL;
-       F_SET(bmap, ISL_BASIC_SET_FINAL);
+       ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
        return bmap;
 }
 
@@ -1024,7 +1024,7 @@ struct isl_map *isl_map_finalize(struct isl_map *map)
                if (!map->p[i])
                        goto error;
        }
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 error:
        isl_map_free(map);
@@ -1125,11 +1125,11 @@ struct isl_basic_map *isl_basic_map_eliminate_vars(
                        bmap = isl_basic_map_convex_hull(bmap);
                        if (!bmap)
                                goto error;
-                       if (F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+                       if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
                                break;
                }
        }
-       F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+       ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
        return bmap;
 error:
        isl_basic_map_free(bmap);
@@ -1365,7 +1365,7 @@ static struct isl_basic_set *uset_gist(struct isl_basic_set *bset,
                        isl_int_clear(opt);
                        goto error;
                }
-               if (F_ISSET(context, ISL_BASIC_MAP_EMPTY)) {
+               if (ISL_F_ISSET(context, ISL_BASIC_MAP_EMPTY)) {
                        bset = isl_basic_set_set_to_empty(bset);
                        break;
                }
@@ -1428,7 +1428,7 @@ struct isl_map *isl_map_gist(struct isl_map *map, struct isl_basic_map *context)
                        goto error;
        }
        isl_basic_map_free(context);
-       F_CLR(map, ISL_MAP_NORMALIZED);
+       ISL_F_CLR(map, ISL_MAP_NORMALIZED);
        return map;
 error:
        isl_map_free(map);

diff --git a/isl_mat.c b/isl_mat.c
index e2566d5..e89b5b3 100644 (file)
--- a/isl_mat.c
+++ b/isl_mat.c
@@ -109,7 +109,7 @@ struct isl_mat *isl_mat_cow(struct isl_ctx *ctx, struct isl_mat *mat)
        if (!mat)
                return NULL;
 
-       if (mat->ref == 1 && !F_ISSET(mat, ISL_MAT_BORROWED))
+       if (mat->ref == 1 && !ISL_F_ISSET(mat, ISL_MAT_BORROWED))
                return mat;
 
        mat2 = isl_mat_dup(ctx, mat);
@@ -125,7 +125,7 @@ void isl_mat_free(struct isl_ctx *ctx, struct isl_mat *mat)
        if (--mat->ref > 0)
                return;
 
-       if (!F_ISSET(mat, ISL_MAT_BORROWED))
+       if (!ISL_F_ISSET(mat, ISL_MAT_BORROWED))
                isl_blk_free(ctx, mat->block);
        free(mat->row);
        free(mat);
@@ -832,7 +832,7 @@ struct isl_set *isl_set_preimage(struct isl_ctx *ctx,
                set->dim->n_out -= mat->n_row;
        }
        isl_mat_free(ctx, mat);
-       F_CLR(set, ISL_SET_NORMALIZED);
+       ISL_F_CLR(set, ISL_SET_NORMALIZED);
        return set;
 error:
        isl_set_free(set);

diff --git a/isl_sample.c b/isl_sample.c
index 1a4c5a7..f0bbd3f 100644 (file)
--- a/isl_sample.c
+++ b/isl_sample.c
@@ -146,7 +146,7 @@ struct isl_vec *isl_basic_set_sample(struct isl_basic_set *bset)
                return NULL;
 
        ctx = bset->ctx;
-       if (F_ISSET(bset, ISL_BASIC_SET_EMPTY)) {
+       if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY)) {
                isl_basic_set_free(bset);
                return isl_vec_alloc(ctx, 0);
        }