/*

 * Copyright 2012-2013 Ecole Normale Superieure

 *

 * Use of this software is governed by the MIT license

 *

 * Written by Sven Verdoolaege,

 * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France

 */

#include <isl_ast_private.h>

#undef BASE

#define BASE ast_expr

#include <isl_list_templ.c>

#undef BASE

#define BASE ast_node

#include <isl_list_templ.c>

isl_ctx *isl_ast_print_options_get_ctx(

	__isl_keep isl_ast_print_options *options)

{

	return options ? options->ctx : NULL;

}

__isl_give isl_ast_print_options *isl_ast_print_options_alloc(isl_ctx *ctx)

{

	isl_ast_print_options *options;

	options = isl_calloc_type(ctx, isl_ast_print_options);

	if (!options)

		return NULL;

	options->ctx = ctx;

	isl_ctx_ref(ctx);

	options->ref = 1;

	return options;

}

__isl_give isl_ast_print_options *isl_ast_print_options_dup(

	__isl_keep isl_ast_print_options *options)

{

	isl_ctx *ctx;

	isl_ast_print_options *dup;

	if (!options)

		return NULL;

	ctx = isl_ast_print_options_get_ctx(options);

	dup = isl_ast_print_options_alloc(ctx);

	if (!dup)

		return NULL;

	dup->print_for = options->print_for;

	dup->print_for_user = options->print_for_user;

	dup->print_user = options->print_user;

	dup->print_user_user = options->print_user_user;

	return dup;

}

__isl_give isl_ast_print_options *isl_ast_print_options_cow(

	__isl_take isl_ast_print_options *options)

{

	if (!options)

		return NULL;

	if (options->ref == 1)

		return options;

	options->ref--;

	return isl_ast_print_options_dup(options);

}

__isl_give isl_ast_print_options *isl_ast_print_options_copy(

	__isl_keep isl_ast_print_options *options)

{

	if (!options)

		return NULL;

	options->ref++;

	return options;

}

__isl_null isl_ast_print_options *isl_ast_print_options_free(

	__isl_take isl_ast_print_options *options)

{

	if (!options)

		return NULL;

	if (--options->ref > 0)

		return NULL;

	isl_ctx_deref(options->ctx);

	free(options);

	return NULL;

}

/* Set the print_user callback of "options" to "print_user".

 *

 * If this callback is set, then it used to print user nodes in the AST.

 * Otherwise, the expression associated to the user node is printed.

 */

__isl_give isl_ast_print_options *isl_ast_print_options_set_print_user(

	__isl_take isl_ast_print_options *options,

	__isl_give isl_printer *(*print_user)(__isl_take isl_printer *p,

		__isl_take isl_ast_print_options *options,

		__isl_keep isl_ast_node *node, void *user),

	void *user)

{

	options = isl_ast_print_options_cow(options);

	if (!options)

		return NULL;

	options->print_user = print_user;

	options->print_user_user = user;

	return options;

}

/* Set the print_for callback of "options" to "print_for".

 *

 * If this callback is set, then it used to print for nodes in the AST.

 */

__isl_give isl_ast_print_options *isl_ast_print_options_set_print_for(

	__isl_take isl_ast_print_options *options,

	__isl_give isl_printer *(*print_for)(__isl_take isl_printer *p,

		__isl_take isl_ast_print_options *options,

		__isl_keep isl_ast_node *node, void *user),

	void *user)

{

	options = isl_ast_print_options_cow(options);

	if (!options)

		return NULL;

	options->print_for = print_for;

	options->print_for_user = user;

	return options;

}

__isl_give isl_ast_expr *isl_ast_expr_copy(__isl_keep isl_ast_expr *expr)

{

	if (!expr)

		return NULL;

	expr->ref++;

	return expr;

}

__isl_give isl_ast_expr *isl_ast_expr_dup(__isl_keep isl_ast_expr *expr)

{

	int i;

	isl_ctx *ctx;

	isl_ast_expr *dup;

	if (!expr)

		return NULL;

	ctx = isl_ast_expr_get_ctx(expr);

	switch (expr->type) {

	case isl_ast_expr_int:

		dup = isl_ast_expr_from_val(isl_val_copy(expr->u.v));

		break;

	case isl_ast_expr_id:

		dup = isl_ast_expr_from_id(isl_id_copy(expr->u.id));

		break;

	case isl_ast_expr_op:

		dup = isl_ast_expr_alloc_op(ctx,

					    expr->u.op.op, expr->u.op.n_arg);

		if (!dup)

			return NULL;

		for (i = 0; i < expr->u.op.n_arg; ++i)

			dup->u.op.args[i] =

				isl_ast_expr_copy(expr->u.op.args[i]);

		break;

	case isl_ast_expr_error:

		dup = NULL;

	}

	if (!dup)

		return NULL;

	return dup;

}

__isl_give isl_ast_expr *isl_ast_expr_cow(__isl_take isl_ast_expr *expr)

{

	if (!expr)

		return NULL;

	if (expr->ref == 1)

		return expr;

	expr->ref--;

	return isl_ast_expr_dup(expr);

}

__isl_null isl_ast_expr *isl_ast_expr_free(__isl_take isl_ast_expr *expr)

{

	int i;

	if (!expr)

		return NULL;

	if (--expr->ref > 0)

		return NULL;

	isl_ctx_deref(expr->ctx);

	switch (expr->type) {

	case isl_ast_expr_int:

		isl_val_free(expr->u.v);

		break;

	case isl_ast_expr_id:

		isl_id_free(expr->u.id);

		break;

	case isl_ast_expr_op:

		if (expr->u.op.args)

			for (i = 0; i < expr->u.op.n_arg; ++i)

				isl_ast_expr_free(expr->u.op.args[i]);

		free(expr->u.op.args);

		break;

	case isl_ast_expr_error:

		break;

	}

	free(expr);

	return NULL;

}

isl_ctx *isl_ast_expr_get_ctx(__isl_keep isl_ast_expr *expr)

{

	return expr ? expr->ctx : NULL;

}

enum isl_ast_expr_type isl_ast_expr_get_type(__isl_keep isl_ast_expr *expr)

{

	return expr ? expr->type : isl_ast_expr_error;

}

/* Return the integer value represented by "expr".

 */

__isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr)

{

	if (!expr)

		return NULL;

	if (expr->type != isl_ast_expr_int)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an int", return NULL);

	return isl_val_copy(expr->u.v);

}

__isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr)

{

	if (!expr)

		return NULL;

	if (expr->type != isl_ast_expr_id)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an identifier", return NULL);

	return isl_id_copy(expr->u.id);

}

enum isl_ast_op_type isl_ast_expr_get_op_type(__isl_keep isl_ast_expr *expr)

{

	if (!expr)

		return isl_ast_op_error;

	if (expr->type != isl_ast_expr_op)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an operation", return isl_ast_op_error);

	return expr->u.op.op;

}

int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr)

{

	if (!expr)

		return -1;

	if (expr->type != isl_ast_expr_op)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an operation", return -1);

	return expr->u.op.n_arg;

}

__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr,

	int pos)

{

	if (!expr)

		return NULL;

	if (expr->type != isl_ast_expr_op)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an operation", return NULL);

	if (pos < 0 || pos >= expr->u.op.n_arg)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"index out of bounds", return NULL);

	return isl_ast_expr_copy(expr->u.op.args[pos]);

}

/* Replace the argument at position "pos" of "expr" by "arg".

 */

__isl_give isl_ast_expr *isl_ast_expr_set_op_arg(__isl_take isl_ast_expr *expr,

	int pos, __isl_take isl_ast_expr *arg)

{

	expr = isl_ast_expr_cow(expr);

	if (!expr || !arg)

		goto error;

	if (expr->type != isl_ast_expr_op)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"expression not an operation", goto error);

	if (pos < 0 || pos >= expr->u.op.n_arg)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"index out of bounds", goto error);

	isl_ast_expr_free(expr->u.op.args[pos]);

	expr->u.op.args[pos] = arg;

	return expr;

error:

	isl_ast_expr_free(arg);

	return isl_ast_expr_free(expr);

}

/* Is "expr1" equal to "expr2"?

 */

isl_bool isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,

	__isl_keep isl_ast_expr *expr2)

{

	int i;

	if (!expr1 || !expr2)

		return isl_bool_error;

	if (expr1 == expr2)

		return isl_bool_true;

	if (expr1->type != expr2->type)

		return isl_bool_false;

	switch (expr1->type) {

	case isl_ast_expr_int:

		return isl_val_eq(expr1->u.v, expr2->u.v);

	case isl_ast_expr_id:

		return expr1->u.id == expr2->u.id;

	case isl_ast_expr_op:

		if (expr1->u.op.op != expr2->u.op.op)

			return isl_bool_false;

		if (expr1->u.op.n_arg != expr2->u.op.n_arg)

			return isl_bool_false;

		for (i = 0; i < expr1->u.op.n_arg; ++i) {

			isl_bool equal;

			equal = isl_ast_expr_is_equal(expr1->u.op.args[i],

							expr2->u.op.args[i]);

			if (equal < 0 || !equal)

				return equal;

		}

		return 1;

	case isl_ast_expr_error:

		return isl_bool_error;

	}

	isl_die(isl_ast_expr_get_ctx(expr1), isl_error_internal,

		"unhandled case", return isl_bool_error);

}

/* Create a new operation expression of operation type "op",

 * with "n_arg" as yet unspecified arguments.

 */

__isl_give isl_ast_expr *isl_ast_expr_alloc_op(isl_ctx *ctx,

	enum isl_ast_op_type op, int n_arg)

{

	isl_ast_expr *expr;

	expr = isl_calloc_type(ctx, isl_ast_expr);

	if (!expr)

		return NULL;

	expr->ctx = ctx;

	isl_ctx_ref(ctx);

	expr->ref = 1;

	expr->type = isl_ast_expr_op;

	expr->u.op.op = op;

	expr->u.op.n_arg = n_arg;

	expr->u.op.args = isl_calloc_array(ctx, isl_ast_expr *, n_arg);

	if (n_arg && !expr->u.op.args)

		return isl_ast_expr_free(expr);

	return expr;

}

/* Create a new id expression representing "id".

 */

__isl_give isl_ast_expr *isl_ast_expr_from_id(__isl_take isl_id *id)

{

	isl_ctx *ctx;

	isl_ast_expr *expr;

	if (!id)

		return NULL;

	ctx = isl_id_get_ctx(id);

	expr = isl_calloc_type(ctx, isl_ast_expr);

	if (!expr)

		goto error;

	expr->ctx = ctx;

	isl_ctx_ref(ctx);

	expr->ref = 1;

	expr->type = isl_ast_expr_id;

	expr->u.id = id;

	return expr;

error:

	isl_id_free(id);

	return NULL;

}

/* Create a new integer expression representing "i".

 */

__isl_give isl_ast_expr *isl_ast_expr_alloc_int_si(isl_ctx *ctx, int i)

{

	isl_ast_expr *expr;

	expr = isl_calloc_type(ctx, isl_ast_expr);

	if (!expr)

		return NULL;

	expr->ctx = ctx;

	isl_ctx_ref(ctx);

	expr->ref = 1;

	expr->type = isl_ast_expr_int;

	expr->u.v = isl_val_int_from_si(ctx, i);

	if (!expr->u.v)

		return isl_ast_expr_free(expr);

	return expr;

}

/* Create a new integer expression representing "v".

 */

__isl_give isl_ast_expr *isl_ast_expr_from_val(__isl_take isl_val *v)

{

	isl_ctx *ctx;

	isl_ast_expr *expr;

	if (!v)

		return NULL;

	if (!isl_val_is_int(v))

		isl_die(isl_val_get_ctx(v), isl_error_invalid,

			"expecting integer value", goto error);

	ctx = isl_val_get_ctx(v);

	expr = isl_calloc_type(ctx, isl_ast_expr);

	if (!expr)

		goto error;

	expr->ctx = ctx;

	isl_ctx_ref(ctx);

	expr->ref = 1;

	expr->type = isl_ast_expr_int;

	expr->u.v = v;

	return expr;

error:

	isl_val_free(v);

	return NULL;

}

/* Create an expression representing the unary operation "type" applied to

 * "arg".

 */

__isl_give isl_ast_expr *isl_ast_expr_alloc_unary(enum isl_ast_op_type type,

	__isl_take isl_ast_expr *arg)

{

	isl_ctx *ctx;

	isl_ast_expr *expr = NULL;

	if (!arg)

		return NULL;

	ctx = isl_ast_expr_get_ctx(arg);

	expr = isl_ast_expr_alloc_op(ctx, type, 1);

	if (!expr)

		goto error;

	expr->u.op.args[0] = arg;

	return expr;

error:

	isl_ast_expr_free(arg);

	return NULL;

}

/* Create an expression representing the negation of "arg".

 */

__isl_give isl_ast_expr *isl_ast_expr_neg(__isl_take isl_ast_expr *arg)

{

	return isl_ast_expr_alloc_unary(isl_ast_op_minus, arg);

}

/* Create an expression representing the address of "expr".

 */

__isl_give isl_ast_expr *isl_ast_expr_address_of(__isl_take isl_ast_expr *expr)

{

	if (!expr)

		return NULL;

	if (isl_ast_expr_get_type(expr) != isl_ast_expr_op ||

	    isl_ast_expr_get_op_type(expr) != isl_ast_op_access)

		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,

			"can only take address of access expressions",

			return isl_ast_expr_free(expr));

	return isl_ast_expr_alloc_unary(isl_ast_op_address_of, expr);

}

/* Create an expression representing the binary operation "type"

 * applied to "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_alloc_binary(enum isl_ast_op_type type,

	__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2)

{

	isl_ctx *ctx;

	isl_ast_expr *expr = NULL;

	if (!expr1 || !expr2)

		goto error;

	ctx = isl_ast_expr_get_ctx(expr1);

	expr = isl_ast_expr_alloc_op(ctx, type, 2);

	if (!expr)

		goto error;

	expr->u.op.args[0] = expr1;

	expr->u.op.args[1] = expr2;

	return expr;

error:

	isl_ast_expr_free(expr1);

	isl_ast_expr_free(expr2);

	return NULL;

}

/* Create an expression representing the sum of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_add(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_add, expr1, expr2);

}

/* Create an expression representing the difference of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_sub(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_sub, expr1, expr2);

}

/* Create an expression representing the product of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_mul(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_mul, expr1, expr2);

}

/* Create an expression representing the quotient of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_div(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_div, expr1, expr2);

}

/* Create an expression representing the quotient of the integer

 * division of "expr1" by "expr2", where "expr1" is known to be

 * non-negative.

 */

__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_pdiv_q, expr1, expr2);

}

/* Create an expression representing the remainder of the integer

 * division of "expr1" by "expr2", where "expr1" is known to be

 * non-negative.

 */

__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_pdiv_r, expr1, expr2);

}

/* Create an expression representing the conjunction of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_and(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_and, expr1, expr2);

}

/* Create an expression representing the conjunction of "expr1" and "expr2",

 * where "expr2" is evaluated only if "expr1" is evaluated to true.

 */

__isl_give isl_ast_expr *isl_ast_expr_and_then(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_and_then, expr1, expr2);

}

/* Create an expression representing the disjunction of "expr1" and "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_or(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_or, expr1, expr2);

}

/* Create an expression representing the disjunction of "expr1" and "expr2",

 * where "expr2" is evaluated only if "expr1" is evaluated to false.

 */

__isl_give isl_ast_expr *isl_ast_expr_or_else(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_or_else, expr1, expr2);

}

/* Create an expression representing "expr1" less than or equal to "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_le(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_le, expr1, expr2);

}

/* Create an expression representing "expr1" less than "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_lt(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_lt, expr1, expr2);

}

/* Create an expression representing "expr1" greater than or equal to "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_ge(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_ge, expr1, expr2);

}

/* Create an expression representing "expr1" greater than "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_gt(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_gt, expr1, expr2);

}

/* Create an expression representing "expr1" equal to "expr2".

 */

__isl_give isl_ast_expr *isl_ast_expr_eq(__isl_take isl_ast_expr *expr1,

	__isl_take isl_ast_expr *expr2)

{

	return isl_ast_expr_alloc_binary(isl_ast_op_eq, expr1, expr2);

}

/* Create an expression of type "type" with as arguments "arg0" followed

 * by "arguments".

 */

static __isl_give isl_ast_expr *ast_expr_with_arguments(

	enum isl_ast_op_type type, __isl_take isl_ast_expr *arg0,

	__isl_take isl_ast_expr_list *arguments)

{

	int i, n;

	isl_ctx *ctx;

	isl_ast_expr *res = NULL;

	if (!arg0 || !arguments)

		goto error;

	ctx = isl_ast_expr_get_ctx(arg0);

	n = isl_ast_expr_list_n_ast_expr(arguments);

	res = isl_ast_expr_alloc_op(ctx, type, 1 + n);

	if (!res)

		goto error;

	for (i = 0; i < n; ++i) {

		isl_ast_expr *arg;

		arg = isl_ast_expr_list_get_ast_expr(arguments, i);

		res->u.op.args[1 + i] = arg;

		if (!arg)

			goto error;

	}

	res->u.op.args[0] = arg0;

	isl_ast_expr_list_free(arguments);

	return res;

error:

	isl_ast_expr_free(arg0);

	isl_ast_expr_list_free(arguments);

	isl_ast_expr_free(res);

	return NULL;

}

/* Create an expression representing an access to "array" with index

 * expressions "indices".

 */

__isl_give isl_ast_expr *isl_ast_expr_access(__isl_take isl_ast_expr *array,

	__isl_take isl_ast_expr_list *indices)

{

	return ast_expr_with_arguments(isl_ast_op_access, array, indices);

}

/* Create an expression representing a call to "function" with argument

 * expressions "arguments".

 */

__isl_give isl_ast_expr *isl_ast_expr_call(__isl_take isl_ast_expr *function,

	__isl_take isl_ast_expr_list *arguments)

{

	return ast_expr_with_arguments(isl_ast_op_call, function, arguments);

}

/* For each subexpression of "expr" of type isl_ast_expr_id,

 * if it appears in "id2expr", then replace it by the corresponding

 * expression.

 */

__isl_give isl_ast_expr *isl_ast_expr_substitute_ids(

	__isl_take isl_ast_expr *expr, __isl_take isl_id_to_ast_expr *id2expr)

{

	int i;

	isl_id *id;

	if (!expr || !id2expr)

		goto error;

	switch (expr->type) {

	case isl_ast_expr_int:

		break;

	case isl_ast_expr_id:

		if (!isl_id_to_ast_expr_has(id2expr, expr->u.id))

			break;

		id = isl_id_copy(expr->u.id);

		isl_ast_expr_free(expr);

		expr = isl_id_to_ast_expr_get(id2expr, id);

		break;

	case isl_ast_expr_op:

		for (i = 0; i < expr->u.op.n_arg; ++i) {

			isl_ast_expr *arg;

			arg = isl_ast_expr_copy(expr->u.op.args[i]);

			arg = isl_ast_expr_substitute_ids(arg,

					    isl_id_to_ast_expr_copy(id2expr));

			if (arg == expr->u.op.args[i]) {

				isl_ast_expr_free(arg);

				continue;

			}

			if (!arg)

				expr = isl_ast_expr_free(expr);

			expr = isl_ast_expr_cow(expr);

			if (!expr) {

				isl_ast_expr_free(arg);

				break;

			}

			isl_ast_expr_free(expr->u.op.args[i]);

			expr->u.op.args[i] = arg;

		}

		break;

	case isl_ast_expr_error:

		expr = isl_ast_expr_free(expr);

		break;

	}

	isl_id_to_ast_expr_free(id2expr);

	return expr;

error:

	isl_ast_expr_free(expr);

	isl_id_to_ast_expr_free(id2expr);

	return NULL;

}

isl_ctx *isl_ast_node_get_ctx(__isl_keep isl_ast_node *node)

{

	return node ? node->ctx : NULL;

}

enum isl_ast_node_type isl_ast_node_get_type(__isl_keep isl_ast_node *node)

{

	return node ? node->type : isl_ast_node_error;

}

__isl_give isl_ast_node *isl_ast_node_alloc(isl_ctx *ctx,

	enum isl_ast_node_type type)

{

	isl_ast_node *node;

	node = isl_calloc_type(ctx, isl_ast_node);

	if (!node)

		return NULL;

	node->ctx = ctx;

	isl_ctx_ref(ctx);

	node->ref = 1;

	node->type = type;

	return node;

}

/* Create an if node with the given guard.

 *

 * The then body needs to be filled in later.

 */

__isl_give isl_ast_node *isl_ast_node_alloc_if(__isl_take isl_ast_expr *guard)

{

	isl_ast_node *node;

	if (!guard)

		return NULL;

	node = isl_ast_node_alloc(isl_ast_expr_get_ctx(guard), isl_ast_node_if);

	if (!node)

		goto error;

	node->u.i.guard = guard;

	return node;

error:

	isl_ast_expr_free(guard);

	return NULL;

}

/* Create a for node with the given iterator.

 *

 * The remaining fields need to be filled in later.

 */

__isl_give isl_ast_node *isl_ast_node_alloc_for(__isl_take isl_id *id)

{

	isl_ast_node *node;

	isl_ctx *ctx;

	if (!id)

		return NULL;

	ctx = isl_id_get_ctx(id);

	node = isl_ast_node_alloc(ctx, isl_ast_node_for);

	if (!node)

		goto error;

	node->u.f.iterator = isl_ast_expr_from_id(id);

	if (!node->u.f.iterator)

		return isl_ast_node_free(node);

	return node;

error:

	isl_id_free(id);

	return NULL;

}

/* Create a mark node, marking "node" with "id".

 */

__isl_give isl_ast_node *isl_ast_node_alloc_mark(__isl_take isl_id *id,

	__isl_take isl_ast_node *node)

{

	isl_ctx *ctx;

	isl_ast_node *mark;

	if (!id || !node)

		goto error;

	ctx = isl_id_get_ctx(id);

	mark = isl_ast_node_alloc(ctx, isl_ast_node_mark);

	if (!mark)

		goto error;

	mark->u.m.mark = id;

	mark->u.m.node = node;

	return mark;

error:

	isl_id_free(id);