?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pet_tree_dump: fix typo in output
[pet.git] / parse.c
blob200b6ec2753728563f5b7ef7be0a220a0db12695
1 /*
2 * Copyright 2011 Leiden University. All rights reserved.
3 * Copyright 2013-2014 Ecole Normale Superieure. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above
13 * copyright notice, this list of conditions and the following
14 * disclaimer in the documentation and/or other materials provided
15 * with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
21 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
24 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * The views and conclusions contained in the software and documentation
30 * are those of the authors and should not be interpreted as
31 * representing official policies, either expressed or implied, of
32 * Leiden University.
33 */
34
35 #include <stdlib.h>
36 #include <yaml.h>
37
38 #include "expr.h"
39 #include "loc.h"
40 #include "scop.h"
41 #include "scop_yaml.h"
42 #include "tree.h"
43
44 static char *extract_string(isl_ctx *ctx, yaml_document_t *document,
45 yaml_node_t *node)
46 {
47 if (node->type != YAML_SCALAR_NODE)
48 isl_die(ctx, isl_error_invalid, "expecting scalar node",
49 return NULL);
50
51 return strdup((char *) node->data.scalar.value);
52 }
53
54 static int extract_int(isl_ctx *ctx, yaml_document_t *document,
55 yaml_node_t *node)
56 {
57 if (node->type != YAML_SCALAR_NODE)
58 isl_die(ctx, isl_error_invalid, "expecting scalar node",
59 return -1);
60
61 return atoi((char *) node->data.scalar.value);
62 }
63
64 static double extract_double(isl_ctx *ctx, yaml_document_t *document,
65 yaml_node_t *node)
66 {
67 if (node->type != YAML_SCALAR_NODE)
68 isl_die(ctx, isl_error_invalid, "expecting scalar node",
69 return -1);
70
71 return strtod((char *) node->data.scalar.value, NULL);
72 }
73
74 static enum pet_expr_type extract_expr_type(isl_ctx *ctx,
75 yaml_document_t *document, yaml_node_t *node)
76 {
77 if (node->type != YAML_SCALAR_NODE)
78 isl_die(ctx, isl_error_invalid, "expecting scalar node",
79 return -1);
80
81 return pet_str_type((char *) node->data.scalar.value);
82 }
83
84 static enum pet_op_type extract_op(isl_ctx *ctx, yaml_document_t *document,
85 yaml_node_t *node)
86 {
87 if (node->type != YAML_SCALAR_NODE)
88 isl_die(ctx, isl_error_invalid, "expecting scalar node",
89 return -1);
90
91 return pet_str_op((char *) node->data.scalar.value);
92 }
93
94 static __isl_give isl_set *extract_set(isl_ctx *ctx, yaml_document_t *document,
95 yaml_node_t *node)
96 {
97 if (node->type != YAML_SCALAR_NODE)
98 isl_die(ctx, isl_error_invalid, "expecting scalar node",
99 return NULL);
100
101 return isl_set_read_from_str(ctx, (char *) node->data.scalar.value);
102 }
103
104 static __isl_give isl_id *extract_id(isl_ctx *ctx, yaml_document_t *document,
105 yaml_node_t *node)
106 {
107 if (node->type != YAML_SCALAR_NODE)
108 isl_die(ctx, isl_error_invalid, "expecting scalar node",
109 return NULL);
110
111 return isl_id_alloc(ctx, (char *) node->data.scalar.value, NULL);
112 }
113
114 static __isl_give isl_map *extract_map(isl_ctx *ctx, yaml_document_t *document,
115 yaml_node_t *node)
116 {
117 if (node->type != YAML_SCALAR_NODE)
118 isl_die(ctx, isl_error_invalid, "expecting scalar node",
119 return NULL);
120
121 return isl_map_read_from_str(ctx, (char *) node->data.scalar.value);
122 }
123
124 /* Extract an isl_union_set from "node".
125 */
126 static __isl_give isl_union_set *extract_union_set(isl_ctx *ctx,
127 yaml_document_t *document, yaml_node_t *node)
128 {
129 if (node->type != YAML_SCALAR_NODE)
130 isl_die(ctx, isl_error_invalid, "expecting scalar node",
131 return NULL);
132
133 return isl_union_set_read_from_str(ctx,
134 (char *) node->data.scalar.value);
135 }
136
137 /* Extract an isl_union_map from "node".
138 */
139 static __isl_give isl_union_map *extract_union_map(isl_ctx *ctx,
140 yaml_document_t *document, yaml_node_t *node)
141 {
142 if (node->type != YAML_SCALAR_NODE)
143 isl_die(ctx, isl_error_invalid, "expecting scalar node",
144 return NULL);
145
146 return isl_union_map_read_from_str(ctx,
147 (char *) node->data.scalar.value);
148 }
149
150 /* Extract an isl_val from "node".
151 */
152 static __isl_give isl_val *extract_val(isl_ctx *ctx, yaml_document_t *document,
153 yaml_node_t *node)
154 {
155 if (node->type != YAML_SCALAR_NODE)
156 isl_die(ctx, isl_error_invalid, "expecting scalar node",
157 return NULL);
158
159 return isl_val_read_from_str(ctx, (char *) node->data.scalar.value);
160 }
161
162 /* Extract an isl_multi_pw_aff from "node".
163 */
164 static __isl_give isl_multi_pw_aff *extract_multi_pw_aff(isl_ctx *ctx,
165 yaml_document_t *document, yaml_node_t *node)
166 {
167 if (node->type != YAML_SCALAR_NODE)
168 isl_die(ctx, isl_error_invalid, "expecting scalar node",
169 return NULL);
170
171 return isl_multi_pw_aff_read_from_str(ctx,
172 (char *) node->data.scalar.value);
173 }
174
175 /* Extract a pet_type from "node".
176 */
177 static struct pet_type *extract_type(isl_ctx *ctx,
178 yaml_document_t *document, yaml_node_t *node)
179 {
180 struct pet_type *type;
181 yaml_node_pair_t * pair;
182
183 if (node->type != YAML_MAPPING_NODE)
184 isl_die(ctx, isl_error_invalid, "expecting mapping",
185 return NULL);
186
187 type = isl_calloc_type(ctx, struct pet_type);
188 if (!type)
189 return NULL;
190
191 for (pair = node->data.mapping.pairs.start;
192 pair < node->data.mapping.pairs.top; ++pair) {
193 yaml_node_t *key, *value;
194
195 key = yaml_document_get_node(document, pair->key);
196 value = yaml_document_get_node(document, pair->value);
197
198 if (key->type != YAML_SCALAR_NODE)
199 isl_die(ctx, isl_error_invalid, "expecting scalar key",
200 return pet_type_free(type));
201
202 if (!strcmp((char *) key->data.scalar.value, "name"))
203 type->name = extract_string(ctx, document, value);
204 if (!strcmp((char *) key->data.scalar.value, "definition"))
205 type->definition = extract_string(ctx, document, value);
206 }
207
208 return type;
209 }
210
211 /* Extract a sequence of types from "node" and store them in scop->types.
212 */
213 static struct pet_scop *extract_types(isl_ctx *ctx,
214 yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
215 {
216 int i;
217 yaml_node_item_t *item;
218
219 if (node->type != YAML_SEQUENCE_NODE)
220 isl_die(ctx, isl_error_invalid, "expecting sequence",
221 return NULL);
222
223 scop->n_type = node->data.sequence.items.top
224 - node->data.sequence.items.start;
225 scop->types = isl_calloc_array(ctx, struct pet_type *, scop->n_type);
226 if (!scop->types)
227 return pet_scop_free(scop);
228
229 for (item = node->data.sequence.items.start, i = 0;
230 item < node->data.sequence.items.top; ++item, ++i) {
231 yaml_node_t *n;
232
233 n = yaml_document_get_node(document, *item);
234 scop->types[i] = extract_type(ctx, document, n);
235 if (!scop->types[i])
236 return pet_scop_free(scop);
237 }
238
239 return scop;
240 }
241
242 static struct pet_array *extract_array(isl_ctx *ctx, yaml_document_t *document,
243 yaml_node_t *node)
244 {
245 struct pet_array *array;
246 yaml_node_pair_t * pair;
247
248 if (node->type != YAML_MAPPING_NODE)
249 isl_die(ctx, isl_error_invalid, "expecting mapping",
250 return NULL);
251
252 array = isl_calloc_type(ctx, struct pet_array);
253 if (!array)
254 return NULL;
255
256 for (pair = node->data.mapping.pairs.start;
257 pair < node->data.mapping.pairs.top; ++pair) {
258 yaml_node_t *key, *value;
259
260 key = yaml_document_get_node(document, pair->key);
261 value = yaml_document_get_node(document, pair->value);
262
263 if (key->type != YAML_SCALAR_NODE)
264 isl_die(ctx, isl_error_invalid, "expecting scalar key",
265 return pet_array_free(array));
266
267 if (!strcmp((char *) key->data.scalar.value, "context"))
268 array->context = extract_set(ctx, document, value);
269 if (!strcmp((char *) key->data.scalar.value, "extent"))
270 array->extent = extract_set(ctx, document, value);
271 if (!strcmp((char *) key->data.scalar.value, "value_bounds"))
272 array->value_bounds = extract_set(ctx, document, value);
273 if (!strcmp((char *) key->data.scalar.value, "element_type"))
274 array->element_type =
275 extract_string(ctx, document, value);
276 if (!strcmp((char *) key->data.scalar.value, "element_size"))
277 array->element_size = extract_int(ctx, document, value);
278 if (!strcmp((char *) key->data.scalar.value,
279 "element_is_record"))
280 array->element_is_record =
281 extract_int(ctx, document, value);
282 if (!strcmp((char *) key->data.scalar.value, "live_out"))
283 array->live_out = extract_int(ctx, document, value);
284 if (!strcmp((char *) key->data.scalar.value,
285 "uniquely_defined"))
286 array->uniquely_defined =
287 extract_int(ctx, document, value);
288 if (!strcmp((char *) key->data.scalar.value, "declared"))
289 array->declared = extract_int(ctx, document, value);
290 if (!strcmp((char *) key->data.scalar.value, "exposed"))
291 array->exposed = extract_int(ctx, document, value);
292 }
293
294 return array;
295 }
296
297 static struct pet_scop *extract_arrays(isl_ctx *ctx, yaml_document_t *document,
298 yaml_node_t *node, struct pet_scop *scop)
299 {
300 int i;
301 yaml_node_item_t *item;
302
303 if (node->type != YAML_SEQUENCE_NODE)
304 isl_die(ctx, isl_error_invalid, "expecting sequence",
305 return NULL);
306
307 scop->n_array = node->data.sequence.items.top
308 - node->data.sequence.items.start;
309 scop->arrays = isl_calloc_array(ctx, struct pet_array *, scop->n_array);
310 if (!scop->arrays)
311 return pet_scop_free(scop);
312
313 for (item = node->data.sequence.items.start, i = 0;
314 item < node->data.sequence.items.top; ++item, ++i) {
315 yaml_node_t *n;
316
317 n = yaml_document_get_node(document, *item);
318 scop->arrays[i] = extract_array(ctx, document, n);
319 if (!scop->arrays[i])
320 return pet_scop_free(scop);
321 }
322
323 return scop;
324 }
325
326 static __isl_give pet_expr *extract_expr(isl_ctx *ctx,
327 yaml_document_t *document, yaml_node_t *node);
328
329 static __isl_give pet_expr *extract_arguments(isl_ctx *ctx,
330 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
331 {
332 int i, n;
333 yaml_node_item_t *item;
334
335 if (node->type != YAML_SEQUENCE_NODE)
336 isl_die(ctx, isl_error_invalid, "expecting sequence",
337 return pet_expr_free(expr));
338
339 n = node->data.sequence.items.top - node->data.sequence.items.start;
340 expr = pet_expr_set_n_arg(expr, n);
341
342 for (item = node->data.sequence.items.start, i = 0;
343 item < node->data.sequence.items.top; ++item, ++i) {
344 yaml_node_t *n;
345 pet_expr *arg;
346
347 n = yaml_document_get_node(document, *item);
348 arg = extract_expr(ctx, document, n);
349 expr = pet_expr_set_arg(expr, i, arg);
350 }
351
352 return expr;
353 }
354
355 /* Extract pet_expr_double specific fields from "node" and
356 * update "expr" accordingly.
357 */
358 static __isl_give pet_expr *extract_expr_double(isl_ctx *ctx,
359 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
360 {
361 yaml_node_pair_t *pair;
362 double d = 0;
363 char *s = NULL;
364
365 for (pair = node->data.mapping.pairs.start;
366 pair < node->data.mapping.pairs.top; ++pair) {
367 yaml_node_t *key, *value;
368
369 key = yaml_document_get_node(document, pair->key);
370 value = yaml_document_get_node(document, pair->value);
371
372 if (key->type != YAML_SCALAR_NODE)
373 isl_die(ctx, isl_error_invalid, "expecting scalar key",
374 return pet_expr_free(expr));
375
376 if (!strcmp((char *) key->data.scalar.value, "value"))
377 d = extract_double(ctx, document, value);
378 if (!strcmp((char *) key->data.scalar.value, "string"))
379 s = extract_string(ctx, document, value);
380 }
381
382 expr = pet_expr_double_set(expr, d, s);
383 free(s);
384
385 return expr;
386 }
387
388 /* Extract pet_expr_access specific fields from "node" and
389 * update "expr" accordingly.
390 *
391 * The depth of the access is initialized by pet_expr_access_set_index.
392 * Any explicitly specified depth therefore needs to be set after
393 * setting the index expression. Similiarly, the access relations (if any)
394 * need to be set after setting the depth.
395 */
396 static __isl_give pet_expr *extract_expr_access(isl_ctx *ctx,
397 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
398 {
399 yaml_node_pair_t *pair;
400 int depth = -1;
401 isl_multi_pw_aff *index = NULL;
402
403 for (pair = node->data.mapping.pairs.start;
404 pair < node->data.mapping.pairs.top; ++pair) {
405 yaml_node_t *key, *value;
406
407 key = yaml_document_get_node(document, pair->key);
408 value = yaml_document_get_node(document, pair->value);
409
410 if (key->type != YAML_SCALAR_NODE)
411 isl_die(ctx, isl_error_invalid, "expecting scalar key",
412 return pet_expr_free(expr));
413
414 if (!strcmp((char *) key->data.scalar.value, "index"))
415 index = extract_multi_pw_aff(ctx, document, value);
416 if (!strcmp((char *) key->data.scalar.value, "depth"))
417 depth = extract_int(ctx, document, value);
418 }
419
420 expr = pet_expr_access_set_index(expr, index);
421 if (depth >= 0)
422 expr = pet_expr_access_set_depth(expr, depth);
423
424 for (pair = node->data.mapping.pairs.start;
425 pair < node->data.mapping.pairs.top; ++pair) {
426 yaml_node_t *key, *value;
427
428 key = yaml_document_get_node(document, pair->key);
429 value = yaml_document_get_node(document, pair->value);
430
431 if (key->type != YAML_SCALAR_NODE)
432 isl_die(ctx, isl_error_invalid, "expecting scalar key",
433 return pet_expr_free(expr));
434
435 if (!strcmp((char *) key->data.scalar.value, "may_read"))
436 expr = pet_expr_access_set_access(expr,
437 pet_expr_access_may_read,
438 extract_union_map(ctx, document, value));
439 if (!strcmp((char *) key->data.scalar.value, "may_write"))
440 expr = pet_expr_access_set_access(expr,
441 pet_expr_access_may_write,
442 extract_union_map(ctx, document, value));
443 if (!strcmp((char *) key->data.scalar.value, "must_write"))
444 expr = pet_expr_access_set_access(expr,
445 pet_expr_access_must_write,
446 extract_union_map(ctx, document, value));
447 if (!strcmp((char *) key->data.scalar.value, "killed"))
448 expr = pet_expr_access_set_access(expr,
449 pet_expr_access_killed,
450 extract_union_map(ctx, document, value));
451 if (!strcmp((char *) key->data.scalar.value, "reference"))
452 expr = pet_expr_access_set_ref_id(expr,
453 extract_id(ctx, document, value));
454 if (!strcmp((char *) key->data.scalar.value, "read"))
455 expr = pet_expr_access_set_read(expr,
456 extract_int(ctx, document, value));
457 if (!strcmp((char *) key->data.scalar.value, "write"))
458 expr = pet_expr_access_set_write(expr,
459 extract_int(ctx, document, value));
460 if (!strcmp((char *) key->data.scalar.value, "kill"))
461 expr = pet_expr_access_set_kill(expr,
462 extract_int(ctx, document, value));
463 }
464
465 return expr;
466 }
467
468 /* Extract operation expression specific fields from "node" and
469 * update "expr" accordingly.
470 */
471 static __isl_give pet_expr *extract_expr_op(isl_ctx *ctx,
472 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
473 {
474 yaml_node_pair_t *pair;
475
476 for (pair = node->data.mapping.pairs.start;
477 pair < node->data.mapping.pairs.top; ++pair) {
478 yaml_node_t *key, *value;
479
480 key = yaml_document_get_node(document, pair->key);
481 value = yaml_document_get_node(document, pair->value);
482
483 if (key->type != YAML_SCALAR_NODE)
484 isl_die(ctx, isl_error_invalid, "expecting scalar key",
485 return pet_expr_free(expr));
486
487 if (!strcmp((char *) key->data.scalar.value, "operation"))
488 expr = pet_expr_op_set_type(expr,
489 extract_op(ctx, document, value));
490 }
491
492 return expr;
493 }
494
495 /* Extract pet_expr_call specific fields from "node" and
496 * update "expr" accordingly.
497 */
498 static __isl_give pet_expr *extract_expr_call(isl_ctx *ctx,
499 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
500 {
501 yaml_node_pair_t *pair;
502
503 for (pair = node->data.mapping.pairs.start;
504 pair < node->data.mapping.pairs.top; ++pair) {
505 yaml_node_t *key, *value;
506
507 key = yaml_document_get_node(document, pair->key);
508 value = yaml_document_get_node(document, pair->value);
509
510 if (key->type != YAML_SCALAR_NODE)
511 isl_die(ctx, isl_error_invalid, "expecting scalar key",
512 return pet_expr_free(expr));
513
514 if (!strcmp((char *) key->data.scalar.value, "name"))
515 expr = pet_expr_call_set_name(expr,
516 extract_string(ctx, document, value));
517 }
518
519 return expr;
520 }
521
522 /* Extract pet_expr_cast specific fields from "node" and
523 * update "expr" accordingly.
524 */
525 static __isl_give pet_expr *extract_expr_cast(isl_ctx *ctx,
526 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
527 {
528 yaml_node_pair_t *pair;
529
530 for (pair = node->data.mapping.pairs.start;
531 pair < node->data.mapping.pairs.top; ++pair) {
532 yaml_node_t *key, *value;
533
534 key = yaml_document_get_node(document, pair->key);
535 value = yaml_document_get_node(document, pair->value);
536
537 if (key->type != YAML_SCALAR_NODE)
538 isl_die(ctx, isl_error_invalid, "expecting scalar key",
539 return pet_expr_free(expr));
540
541 if (!strcmp((char *) key->data.scalar.value, "type_name"))
542 expr = pet_expr_cast_set_type_name(expr,
543 extract_string(ctx, document, value));
544 }
545
546 return expr;
547 }
548
549 /* Extract pet_expr_int specific fields from "node" and
550 * update "expr" accordingly.
551 */
552 static __isl_give pet_expr *extract_expr_int(isl_ctx *ctx,
553 yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
554 {
555 yaml_node_pair_t * pair;
556
557 for (pair = node->data.mapping.pairs.start;
558 pair < node->data.mapping.pairs.top; ++pair) {
559 yaml_node_t *key, *value;
560
561 key = yaml_document_get_node(document, pair->key);
562 value = yaml_document_get_node(document, pair->value);
563
564 if (key->type != YAML_SCALAR_NODE)
565 isl_die(ctx, isl_error_invalid, "expecting scalar key",
566 return pet_expr_free(expr));
567
568 if (!strcmp((char *) key->data.scalar.value, "value"))
569 expr = pet_expr_int_set_val(expr,
570 extract_val(ctx, document, value));
571 }
572
573 return expr;
574 }
575
576 /* Extract a pet_expr from "node".
577 *
578 * We first extract the type and arguments of the expression and
579 * then extract additional fields depending on the type.
580 */
581 static __isl_give pet_expr *extract_expr(isl_ctx *ctx,
582 yaml_document_t *document, yaml_node_t *node)
583 {
584 enum pet_expr_type type = pet_expr_error;
585 pet_expr *expr;
586 yaml_node_pair_t *pair;
587
588 if (node->type != YAML_MAPPING_NODE)
589 isl_die(ctx, isl_error_invalid, "expecting mapping",
590 return NULL);
591
592 for (pair = node->data.mapping.pairs.start;
593 pair < node->data.mapping.pairs.top; ++pair) {
594 yaml_node_t *key, *value;
595
596 key = yaml_document_get_node(document, pair->key);
597 value = yaml_document_get_node(document, pair->value);
598
599 if (key->type != YAML_SCALAR_NODE)
600 isl_die(ctx, isl_error_invalid, "expecting scalar key",
601 return pet_expr_free(expr));
602
603 if (!strcmp((char *) key->data.scalar.value, "type"))
604 type = extract_expr_type(ctx, document, value);
605 }
606
607 if (type == pet_expr_error)
608 isl_die(ctx, isl_error_invalid, "cannot determine type",
609 return NULL);
610
611 expr = pet_expr_alloc(ctx, type);
612 if (!expr)
613 return NULL;
614
615 for (pair = node->data.mapping.pairs.start;
616 pair < node->data.mapping.pairs.top; ++pair) {
617 yaml_node_t *key, *value;
618
619 key = yaml_document_get_node(document, pair->key);
620 value = yaml_document_get_node(document, pair->value);
621
622 if (!strcmp((char *) key->data.scalar.value, "arguments"))
623 expr = extract_arguments(ctx, document, value, expr);
624 if (!expr)
625 return NULL;
626 }
627
628 switch (type) {
629 case pet_expr_error:
630 isl_die(ctx, isl_error_internal, "unreachable code",
631 return NULL);
632 case pet_expr_access:
633 expr = extract_expr_access(ctx, document, node, expr);
634 break;
635 case pet_expr_double:
636 expr = extract_expr_double(ctx, document, node, expr);
637 break;
638 case pet_expr_call:
639 expr = extract_expr_call(ctx, document, node, expr);
640 break;
641 case pet_expr_cast:
642 expr = extract_expr_cast(ctx, document, node, expr);
643 break;
644 case pet_expr_int:
645 expr = extract_expr_int(ctx, document, node, expr);
646 break;
647 case pet_expr_op:
648 expr = extract_expr_op(ctx, document, node, expr);
649 break;
650 }
651
652 return expr;
653 }
654
655 /* Extract a pet_tree_type from "node".
656 */
657 static enum pet_tree_type extract_tree_type(isl_ctx *ctx,
658 yaml_document_t *document, yaml_node_t *node)
659 {
660 if (node->type != YAML_SCALAR_NODE)
661 isl_die(ctx, isl_error_invalid, "expecting scalar node",
662 return -1);
663
664 return pet_tree_str_type((char *) node->data.scalar.value);
665 }
666
667 static __isl_give pet_tree *extract_tree(isl_ctx *ctx,
668 yaml_document_t *document, yaml_node_t *node);
669
670 /* Extract a pet_tree of type pet_tree_block from "node".
671 */
672 static __isl_give pet_tree *extract_tree_block(isl_ctx *ctx,
673 yaml_document_t *document, yaml_node_t *node)
674 {
675 int block = 0;
676 int i, n;
677 yaml_node_pair_t *pair;
678 yaml_node_item_t *item;
679 yaml_node_t *children = NULL;
680 pet_tree *tree;
681
682 for (pair = node->data.mapping.pairs.start;
683 pair < node->data.mapping.pairs.top; ++pair) {
684 yaml_node_t *key, *value;
685
686 key = yaml_document_get_node(document, pair->key);
687 value = yaml_document_get_node(document, pair->value);
688
689 if (key->type != YAML_SCALAR_NODE)
690 isl_die(ctx, isl_error_invalid, "expecting scalar key",
691 return NULL);
692
693 if (!strcmp((char *) key->data.scalar.value, "block"))
694 block = extract_int(ctx, document, value);
695 if (!strcmp((char *) key->data.scalar.value, "children"))
696 children = value;
697 }
698
699 if (!children)
700 n = 0;
701 else
702 n = children->data.sequence.items.top -
703 children->data.sequence.items.start;
704
705 tree = pet_tree_new_block(ctx, block, n);
706 if (!children)
707 return tree;
708
709 for (item = children->data.sequence.items.start, i = 0;
710 item < children->data.sequence.items.top; ++item, ++i) {
711 yaml_node_t *n;
712 pet_tree *child;
713
714 n = yaml_document_get_node(document, *item);
715 child = extract_tree(ctx, document, n);
716 tree = pet_tree_block_add_child(tree, child);
717 }
718
719 return tree;
720 }
721
722 /* Extract a pet_tree of type pet_tree_decl from "node".
723 */
724 static __isl_give pet_tree *extract_tree_decl(isl_ctx *ctx,
725 yaml_document_t *document, yaml_node_t *node)
726 {
727 yaml_node_pair_t *pair;
728 pet_expr *var = NULL;
729
730 for (pair = node->data.mapping.pairs.start;
731 pair < node->data.mapping.pairs.top; ++pair) {
732 yaml_node_t *key, *value;
733
734 key = yaml_document_get_node(document, pair->key);
735 value = yaml_document_get_node(document, pair->value);
736
737 if (key->type != YAML_SCALAR_NODE)
738 isl_die(ctx, isl_error_invalid, "expecting scalar key",
739 return NULL);
740
741 if (!strcmp((char *) key->data.scalar.value, "variable")) {
742 var = extract_expr(ctx, document, value);
743 if (!var)
744 return NULL;
745 }
746 }
747
748 if (!var)
749 isl_die(ctx, isl_error_invalid,
750 "no variable field", return NULL);
751
752 return pet_tree_new_decl(var);
753 }
754
755 /* Extract a pet_tree of type pet_tree_decl_init from "node".
756 */
757 static __isl_give pet_tree *extract_tree_decl_init(isl_ctx *ctx,
758 yaml_document_t *document, yaml_node_t *node)
759 {
760 yaml_node_pair_t *pair;
761 pet_expr *var = NULL;
762 pet_expr *init = NULL;
763
764 for (pair = node->data.mapping.pairs.start;
765 pair < node->data.mapping.pairs.top; ++pair) {
766 yaml_node_t *key, *value;
767
768 key = yaml_document_get_node(document, pair->key);
769 value = yaml_document_get_node(document, pair->value);
770
771 if (key->type != YAML_SCALAR_NODE)
772 isl_die(ctx, isl_error_invalid, "expecting scalar key",
773 return NULL);
774
775 if (!strcmp((char *) key->data.scalar.value, "variable")) {
776 var = extract_expr(ctx, document, value);
777 if (!var)
778 goto error;
779 }
780 if (!strcmp((char *) key->data.scalar.value,
781 "initialization")) {
782 init = extract_expr(ctx, document, value);
783 if (!init)
784 goto error;
785 }
786 }
787
788 if (!var)
789 isl_die(ctx, isl_error_invalid,
790 "no variable field", goto error);
791 if (!init)
792 isl_die(ctx, isl_error_invalid,
793 "no initialization field", goto error);
794
795 return pet_tree_new_decl_init(var, init);
796 error:
797 pet_expr_free(var);
798 pet_expr_free(init);
799 return NULL;
800 }
801
802 /* Extract a pet_tree of type pet_tree_expr from "node".
803 */
804 static __isl_give pet_tree *extract_tree_expr(isl_ctx *ctx,
805 yaml_document_t *document, yaml_node_t *node)
806 {
807 yaml_node_pair_t *pair;
808 pet_expr *expr = NULL;
809
810 for (pair = node->data.mapping.pairs.start;
811 pair < node->data.mapping.pairs.top; ++pair) {
812 yaml_node_t *key, *value;
813
814 key = yaml_document_get_node(document, pair->key);
815 value = yaml_document_get_node(document, pair->value);
816
817 if (key->type != YAML_SCALAR_NODE)
818 isl_die(ctx, isl_error_invalid, "expecting scalar key",
819 return NULL);
820
821 if (!strcmp((char *) key->data.scalar.value, "expr")) {
822 expr = extract_expr(ctx, document, value);
823 if (!expr)
824 return NULL;
825 }
826 }
827
828 if (!expr)
829 isl_die(ctx, isl_error_invalid,
830 "no expr field", return NULL);
831
832 return pet_tree_new_expr(expr);
833 }
834
835 /* Extract a pet_tree of type pet_tree_while from "node".
836 */
837 static __isl_give pet_tree *extract_tree_while(isl_ctx *ctx,
838 yaml_document_t *document, yaml_node_t *node)
839 {
840 yaml_node_pair_t *pair;
841 pet_expr *cond = NULL;
842 pet_tree *body = NULL;
843
844 for (pair = node->data.mapping.pairs.start;
845 pair < node->data.mapping.pairs.top; ++pair) {
846 yaml_node_t *key, *value;
847
848 key = yaml_document_get_node(document, pair->key);
849 value = yaml_document_get_node(document, pair->value);
850
851 if (key->type != YAML_SCALAR_NODE)
852 isl_die(ctx, isl_error_invalid, "expecting scalar key",
853 return NULL);
854
855 if (!strcmp((char *) key->data.scalar.value, "condition")) {
856 cond = extract_expr(ctx, document, value);
857 if (!cond)
858 goto error;
859 }
860 if (!strcmp((char *) key->data.scalar.value, "body")) {
861 body = extract_tree(ctx, document, value);
862 if (!body)
863 goto error;
864 }
865 }
866
867 if (!cond)
868 isl_die(ctx, isl_error_invalid,
869 "no condition field", goto error);
870 if (!body)
871 isl_die(ctx, isl_error_invalid,
872 "no body field", goto error);
873
874 return pet_tree_new_while(cond, body);
875 error:
876 pet_expr_free(cond);
877 pet_tree_free(body);
878 return NULL;
879 }
880
881 /* Extract a pet_tree of type pet_tree_infinite_loop from "node".
882 */
883 static __isl_give pet_tree *extract_tree_infinite_loop(isl_ctx *ctx,
884 yaml_document_t *document, yaml_node_t *node)
885 {
886 yaml_node_pair_t *pair;
887 pet_tree *body;
888
889 for (pair = node->data.mapping.pairs.start;
890 pair < node->data.mapping.pairs.top; ++pair) {
891 yaml_node_t *key, *value;
892
893 key = yaml_document_get_node(document, pair->key);
894 value = yaml_document_get_node(document, pair->value);
895
896 if (key->type != YAML_SCALAR_NODE)
897 isl_die(ctx, isl_error_invalid, "expecting scalar key",
898 return NULL);
899
900 if (!strcmp((char *) key->data.scalar.value, "body")) {
901 body = extract_tree(ctx, document, value);
902 if (!body)
903 return NULL;
904 }
905 }
906
907 if (!body)
908 isl_die(ctx, isl_error_invalid,
909 "no body field", return NULL);
910
911 return pet_tree_new_infinite_loop(body);
912 }
913
914 /* Extract a pet_tree of type pet_tree_if from "node".
915 */
916 static __isl_give pet_tree *extract_tree_if(isl_ctx *ctx,
917 yaml_document_t *document, yaml_node_t *node)
918 {
919 yaml_node_pair_t *pair;
920 pet_expr *cond = NULL;
921 pet_tree *then_body = NULL;
922
923 for (pair = node->data.mapping.pairs.start;
924 pair < node->data.mapping.pairs.top; ++pair) {
925 yaml_node_t *key, *value;
926
927 key = yaml_document_get_node(document, pair->key);
928 value = yaml_document_get_node(document, pair->value);
929
930 if (key->type != YAML_SCALAR_NODE)
931 isl_die(ctx, isl_error_invalid, "expecting scalar key",
932 return NULL);
933
934 if (!strcmp((char *) key->data.scalar.value, "condition")) {
935 cond = extract_expr(ctx, document, value);
936 if (!cond)
937 goto error;
938 }
939 if (!strcmp((char *) key->data.scalar.value, "then")) {
940 then_body = extract_tree(ctx, document, value);
941 if (!then_body)
942 goto error;
943 }
944 }
945
946 if (!cond)
947 isl_die(ctx, isl_error_invalid,
948 "no condition field", goto error);
949 if (!then_body)
950 isl_die(ctx, isl_error_invalid,
951 "no then body", goto error);
952
953 return pet_tree_new_if(cond, then_body);
954 error:
955 pet_expr_free(cond);
956 pet_tree_free(then_body);
957 return NULL;
958 }
959
960 /* Extract a pet_tree of type pet_tree_if_else from "node".
961 */
962 static __isl_give pet_tree *extract_tree_if_else(isl_ctx *ctx,
963 yaml_document_t *document, yaml_node_t *node)
964 {
965 yaml_node_pair_t *pair;
966 pet_expr *cond = NULL;
967 pet_tree *then_body = NULL;
968 pet_tree *else_body = NULL;
969
970 for (pair = node->data.mapping.pairs.start;
971 pair < node->data.mapping.pairs.top; ++pair) {
972 yaml_node_t *key, *value;
973
974 key = yaml_document_get_node(document, pair->key);
975 value = yaml_document_get_node(document, pair->value);
976
977 if (key->type != YAML_SCALAR_NODE)
978 isl_die(ctx, isl_error_invalid, "expecting scalar key",
979 return NULL);
980
981 if (!strcmp((char *) key->data.scalar.value, "condition")) {
982 cond = extract_expr(ctx, document, value);
983 if (!cond)
984 goto error;
985 }
986 if (!strcmp((char *) key->data.scalar.value, "then")) {
987 then_body = extract_tree(ctx, document, value);
988 if (!then_body)
989 goto error;
990 }
991 if (!strcmp((char *) key->data.scalar.value, "else")) {
992 else_body = extract_tree(ctx, document, value);
993 if (!else_body)
994 goto error;
995 }
996 }
997
998 if (!cond)
999 isl_die(ctx, isl_error_invalid,
1000 "no condition field", goto error);
1001 if (!then_body)
1002 isl_die(ctx, isl_error_invalid,
1003 "no then body", goto error);
1004 if (!else_body)
1005 isl_die(ctx, isl_error_invalid,
1006 "no else body", goto error);
1007
1008 return pet_tree_new_if_else(cond, then_body, else_body);
1009 error:
1010 pet_expr_free(cond);
1011 pet_tree_free(then_body);
1012 pet_tree_free(else_body);
1013 return NULL;
1014 }
1015
1016 /* Extract a pet_tree of type pet_tree_for from "node".
1017 */
1018 static __isl_give pet_tree *extract_tree_for(isl_ctx *ctx,
1019 yaml_document_t *document, yaml_node_t *node)
1020 {
1021 yaml_node_pair_t *pair;
1022 int declared = 0;
1023 int independent = 0;
1024 pet_expr *iv = NULL;
1025 pet_expr *init = NULL;
1026 pet_expr *cond = NULL;
1027 pet_expr *inc = NULL;
1028 pet_tree *body = NULL;
1029
1030 for (pair = node->data.mapping.pairs.start;
1031 pair < node->data.mapping.pairs.top; ++pair) {
1032 yaml_node_t *key, *value;
1033
1034 key = yaml_document_get_node(document, pair->key);
1035 value = yaml_document_get_node(document, pair->value);
1036
1037 if (key->type != YAML_SCALAR_NODE)
1038 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1039 return NULL);
1040
1041 if (!strcmp((char *) key->data.scalar.value, "declared"))
1042 declared = extract_int(ctx, document, value);
1043 if (!strcmp((char *) key->data.scalar.value, "independent"))
1044 independent = extract_int(ctx, document, value);
1045 if (!strcmp((char *) key->data.scalar.value, "variable")) {
1046 iv = extract_expr(ctx, document, value);
1047 if (!iv)
1048 goto error;
1049 }
1050 if (!strcmp((char *) key->data.scalar.value,
1051 "initialization")) {
1052 init = extract_expr(ctx, document, value);
1053 if (!init)
1054 goto error;
1055 }
1056 if (!strcmp((char *) key->data.scalar.value, "condition")) {
1057 cond = extract_expr(ctx, document, value);
1058 if (!cond)
1059 goto error;
1060 }
1061 if (!strcmp((char *) key->data.scalar.value, "increment")) {
1062 inc = extract_expr(ctx, document, value);
1063 if (!inc)
1064 goto error;
1065 }
1066 if (!strcmp((char *) key->data.scalar.value, "body")) {
1067 body = extract_tree(ctx, document, value);
1068 if (!body)
1069 goto error;
1070 }
1071 }
1072
1073 if (!iv)
1074 isl_die(ctx, isl_error_invalid,
1075 "no variable field", goto error);
1076 if (!init)
1077 isl_die(ctx, isl_error_invalid,
1078 "no initialization field", goto error);
1079 if (!cond)
1080 isl_die(ctx, isl_error_invalid,
1081 "no condition field", goto error);
1082 if (!inc)
1083 isl_die(ctx, isl_error_invalid,
1084 "no increment field", goto error);
1085 if (!body)
1086 isl_die(ctx, isl_error_invalid,
1087 "no body field", goto error);
1088
1089 return pet_tree_new_for(independent, declared, iv, init, cond, inc,
1090 body);
1091 error:
1092 pet_expr_free(iv);
1093 pet_expr_free(init);
1094 pet_expr_free(cond);
1095 pet_expr_free(inc);
1096 pet_tree_free(body);
1097 return NULL;
1098 }
1099
1100 /* Extract a pet_tree from "node".
1101 *
1102 * We first extract the type of the pet_tree and then call
1103 * the appropriate function to extract and construct a pet_tree
1104 * of that type.
1105 */
1106 static __isl_give pet_tree *extract_tree(isl_ctx *ctx,
1107 yaml_document_t *document, yaml_node_t *node)
1108 {
1109 enum pet_tree_type type = pet_tree_error;
1110 pet_tree *tree;
1111 yaml_node_pair_t *pair;
1112
1113 if (node->type != YAML_MAPPING_NODE)
1114 isl_die(ctx, isl_error_invalid, "expecting mapping",
1115 return NULL);
1116
1117 for (pair = node->data.mapping.pairs.start;
1118 pair < node->data.mapping.pairs.top; ++pair) {
1119 yaml_node_t *key, *value;
1120
1121 key = yaml_document_get_node(document, pair->key);
1122 value = yaml_document_get_node(document, pair->value);
1123
1124 if (key->type != YAML_SCALAR_NODE)
1125 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1126 return pet_tree_free(tree));
1127
1128 if (!strcmp((char *) key->data.scalar.value, "type"))
1129 type = extract_tree_type(ctx, document, value);
1130 }
1131
1132 if (type == pet_tree_error)
1133 isl_die(ctx, isl_error_invalid, "cannot determine type",
1134 return NULL);
1135
1136 switch (type) {
1137 case pet_tree_error:
1138 return NULL;
1139 case pet_tree_block:
1140 tree = extract_tree_block(ctx, document, node);
1141 break;
1142 case pet_tree_break:
1143 tree = pet_tree_new_break(ctx);
1144 break;
1145 case pet_tree_continue:
1146 tree = pet_tree_new_continue(ctx);
1147 break;
1148 case pet_tree_decl:
1149 tree = extract_tree_decl(ctx, document, node);
1150 break;
1151 case pet_tree_decl_init:
1152 tree = extract_tree_decl_init(ctx, document, node);
1153 break;
1154 case pet_tree_expr:
1155 tree = extract_tree_expr(ctx, document, node);
1156 break;
1157 case pet_tree_for:
1158 tree = extract_tree_for(ctx, document, node);
1159 break;
1160 case pet_tree_while:
1161 tree = extract_tree_while(ctx, document, node);
1162 break;
1163 case pet_tree_infinite_loop:
1164 tree = extract_tree_infinite_loop(ctx, document, node);
1165 break;
1166 case pet_tree_if:
1167 tree = extract_tree_if(ctx, document, node);
1168 break;
1169 case pet_tree_if_else:
1170 tree = extract_tree_if_else(ctx, document, node);
1171 break;
1172 }
1173
1174 return tree;
1175 }
1176
1177 static struct pet_stmt *extract_stmt_arguments(isl_ctx *ctx,
1178 yaml_document_t *document, yaml_node_t *node, struct pet_stmt *stmt)
1179 {
1180 int i;
1181 yaml_node_item_t *item;
1182
1183 if (node->type != YAML_SEQUENCE_NODE)
1184 isl_die(ctx, isl_error_invalid, "expecting sequence",
1185 return pet_stmt_free(stmt));
1186
1187 stmt->n_arg = node->data.sequence.items.top
1188 - node->data.sequence.items.start;
1189 stmt->args = isl_calloc_array(ctx, pet_expr *, stmt->n_arg);
1190 if (!stmt->args)
1191 return pet_stmt_free(stmt);
1192
1193 for (item = node->data.sequence.items.start, i = 0;
1194 item < node->data.sequence.items.top; ++item, ++i) {
1195 yaml_node_t *n;
1196
1197 n = yaml_document_get_node(document, *item);
1198 stmt->args[i] = extract_expr(ctx, document, n);
1199 if (!stmt->args[i])
1200 return pet_stmt_free(stmt);
1201 }
1202
1203 return stmt;
1204 }
1205
1206 static struct pet_stmt *extract_stmt(isl_ctx *ctx, yaml_document_t *document,
1207 yaml_node_t *node)
1208 {
1209 struct pet_stmt *stmt;
1210 yaml_node_pair_t * pair;
1211 int line = -1;
1212 unsigned start = 0, end = 0;
1213 char *indent = NULL;
1214
1215 if (node->type != YAML_MAPPING_NODE)
1216 isl_die(ctx, isl_error_invalid, "expecting mapping",
1217 return NULL);
1218
1219 stmt = isl_calloc_type(ctx, struct pet_stmt);
1220 if (!stmt)
1221 return NULL;
1222
1223 stmt->loc = &pet_loc_dummy;
1224
1225 for (pair = node->data.mapping.pairs.start;
1226 pair < node->data.mapping.pairs.top; ++pair) {
1227 yaml_node_t *key, *value;
1228
1229 key = yaml_document_get_node(document, pair->key);
1230 value = yaml_document_get_node(document, pair->value);
1231
1232 if (key->type != YAML_SCALAR_NODE)
1233 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1234 return pet_stmt_free(stmt));
1235
1236 if (!strcmp((char *) key->data.scalar.value, "indent"))
1237 indent = extract_string(ctx, document, value);
1238 if (!strcmp((char *) key->data.scalar.value, "line"))
1239 line = extract_int(ctx, document, value);
1240 if (!strcmp((char *) key->data.scalar.value, "start"))
1241 start = extract_int(ctx, document, value);
1242 if (!strcmp((char *) key->data.scalar.value, "end"))
1243 end = extract_int(ctx, document, value);
1244 if (!strcmp((char *) key->data.scalar.value, "domain"))
1245 stmt->domain = extract_set(ctx, document, value);
1246 if (!strcmp((char *) key->data.scalar.value, "schedule"))
1247 stmt->schedule = extract_map(ctx, document, value);
1248 if (!strcmp((char *) key->data.scalar.value, "body"))
1249 stmt->body = extract_tree(ctx, document, value);
1250
1251 if (!strcmp((char *) key->data.scalar.value, "arguments"))
1252 stmt = extract_stmt_arguments(ctx, document,
1253 value, stmt);
1254 if (!stmt)
1255 return NULL;
1256 }
1257
1258 if (!indent)
1259 indent = strdup("");
1260 stmt->loc = pet_loc_alloc(ctx, start, end, line, indent);
1261 if (!stmt->loc)
1262 return pet_stmt_free(stmt);
1263
1264 return stmt;
1265 }
1266
1267 static struct pet_scop *extract_statements(isl_ctx *ctx,
1268 yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1269 {
1270 int i;
1271 yaml_node_item_t *item;
1272
1273 if (node->type != YAML_SEQUENCE_NODE)
1274 isl_die(ctx, isl_error_invalid, "expecting sequence",
1275 return NULL);
1276
1277 scop->n_stmt = node->data.sequence.items.top
1278 - node->data.sequence.items.start;
1279 scop->stmts = isl_calloc_array(ctx, struct pet_stmt *, scop->n_stmt);
1280 if (!scop->stmts)
1281 return pet_scop_free(scop);
1282
1283 for (item = node->data.sequence.items.start, i = 0;
1284 item < node->data.sequence.items.top; ++item, ++i) {
1285 yaml_node_t *n;
1286
1287 n = yaml_document_get_node(document, *item);
1288 scop->stmts[i] = extract_stmt(ctx, document, n);
1289 if (!scop->stmts[i])
1290 return pet_scop_free(scop);
1291 }
1292
1293 return scop;
1294 }
1295
1296 /* Extract a pet_implication from "node".
1297 */
1298 static struct pet_implication *extract_implication(isl_ctx *ctx,
1299 yaml_document_t *document, yaml_node_t *node)
1300 {
1301 struct pet_implication *implication;
1302 yaml_node_pair_t * pair;
1303
1304 if (node->type != YAML_MAPPING_NODE)
1305 isl_die(ctx, isl_error_invalid, "expecting mapping",
1306 return NULL);
1307
1308 implication = isl_calloc_type(ctx, struct pet_implication);
1309 if (!implication)
1310 return NULL;
1311
1312 for (pair = node->data.mapping.pairs.start;
1313 pair < node->data.mapping.pairs.top; ++pair) {
1314 yaml_node_t *key, *value;
1315
1316 key = yaml_document_get_node(document, pair->key);
1317 value = yaml_document_get_node(document, pair->value);
1318
1319 if (key->type != YAML_SCALAR_NODE)
1320 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1321 return pet_implication_free(implication));
1322
1323 if (!strcmp((char *) key->data.scalar.value, "satisfied"))
1324 implication->satisfied =
1325 extract_int(ctx, document, value);
1326 if (!strcmp((char *) key->data.scalar.value, "extension"))
1327 implication->extension =
1328 extract_map(ctx, document, value);
1329 }
1330
1331 return implication;
1332 }
1333
1334 /* Extract a sequence of implications from "node" and
1335 * store them in scop->implications.
1336 */
1337 static struct pet_scop *extract_implications(isl_ctx *ctx,
1338 yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1339 {
1340 int i;
1341 yaml_node_item_t *item;
1342
1343 if (node->type != YAML_SEQUENCE_NODE)
1344 isl_die(ctx, isl_error_invalid, "expecting sequence",
1345 return NULL);
1346
1347 scop->n_implication = node->data.sequence.items.top
1348 - node->data.sequence.items.start;
1349 scop->implications = isl_calloc_array(ctx, struct pet_implication *,
1350 scop->n_implication);
1351 if (!scop->implications)
1352 return pet_scop_free(scop);
1353
1354 for (item = node->data.sequence.items.start, i = 0;
1355 item < node->data.sequence.items.top; ++item, ++i) {
1356 yaml_node_t *n;
1357
1358 n = yaml_document_get_node(document, *item);
1359 scop->implications[i] = extract_implication(ctx, document, n);
1360 if (!scop->implications[i])
1361 return pet_scop_free(scop);
1362 }
1363
1364 return scop;
1365 }
1366
1367 /* Extract a pet_independence from "node".
1368 */
1369 static struct pet_independence *extract_independence(isl_ctx *ctx,
1370 yaml_document_t *document, yaml_node_t *node)
1371 {
1372 struct pet_independence *independence;
1373 yaml_node_pair_t * pair;
1374
1375 if (node->type != YAML_MAPPING_NODE)
1376 isl_die(ctx, isl_error_invalid, "expecting mapping",
1377 return NULL);
1378
1379 independence = isl_calloc_type(ctx, struct pet_independence);
1380 if (!independence)
1381 return NULL;
1382
1383 for (pair = node->data.mapping.pairs.start;
1384 pair < node->data.mapping.pairs.top; ++pair) {
1385 yaml_node_t *key, *value;
1386
1387 key = yaml_document_get_node(document, pair->key);
1388 value = yaml_document_get_node(document, pair->value);
1389
1390 if (key->type != YAML_SCALAR_NODE)
1391 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1392 return pet_independence_free(independence));
1393
1394 if (!strcmp((char *) key->data.scalar.value, "filter"))
1395 independence->filter =
1396 extract_union_map(ctx, document, value);
1397 if (!strcmp((char *) key->data.scalar.value, "local"))
1398 independence->local =
1399 extract_union_set(ctx, document, value);
1400 }
1401
1402 if (!independence->filter)
1403 isl_die(ctx, isl_error_invalid, "no filter field",
1404 return pet_independence_free(independence));
1405 if (!independence->local)
1406 isl_die(ctx, isl_error_invalid, "no local field",
1407 return pet_independence_free(independence));
1408
1409 return independence;
1410 }
1411
1412 /* Extract a sequence of independences from "node" and
1413 * store them in scop->independences.
1414 */
1415 static struct pet_scop *extract_independences(isl_ctx *ctx,
1416 yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1417 {
1418 int i;
1419 yaml_node_item_t *item;
1420
1421 if (node->type != YAML_SEQUENCE_NODE)
1422 isl_die(ctx, isl_error_invalid, "expecting sequence",
1423 return NULL);
1424
1425 scop->n_independence = node->data.sequence.items.top
1426 - node->data.sequence.items.start;
1427 scop->independences = isl_calloc_array(ctx, struct pet_independence *,
1428 scop->n_independence);
1429 if (!scop->independences)
1430 return pet_scop_free(scop);
1431
1432 for (item = node->data.sequence.items.start, i = 0;
1433 item < node->data.sequence.items.top; ++item, ++i) {
1434 yaml_node_t *n;
1435
1436 n = yaml_document_get_node(document, *item);
1437 scop->independences[i] = extract_independence(ctx, document, n);
1438 if (!scop->independences[i])
1439 return pet_scop_free(scop);
1440 }
1441
1442 return scop;
1443 }
1444
1445 static struct pet_scop *extract_scop(isl_ctx *ctx, yaml_document_t *document,
1446 yaml_node_t *node)
1447 {
1448 struct pet_scop *scop;
1449 yaml_node_pair_t * pair;
1450
1451 if (!node)
1452 return NULL;
1453
1454 if (node->type != YAML_MAPPING_NODE)
1455 isl_die(ctx, isl_error_invalid, "expecting mapping",
1456 return NULL);
1457
1458 scop = pet_scop_alloc(ctx);
1459 if (!scop)
1460 return NULL;
1461
1462 for (pair = node->data.mapping.pairs.start;
1463 pair < node->data.mapping.pairs.top; ++pair) {
1464 yaml_node_t *key, *value;
1465
1466 key = yaml_document_get_node(document, pair->key);
1467 value = yaml_document_get_node(document, pair->value);
1468
1469 if (key->type != YAML_SCALAR_NODE)
1470 isl_die(ctx, isl_error_invalid, "expecting scalar key",
1471 return pet_scop_free(scop));
1472 if (!strcmp((char *) key->data.scalar.value, "context"))
1473 scop->context = extract_set(ctx, document, value);
1474 if (!strcmp((char *) key->data.scalar.value, "context_value"))
1475 scop->context_value = extract_set(ctx, document, value);
1476 if (!strcmp((char *) key->data.scalar.value, "types"))
1477 scop = extract_types(ctx, document, value, scop);
1478 if (!strcmp((char *) key->data.scalar.value, "arrays"))
1479 scop = extract_arrays(ctx, document, value, scop);
1480 if (!strcmp((char *) key->data.scalar.value, "statements"))
1481 scop = extract_statements(ctx, document, value, scop);
1482 if (!strcmp((char *) key->data.scalar.value, "implications"))
1483 scop = extract_implications(ctx, document, value, scop);
1484 if (!strcmp((char *) key->data.scalar.value, "independences"))
1485 scop = extract_independences(ctx,
1486 document, value, scop);
1487 if (!scop)
1488 return NULL;
1489 }
1490
1491 if (!scop->context_value) {
1492 isl_space *space = isl_space_params_alloc(ctx, 0);
1493 scop->context_value = isl_set_universe(space);
1494 if (!scop->context_value)
1495 return pet_scop_free(scop);
1496 }
1497
1498 return scop;
1499 }
1500
1501 /* Extract a pet_scop from the YAML description in "in".
1502 */
1503 struct pet_scop *pet_scop_parse(isl_ctx *ctx, FILE *in)
1504 {
1505 struct pet_scop *scop = NULL;
1506 yaml_parser_t parser;
1507 yaml_node_t *root;
1508 yaml_document_t document = { 0 };
1509
1510 yaml_parser_initialize(&parser);
1511
1512 yaml_parser_set_input_file(&parser, in);
1513
1514 if (!yaml_parser_load(&parser, &document))
1515 goto error;
1516
1517 root = yaml_document_get_root_node(&document);
1518
1519 scop = extract_scop(ctx, &document, root);
1520
1521 yaml_document_delete(&document);
1522
1523 yaml_parser_delete(&parser);
1524
1525 return scop;
1526 error:
1527 yaml_parser_delete(&parser);
1528 pet_scop_free(scop);
1529 return NULL;
1530 }