isl_input.c

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