isl_stream: accept "." token
[platform/upstream/isl.git] / isl_stream.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 <string.h>
12 #include <strings.h>
13 #include <isl_ctx.h>
14 #include "isl_stream.h"
15
16 struct isl_keyword {
17         char                    *name;
18         enum isl_token_type     type;
19 };
20
21 static int same_name(const void *entry, const void *val)
22 {
23         const struct isl_keyword *keyword = (const struct isl_keyword *)entry;
24
25         return !strcmp(keyword->name, val);
26 }
27
28 enum isl_token_type isl_stream_register_keyword(struct isl_stream *s,
29         const char *name)
30 {
31         struct isl_hash_table_entry *entry;
32         struct isl_keyword *keyword;
33         uint32_t name_hash;
34
35         if (!s->keywords) {
36                 s->keywords = isl_hash_table_alloc(s->ctx, 10);
37                 if (!s->keywords)
38                         return ISL_TOKEN_ERROR;
39                 s->next_type = ISL_TOKEN_LAST;
40         }
41
42         name_hash = isl_hash_string(isl_hash_init(), name);
43
44         entry = isl_hash_table_find(s->ctx, s->keywords, name_hash,
45                                         same_name, name, 1);
46         if (!entry)
47                 return ISL_TOKEN_ERROR;
48         if (entry->data) {
49                 keyword = entry->data;
50                 return keyword->type;
51         }
52
53         keyword = isl_calloc_type(s->ctx, struct isl_keyword);
54         if (!keyword)
55                 return ISL_TOKEN_ERROR;
56         keyword->type = s->next_type++;
57         keyword->name = strdup(name);
58         if (!keyword->name) {
59                 free(keyword);
60                 return ISL_TOKEN_ERROR;
61         }
62         entry->data = keyword;
63
64         return keyword->type;
65 }
66
67 static struct isl_token *isl_token_new(struct isl_ctx *ctx,
68         int line, int col, unsigned on_new_line)
69 {
70         struct isl_token *tok = isl_alloc_type(ctx, struct isl_token);
71         if (!tok)
72                 return NULL;
73         tok->line = line;
74         tok->col = col;
75         tok->on_new_line = on_new_line;
76         return tok;
77 }
78
79 void isl_token_free(struct isl_token *tok)
80 {
81         if (!tok)
82                 return;
83         if (tok->type == ISL_TOKEN_VALUE)
84                 isl_int_clear(tok->u.v);
85         else if (tok->type == ISL_TOKEN_IDENT)
86                 free(tok->u.s);
87         free(tok);
88 }
89
90 void isl_stream_error(struct isl_stream *s, struct isl_token *tok, char *msg)
91 {
92         int line = tok ? tok->line : s->line;
93         int col = tok ? tok->col : s->col;
94         fprintf(stderr, "syntax error (%d, %d): %s\n", line, col, msg);
95         if (tok) {
96                 if (tok->type < 256)
97                         fprintf(stderr, "got '%c'\n", tok->type);
98                 else
99                         fprintf(stderr, "got token type %d\n", tok->type);
100         }
101 }
102
103 static struct isl_stream* isl_stream_new(struct isl_ctx *ctx)
104 {
105         int i;
106         struct isl_stream *s = isl_alloc_type(ctx, struct isl_stream);
107         if (!s)
108                 return NULL;
109         s->ctx = ctx;
110         isl_ctx_ref(s->ctx);
111         s->size = 256;
112         s->file = NULL;
113         s->str = NULL;
114         s->buffer = isl_alloc_array(ctx, char, s->size);
115         if (!s->buffer)
116                 goto error;
117         s->len = 0;
118         s->line = 1;
119         s->col = 0;
120         s->eof = 0;
121         s->c = -1;
122         for (i = 0; i < 5; ++i)
123                 s->tokens[i] = NULL;
124         s->n_token = 0;
125         s->keywords = NULL;
126         return s;
127 error:
128         isl_stream_free(s);
129         return NULL;
130 }
131
132 struct isl_stream* isl_stream_new_file(struct isl_ctx *ctx, FILE *file)
133 {
134         struct isl_stream *s = isl_stream_new(ctx);
135         if (!s)
136                 return NULL;
137         s->file = file;
138         return s;
139 }
140
141 struct isl_stream* isl_stream_new_str(struct isl_ctx *ctx, const char *str)
142 {
143     struct isl_stream *s = isl_stream_new(ctx);
144     s->str = str;
145     return s;
146 }
147
148 static int isl_stream_getc(struct isl_stream *s)
149 {
150         int c;
151         if (s->eof)
152                 return -1;
153         if (s->file)
154                 c = fgetc(s->file);
155         else {
156                 c = *s->str++;
157                 if (c == '\0')
158                         c = -1;
159         }
160         if (c == -1)
161                 s->eof = 1;
162         if (!s->eof) {
163                 if (s->c == '\n') {
164                         s->line++;
165                         s->col = 0;
166                 } else
167                         s->col++;
168         }
169         s->c = c;
170         return c;
171 }
172
173 static void isl_stream_ungetc(struct isl_stream *s, int c)
174 {
175         if (s->file)
176                 ungetc(c, s->file);
177         else
178                 --s->str;
179         s->c = -1;
180 }
181
182 static int isl_stream_push_char(struct isl_stream *s, int c)
183 {
184         if (s->len >= s->size) {
185                 s->size = (3*s->size)/2;
186                 s->buffer = isl_realloc_array(ctx, s->buffer, char, s->size);
187                 if (!s->buffer)
188                         return -1;
189         }
190         s->buffer[s->len++] = c;
191         return 0;
192 }
193
194 void isl_stream_push_token(struct isl_stream *s, struct isl_token *tok)
195 {
196         isl_assert(s->ctx, s->n_token < 5, return);
197         s->tokens[s->n_token++] = tok;
198 }
199
200 static enum isl_token_type check_keywords(struct isl_stream *s)
201 {
202         struct isl_hash_table_entry *entry;
203         struct isl_keyword *keyword;
204         uint32_t name_hash;
205
206         if (!strcasecmp(s->buffer, "exists"))
207                 return ISL_TOKEN_EXISTS;
208         if (!strcasecmp(s->buffer, "and"))
209                 return ISL_TOKEN_AND;
210         if (!strcasecmp(s->buffer, "or"))
211                 return ISL_TOKEN_OR;
212         if (!strcasecmp(s->buffer, "infty"))
213                 return ISL_TOKEN_INFTY;
214         if (!strcasecmp(s->buffer, "infinity"))
215                 return ISL_TOKEN_INFTY;
216         if (!strcasecmp(s->buffer, "NaN"))
217                 return ISL_TOKEN_NAN;
218
219         if (!s->keywords)
220                 return ISL_TOKEN_IDENT;
221
222         name_hash = isl_hash_string(isl_hash_init(), s->buffer);
223         entry = isl_hash_table_find(s->ctx, s->keywords, name_hash, same_name,
224                                         s->buffer, 0);
225         if (entry) {
226                 keyword = entry->data;
227                 return keyword->type;
228         }
229
230         return ISL_TOKEN_IDENT;
231 }
232
233 static struct isl_token *next_token(struct isl_stream *s, int same_line)
234 {
235         int c;
236         struct isl_token *tok = NULL;
237         int line, col;
238         int old_line = s->line;
239
240         if (s->n_token) {
241                 if (same_line && s->tokens[s->n_token - 1]->on_new_line)
242                         return NULL;
243                 return s->tokens[--s->n_token];
244         }
245
246         if (same_line && s->c == '\n')
247                 return NULL;
248
249         s->len = 0;
250
251         /* skip spaces and comment lines */
252         while ((c = isl_stream_getc(s)) != -1) {
253                 if (c == '#') {
254                         while ((c = isl_stream_getc(s)) != -1 && c != '\n')
255                                 /* nothing */
256                                 ;
257                         if (c == -1 || (same_line && c == '\n'))
258                                 break;
259                 } else if (!isspace(c) || (same_line && c == '\n'))
260                         break;
261         }
262
263         line = s->line;
264         col = s->col;
265
266         if (c == -1 || (same_line && c == '\n'))
267                 return NULL;
268         if (c == '(' ||
269             c == ')' ||
270             c == '+' ||
271             c == '/' ||
272             c == '*' ||
273             c == '^' ||
274             c == '=' ||
275             c == '@' ||
276             c == ',' ||
277             c == '.' ||
278             c == ';' ||
279             c == '[' ||
280             c == ']' ||
281             c == '{' ||
282             c == '}') {
283                 tok = isl_token_new(s->ctx, line, col, old_line != line);
284                 if (!tok)
285                         return NULL;
286                 tok->type = (enum isl_token_type)c;
287                 return tok;
288         }
289         if (c == '-') {
290                 int c;
291                 if ((c = isl_stream_getc(s)) == '>') {
292                         tok = isl_token_new(s->ctx, line, col, old_line != line);
293                         if (!tok)
294                                 return NULL;
295                         tok->type = ISL_TOKEN_TO;
296                         return tok;
297                 }
298                 if (c != -1)
299                         isl_stream_ungetc(s, c);
300                 if (!isdigit(c)) {
301                         tok = isl_token_new(s->ctx, line, col, old_line != line);
302                         if (!tok)
303                                 return NULL;
304                         tok->type = (enum isl_token_type) '-';
305                         return tok;
306                 }
307         }
308         if (c == '-' || isdigit(c)) {
309                 tok = isl_token_new(s->ctx, line, col, old_line != line);
310                 if (!tok)
311                         return NULL;
312                 tok->type = ISL_TOKEN_VALUE;
313                 isl_int_init(tok->u.v);
314                 if (isl_stream_push_char(s, c))
315                         goto error;
316                 while ((c = isl_stream_getc(s)) != -1 && isdigit(c))
317                         if (isl_stream_push_char(s, c))
318                                 goto error;
319                 if (c != -1)
320                         isl_stream_ungetc(s, c);
321                 isl_stream_push_char(s, '\0');
322                 isl_int_read(tok->u.v, s->buffer);
323                 return tok;
324         }
325         if (isalpha(c)) {
326                 tok = isl_token_new(s->ctx, line, col, old_line != line);
327                 if (!tok)
328                         return NULL;
329                 isl_stream_push_char(s, c);
330                 while ((c = isl_stream_getc(s)) != -1 &&
331                                 (isalnum(c) || c == '_'))
332                         isl_stream_push_char(s, c);
333                 if (c != -1)
334                         isl_stream_ungetc(s, c);
335                 while ((c = isl_stream_getc(s)) != -1 && c == '\'')
336                         isl_stream_push_char(s, c);
337                 if (c != -1)
338                         isl_stream_ungetc(s, c);
339                 isl_stream_push_char(s, '\0');
340                 tok->type = check_keywords(s);
341                 if (tok->type == ISL_TOKEN_IDENT)
342                         tok->u.s = strdup(s->buffer);
343                 return tok;
344         }
345         if (c == ':') {
346                 int c;
347                 tok = isl_token_new(s->ctx, line, col, old_line != line);
348                 if (!tok)
349                         return NULL;
350                 if ((c = isl_stream_getc(s)) == '=') {
351                         tok->type = ISL_TOKEN_DEF;
352                         return tok;
353                 }
354                 if (c != -1)
355                         isl_stream_ungetc(s, c);
356                 tok->type = ':';
357                 return tok;
358         }
359         if (c == '>') {
360                 int c;
361                 tok = isl_token_new(s->ctx, line, col, old_line != line);
362                 if (!tok)
363                         return NULL;
364                 if ((c = isl_stream_getc(s)) == '=') {
365                         tok->type = ISL_TOKEN_GE;
366                         return tok;
367                 }
368                 if (c != -1)
369                         isl_stream_ungetc(s, c);
370                 tok->type = ISL_TOKEN_GT;
371                 return tok;
372         }
373         if (c == '<') {
374                 int c;
375                 tok = isl_token_new(s->ctx, line, col, old_line != line);
376                 if (!tok)
377                         return NULL;
378                 if ((c = isl_stream_getc(s)) == '=') {
379                         tok->type = ISL_TOKEN_LE;
380                         return tok;
381                 }
382                 if (c != -1)
383                         isl_stream_ungetc(s, c);
384                 tok->type = ISL_TOKEN_LT;
385                 return tok;
386         }
387         if (c == '&') {
388                 tok = isl_token_new(s->ctx, line, col, old_line != line);
389                 if (!tok)
390                         return NULL;
391                 tok->type = ISL_TOKEN_AND;
392                 if ((c = isl_stream_getc(s)) != '&' && c != -1)
393                         isl_stream_ungetc(s, c);
394                 return tok;
395         }
396         if (c == '|') {
397                 tok = isl_token_new(s->ctx, line, col, old_line != line);
398                 if (!tok)
399                         return NULL;
400                 tok->type = ISL_TOKEN_OR;
401                 if ((c = isl_stream_getc(s)) != '|' && c != -1)
402                         isl_stream_ungetc(s, c);
403                 return tok;
404         }
405
406         tok = isl_token_new(s->ctx, line, col, old_line != line);
407         if (!tok)
408                 return NULL;
409         tok->type = ISL_TOKEN_UNKNOWN;
410         return tok;
411 error:
412         isl_token_free(tok);
413         return NULL;
414 }
415
416 struct isl_token *isl_stream_next_token(struct isl_stream *s)
417 {
418         return next_token(s, 0);
419 }
420
421 struct isl_token *isl_stream_next_token_on_same_line(struct isl_stream *s)
422 {
423         return next_token(s, 1);
424 }
425
426 int isl_stream_eat_if_available(struct isl_stream *s, int type)
427 {
428         struct isl_token *tok;
429
430         tok = isl_stream_next_token(s);
431         if (!tok)
432                 return 0;
433         if (tok->type == type) {
434                 isl_token_free(tok);
435                 return 1;
436         }
437         isl_stream_push_token(s, tok);
438         return 0;
439 }
440
441 int isl_stream_next_token_is(struct isl_stream *s, int type)
442 {
443         struct isl_token *tok;
444         int r;
445
446         tok = isl_stream_next_token(s);
447         if (!tok)
448                 return 0;
449         r = tok->type == type;
450         isl_stream_push_token(s, tok);
451         return r;
452 }
453
454 char *isl_stream_read_ident_if_available(struct isl_stream *s)
455 {
456         struct isl_token *tok;
457
458         tok = isl_stream_next_token(s);
459         if (!tok)
460                 return NULL;
461         if (tok->type == ISL_TOKEN_IDENT) {
462                 char *ident = strdup(tok->u.s);
463                 isl_token_free(tok);
464                 return ident;
465         }
466         isl_stream_push_token(s, tok);
467         return NULL;
468 }
469
470 int isl_stream_eat(struct isl_stream *s, int type)
471 {
472         struct isl_token *tok;
473
474         tok = isl_stream_next_token(s);
475         if (!tok)
476                 return -1;
477         if (tok->type == type) {
478                 isl_token_free(tok);
479                 return 0;
480         }
481         isl_stream_error(s, tok, "expecting other token");
482         isl_stream_push_token(s, tok);
483         return -1;
484 }
485
486 int isl_stream_is_empty(struct isl_stream *s)
487 {
488         struct isl_token *tok;
489
490         tok = isl_stream_next_token(s);
491
492         if (!tok)
493                 return 1;
494
495         isl_stream_push_token(s, tok);
496         return 0;
497 }
498
499 static int free_keyword(void *p)
500 {
501         struct isl_keyword *keyword = p;
502
503         free(keyword->name);
504         free(keyword);
505
506         return 0;
507 }
508
509 void isl_stream_free(struct isl_stream *s)
510 {
511         if (!s)
512                 return;
513         free(s->buffer);
514         if (s->n_token != 0) {
515                 struct isl_token *tok = isl_stream_next_token(s);
516                 isl_stream_error(s, tok, "unexpected token");
517                 isl_token_free(tok);
518         }
519         if (s->keywords) {
520                 isl_hash_table_foreach(s->ctx, s->keywords, free_keyword);
521                 isl_hash_table_free(s->ctx, s->keywords);
522         }
523         isl_ctx_deref(s->ctx);
524         free(s);
525 }