final/lib/External/isl/isl_schedule_read.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;
}