isl_input.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <isl_set.h>
   4 #include "isl_dim.h"
   5 #include "isl_map_private.h"
   6 #include "isl_input_omega.h"
   7
   8 static char *next_line(FILE *input, char *line, unsigned len)
   9 {
  10         char *p;
  11
  12         do {
  13                 if (!(p = fgets(line, len, input)))
  14                         return NULL;
  15                 while (isspace(*p) && *p != '\n')
  16                         ++p;
  17         } while (*p == '#' || *p == '\n');
  18
  19         return p;
  20 }
  21
  22 static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
  23                 struct isl_ctx *ctx, FILE *input, unsigned nparam)
  24 {
  25         struct isl_basic_set *bset = NULL;
  26         int i, j;
  27         unsigned n_row, n_col;
  28         unsigned dim;
  29         char line[1024];
  30         char val[1024];
  31         char *p;
  32
  33         isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
  34         isl_assert(ctx, sscanf(line, "%u %u", &n_row, &n_col) == 2, return NULL);
  35         isl_assert(ctx, n_col >= 2, return NULL);
  36         dim = n_col - 2 - nparam;
  37         bset = isl_basic_set_alloc(ctx, nparam, dim, 0, n_row, n_row);
  38         if (!bset)
  39                 return NULL;
  40         for (i = 0; i < n_row; ++i) {
  41                 int type;
  42                 int offset;
  43                 int n;
  44                 int k;
  45                 isl_int *c;
  46
  47                 p = next_line(input, line, sizeof(line));
  48                 isl_assert(ctx, p, goto error);
  49                 n = sscanf(p, "%u%n", &type, &offset);
  50                 isl_assert(ctx, n != 0, goto error);
  51                 p += offset;
  52                 isl_assert(ctx, type == 0 || type == 1, goto error);
  53                 if (type == 0) {
  54                         k = isl_basic_set_alloc_equality(bset);
  55                         c = bset->eq[k];
  56                 } else {
  57                         k = isl_basic_set_alloc_inequality(bset);
  58                         c = bset->ineq[k];
  59                 }
  60                 isl_assert(ctx, k >= 0, goto error);
  61                 for (j = 0; j < dim; ++j) {
  62                         n = sscanf(p, "%s%n", val, &offset);
  63                         isl_assert(ctx, n != 0, goto error);
  64                         isl_int_read(c[1+nparam+j], val);
  65                         p += offset;
  66                 }
  67                 for (j = 0; j < nparam; ++j) {
  68                         n = sscanf(p, "%s%n", val, &offset);
  69                         isl_assert(ctx, n != 0, goto error);
  70                         isl_int_read(c[1+j], val);
  71                         p += offset;
  72                 }
  73                 n = sscanf(p, "%s%n", val, &offset);
  74                 isl_assert(ctx, n != 0, goto error);
  75                 isl_int_read(c[0], val);
  76         }
  77         bset = isl_basic_set_simplify(bset);
  78         bset = isl_basic_set_finalize(bset);
  79         return bset;
  80 error:
  81         isl_basic_set_free(bset);
  82         return NULL;
  83 }
  84
  85 static struct isl_set *isl_set_read_from_file_polylib(
  86                 struct isl_ctx *ctx, FILE *input, unsigned nparam)
  87 {
  88         struct isl_set *set = NULL;
  89         char line[1024];
  90         int i;
  91         unsigned n;
  92
  93         isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
  94         isl_assert(ctx, sscanf(line, "%u", &n) == 1, return NULL);
  95
  96         set = isl_set_alloc(ctx, nparam, 0, n, 0);
  97         if (!set)
  98                 return NULL;
  99         if (n == 0)
 100                 return set;
 101         for (i = 0; i < n; ++i) {
 102                 set->p[i] = isl_basic_set_read_from_file_polylib(ctx, input,
 103                                                                  nparam);
 104                 if (!set->p[i])
 105                         goto error;
 106         }
 107         set->n = n;
 108         isl_dim_free(set->dim);
 109         set->dim = isl_dim_copy(set->p[0]->dim);
 110         for (i = 1; i < n; ++i)
 111                 isl_assert(ctx, isl_dim_equal(set->dim, set->p[i]->dim),
 112                                 goto error);
 113         return set;
 114 error:
 115         isl_set_free(set);
 116         return NULL;
 117 }
 118
 119 struct isl_basic_set *isl_basic_set_read_from_file(struct isl_ctx *ctx,
 120                 FILE *input, unsigned nparam, unsigned input_format)
 121 {
 122         if (input_format == ISL_FORMAT_POLYLIB)
 123                 return isl_basic_set_read_from_file_polylib(ctx, input, nparam);
 124         else if (input_format == ISL_FORMAT_OMEGA) {
 125                 isl_assert(ctx, nparam == 0, return NULL);
 126                 return isl_basic_set_read_from_file_omega(ctx, input);
 127         } else
 128                 isl_assert(ctx, 0, return NULL);
 129 }
 130
 131 struct isl_basic_set *isl_basic_set_read_from_str(struct isl_ctx *ctx,
 132                 const char *str, unsigned nparam, unsigned input_format)
 133 {
 134         if (input_format == ISL_FORMAT_OMEGA) {
 135                 isl_assert(ctx, nparam == 0, return NULL);
 136                 return isl_basic_set_read_from_str_omega(ctx, str);
 137         } else
 138                 isl_assert(ctx, 0, return NULL);
 139 }
 140
 141 struct isl_basic_map *isl_basic_map_read_from_file(struct isl_ctx *ctx,
 142                 FILE *input, unsigned nparam, unsigned input_format)
 143 {
 144         if (input_format == ISL_FORMAT_OMEGA)
 145                 return isl_basic_map_read_from_file_omega(ctx, input);
 146         else
 147                 isl_assert(ctx, 0, return NULL);
 148 }
 149
 150 struct isl_set *isl_set_read_from_file(struct isl_ctx *ctx,
 151                 FILE *input, unsigned nparam, unsigned input_format)
 152 {
 153         if (input_format == ISL_FORMAT_POLYLIB)
 154                 return isl_set_read_from_file_polylib(ctx, input, nparam);
 155         else
 156                 isl_assert(ctx, 0, return NULL);
 157 }
 158
 159 static struct isl_vec *isl_vec_read_from_file_polylib(struct isl_ctx *ctx,
 160                 FILE *input)
 161 {
 162         struct isl_vec *vec = NULL;
 163         char line[1024];
 164         char val[1024];
 165         char *p;
 166         unsigned size;
 167         int j;
 168         int n;
 169         int offset;
 170
 171         isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
 172         isl_assert(ctx, sscanf(line, "%u", &size) == 1, return NULL);
 173
 174         vec = isl_vec_alloc(ctx, size);
 175
 176         p = next_line(input, line, sizeof(line));
 177         isl_assert(ctx, p, goto error);
 178
 179         for (j = 0; j < size; ++j) {
 180                 n = sscanf(p, "%s%n", val, &offset);
 181                 isl_assert(ctx, n != 0, goto error);
 182                 isl_int_read(vec->el[j], val);
 183                 p += offset;
 184         }
 185
 186         return vec;
 187 error:
 188         isl_vec_free(vec);
 189         return NULL;
 190 }
 191
 192 struct isl_vec *isl_vec_read_from_file(struct isl_ctx *ctx,
 193                 FILE *input, unsigned input_format)
 194 {
 195         if (input_format == ISL_FORMAT_POLYLIB)
 196                 return isl_vec_read_from_file_polylib(ctx, input);
 197         else
 198                 isl_assert(ctx, 0, return NULL);
 199 }