source/input.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include "../include/cloog/cloog.h"
   5
   6 #define ALLOC(type) (type*)malloc(sizeof(type))
   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 /**
  23  * Read input from a .cloog file, putting most of the information
  24  * in the returned CloogInput.  The chosen language is put in
  25  * options->language.
  26  */
  27 CloogInput *cloog_input_read(FILE *file, CloogOptions *options)
  28 {
  29         char line[MAX_STRING];
  30         char language;
  31         CloogDomain *context;
  32         CloogUnionDomain *ud;
  33         int nb_par;
  34
  35         /* First of all, we read the language to use. */
  36         if (!next_line(file, line, sizeof(line)))
  37                 cloog_die("Input error.\n");
  38         if (sscanf(line, "%c", &language) != 1)
  39                 cloog_die("Input error.\n");
  40
  41         if (language == 'f')
  42                 options->language = LANGUAGE_FORTRAN;
  43         else
  44                 options->language = LANGUAGE_C;
  45
  46         /* We then read the context data. */
  47         context = cloog_domain_read_context(options->state, file);
  48         nb_par = cloog_domain_parameter_dimension(context);
  49
  50         ud = cloog_union_domain_read(file, nb_par, options);
  51
  52         return cloog_input_alloc(context, ud);
  53 }
  54
  55 /**
  56  * Create a CloogInput from a CloogDomain context and a CloogUnionDomain.
  57  */
  58 CloogInput *cloog_input_alloc(CloogDomain *context, CloogUnionDomain *ud)
  59 {
  60         CloogInput *input;
  61
  62         input = ALLOC(CloogInput);
  63         if (!input)
  64                 cloog_die("memory overflow.\n");
  65
  66         input->context = context;
  67         input->ud = ud;
  68
  69         return input;
  70 }
  71
  72 void cloog_input_free(CloogInput *input)
  73 {
  74         cloog_domain_free(input->context);
  75         cloog_union_domain_free(input->ud);
  76         free(input);
  77 }
  78
  79 static void print_names(FILE *file, CloogUnionDomain *ud,
  80         enum cloog_dim_type type, const char *name)
  81 {
  82         int i;
  83
  84         fprintf(file, "\n%d # %s name(s)\n", ud->name[type] ? 1 : 0, name);
  85         if (!ud->name[type])
  86                 return;
  87
  88         for (i = 0; i < ud->n_name[type]; i++)
  89                 fprintf(file, "%s ", ud->name[type][i]);
  90
  91         fprintf(file, "\n");
  92 }
  93
  94 /**
  95  * Dump the .cloog description of a CloogInput and a CloogOptions data structure
  96  * into a file. The generated .cloog file will contain the same information as
  97  * the data structures. The file can be used to run the cloog program on the
  98  * example.
  99  */
 100 void cloog_input_dump_cloog(FILE *file, CloogInput *input, CloogOptions *opt)
 101 {
 102         int i, num_statements;
 103         CloogUnionDomain *ud = input->ud;
 104         CloogNamedDomainList *ndl = ud->domain;
 105
 106         fprintf(file,
 107                 "# CLooG -> CLooG\n"
 108                 "# This is an automatic dump of a CLooG input file from a "
 109                 "CloogInput data\n"
 110                 "# structure.\n\n");
 111
 112         /* Language. */
 113         if (opt->language == LANGUAGE_FORTRAN) {
 114                 fprintf(file, "# Language: FORTRAN\n");
 115                 fprintf(file, "f\n\n");
 116         } else {
 117                 fprintf(file, "# Language: C\n");
 118                 fprintf(file, "c\n\n");
 119         }
 120
 121         /* Context. */
 122         fprintf(file, "# Context:\n");
 123         cloog_domain_print_constraints(file, input->context, 1);
 124
 125         print_names(file, ud, CLOOG_PARAM, "Parameter");
 126
 127         /* Statement number. */
 128         i = 0;
 129         while (ndl != NULL) {
 130                 i++;
 131                 ndl = ndl->next;
 132         }
 133         num_statements = i;
 134         fprintf(file, "\n# Statement number:\n%d\n\n", num_statements);
 135
 136         /* Iteration domains. */
 137         i = 1;
 138         ndl = ud->domain;
 139         while (ndl != NULL) {
 140                 fprintf(file, "# Iteration domain of statement %d (%s).\n", i,
 141                         ndl->name);
 142
 143                 cloog_domain_print_constraints(file, ndl->domain, 1);
 144                 fprintf(file,"\n0 0 0 # For future options.\n\n");
 145
 146                 i++;
 147                 ndl = ndl->next;
 148         }
 149
 150         print_names(file, ud, CLOOG_ITER, "Iterator");
 151
 152         /* Exit, if no scattering is supplied. */
 153         if (!ud->domain || !ud->domain->scattering) {
 154                 fprintf(file, "# No scattering functions.\n0\n\n");
 155                 return;
 156         }
 157
 158         /* Scattering relations. */
 159         fprintf(file,
 160                 "# --------------------- SCATTERING --------------------\n");
 161
 162         fprintf(file, "%d # Scattering functions\n", num_statements);
 163
 164         i = 1;
 165         ndl = ud->domain;
 166         while (ndl != NULL) {
 167                 fprintf(file, "\n# Scattering of statement %d (%s).\n", i,
 168                         ndl->name);
 169
 170                 cloog_scattering_print_constraints(file, ndl->scattering);
 171
 172                 i++;
 173                 ndl = ndl->next;
 174         }
 175
 176         print_names(file, ud, CLOOG_SCAT, "Scattering dimension");
 177 }