add isl_aff_mod_val

[platform/upstream/isl.git] / bound.c

diff --git a/bound.c b/bound.c
index a326e35..9a0ee8d 100644 (file)
--- a/bound.c
+++ b/bound.c
@@ -1,7 +1,8 @@
 #include <assert.h>
-#include <isl_stream.h>
+#include <isl/stream.h>
 #include <isl_polynomial_private.h>
 #include <isl_scan.h>
+#include <isl/options.h>
 
 struct bound_options {
        struct isl_options      *isl;
@@ -10,15 +11,15 @@ struct bound_options {
        int                      continue_on_error;
 };
 
-struct isl_arg bound_options_arg[] = {
-ISL_ARG_CHILD(struct bound_options, isl, "isl", isl_options_arg, "isl options")
+ISL_ARGS_START(struct bound_options, bound_options_args)
+ISL_ARG_CHILD(struct bound_options, isl, "isl", &isl_options_args,
+       "isl options")
 ISL_ARG_BOOL(struct bound_options, verify, 'T', "verify", 0, NULL)
 ISL_ARG_BOOL(struct bound_options, print_all, 'A', "print-all", 0, NULL)
 ISL_ARG_BOOL(struct bound_options, continue_on_error, '\0', "continue-on-error", 0, NULL)
-ISL_ARG_END
-};
+ISL_ARGS_END
 
-ISL_ARG_DEF(bound_options, struct bound_options, bound_options_arg)
+ISL_ARG_DEF(bound_options, struct bound_options, bound_options_args)
 
 static __isl_give isl_set *set_bounds(__isl_take isl_set *set)
 {
@@ -57,18 +58,20 @@ struct verify_point_bound {
 static int verify_point(__isl_take isl_point *pnt, void *user)
 {
        int i;
+       unsigned nvar;
        unsigned nparam;
        struct verify_point_bound *vpb = (struct verify_point_bound *) user;
        isl_int t;
+       isl_ctx *ctx;
        isl_pw_qpolynomial_fold *pwf;
        isl_qpolynomial *bound = NULL;
        isl_qpolynomial *opt = NULL;
        isl_set *dom = NULL;
+       isl_printer *p;
        const char *minmax;
        int bounded;
        int sign;
        int ok;
-       int cst;
        FILE *out = vpb->options->print_all ? stdout : stderr;
 
        vpb->n--;
@@ -81,6 +84,9 @@ static int verify_point(__isl_take isl_point *pnt, void *user)
                sign = -1;
        }
 
+       ctx = isl_point_get_ctx(pnt);
+       p = isl_printer_to_file(ctx, out);
+
        isl_int_init(t);
 
        pwf = isl_pw_qpolynomial_fold_copy(vpb->pwf);
@@ -110,8 +116,10 @@ static int verify_point(__isl_take isl_point *pnt, void *user)
        else
                opt = isl_pw_qpolynomial_fold_min(isl_pw_qpolynomial_fold_copy(pwf));
 
+       nvar = isl_set_dim(dom, isl_dim_set);
+       opt = isl_qpolynomial_project_domain_on_params(opt);
        if (vpb->exact && bounded)
-               ok = isl_qpolynomial_is_equal(opt, bound);
+               ok = isl_qpolynomial_plain_is_equal(opt, bound);
        else if (sign > 0)
                ok = isl_qpolynomial_le_cst(opt, bound);
        else
@@ -120,24 +128,28 @@ static int verify_point(__isl_take isl_point *pnt, void *user)
                goto error;
 
        if (vpb->options->print_all || !ok) {
-               fprintf(out, "%s(", minmax);
+               p = isl_printer_print_str(p, minmax);
+               p = isl_printer_print_str(p, "(");
                for (i = 0; i < nparam; ++i) {
                        if (i)
-                               fprintf(out, ", ");
+                               p = isl_printer_print_str(p, ", ");
                        isl_point_get_coordinate(pnt, isl_dim_param, i, &t);
-                       isl_int_print(out, t, 0);
+                       p = isl_printer_print_isl_int(p, t);
                }
-               fprintf(out, ") = ");
-               isl_qpolynomial_print(bound, out, ISL_FORMAT_ISL);
-               fprintf(out, ", %s = ", bounded ? "opt" : "sample");
-               isl_qpolynomial_print(opt, out, ISL_FORMAT_ISL);
+               p = isl_printer_print_str(p, ") = ");
+               p = isl_printer_print_qpolynomial(p, bound);
+               p = isl_printer_print_str(p, ", ");
+               p = isl_printer_print_str(p, bounded ? "opt" : "sample");
+               p = isl_printer_print_str(p, " = ");
+               p = isl_printer_print_qpolynomial(p, opt);
                if (ok)
-                       fprintf(out, ". OK\n");
+                       p = isl_printer_print_str(p, ". OK");
                else
-                       fprintf(out, ". NOT OK\n");
+                       p = isl_printer_print_str(p, ". NOT OK");
+               p = isl_printer_end_line(p);
        } else if ((vpb->n % vpb->stride) == 0) {
-               printf("o");
-               fflush(stdout);
+               p = isl_printer_print_str(p, "o");
+               p = isl_printer_flush(p);
        }
 
        if (0) {
@@ -153,6 +165,8 @@ error:
 
        isl_int_clear(t);
 
+       isl_printer_free(p);
+
        if (!ok)
                vpb->error = 1;
 
@@ -173,8 +187,7 @@ static int check_solution(__isl_take isl_pw_qpolynomial_fold *pwf,
        int i, r, n;
 
        dom = isl_pw_qpolynomial_fold_domain(isl_pw_qpolynomial_fold_copy(pwf));
-       context = isl_set_remove_dims(isl_set_copy(dom), isl_dim_set,
-                                       0, isl_set_dim(dom, isl_dim_set));
+       context = isl_set_params(isl_set_copy(dom));
        context = isl_set_remove_divs(context);
        context = set_bounds(context);
 
@@ -225,10 +238,10 @@ static int check_solution(__isl_take isl_pw_qpolynomial_fold *pwf,
 int main(int argc, char **argv)
 {
        isl_ctx *ctx;
-       isl_pw_qpolynomial *pwqp;
        isl_pw_qpolynomial_fold *copy;
        isl_pw_qpolynomial_fold *pwf;
        struct isl_stream *s;
+       struct isl_obj obj;
        struct bound_options *options;
        int exact;
        int r = 0;
@@ -237,11 +250,19 @@ int main(int argc, char **argv)
        assert(options);
        argc = bound_options_parse(options, argc, argv, ISL_ARG_ALL);
 
-       ctx = isl_ctx_alloc_with_options(bound_options_arg, options);
+       ctx = isl_ctx_alloc_with_options(&bound_options_args, options);
 
        s = isl_stream_new_file(ctx, stdin);
-       pwqp = isl_stream_read_pw_qpolynomial(s);
-       pwf = isl_pw_qpolynomial_fold_from_pw_qpolynomial(isl_fold_max, pwqp);
+       obj = isl_stream_read_obj(s);
+       if (obj.type == isl_obj_pw_qpolynomial)
+               pwf = isl_pw_qpolynomial_fold_from_pw_qpolynomial(isl_fold_max,
+                                                                 obj.v);
+       else if (obj.type == isl_obj_pw_qpolynomial_fold)
+               pwf = obj.v;
+       else {
+               obj.type->free(obj.v);
+               isl_die(ctx, isl_error_invalid, "invalid input", goto error);
+       }
 
        if (options->verify)
                copy = isl_pw_qpolynomial_fold_copy(pwf);
@@ -259,6 +280,7 @@ int main(int argc, char **argv)
                isl_pw_qpolynomial_fold_free(pwf);
        }
 
+error:
        isl_stream_free(s);
 
        isl_ctx_free(ctx);