isl_input.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <isl_set.h>
   4 #include "isl_map_private.h"
   5
   6 static char *next_line(FILE *input, char *line, unsigned len)
   7 {
   8         char *p;
   9
  10         do {
  11                 if (!(p = fgets(line, len, input)))
  12                         return NULL;
  13                 while (isspace(*p) && *p != '\n')
  14                         ++p;
  15         } while (*p == '#' || *p == '\n');
  16
  17         return p;
  18 }
  19
  20 struct isl_basic_set *isl_basic_set_read_from_file(struct isl_ctx *ctx,
  21                 FILE *input, unsigned input_format)
  22 {
  23         struct isl_basic_set *bset = NULL;
  24         int i, j;
  25         unsigned n_row, n_col;
  26         unsigned dim;
  27         char line[1024];
  28         char val[1024];
  29         char *p;
  30
  31         isl_assert(ctx, input_format == ISL_FORMAT_POLYLIB, return NULL);
  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;
  36         bset = isl_basic_set_alloc(ctx, 0, 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(ctx, bset);
  54                         c = bset->eq[k];
  55                 } else {
  56                         k = isl_basic_set_alloc_inequality(ctx, 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+j], val);
  64                         p += offset;
  65                 }
  66                 n = sscanf(p, "%s%n", val, &offset);
  67                 isl_assert(ctx, n != 0, goto error);
  68                 isl_int_read(c[0], val);
  69         }
  70         bset = isl_basic_set_simplify(ctx, bset);
  71         bset = isl_basic_set_finalize(ctx, bset);
  72         return bset;
  73 error:
  74         isl_basic_set_free(ctx, bset);
  75         return NULL;
  76 }