privately export isl_tab_kill_col

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

diff --git a/isl_input.c b/isl_input.c
index 23b3c07..e56c427 100644 (file)
--- a/isl_input.c
+++ b/isl_input.c
@@ -1,6 +1,7 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <isl_set.h>
+#include "isl_dim.h"
 #include "isl_map_private.h"
 #include "isl_input_omega.h"
 
@@ -19,7 +20,7 @@ static char *next_line(FILE *input, char *line, unsigned len)
 }
 
 static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
-               struct isl_ctx *ctx, FILE *input)
+               struct isl_ctx *ctx, FILE *input, unsigned nparam)
 {
        struct isl_basic_set *bset = NULL;
        int i, j;
@@ -32,8 +33,8 @@ static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
        isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
        isl_assert(ctx, sscanf(line, "%u %u", &n_row, &n_col) == 2, return NULL);
        isl_assert(ctx, n_col >= 2, return NULL);
-       dim = n_col - 2;
-       bset = isl_basic_set_alloc(ctx, 0, dim, 0, n_row, n_row);
+       dim = n_col - 2 - nparam;
+       bset = isl_basic_set_alloc(ctx, nparam, dim, 0, n_row, n_row);
        if (!bset)
                return NULL;
        for (i = 0; i < n_row; ++i) {
@@ -50,16 +51,22 @@ static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
                p += offset;
                isl_assert(ctx, type == 0 || type == 1, goto error);
                if (type == 0) {
-                       k = isl_basic_set_alloc_equality(ctx, bset);
+                       k = isl_basic_set_alloc_equality(bset);
                        c = bset->eq[k];
                } else {
-                       k = isl_basic_set_alloc_inequality(ctx, bset);
+                       k = isl_basic_set_alloc_inequality(bset);
                        c = bset->ineq[k];
                }
                isl_assert(ctx, k >= 0, goto error);
                for (j = 0; j < dim; ++j) {
                        n = sscanf(p, "%s%n", val, &offset);
                        isl_assert(ctx, n != 0, goto error);
+                       isl_int_read(c[1+nparam+j], val);
+                       p += offset;
+               }
+               for (j = 0; j < nparam; ++j) {
+                       n = sscanf(p, "%s%n", val, &offset);
+                       isl_assert(ctx, n != 0, goto error);
                        isl_int_read(c[1+j], val);
                        p += offset;
                }
@@ -67,16 +74,16 @@ static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
                isl_assert(ctx, n != 0, goto error);
                isl_int_read(c[0], val);
        }
-       bset = isl_basic_set_simplify(ctx, bset);
-       bset = isl_basic_set_finalize(ctx, bset);
+       bset = isl_basic_set_simplify(bset);
+       bset = isl_basic_set_finalize(bset);
        return bset;
 error:
-       isl_basic_set_free(ctx, bset);
+       isl_basic_set_free(bset);
        return NULL;
 }
 
 static struct isl_set *isl_set_read_from_file_polylib(
-               struct isl_ctx *ctx, FILE *input)
+               struct isl_ctx *ctx, FILE *input, unsigned nparam)
 {
        struct isl_set *set = NULL;
        char line[1024];
@@ -86,39 +93,53 @@ static struct isl_set *isl_set_read_from_file_polylib(
        isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
        isl_assert(ctx, sscanf(line, "%u", &n) == 1, return NULL);
 
-       set = isl_set_alloc(ctx, 0, 0, n, 0);
+       set = isl_set_alloc(ctx, nparam, 0, n, 0);
        if (!set)
                return NULL;
        if (n == 0)
                return set;
        for (i = 0; i < n; ++i) {
-               set->p[i] = isl_basic_set_read_from_file_polylib(ctx, input);
+               set->p[i] = isl_basic_set_read_from_file_polylib(ctx, input,
+                                                                nparam);
                if (!set->p[i])
                        goto error;
        }
        set->n = n;
-       set->dim = set->p[0]->dim;
+       isl_dim_free(set->dim);
+       set->dim = isl_dim_copy(set->p[0]->dim);
        for (i = 1; i < n; ++i)
-               isl_assert(ctx, set->dim == set->p[i]->dim, goto error);
+               isl_assert(ctx, isl_dim_equal(set->dim, set->p[i]->dim),
+                               goto error);
        return set;
 error:
-       isl_set_free(ctx, set);
+       isl_set_free(set);
        return NULL;
 }
 
 struct isl_basic_set *isl_basic_set_read_from_file(struct isl_ctx *ctx,
-               FILE *input, unsigned input_format)
+               FILE *input, unsigned nparam, unsigned input_format)
 {
        if (input_format == ISL_FORMAT_POLYLIB)
-               return isl_basic_set_read_from_file_polylib(ctx, input);
-       else if (input_format == ISL_FORMAT_OMEGA)
+               return isl_basic_set_read_from_file_polylib(ctx, input, nparam);
+       else if (input_format == ISL_FORMAT_OMEGA) {
+               isl_assert(ctx, nparam == 0, return NULL);
                return isl_basic_set_read_from_file_omega(ctx, input);
-       else
+       } else
+               isl_assert(ctx, 0, return NULL);
+}
+
+struct isl_basic_set *isl_basic_set_read_from_str(struct isl_ctx *ctx,
+               const char *str, unsigned nparam, unsigned input_format)
+{
+       if (input_format == ISL_FORMAT_OMEGA) {
+               isl_assert(ctx, nparam == 0, return NULL);
+               return isl_basic_set_read_from_str_omega(ctx, str);
+       } else
                isl_assert(ctx, 0, return NULL);
 }
 
 struct isl_basic_map *isl_basic_map_read_from_file(struct isl_ctx *ctx,
-               FILE *input, unsigned input_format)
+               FILE *input, unsigned nparam, unsigned input_format)
 {
        if (input_format == ISL_FORMAT_OMEGA)
                return isl_basic_map_read_from_file_omega(ctx, input);
@@ -127,10 +148,52 @@ struct isl_basic_map *isl_basic_map_read_from_file(struct isl_ctx *ctx,
 }
 
 struct isl_set *isl_set_read_from_file(struct isl_ctx *ctx,
+               FILE *input, unsigned nparam, unsigned input_format)
+{
+       if (input_format == ISL_FORMAT_POLYLIB)
+               return isl_set_read_from_file_polylib(ctx, input, nparam);
+       else
+               isl_assert(ctx, 0, return NULL);
+}
+
+static struct isl_vec *isl_vec_read_from_file_polylib(struct isl_ctx *ctx,
+               FILE *input)
+{
+       struct isl_vec *vec = NULL;
+       char line[1024];
+       char val[1024];
+       char *p;
+       unsigned size;
+       int j;
+       int n;
+       int offset;
+
+       isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
+       isl_assert(ctx, sscanf(line, "%u", &size) == 1, return NULL);
+
+       vec = isl_vec_alloc(ctx, size);
+
+       p = next_line(input, line, sizeof(line));
+       isl_assert(ctx, p, goto error);
+
+       for (j = 0; j < size; ++j) {
+               n = sscanf(p, "%s%n", val, &offset);
+               isl_assert(ctx, n != 0, goto error);
+               isl_int_read(vec->el[j], val);
+               p += offset;
+       }
+
+       return vec;
+error:
+       isl_vec_free(vec);
+       return NULL;
+}
+
+struct isl_vec *isl_vec_read_from_file(struct isl_ctx *ctx,
                FILE *input, unsigned input_format)
 {
        if (input_format == ISL_FORMAT_POLYLIB)
-               return isl_set_read_from_file_polylib(ctx, input);
+               return isl_vec_read_from_file_polylib(ctx, input);
        else
                isl_assert(ctx, 0, return NULL);
 }