isl_input.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <isl_set.h>
   4 #include "isl_map_private.h"
   5 #include "isl_input_omega.h"
   6
   7 static char *next_line(FILE *input, char *line, unsigned len)
   8 {
   9         char *p;
  10
  11         do {
  12                 if (!(p = fgets(line, len, input)))
  13                         return NULL;
  14                 while (isspace(*p) && *p != '\n')
  15                         ++p;
  16         } while (*p == '#' || *p == '\n');
  17
  18         return p;
  19 }
  20
  21 static struct isl_basic_set *isl_basic_set_read_from_file_polylib(
  22                 struct isl_ctx *ctx, FILE *input, unsigned nparam)
  23 {
  24         struct isl_basic_set *bset = NULL;
  25         int i, j;
  26         unsigned n_row, n_col;
  27         unsigned dim;
  28         char line[1024];
  29         char val[1024];
  30         char *p;
  31
  32         isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
  33         isl_assert(ctx, sscanf(line, "%u %u", &n_row, &n_col) == 2, return NULL);
  34         isl_assert(ctx, n_col >= 2, return NULL);
  35         dim = n_col - 2 - nparam;
  36         bset = isl_basic_set_alloc(ctx, nparam, dim, 0, n_row, n_row);
  37         if (!bset)
  38                 return NULL;
  39         for (i = 0; i < n_row; ++i) {
  40                 int type;
  41                 int offset;
  42                 int n;
  43                 int k;
  44                 isl_int *c;
  45
  46                 p = next_line(input, line, sizeof(line));
  47                 isl_assert(ctx, p, goto error);
  48                 n = sscanf(p, "%u%n", &type, &offset);
  49                 isl_assert(ctx, n != 0, goto error);
  50                 p += offset;
  51                 isl_assert(ctx, type == 0 || type == 1, goto error);
  52                 if (type == 0) {
  53                         k = isl_basic_set_alloc_equality(bset);
  54                         c = bset->eq[k];
  55                 } else {
  56                         k = isl_basic_set_alloc_inequality(bset);
  57                         c = bset->ineq[k];
  58                 }
  59                 isl_assert(ctx, k >= 0, goto error);
  60                 for (j = 0; j < dim; ++j) {
  61                         n = sscanf(p, "%s%n", val, &offset);
  62                         isl_assert(ctx, n != 0, goto error);
  63                         isl_int_read(c[1+nparam+j], val);
  64                         p += offset;
  65                 }
  66                 for (j = 0; j < nparam; ++j) {
  67                         n = sscanf(p, "%s%n", val, &offset);
  68                         isl_assert(ctx, n != 0, goto error);
  69                         isl_int_read(c[1+j], val);
  70                         p += offset;
  71                 }
  72                 n = sscanf(p, "%s%n", val, &offset);
  73                 isl_assert(ctx, n != 0, goto error);
  74                 isl_int_read(c[0], val);
  75         }
  76         bset = isl_basic_set_simplify(bset);
  77         bset = isl_basic_set_finalize(bset);
  78         return bset;
  79 error:
  80         isl_basic_set_free(bset);
  81         return NULL;
  82 }
  83
  84 static struct isl_set *isl_set_read_from_file_polylib(
  85                 struct isl_ctx *ctx, FILE *input, unsigned nparam)
  86 {
  87         struct isl_set *set = NULL;
  88         char line[1024];
  89         int i;
  90         unsigned n;
  91
  92         isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
  93         isl_assert(ctx, sscanf(line, "%u", &n) == 1, return NULL);
  94
  95         set = isl_set_alloc(ctx, nparam, 0, n, 0);
  96         if (!set)
  97                 return NULL;
  98         if (n == 0)
  99                 return set;
 100         for (i = 0; i < n; ++i) {
 101                 set->p[i] = isl_basic_set_read_from_file_polylib(ctx, input,
 102                                                                  nparam);
 103                 if (!set->p[i])
 104                         goto error;
 105         }
 106         set->n = n;
 107         set->dim = set->p[0]->dim;
 108         for (i = 1; i < n; ++i)
 109                 isl_assert(ctx, set->dim == set->p[i]->dim, goto error);
 110         return set;
 111 error:
 112         isl_set_free(set);
 113         return NULL;
 114 }
 115
 116 struct isl_basic_set *isl_basic_set_read_from_file(struct isl_ctx *ctx,
 117                 FILE *input, unsigned nparam, unsigned input_format)
 118 {
 119         if (input_format == ISL_FORMAT_POLYLIB)
 120                 return isl_basic_set_read_from_file_polylib(ctx, input, nparam);
 121         else if (input_format == ISL_FORMAT_OMEGA) {
 122                 isl_assert(ctx, nparam == 0, return NULL);
 123                 return isl_basic_set_read_from_file_omega(ctx, input);
 124         } else
 125                 isl_assert(ctx, 0, return NULL);
 126 }
 127
 128 struct isl_basic_map *isl_basic_map_read_from_file(struct isl_ctx *ctx,
 129                 FILE *input, unsigned nparam, unsigned input_format)
 130 {
 131         if (input_format == ISL_FORMAT_OMEGA)
 132                 return isl_basic_map_read_from_file_omega(ctx, input);
 133         else
 134                 isl_assert(ctx, 0, return NULL);
 135 }
 136
 137 struct isl_set *isl_set_read_from_file(struct isl_ctx *ctx,
 138                 FILE *input, unsigned nparam, unsigned input_format)
 139 {
 140         if (input_format == ISL_FORMAT_POLYLIB)
 141                 return isl_set_read_from_file_polylib(ctx, input, nparam);
 142         else
 143                 isl_assert(ctx, 0, return NULL);
 144 }