2 * Copyright 2011 Leiden University. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above
12 * copyright notice, this list of conditions and the following
13 * disclaimer in the documentation and/or other materials provided
14 * with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
23 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 * The views and conclusions contained in the software and documentation
29 * are those of the authors and should not be interpreted as
30 * representing official policies, either expressed or implied, of
38 #include "scop_yaml.h"
40 static char *extract_string(isl_ctx
*ctx
, yaml_document_t
*document
,
43 if (node
->type
!= YAML_SCALAR_NODE
)
44 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
47 return strdup((char *) node
->data
.scalar
.value
);
50 static int extract_int(isl_ctx
*ctx
, yaml_document_t
*document
,
53 if (node
->type
!= YAML_SCALAR_NODE
)
54 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
57 return atoi((char *) node
->data
.scalar
.value
);
60 static int extract_double(isl_ctx
*ctx
, yaml_document_t
*document
,
63 if (node
->type
!= YAML_SCALAR_NODE
)
64 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
67 return strtod((char *) node
->data
.scalar
.value
, NULL
);
70 static enum pet_expr_type
extract_type(isl_ctx
*ctx
, yaml_document_t
*document
,
73 if (node
->type
!= YAML_SCALAR_NODE
)
74 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
77 return pet_str_type((char *) node
->data
.scalar
.value
);
80 static enum pet_op_type
extract_op(isl_ctx
*ctx
, yaml_document_t
*document
,
83 if (node
->type
!= YAML_SCALAR_NODE
)
84 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
87 return pet_str_op((char *) node
->data
.scalar
.value
);
90 static __isl_give isl_set
*extract_set(isl_ctx
*ctx
, yaml_document_t
*document
,
93 if (node
->type
!= YAML_SCALAR_NODE
)
94 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
97 return isl_set_read_from_str(ctx
, (char *) node
->data
.scalar
.value
);
100 static __isl_give isl_map
*extract_map(isl_ctx
*ctx
, yaml_document_t
*document
,
103 if (node
->type
!= YAML_SCALAR_NODE
)
104 isl_die(ctx
, isl_error_invalid
, "expecting scalar node",
107 return isl_map_read_from_str(ctx
, (char *) node
->data
.scalar
.value
);
110 static struct pet_array
*extract_array(isl_ctx
*ctx
, yaml_document_t
*document
,
113 struct pet_array
*array
;
114 yaml_node_pair_t
* pair
;
116 if (node
->type
!= YAML_MAPPING_NODE
)
117 isl_die(ctx
, isl_error_invalid
, "expecting mapping",
120 array
= isl_calloc_type(ctx
, struct pet_array
);
124 for (pair
= node
->data
.mapping
.pairs
.start
;
125 pair
< node
->data
.mapping
.pairs
.top
; ++pair
) {
126 yaml_node_t
*key
, *value
;
128 key
= yaml_document_get_node(document
, pair
->key
);
129 value
= yaml_document_get_node(document
, pair
->value
);
131 if (key
->type
!= YAML_SCALAR_NODE
)
132 isl_die(ctx
, isl_error_invalid
, "expecting scalar key",
133 return pet_array_free(array
));
135 if (!strcmp((char *) key
->data
.scalar
.value
, "context"))
136 array
->context
= extract_set(ctx
, document
, value
);
137 if (!strcmp((char *) key
->data
.scalar
.value
, "extent"))
138 array
->extent
= extract_set(ctx
, document
, value
);
139 if (!strcmp((char *) key
->data
.scalar
.value
, "value_bounds"))
140 array
->value_bounds
= extract_set(ctx
, document
, value
);
141 if (!strcmp((char *) key
->data
.scalar
.value
, "element_type"))
142 array
->element_type
=
143 extract_string(ctx
, document
, value
);
144 if (!strcmp((char *) key
->data
.scalar
.value
, "element_size"))
145 array
->element_size
= extract_int(ctx
, document
, value
);
146 if (!strcmp((char *) key
->data
.scalar
.value
, "live_out"))
147 array
->live_out
= extract_int(ctx
, document
, value
);
148 if (!strcmp((char *) key
->data
.scalar
.value
,
150 array
->uniquely_defined
=
151 extract_int(ctx
, document
, value
);
152 if (!strcmp((char *) key
->data
.scalar
.value
, "declared"))
153 array
->declared
= extract_int(ctx
, document
, value
);
154 if (!strcmp((char *) key
->data
.scalar
.value
, "exposed"))
155 array
->exposed
= extract_int(ctx
, document
, value
);
161 static struct pet_scop
*extract_arrays(isl_ctx
*ctx
, yaml_document_t
*document
,
162 yaml_node_t
*node
, struct pet_scop
*scop
)
165 yaml_node_item_t
*item
;
167 if (node
->type
!= YAML_SEQUENCE_NODE
)
168 isl_die(ctx
, isl_error_invalid
, "expecting sequence",
171 scop
->n_array
= node
->data
.sequence
.items
.top
172 - node
->data
.sequence
.items
.start
;
173 scop
->arrays
= isl_calloc_array(ctx
, struct pet_array
*, scop
->n_array
);
175 return pet_scop_free(scop
);
177 for (item
= node
->data
.sequence
.items
.start
, i
= 0;
178 item
< node
->data
.sequence
.items
.top
; ++item
, ++i
) {
181 n
= yaml_document_get_node(document
, *item
);
182 scop
->arrays
[i
] = extract_array(ctx
, document
, n
);
183 if (!scop
->arrays
[i
])
184 return pet_scop_free(scop
);
190 static struct pet_expr
*extract_expr(isl_ctx
*ctx
, yaml_document_t
*document
,
193 static struct pet_expr
*extract_arguments(isl_ctx
*ctx
,
194 yaml_document_t
*document
, yaml_node_t
*node
, struct pet_expr
*expr
)
197 yaml_node_item_t
*item
;
199 if (node
->type
!= YAML_SEQUENCE_NODE
)
200 isl_die(ctx
, isl_error_invalid
, "expecting sequence",
201 return pet_expr_free(expr
));
203 expr
->n_arg
= node
->data
.sequence
.items
.top
204 - node
->data
.sequence
.items
.start
;
205 expr
->args
= isl_calloc_array(ctx
, struct pet_expr
*, expr
->n_arg
);
207 return pet_expr_free(expr
);
209 for (item
= node
->data
.sequence
.items
.start
, i
= 0;
210 item
< node
->data
.sequence
.items
.top
; ++item
, ++i
) {
213 n
= yaml_document_get_node(document
, *item
);
214 expr
->args
[i
] = extract_expr(ctx
, document
, n
);
216 return pet_expr_free(expr
);
222 static struct pet_expr
*extract_expr(isl_ctx
*ctx
, yaml_document_t
*document
,
225 struct pet_expr
*expr
;
226 yaml_node_pair_t
* pair
;
228 if (node
->type
!= YAML_MAPPING_NODE
)
229 isl_die(ctx
, isl_error_invalid
, "expecting mapping",
232 expr
= isl_calloc_type(ctx
, struct pet_expr
);
236 for (pair
= node
->data
.mapping
.pairs
.start
;
237 pair
< node
->data
.mapping
.pairs
.top
; ++pair
) {
238 yaml_node_t
*key
, *value
;
240 key
= yaml_document_get_node(document
, pair
->key
);
241 value
= yaml_document_get_node(document
, pair
->value
);
243 if (key
->type
!= YAML_SCALAR_NODE
)
244 isl_die(ctx
, isl_error_invalid
, "expecting scalar key",
245 return pet_expr_free(expr
));
247 if (!strcmp((char *) key
->data
.scalar
.value
, "type"))
248 expr
->type
= extract_type(ctx
, document
, value
);
250 if (!strcmp((char *) key
->data
.scalar
.value
, "value"))
251 expr
->d
= extract_double(ctx
, document
, value
);
253 if (!strcmp((char *) key
->data
.scalar
.value
, "relation"))
254 expr
->acc
.access
= extract_map(ctx
, document
, value
);
255 if (!strcmp((char *) key
->data
.scalar
.value
, "read"))
256 expr
->acc
.read
= extract_int(ctx
, document
, value
);
257 if (!strcmp((char *) key
->data
.scalar
.value
, "write"))
258 expr
->acc
.write
= extract_int(ctx
, document
, value
);
260 if (!strcmp((char *) key
->data
.scalar
.value
, "operation"))
261 expr
->op
= extract_op(ctx
, document
, value
);
263 if (!strcmp((char *) key
->data
.scalar
.value
, "name"))
264 expr
->name
= extract_string(ctx
, document
, value
);
266 if (!strcmp((char *) key
->data
.scalar
.value
, "arguments"))
267 expr
= extract_arguments(ctx
, document
, value
, expr
);
275 static struct pet_stmt
*extract_stmt_arguments(isl_ctx
*ctx
,
276 yaml_document_t
*document
, yaml_node_t
*node
, struct pet_stmt
*stmt
)
279 yaml_node_item_t
*item
;
281 if (node
->type
!= YAML_SEQUENCE_NODE
)
282 isl_die(ctx
, isl_error_invalid
, "expecting sequence",
283 return pet_stmt_free(stmt
));
285 stmt
->n_arg
= node
->data
.sequence
.items
.top
286 - node
->data
.sequence
.items
.start
;
287 stmt
->args
= isl_calloc_array(ctx
, struct pet_expr
*, stmt
->n_arg
);
289 return pet_stmt_free(stmt
);
291 for (item
= node
->data
.sequence
.items
.start
, i
= 0;
292 item
< node
->data
.sequence
.items
.top
; ++item
, ++i
) {
295 n
= yaml_document_get_node(document
, *item
);
296 stmt
->args
[i
] = extract_expr(ctx
, document
, n
);
298 return pet_stmt_free(stmt
);
304 static struct pet_stmt
*extract_stmt(isl_ctx
*ctx
, yaml_document_t
*document
,
307 struct pet_stmt
*stmt
;
308 yaml_node_pair_t
* pair
;
310 if (node
->type
!= YAML_MAPPING_NODE
)
311 isl_die(ctx
, isl_error_invalid
, "expecting mapping",
314 stmt
= isl_calloc_type(ctx
, struct pet_stmt
);
318 for (pair
= node
->data
.mapping
.pairs
.start
;
319 pair
< node
->data
.mapping
.pairs
.top
; ++pair
) {
320 yaml_node_t
*key
, *value
;
322 key
= yaml_document_get_node(document
, pair
->key
);
323 value
= yaml_document_get_node(document
, pair
->value
);
325 if (key
->type
!= YAML_SCALAR_NODE
)
326 isl_die(ctx
, isl_error_invalid
, "expecting scalar key",
327 return pet_stmt_free(stmt
));
329 if (!strcmp((char *) key
->data
.scalar
.value
, "line"))
330 stmt
->line
= extract_int(ctx
, document
, value
);
331 if (!strcmp((char *) key
->data
.scalar
.value
, "domain"))
332 stmt
->domain
= extract_set(ctx
, document
, value
);
333 if (!strcmp((char *) key
->data
.scalar
.value
, "schedule"))
334 stmt
->schedule
= extract_map(ctx
, document
, value
);
335 if (!strcmp((char *) key
->data
.scalar
.value
, "body"))
336 stmt
->body
= extract_expr(ctx
, document
, value
);
338 if (!strcmp((char *) key
->data
.scalar
.value
, "arguments"))
339 stmt
= extract_stmt_arguments(ctx
, document
,
348 static struct pet_scop
*extract_statements(isl_ctx
*ctx
,
349 yaml_document_t
*document
, yaml_node_t
*node
, struct pet_scop
*scop
)
352 yaml_node_item_t
*item
;
354 if (node
->type
!= YAML_SEQUENCE_NODE
)
355 isl_die(ctx
, isl_error_invalid
, "expecting sequence",
358 scop
->n_stmt
= node
->data
.sequence
.items
.top
359 - node
->data
.sequence
.items
.start
;
360 scop
->stmts
= isl_calloc_array(ctx
, struct pet_stmt
*, scop
->n_stmt
);
362 return pet_scop_free(scop
);
364 for (item
= node
->data
.sequence
.items
.start
, i
= 0;
365 item
< node
->data
.sequence
.items
.top
; ++item
, ++i
) {
368 n
= yaml_document_get_node(document
, *item
);
369 scop
->stmts
[i
] = extract_stmt(ctx
, document
, n
);
371 return pet_scop_free(scop
);
377 static struct pet_scop
*extract_scop(isl_ctx
*ctx
, yaml_document_t
*document
,
380 struct pet_scop
*scop
;
381 yaml_node_pair_t
* pair
;
386 if (node
->type
!= YAML_MAPPING_NODE
)
387 isl_die(ctx
, isl_error_invalid
, "expecting mapping",
390 scop
= pet_scop_alloc(ctx
);
394 for (pair
= node
->data
.mapping
.pairs
.start
;
395 pair
< node
->data
.mapping
.pairs
.top
; ++pair
) {
396 yaml_node_t
*key
, *value
;
398 key
= yaml_document_get_node(document
, pair
->key
);
399 value
= yaml_document_get_node(document
, pair
->value
);
401 if (key
->type
!= YAML_SCALAR_NODE
)
402 isl_die(ctx
, isl_error_invalid
, "expecting scalar key",
403 return pet_scop_free(scop
));
404 if (!strcmp((char *) key
->data
.scalar
.value
, "context"))
405 scop
->context
= extract_set(ctx
, document
, value
);
406 if (!strcmp((char *) key
->data
.scalar
.value
, "context_value"))
407 scop
->context_value
= extract_set(ctx
, document
, value
);
408 if (!strcmp((char *) key
->data
.scalar
.value
, "arrays"))
409 scop
= extract_arrays(ctx
, document
, value
, scop
);
410 if (!strcmp((char *) key
->data
.scalar
.value
, "statements"))
411 scop
= extract_statements(ctx
, document
, value
, scop
);
416 if (!scop
->context_value
) {
417 isl_space
*space
= isl_space_params_alloc(ctx
, 0);
418 scop
->context_value
= isl_set_universe(space
);
419 if (!scop
->context_value
)
420 return pet_scop_free(scop
);
426 /* Extract a pet_scop from the YAML description in "in".
428 struct pet_scop
*pet_scop_parse(isl_ctx
*ctx
, FILE *in
)
430 struct pet_scop
*scop
= NULL
;
431 yaml_parser_t parser
;
433 yaml_document_t document
= { 0 };
435 yaml_parser_initialize(&parser
);
437 yaml_parser_set_input_file(&parser
, in
);
439 if (!yaml_parser_load(&parser
, &document
))
442 root
= yaml_document_get_root_node(&document
);
444 scop
= extract_scop(ctx
, &document
, root
);
446 yaml_document_delete(&document
);
448 yaml_parser_delete(&parser
);
452 yaml_parser_delete(&parser
);