forked from OSchip/llvm-project
821 lines
19 KiB
C
821 lines
19 KiB
C
#include <string.h>
|
|
|
|
#include <isl/schedule.h>
|
|
#include <isl/stream.h>
|
|
#include <isl_schedule_private.h>
|
|
#include <isl_schedule_tree.h>
|
|
|
|
/* An enumeration of the various keys that may appear in a YAML mapping
|
|
* of a schedule.
|
|
*/
|
|
enum isl_schedule_key {
|
|
isl_schedule_key_error = -1,
|
|
isl_schedule_key_child,
|
|
isl_schedule_key_coincident,
|
|
isl_schedule_key_context,
|
|
isl_schedule_key_contraction,
|
|
isl_schedule_key_domain,
|
|
isl_schedule_key_expansion,
|
|
isl_schedule_key_extension,
|
|
isl_schedule_key_filter,
|
|
isl_schedule_key_guard,
|
|
isl_schedule_key_leaf,
|
|
isl_schedule_key_mark,
|
|
isl_schedule_key_options,
|
|
isl_schedule_key_permutable,
|
|
isl_schedule_key_schedule,
|
|
isl_schedule_key_sequence,
|
|
isl_schedule_key_set
|
|
};
|
|
|
|
/* Extract a mapping key from the token "tok".
|
|
* Return isl_schedule_key_error on error, i.e., if "tok" does not
|
|
* correspond to any known key.
|
|
*/
|
|
static enum isl_schedule_key extract_key(__isl_keep isl_stream *s,
|
|
struct isl_token *tok)
|
|
{
|
|
int type;
|
|
char *name;
|
|
enum isl_schedule_key key;
|
|
isl_ctx *ctx;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
type = isl_token_get_type(tok);
|
|
if (type != ISL_TOKEN_IDENT && type != ISL_TOKEN_STRING) {
|
|
isl_stream_error(s, tok, "expecting key");
|
|
return isl_schedule_key_error;
|
|
}
|
|
name = isl_token_get_str(ctx, tok);
|
|
if (!strcmp(name, "child"))
|
|
key = isl_schedule_key_child;
|
|
else if (!strcmp(name, "coincident"))
|
|
key = isl_schedule_key_coincident;
|
|
else if (!strcmp(name, "context"))
|
|
key = isl_schedule_key_context;
|
|
else if (!strcmp(name, "contraction"))
|
|
key = isl_schedule_key_contraction;
|
|
else if (!strcmp(name, "domain"))
|
|
key = isl_schedule_key_domain;
|
|
else if (!strcmp(name, "expansion"))
|
|
key = isl_schedule_key_expansion;
|
|
else if (!strcmp(name, "extension"))
|
|
key = isl_schedule_key_extension;
|
|
else if (!strcmp(name, "filter"))
|
|
key = isl_schedule_key_filter;
|
|
else if (!strcmp(name, "guard"))
|
|
key = isl_schedule_key_guard;
|
|
else if (!strcmp(name, "leaf"))
|
|
key = isl_schedule_key_leaf;
|
|
else if (!strcmp(name, "mark"))
|
|
key = isl_schedule_key_mark;
|
|
else if (!strcmp(name, "options"))
|
|
key = isl_schedule_key_options;
|
|
else if (!strcmp(name, "schedule"))
|
|
key = isl_schedule_key_schedule;
|
|
else if (!strcmp(name, "sequence"))
|
|
key = isl_schedule_key_sequence;
|
|
else if (!strcmp(name, "set"))
|
|
key = isl_schedule_key_set;
|
|
else if (!strcmp(name, "permutable"))
|
|
key = isl_schedule_key_permutable;
|
|
else
|
|
isl_die(ctx, isl_error_invalid, "unknown key",
|
|
key = isl_schedule_key_error);
|
|
free(name);
|
|
return key;
|
|
}
|
|
|
|
/* Read a key from "s" and return the corresponding enum.
|
|
* Return isl_schedule_key_error on error, i.e., if the first token
|
|
* on the stream does not correspond to any known key.
|
|
*/
|
|
static enum isl_schedule_key get_key(__isl_keep isl_stream *s)
|
|
{
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
key = extract_key(s, tok);
|
|
isl_token_free(tok);
|
|
|
|
return key;
|
|
}
|
|
|
|
static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
|
|
__isl_keep isl_stream *s);
|
|
|
|
/* Read a subtree with context root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_context(__isl_keep isl_stream *s)
|
|
{
|
|
isl_set *context = NULL;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
context = isl_set_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
tree = isl_schedule_tree_from_context(context);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_context(tree, context);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_set_free(context);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with domain root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_domain(__isl_keep isl_stream *s)
|
|
{
|
|
isl_union_set *domain = NULL;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
domain = isl_union_set_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
tree = isl_schedule_tree_from_domain(domain);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_domain(tree, domain);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_union_set_free(domain);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with expansion root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_expansion(isl_stream *s)
|
|
{
|
|
isl_ctx *ctx;
|
|
isl_union_pw_multi_aff *contraction = NULL;
|
|
isl_union_map *expansion = NULL;
|
|
isl_schedule_tree *tree = NULL;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
do {
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
|
|
key = get_key(s);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
|
|
switch (key) {
|
|
case isl_schedule_key_contraction:
|
|
isl_union_pw_multi_aff_free(contraction);
|
|
tok = isl_stream_next_token(s);
|
|
str = isl_token_get_str(ctx, tok);
|
|
contraction = isl_union_pw_multi_aff_read_from_str(ctx,
|
|
str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
if (!contraction)
|
|
goto error;
|
|
break;
|
|
case isl_schedule_key_expansion:
|
|
isl_union_map_free(expansion);
|
|
tok = isl_stream_next_token(s);
|
|
str = isl_token_get_str(ctx, tok);
|
|
expansion = isl_union_map_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
if (!expansion)
|
|
goto error;
|
|
break;
|
|
case isl_schedule_key_child:
|
|
isl_schedule_tree_free(tree);
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
if (!tree)
|
|
goto error;
|
|
break;
|
|
default:
|
|
isl_die(ctx, isl_error_invalid, "unexpected key",
|
|
goto error);
|
|
}
|
|
} while ((more = isl_stream_yaml_next(s)) > 0);
|
|
|
|
if (more < 0)
|
|
goto error;
|
|
|
|
if (!contraction)
|
|
isl_die(ctx, isl_error_invalid, "missing contraction",
|
|
goto error);
|
|
if (!expansion)
|
|
isl_die(ctx, isl_error_invalid, "missing expansion",
|
|
goto error);
|
|
|
|
if (!tree)
|
|
return isl_schedule_tree_from_expansion(contraction, expansion);
|
|
return isl_schedule_tree_insert_expansion(tree, contraction, expansion);
|
|
error:
|
|
isl_schedule_tree_free(tree);
|
|
isl_union_pw_multi_aff_free(contraction);
|
|
isl_union_map_free(expansion);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with extension root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_extension(isl_stream *s)
|
|
{
|
|
isl_union_map *extension = NULL;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
extension = isl_union_map_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
tree = isl_schedule_tree_from_extension(extension);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_extension(tree, extension);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_union_map_free(extension);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with filter root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_filter(__isl_keep isl_stream *s)
|
|
{
|
|
isl_union_set *filter = NULL;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
filter = isl_union_set_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
tree = isl_schedule_tree_from_filter(filter);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_filter(tree, filter);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_union_set_free(filter);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with guard root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_guard(isl_stream *s)
|
|
{
|
|
isl_set *guard = NULL;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
guard = isl_set_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
tree = isl_schedule_tree_from_guard(guard);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_guard(tree, guard);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_set_free(guard);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with mark root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_mark(isl_stream *s)
|
|
{
|
|
isl_id *mark;
|
|
isl_schedule_tree *tree;
|
|
isl_ctx *ctx;
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
key = get_key(s);
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
return NULL;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
mark = isl_id_alloc(ctx, str, NULL);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
goto error;
|
|
if (!more) {
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
} else {
|
|
key = get_key(s);
|
|
if (key != isl_schedule_key_child)
|
|
isl_die(ctx, isl_error_invalid, "expecting child",
|
|
goto error);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
tree = isl_schedule_tree_insert_mark(tree, mark);
|
|
}
|
|
|
|
return tree;
|
|
error:
|
|
isl_id_free(mark);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a sequence of integers from "s" (representing the coincident
|
|
* property of a band node).
|
|
*/
|
|
static __isl_give isl_val_list *read_coincident(__isl_keep isl_stream *s)
|
|
{
|
|
isl_ctx *ctx;
|
|
isl_val_list *list;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
if (isl_stream_yaml_read_start_sequence(s) < 0)
|
|
return NULL;
|
|
|
|
list = isl_val_list_alloc(ctx, 0);
|
|
while ((more = isl_stream_yaml_next(s)) > 0) {
|
|
isl_val *val;
|
|
|
|
val = isl_stream_read_val(s);
|
|
list = isl_val_list_add(list, val);
|
|
}
|
|
|
|
if (more < 0 || isl_stream_yaml_read_end_sequence(s))
|
|
list = isl_val_list_free(list);
|
|
|
|
return list;
|
|
}
|
|
|
|
/* Set the (initial) coincident properties of "band" according to
|
|
* the (initial) elements of "coincident".
|
|
*/
|
|
static __isl_give isl_schedule_band *set_coincident(
|
|
__isl_take isl_schedule_band *band, __isl_take isl_val_list *coincident)
|
|
{
|
|
int i;
|
|
int n, m;
|
|
|
|
n = isl_schedule_band_n_member(band);
|
|
m = isl_val_list_n_val(coincident);
|
|
|
|
for (i = 0; i < n && i < m; ++i) {
|
|
isl_val *v;
|
|
|
|
v = isl_val_list_get_val(coincident, i);
|
|
if (!v)
|
|
band = isl_schedule_band_free(band);
|
|
band = isl_schedule_band_member_set_coincident(band, i,
|
|
!isl_val_is_zero(v));
|
|
isl_val_free(v);
|
|
}
|
|
isl_val_list_free(coincident);
|
|
return band;
|
|
}
|
|
|
|
/* Read a subtree with band root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_band(isl_stream *s)
|
|
{
|
|
isl_multi_union_pw_aff *schedule = NULL;
|
|
isl_schedule_tree *tree = NULL;
|
|
isl_val_list *coincident = NULL;
|
|
isl_union_set *options = NULL;
|
|
isl_ctx *ctx;
|
|
isl_schedule_band *band;
|
|
int permutable = 0;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
do {
|
|
struct isl_token *tok;
|
|
enum isl_schedule_key key;
|
|
char *str;
|
|
isl_val *v;
|
|
|
|
key = get_key(s);
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
goto error;
|
|
|
|
switch (key) {
|
|
case isl_schedule_key_schedule:
|
|
isl_multi_union_pw_aff_free(schedule);
|
|
tok = isl_stream_next_token(s);
|
|
if (!tok) {
|
|
isl_stream_error(s, NULL, "unexpected EOF");
|
|
goto error;
|
|
}
|
|
str = isl_token_get_str(ctx, tok);
|
|
schedule = isl_multi_union_pw_aff_read_from_str(ctx,
|
|
str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
if (!schedule)
|
|
goto error;
|
|
break;
|
|
case isl_schedule_key_coincident:
|
|
coincident = read_coincident(s);
|
|
if (!coincident)
|
|
goto error;
|
|
break;
|
|
case isl_schedule_key_permutable:
|
|
v = isl_stream_read_val(s);
|
|
permutable = !isl_val_is_zero(v);
|
|
isl_val_free(v);
|
|
break;
|
|
case isl_schedule_key_options:
|
|
isl_union_set_free(options);
|
|
tok = isl_stream_next_token(s);
|
|
str = isl_token_get_str(ctx, tok);
|
|
options = isl_union_set_read_from_str(ctx, str);
|
|
free(str);
|
|
isl_token_free(tok);
|
|
if (!options)
|
|
goto error;
|
|
break;
|
|
case isl_schedule_key_child:
|
|
isl_schedule_tree_free(tree);
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
if (!tree)
|
|
goto error;
|
|
break;
|
|
default:
|
|
isl_die(ctx, isl_error_invalid, "unexpected key",
|
|
goto error);
|
|
}
|
|
} while ((more = isl_stream_yaml_next(s)) > 0);
|
|
|
|
if (more < 0)
|
|
goto error;
|
|
|
|
if (!schedule)
|
|
isl_die(ctx, isl_error_invalid, "missing schedule", goto error);
|
|
|
|
band = isl_schedule_band_from_multi_union_pw_aff(schedule);
|
|
band = isl_schedule_band_set_permutable(band, permutable);
|
|
if (coincident)
|
|
band = set_coincident(band, coincident);
|
|
if (options)
|
|
band = isl_schedule_band_set_ast_build_options(band, options);
|
|
if (tree)
|
|
tree = isl_schedule_tree_insert_band(tree, band);
|
|
else
|
|
tree = isl_schedule_tree_from_band(band);
|
|
|
|
return tree;
|
|
error:
|
|
isl_val_list_free(coincident);
|
|
isl_union_set_free(options);
|
|
isl_schedule_tree_free(tree);
|
|
isl_multi_union_pw_aff_free(schedule);
|
|
return NULL;
|
|
}
|
|
|
|
/* Read a subtree with root node of type "type" from "s".
|
|
* The node is represented by a sequence of children.
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_children(isl_stream *s,
|
|
enum isl_schedule_node_type type)
|
|
{
|
|
isl_ctx *ctx;
|
|
isl_schedule_tree_list *list;
|
|
int more;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
|
|
isl_token_free(isl_stream_next_token(s));
|
|
|
|
if (isl_stream_yaml_next(s) < 0)
|
|
return NULL;
|
|
|
|
if (isl_stream_yaml_read_start_sequence(s))
|
|
return NULL;
|
|
|
|
list = isl_schedule_tree_list_alloc(ctx, 0);
|
|
while ((more = isl_stream_yaml_next(s)) > 0) {
|
|
isl_schedule_tree *tree;
|
|
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
list = isl_schedule_tree_list_add(list, tree);
|
|
}
|
|
|
|
if (more < 0 || isl_stream_yaml_read_end_sequence(s))
|
|
list = isl_schedule_tree_list_free(list);
|
|
|
|
return isl_schedule_tree_from_children(type, list);
|
|
}
|
|
|
|
/* Read a subtree with sequence root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_sequence(isl_stream *s)
|
|
{
|
|
return read_children(s, isl_schedule_node_sequence);
|
|
}
|
|
|
|
/* Read a subtree with set root node from "s".
|
|
*/
|
|
static __isl_give isl_schedule_tree *read_set(isl_stream *s)
|
|
{
|
|
return read_children(s, isl_schedule_node_set);
|
|
}
|
|
|
|
/* Read a schedule (sub)tree from "s".
|
|
*
|
|
* We first determine the type of the root node based on the first
|
|
* mapping key and then hand over to a function tailored to reading
|
|
* nodes of this type.
|
|
*/
|
|
static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
|
|
struct isl_stream *s)
|
|
{
|
|
enum isl_schedule_key key;
|
|
struct isl_token *tok;
|
|
isl_schedule_tree *tree = NULL;
|
|
int more;
|
|
|
|
if (isl_stream_yaml_read_start_mapping(s))
|
|
return NULL;
|
|
more = isl_stream_yaml_next(s);
|
|
if (more < 0)
|
|
return NULL;
|
|
if (!more) {
|
|
isl_stream_error(s, NULL, "missing key");
|
|
return NULL;
|
|
}
|
|
|
|
tok = isl_stream_next_token(s);
|
|
key = extract_key(s, tok);
|
|
isl_stream_push_token(s, tok);
|
|
if (key < 0)
|
|
return NULL;
|
|
switch (key) {
|
|
case isl_schedule_key_context:
|
|
tree = read_context(s);
|
|
break;
|
|
case isl_schedule_key_domain:
|
|
tree = read_domain(s);
|
|
break;
|
|
case isl_schedule_key_contraction:
|
|
case isl_schedule_key_expansion:
|
|
tree = read_expansion(s);
|
|
break;
|
|
case isl_schedule_key_extension:
|
|
tree = read_extension(s);
|
|
break;
|
|
case isl_schedule_key_filter:
|
|
tree = read_filter(s);
|
|
break;
|
|
case isl_schedule_key_guard:
|
|
tree = read_guard(s);
|
|
break;
|
|
case isl_schedule_key_leaf:
|
|
isl_token_free(isl_stream_next_token(s));
|
|
tree = isl_schedule_tree_leaf(isl_stream_get_ctx(s));
|
|
break;
|
|
case isl_schedule_key_mark:
|
|
tree = read_mark(s);
|
|
break;
|
|
case isl_schedule_key_sequence:
|
|
tree = read_sequence(s);
|
|
break;
|
|
case isl_schedule_key_set:
|
|
tree = read_set(s);
|
|
break;
|
|
case isl_schedule_key_schedule:
|
|
case isl_schedule_key_coincident:
|
|
case isl_schedule_key_options:
|
|
case isl_schedule_key_permutable:
|
|
tree = read_band(s);
|
|
break;
|
|
case isl_schedule_key_child:
|
|
isl_die(isl_stream_get_ctx(s), isl_error_unsupported,
|
|
"cannot identity node type", return NULL);
|
|
case isl_schedule_key_error:
|
|
return NULL;
|
|
}
|
|
|
|
if (isl_stream_yaml_read_end_mapping(s) < 0) {
|
|
isl_stream_error(s, NULL, "unexpected extra elements");
|
|
return isl_schedule_tree_free(tree);
|
|
}
|
|
|
|
return tree;
|
|
}
|
|
|
|
/* Read an isl_schedule from "s".
|
|
*/
|
|
__isl_give isl_schedule *isl_stream_read_schedule(isl_stream *s)
|
|
{
|
|
isl_ctx *ctx;
|
|
isl_schedule_tree *tree;
|
|
|
|
if (!s)
|
|
return NULL;
|
|
|
|
ctx = isl_stream_get_ctx(s);
|
|
tree = isl_stream_read_schedule_tree(s);
|
|
return isl_schedule_from_schedule_tree(ctx, tree);
|
|
}
|
|
|
|
/* Read an isl_schedule from "input".
|
|
*/
|
|
__isl_give isl_schedule *isl_schedule_read_from_file(isl_ctx *ctx, FILE *input)
|
|
{
|
|
struct isl_stream *s;
|
|
isl_schedule *schedule;
|
|
|
|
s = isl_stream_new_file(ctx, input);
|
|
if (!s)
|
|
return NULL;
|
|
schedule = isl_stream_read_schedule(s);
|
|
isl_stream_free(s);
|
|
|
|
return schedule;
|
|
}
|
|
|
|
/* Read an isl_schedule from "str".
|
|
*/
|
|
__isl_give isl_schedule *isl_schedule_read_from_str(isl_ctx *ctx,
|
|
const char *str)
|
|
{
|
|
struct isl_stream *s;
|
|
isl_schedule *schedule;
|
|
|
|
s = isl_stream_new_str(ctx, str);
|
|
if (!s)
|
|
return NULL;
|
|
schedule = isl_stream_read_schedule(s);
|
|
isl_stream_free(s);
|
|
|
|
return schedule;
|
|
}
|