isl_ast.c

Go to the documentation of this file.

/*
 * Copyright 2012-2013 Ecole Normale Superieure
 * Copyright 2022      Cerebras Systems
 *
 * Use of this software is governed by the MIT license
 *
 * Written by Sven Verdoolaege,
 * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
 * and Cerebras Systems, 1237 E Arques Ave, Sunnyvale, CA, USA
 */
 
#include <string.h>
 
#include <isl/id.h>
#include <isl/stream.h>
#include <isl/val.h>
#include <isl_ast_private.h>
 
#undef EL_BASE
#define EL_BASE ast_expr
 
#include <isl_list_templ.c>
 
#undef EL_BASE
#define EL_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 is 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;
}
 
/* Create a new operation expression of operation type "op",
 * with arguments "args".
 */
static __isl_give isl_ast_expr *alloc_op(enum isl_ast_expr_op_type op,
  __isl_take isl_ast_expr_list *args)
{
  isl_ctx *ctx;
  isl_ast_expr *expr;
 
  if (!args)
    return NULL;
 
  ctx = isl_ast_expr_list_get_ctx(args);
  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_op;
  expr->u.op.op = op;
  expr->u.op.args = args;
 
  return expr;
error:
  isl_ast_expr_list_free(args);
  return NULL;
}
 
/* Create a new operation expression of operation type "op",
 * which will end up having "n_arg" arguments.
 * The caller still needs to add those arguments.
 */
__isl_give isl_ast_expr *isl_ast_expr_alloc_op(isl_ctx *ctx,
  enum isl_ast_expr_op_type op, int n_arg)
{
  isl_ast_expr_list *args;
 
  args = isl_ast_expr_list_alloc(ctx, n_arg);
  return alloc_op(op, args);
}
 
__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)
{
  isl_ast_expr *dup;
 
  if (!expr)
    return NULL;
 
  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 = alloc_op(expr->u.op.op,
        isl_ast_expr_list_copy(expr->u.op.args));
    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)
{
  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:
    isl_ast_expr_list_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_int_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);
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr)
{
  return isl_ast_expr_int_get_val(expr);
}
 
__isl_give isl_id *isl_ast_expr_id_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);
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr)
{
  return isl_ast_expr_id_get_id(expr);
}
 
/* Check that "expr" is of type isl_ast_expr_op.
 */
static isl_stat isl_ast_expr_check_op(__isl_keep isl_ast_expr *expr)
{
  if (!expr)
    return isl_stat_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_stat_error);
  return isl_stat_ok;
}
 
/* Return the type of operation represented by "expr".
 */
enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
  __isl_keep isl_ast_expr *expr)
{
  if (isl_ast_expr_check_op(expr) < 0)
    return isl_ast_expr_op_error;
  return expr->u.op.op;
}
 
/* This is an alternative name for the function above.
 */
enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
  __isl_keep isl_ast_expr *expr)
{
  return isl_ast_expr_op_get_type(expr);
}
 
/* Return the number of arguments of the operation represented by "expr".
 */
isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr)
{
  if (isl_ast_expr_check_op(expr) < 0)
    return isl_size_error;
  return isl_ast_expr_list_size(expr->u.op.args);
}
 
/* This is an alternative name for the function above.
 */
isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr)
{
  return isl_ast_expr_op_get_n_arg(expr);
}
 
/* Return the argument at position "pos" of the operation represented by "expr".
 */
__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(__isl_keep isl_ast_expr *expr,
  int pos)
{
  if (isl_ast_expr_check_op(expr) < 0)
    return NULL;
 
  return isl_ast_expr_list_get_at(expr->u.op.args, pos);
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr,
  int pos)
{
  return isl_ast_expr_op_get_arg(expr, pos);
}
 
/* Return a copy of the arguments of the operation represented by "expr".
 */
static __isl_give isl_ast_expr_list *isl_ast_expr_op_get_args(
  __isl_keep isl_ast_expr *expr)
{
  if (isl_ast_expr_check_op(expr) < 0)
    return NULL;
  return isl_ast_expr_list_copy(expr->u.op.args);
}
 
/* Return the arguments of the operation expression "expr".
 * This may be either a copy or the arguments themselves
 * if there is only one reference to "expr".
 * This allows the arguments to be modified inplace
 * if both "expr" and its arguments have only a single reference.
 * The caller is not allowed to modify "expr" between this call and
 * the subsequent call to isl_ast_expr_op_restore_args.
 * The only exception is that isl_ast_expr_free can be called instead.
 */
static __isl_give isl_ast_expr_list *isl_ast_expr_op_take_args(
  __isl_keep isl_ast_expr *expr)
{
  isl_ast_expr_list *args;
 
  if (isl_ast_expr_check_op(expr) < 0)
    return NULL;
  if (expr->ref != 1)
    return isl_ast_expr_op_get_args(expr);
  args = expr->u.op.args;
  expr->u.op.args = NULL;
  return args;
}
 
/* Set the arguments of the operation expression "expr" to "args",
 * where the arguments of "args" may be missing
 * due to a preceding call to isl_ast_expr_op_take_args.
 * However, in this case, "expr" only has a single reference and
 * then the call to isl_ast_expr_cow has no effect.
 */
static __isl_give isl_ast_expr *isl_ast_expr_op_restore_args(
  __isl_take isl_ast_expr *expr, __isl_take isl_ast_expr_list *args)
{
  if (isl_ast_expr_check_op(expr) < 0 || !args)
    goto error;
  if (expr->u.op.args == args) {
    isl_ast_expr_list_free(args);
    return expr;
  }
 
  expr = isl_ast_expr_cow(expr);
  if (!expr)
    goto error;
 
  isl_ast_expr_list_free(expr->u.op.args);
  expr->u.op.args = args;
 
  return expr;
error:
  isl_ast_expr_free(expr);
  isl_ast_expr_list_free(args);
  return NULL;
}
 
/* Add "arg" to the arguments of the operation expression "expr".
 */
__isl_give isl_ast_expr *isl_ast_expr_op_add_arg(__isl_take isl_ast_expr *expr,
  __isl_take isl_ast_expr *arg)
{
  isl_ast_expr_list *args;
 
  args = isl_ast_expr_op_take_args(expr);
  args = isl_ast_expr_list_add(args, arg);
  expr = isl_ast_expr_op_restore_args(expr, args);
 
  return expr;
}
 
/* 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)
{
  isl_ast_expr_list *args;
 
  args = isl_ast_expr_op_take_args(expr);
  args = isl_ast_expr_list_set_at(args, pos, arg);
  expr = isl_ast_expr_op_restore_args(expr, args);
 
  return expr;
}
 
/* Are the lists of AST expressions "list1" and "list2" the same?
 */
static isl_bool isl_ast_expr_list_is_equal(__isl_keep isl_ast_expr_list *list1,
  __isl_keep isl_ast_expr_list *list2)
{
  int i;
  isl_size n1, n2;
 
  if (!list1 || !list2)
    return isl_bool_error;
  if (list1 == list2)
    return isl_bool_true;
 
  n1 = isl_ast_expr_list_size(list1);
  n2 = isl_ast_expr_list_size(list2);
  if (n1 < 0 || n2 < 0)
    return isl_bool_error;
  if (n1 != n2)
    return isl_bool_false;
  for (i = 0; i < n1; ++i) {
    isl_ast_expr *expr1, *expr2;
    isl_bool equal;
 
    expr1 = isl_ast_expr_list_get_at(list1, i);
    expr2 = isl_ast_expr_list_get_at(list2, i);
    equal = isl_ast_expr_is_equal(expr1, expr2);
    isl_ast_expr_free(expr1);
    isl_ast_expr_free(expr2);
    if (equal < 0 || !equal)
      return equal;
  }
 
  return isl_bool_true;
}
 
/* Is "expr1" equal to "expr2"?
 */
isl_bool isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
  __isl_keep isl_ast_expr *expr2)
{
  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 isl_bool_ok(expr1->u.id == expr2->u.id);
  case isl_ast_expr_op:
    if (expr1->u.op.op != expr2->u.op.op)
      return isl_bool_false;
    return isl_ast_expr_list_is_equal(expr1->u.op.args,
            expr2->u.op.args);
  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 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_expr_op_type type, __isl_take isl_ast_expr *arg)
{
  isl_ctx *ctx;
  isl_ast_expr *expr = NULL;
  isl_ast_expr_list *args;
 
  if (!arg)
    return NULL;
 
  ctx = isl_ast_expr_get_ctx(arg);
  expr = isl_ast_expr_alloc_op(ctx, type, 1);
 
  args = isl_ast_expr_op_take_args(expr);
  args = isl_ast_expr_list_add(args, arg);
  expr = isl_ast_expr_op_restore_args(expr, args);
 
  return expr;
}
 
/* 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_expr_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_expr_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_expr_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_expr_op_type type,
  __isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2)
{
  isl_ctx *ctx;
  isl_ast_expr *expr = NULL;
  isl_ast_expr_list *args;
 
  if (!expr1 || !expr2)
    goto error;
 
  ctx = isl_ast_expr_get_ctx(expr1);
  expr = isl_ast_expr_alloc_op(ctx, type, 2);
 
  args = isl_ast_expr_op_take_args(expr);
  args = isl_ast_expr_list_add(args, expr1);
  args = isl_ast_expr_list_add(args, expr2);
  expr = isl_ast_expr_op_restore_args(expr, args);
 
  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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_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_expr_op_type type, __isl_take isl_ast_expr *arg0,
  __isl_take isl_ast_expr_list *arguments)
{
  arguments = isl_ast_expr_list_insert(arguments, 0, arg0);
  return alloc_op(type, arguments);
}
 
/* 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_expr_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_expr_op_call, function, arguments);
}
 
/* Wrapper around isl_ast_expr_substitute_ids for use
 * as an isl_ast_expr_list_map callback.
 */
static __isl_give isl_ast_expr *substitute_ids(__isl_take isl_ast_expr *expr,
  void *user)
{
  isl_id_to_ast_expr *id2expr = user;
 
  return isl_ast_expr_substitute_ids(expr,
              isl_id_to_ast_expr_copy(id2expr));
}
 
/* 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)
{
  isl_maybe_isl_ast_expr m;
  isl_ast_expr_list *args;
 
  if (!expr || !id2expr)
    goto error;
 
  switch (expr->type) {
  case isl_ast_expr_int:
    break;
  case isl_ast_expr_id:
    m = isl_id_to_ast_expr_try_get(id2expr, expr->u.id);
    if (m.valid < 0)
      goto error;
    if (!m.valid)
      break;
    isl_ast_expr_free(expr);
    expr = m.value;
    break;
  case isl_ast_expr_op:
    args = isl_ast_expr_op_take_args(expr);
    args = isl_ast_expr_list_map(args, &substitute_ids, id2expr);
    expr = isl_ast_expr_op_restore_args(expr, args);
    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);
  isl_ast_node_free(node);
  return NULL;
}
 
/* Create a user node evaluating "expr".
 */
__isl_give isl_ast_node *isl_ast_node_user_from_expr(
  __isl_take isl_ast_expr *expr)
{
  isl_ctx *ctx;
  isl_ast_node *node;
 
  if (!expr)
    return NULL;
 
  ctx = isl_ast_expr_get_ctx(expr);
  node = isl_ast_node_alloc(ctx, isl_ast_node_user);
  if (!node)
    goto error;
 
  node->u.e.expr = expr;
 
  return node;
error:
  isl_ast_expr_free(expr);
  return NULL;
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_ast_node *isl_ast_node_alloc_user(__isl_take isl_ast_expr *expr)
{
  return isl_ast_node_user_from_expr(expr);
}
 
/* Create a block node with the given children.
 */
__isl_give isl_ast_node *isl_ast_node_block_from_children(
  __isl_take isl_ast_node_list *list)
{
  isl_ast_node *node;
  isl_ctx *ctx;
 
  if (!list)
    return NULL;
 
  ctx = isl_ast_node_list_get_ctx(list);
  node = isl_ast_node_alloc(ctx, isl_ast_node_block);
  if (!node)
    goto error;
 
  node->u.b.children = list;
 
  return node;
error:
  isl_ast_node_list_free(list);
  return NULL;
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_ast_node *isl_ast_node_alloc_block(
  __isl_take isl_ast_node_list *list)
{
  return isl_ast_node_block_from_children(list);
}
 
/* Represent the given list of nodes as a single node, either by
 * extract the node from a single element list or by creating
 * a block node with the list of nodes as children.
 */
__isl_give isl_ast_node *isl_ast_node_from_ast_node_list(
  __isl_take isl_ast_node_list *list)
{
  isl_size n;
  isl_ast_node *node;
 
  n = isl_ast_node_list_n_ast_node(list);
  if (n < 0)
    goto error;
  if (n != 1)
    return isl_ast_node_alloc_block(list);
 
  node = isl_ast_node_list_get_ast_node(list, 0);
  isl_ast_node_list_free(list);
 
  return node;
error:
  isl_ast_node_list_free(list);
  return NULL;
}
 
__isl_give isl_ast_node *isl_ast_node_copy(__isl_keep isl_ast_node *node)
{
  if (!node)
    return NULL;
 
  node->ref++;
  return node;
}
 
/* Return a fresh copy of "node".
 *
 * In the case of a degenerate for node, take into account
 * that "cond" and "inc" are NULL.
 */
__isl_give isl_ast_node *isl_ast_node_dup(__isl_keep isl_ast_node *node)
{
  isl_ast_node *dup;
 
  if (!node)
    return NULL;
 
  dup = isl_ast_node_alloc(isl_ast_node_get_ctx(node), node->type);
  if (!dup)
    return NULL;
 
  switch (node->type) {
  case isl_ast_node_if:
    dup->u.i.guard = isl_ast_expr_copy(node->u.i.guard);
    dup->u.i.then = isl_ast_node_copy(node->u.i.then);
    dup->u.i.else_node = isl_ast_node_copy(node->u.i.else_node);
    if (!dup->u.i.guard  || !dup->u.i.then ||
        (node->u.i.else_node && !dup->u.i.else_node))
      return isl_ast_node_free(dup);
    break;
  case isl_ast_node_for:
    dup->u.f.degenerate = node->u.f.degenerate;
    dup->u.f.iterator = isl_ast_expr_copy(node->u.f.iterator);
    dup->u.f.init = isl_ast_expr_copy(node->u.f.init);
    dup->u.f.body = isl_ast_node_copy(node->u.f.body);
    if (!dup->u.f.iterator || !dup->u.f.init || !dup->u.f.body)
      return isl_ast_node_free(dup);
    if (node->u.f.degenerate)
      break;
    dup->u.f.cond = isl_ast_expr_copy(node->u.f.cond);
    dup->u.f.inc = isl_ast_expr_copy(node->u.f.inc);
    if (!dup->u.f.cond || !dup->u.f.inc)
      return isl_ast_node_free(dup);
    break;
  case isl_ast_node_block:
    dup->u.b.children = isl_ast_node_list_copy(node->u.b.children);
    if (!dup->u.b.children)
      return isl_ast_node_free(dup);
    break;
  case isl_ast_node_mark:
    dup->u.m.mark = isl_id_copy(node->u.m.mark);
    dup->u.m.node = isl_ast_node_copy(node->u.m.node);
    if (!dup->u.m.mark || !dup->u.m.node)
      return isl_ast_node_free(dup);
    break;
  case isl_ast_node_user:
    dup->u.e.expr = isl_ast_expr_copy(node->u.e.expr);
    if (!dup->u.e.expr)
      return isl_ast_node_free(dup);
    break;
  case isl_ast_node_error:
    break;
  }
 
  if (!node->annotation)
    return dup;
  dup->annotation = isl_id_copy(node->annotation);
  if (!dup->annotation)
    return isl_ast_node_free(dup);
 
  return dup;
}
 
__isl_give isl_ast_node *isl_ast_node_cow(__isl_take isl_ast_node *node)
{
  if (!node)
    return NULL;
 
  if (node->ref == 1)
    return node;
  node->ref--;
  return isl_ast_node_dup(node);
}
 
__isl_null isl_ast_node *isl_ast_node_free(__isl_take isl_ast_node *node)
{
  if (!node)
    return NULL;
 
  if (--node->ref > 0)
    return NULL;
 
  switch (node->type) {
  case isl_ast_node_if:
    isl_ast_expr_free(node->u.i.guard);
    isl_ast_node_free(node->u.i.then);
    isl_ast_node_free(node->u.i.else_node);
    break;
  case isl_ast_node_for:
    isl_ast_expr_free(node->u.f.iterator);
    isl_ast_expr_free(node->u.f.init);
    isl_ast_expr_free(node->u.f.cond);
    isl_ast_expr_free(node->u.f.inc);
    isl_ast_node_free(node->u.f.body);
    break;
  case isl_ast_node_block:
    isl_ast_node_list_free(node->u.b.children);
    break;
  case isl_ast_node_mark:
    isl_id_free(node->u.m.mark);
    isl_ast_node_free(node->u.m.node);
    break;
  case isl_ast_node_user:
    isl_ast_expr_free(node->u.e.expr);
    break;
  case isl_ast_node_error:
    break;
  }
 
  isl_id_free(node->annotation);
  isl_ctx_deref(node->ctx);
  free(node);
 
  return NULL;
}
 
/* Check that "node" is of type "type", printing "msg" if not.
 */
static isl_stat isl_ast_node_check_type(__isl_keep isl_ast_node *node,
  enum isl_ast_node_type type, const char *msg)
{
  if (!node)
    return isl_stat_error;
  if (node->type != type)
    isl_die(isl_ast_node_get_ctx(node), isl_error_invalid, msg,
      return isl_stat_error);
  return isl_stat_ok;
}
 
/* Check that "node" is of type isl_ast_node_block.
 */
static isl_stat isl_ast_node_check_block(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_check_type(node, isl_ast_node_block,
          "not a block node");
}
 
/* Check that "node" is of type isl_ast_node_if.
 */
static isl_stat isl_ast_node_check_if(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_check_type(node, isl_ast_node_if, "not an if node");
}
 
/* Check that "node" is of type isl_ast_node_for.
 */
static isl_stat isl_ast_node_check_for(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_check_type(node, isl_ast_node_for,
          "not a for node");
}
 
/* Check that "node" is of type isl_ast_node_mark.
 */
static isl_stat isl_ast_node_check_mark(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_check_type(node, isl_ast_node_mark,
          "not a mark node");
}
 
/* Check that "node" is of type isl_ast_node_user.
 */
static isl_stat isl_ast_node_check_user(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_check_type(node, isl_ast_node_user,
          "not a user node");
}
 
#undef NODE_TYPE
#define NODE_TYPE for
#undef FIELD_NAME
#define FIELD_NAME  init
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_expr
#undef FIELD
#define FIELD   u.f.init
#include "isl_ast_node_set_field_templ.c"
 
#undef NODE_TYPE
#define NODE_TYPE for
#undef FIELD_NAME
#define FIELD_NAME  cond
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_expr
#undef FIELD
#define FIELD   u.f.cond
#include "isl_ast_node_set_field_templ.c"
 
#undef NODE_TYPE
#define NODE_TYPE for
#undef FIELD_NAME
#define FIELD_NAME  inc
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_expr
#undef FIELD
#define FIELD   u.f.inc
#include "isl_ast_node_set_field_templ.c"
 
#undef NODE_TYPE
#define NODE_TYPE for
#undef FIELD_NAME
#define FIELD_NAME  body
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_node
#undef FIELD
#define FIELD   u.f.body
#include "isl_ast_node_set_field_templ.c"
 
/* Return the body of the for-node "node",
 * This may be either a copy or the body itself
 * if there is only one reference to "node".
 * This allows the body to be modified inplace
 * if both "node" and its body have only a single reference.
 * The caller is not allowed to modify "node" between this call and
 * the subsequent call to isl_ast_node_for_restore_body.
 * The only exception is that isl_ast_node_free can be called instead.
 */
static __isl_give isl_ast_node *isl_ast_node_for_take_body(
  __isl_keep isl_ast_node *node)
{
  isl_ast_node *body;
 
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  if (node->ref != 1)
    return isl_ast_node_for_get_body(node);
  body = node->u.f.body;
  node->u.f.body = NULL;
  return body;
}
 
/* Set the body of the for-node "node" to "body",
 * where the body of "node" may be missing
 * due to a preceding call to isl_ast_node_for_take_body.
 * However, in this case, "node" only has a single reference.
 */
static __isl_give isl_ast_node *isl_ast_node_for_restore_body(
  __isl_take isl_ast_node *node, __isl_take isl_ast_node *body)
{
  return isl_ast_node_for_set_body(node, body);
}
 
__isl_give isl_ast_node *isl_ast_node_for_get_body(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  return isl_ast_node_copy(node->u.f.body);
}
 
/* Mark the given for node as being degenerate.
 */
__isl_give isl_ast_node *isl_ast_node_for_mark_degenerate(
  __isl_take isl_ast_node *node)
{
  node = isl_ast_node_cow(node);
  if (!node)
    return NULL;
  node->u.f.degenerate = 1;
  return node;
}
 
isl_bool isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return isl_bool_error;
  return isl_bool_ok(node->u.f.degenerate);
}
 
__isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  return isl_ast_expr_copy(node->u.f.iterator);
}
 
__isl_give isl_ast_expr *isl_ast_node_for_get_init(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  return isl_ast_expr_copy(node->u.f.init);
}
 
/* Return the condition expression of the given for node.
 *
 * If the for node is degenerate, then the condition is not explicitly
 * stored in the node.  Instead, it is constructed as
 *
 *  iterator <= init
 */
__isl_give isl_ast_expr *isl_ast_node_for_get_cond(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  if (!node->u.f.degenerate)
    return isl_ast_expr_copy(node->u.f.cond);
 
  return isl_ast_expr_alloc_binary(isl_ast_expr_op_le,
        isl_ast_expr_copy(node->u.f.iterator),
        isl_ast_expr_copy(node->u.f.init));
}
 
/* Return the increment of the given for node.
 *
 * If the for node is degenerate, then the increment is not explicitly
 * stored in the node.  We simply return "1".
 */
__isl_give isl_ast_expr *isl_ast_node_for_get_inc(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_for(node) < 0)
    return NULL;
  if (!node->u.f.degenerate)
    return isl_ast_expr_copy(node->u.f.inc);
  return isl_ast_expr_alloc_int_si(isl_ast_node_get_ctx(node), 1);
}
 
#undef NODE_TYPE
#define NODE_TYPE if
#undef FIELD_NAME
#define FIELD_NAME  then
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_node
#undef FIELD
#define FIELD   u.i.then
#include "isl_ast_node_set_field_templ.c"
 
/* Return the then-branch of the if-node "node",
 * This may be either a copy or the branch itself
 * if there is only one reference to "node".
 * This allows the branch to be modified inplace
 * if both "node" and its then-branch have only a single reference.
 * The caller is not allowed to modify "node" between this call and
 * the subsequent call to isl_ast_node_if_restore_then_node.
 * The only exception is that isl_ast_node_free can be called instead.
 */
static __isl_give isl_ast_node *isl_ast_node_if_take_then_node(
  __isl_keep isl_ast_node *node)
{
  isl_ast_node *then_node;
 
  if (isl_ast_node_check_if(node) < 0)
    return NULL;
  if (node->ref != 1)
    return isl_ast_node_if_get_then_node(node);
  then_node = node->u.i.then;
  node->u.i.then = NULL;
  return then_node;
}
 
/* Set the then-branch of the if-node "node" to "child",
 * where the then-branch of "node" may be missing
 * due to a preceding call to isl_ast_node_if_take_then_node.
 * However, in this case, "node" only has a single reference.
 */
static __isl_give isl_ast_node *isl_ast_node_if_restore_then_node(
  __isl_take isl_ast_node *node, __isl_take isl_ast_node *child)
{
  return isl_ast_node_if_set_then(node, child);
}
 
/* Return the then-node of the given if-node.
 */
__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_if(node) < 0)
    return NULL;
  return isl_ast_node_copy(node->u.i.then);
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_ast_node *isl_ast_node_if_get_then(
  __isl_keep isl_ast_node *node)
{
  return isl_ast_node_if_get_then_node(node);
}
 
/* Does the given if-node have an else-node?
 */
isl_bool isl_ast_node_if_has_else_node(__isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_if(node) < 0)
    return isl_bool_error;
  return isl_bool_ok(node->u.i.else_node != NULL);
}
 
/* This is an alternative name for the function above.
 */
isl_bool isl_ast_node_if_has_else(__isl_keep isl_ast_node *node)
{
  return isl_ast_node_if_has_else_node(node);
}
 
/* Return the else-node of the given if-node,
 * assuming there is one.
 */
__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_if(node) < 0)
    return NULL;
  return isl_ast_node_copy(node->u.i.else_node);
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_ast_node *isl_ast_node_if_get_else(
  __isl_keep isl_ast_node *node)
{
  return isl_ast_node_if_get_else_node(node);
}
 
#undef NODE_TYPE
#define NODE_TYPE if
#undef FIELD_NAME
#define FIELD_NAME  else_node
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_node
#undef FIELD
#define FIELD   u.i.else_node
static
#include "isl_ast_node_set_field_templ.c"
 
/* Return the else-branch of the if-node "node",
 * This may be either a copy or the branch itself
 * if there is only one reference to "node".
 * This allows the branch to be modified inplace
 * if both "node" and its else-branch have only a single reference.
 * The caller is not allowed to modify "node" between this call and
 * the subsequent call to isl_ast_node_if_restore_else_node.
 * The only exception is that isl_ast_node_free can be called instead.
 */
static __isl_give isl_ast_node *isl_ast_node_if_take_else_node(
  __isl_keep isl_ast_node *node)
{
  isl_ast_node *else_node;
 
  if (isl_ast_node_check_if(node) < 0)
    return NULL;
  if (node->ref != 1)
    return isl_ast_node_if_get_else_node(node);
  else_node = node->u.i.else_node;
  node->u.i.else_node = NULL;
  return else_node;
}
 
/* Set the else-branch of the if-node "node" to "child",
 * where the else-branch of "node" may be missing
 * due to a preceding call to isl_ast_node_if_take_else_node.
 * However, in this case, "node" only has a single reference.
 */
static __isl_give isl_ast_node *isl_ast_node_if_restore_else_node(
  __isl_take isl_ast_node *node, __isl_take isl_ast_node *child)
{
  return isl_ast_node_if_set_else_node(node, child);
}
 
__isl_give isl_ast_expr *isl_ast_node_if_get_cond(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_if(node) < 0)
    return NULL;
  return isl_ast_expr_copy(node->u.i.guard);
}
 
__isl_give isl_ast_node_list *isl_ast_node_block_get_children(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_block(node) < 0)
    return NULL;
  return isl_ast_node_list_copy(node->u.b.children);
}
 
#undef NODE_TYPE
#define NODE_TYPE block
#undef FIELD_NAME
#define FIELD_NAME  children
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_node_list
#undef FIELD
#define FIELD   u.b.children
static
#include "isl_ast_node_set_field_templ.c"
 
/* Return the children of the block-node "node",
 * This may be either a copy or the children themselves
 * if there is only one reference to "node".
 * This allows the children to be modified inplace
 * if both "node" and its children have only a single reference.
 * The caller is not allowed to modify "node" between this call and
 * the subsequent call to isl_ast_node_block_restore_children.
 * The only exception is that isl_ast_node_free can be called instead.
 */
static __isl_give isl_ast_node_list *isl_ast_node_block_take_children(
  __isl_keep isl_ast_node *node)
{
  isl_ast_node_list *children;
 
  if (isl_ast_node_check_block(node) < 0)
    return NULL;
  if (node->ref != 1)
    return isl_ast_node_block_get_children(node);
  children = node->u.b.children;
  node->u.b.children = NULL;
  return children;
}
 
/* Set the children of the block-node "node" to "children",
 * where the children of "node" may be missing
 * due to a preceding call to isl_ast_node_block_take_children.
 * However, in this case, "node" only has a single reference.
 */
static __isl_give isl_ast_node *isl_ast_node_block_restore_children(
  __isl_take isl_ast_node *node, __isl_take isl_ast_node_list *children)
{
  return isl_ast_node_block_set_children(node, children);
}
 
__isl_give isl_ast_expr *isl_ast_node_user_get_expr(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_user(node) < 0)
    return NULL;
 
  return isl_ast_expr_copy(node->u.e.expr);
}
 
/* Return the mark identifier of the mark node "node".
 */
__isl_give isl_id *isl_ast_node_mark_get_id(__isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_mark(node) < 0)
    return NULL;
 
  return isl_id_copy(node->u.m.mark);
}
 
/* Return the node marked by mark node "node".
 */
__isl_give isl_ast_node *isl_ast_node_mark_get_node(
  __isl_keep isl_ast_node *node)
{
  if (isl_ast_node_check_mark(node) < 0)
    return NULL;
 
  return isl_ast_node_copy(node->u.m.node);
}
 
#undef NODE_TYPE
#define NODE_TYPE mark
#undef FIELD_NAME
#define FIELD_NAME  node
#undef FIELD_TYPE
#define FIELD_TYPE  isl_ast_node
#undef FIELD
#define FIELD   u.m.node
static
#include "isl_ast_node_set_field_templ.c"
 
/* Return the child of the mark-node "node",
 * This may be either a copy or the child itself
 * if there is only one reference to "node".
 * This allows the child to be modified inplace
 * if both "node" and its child have only a single reference.
 * The caller is not allowed to modify "node" between this call and
 * the subsequent call to isl_ast_node_mark_restore_node.
 * The only exception is that isl_ast_node_free can be called instead.
 */
static __isl_give isl_ast_node *isl_ast_node_mark_take_node(
  __isl_keep isl_ast_node *node)
{
  isl_ast_node *child;
 
  if (isl_ast_node_check_mark(node) < 0)
    return NULL;
  if (node->ref != 1)
    return isl_ast_node_mark_get_node(node);
  child = node->u.m.node;
  node->u.m.node = NULL;
  return child;
}
 
/* Set the child of the mark-node "node" to "child",
 * where the child of "node" may be missing
 * due to a preceding call to isl_ast_node_mark_take_node.
 * However, in this case, "node" only has a single reference.
 */
static __isl_give isl_ast_node *isl_ast_node_mark_restore_node(
  __isl_take isl_ast_node *node, __isl_take isl_ast_node *child)
{
  return isl_ast_node_mark_set_node(node, child);
}
 
__isl_give isl_id *isl_ast_node_get_annotation(__isl_keep isl_ast_node *node)
{
  return node ? isl_id_copy(node->annotation) : NULL;
}
 
/* Check that "node" is of any type.
 * That is, simply check that it is a valid node.
 */
static isl_stat isl_ast_node_check_any(__isl_keep isl_ast_node *node)
{
  return isl_stat_non_null(node);
}
 
#undef NODE_TYPE
#define NODE_TYPE any
#undef FIELD_NAME
#define FIELD_NAME  annotation
#undef FIELD_TYPE
#define FIELD_TYPE  isl_id
#undef FIELD
#define FIELD   annotation
static
#include "isl_ast_node_set_field_templ.c"
 
/* Replace node->annotation by "annotation".
 */
__isl_give isl_ast_node *isl_ast_node_set_annotation(
  __isl_take isl_ast_node *node, __isl_take isl_id *annotation)
{
  return isl_ast_node_any_set_annotation(node, annotation);
}
 
static __isl_give isl_ast_node *traverse(__isl_take isl_ast_node *node,
  __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node,
    int *more, void *user),
  __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node,
    void *user),
  void *user);
 
/* Traverse the elements of "list" and all their descendants
 * in depth first preorder.  Call "enter" whenever a node is entered and "leave"
 * whenever a node is left.
 *
 * Return the updated node.
 */
static __isl_give isl_ast_node_list *traverse_list(
  __isl_take isl_ast_node_list *list,
  __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node,
    int *more, void *user),
  __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node,
    void *user),
  void *user)
{
  int i;
  isl_size n;
 
  n = isl_ast_node_list_size(list);
  if (n < 0)
    return isl_ast_node_list_free(list);
 
  for (i = 0; i < n; ++i) {
    isl_ast_node *node;
 
    node = isl_ast_node_list_get_at(list, i);
    node = traverse(node, enter, leave, user);
    list = isl_ast_node_list_set_at(list, i, node);
  }
 
  return list;
}
 
/* Traverse the descendants of "node" (including the node itself)
 * in depth first preorder.  Call "enter" whenever a node is entered and "leave"
 * whenever a node is left.
 *
 * If "enter" sets the "more" argument to zero, then the subtree rooted
 * at the given node is skipped.
 *
 * Return the updated node.
 */
static __isl_give isl_ast_node *traverse(__isl_take isl_ast_node *node,
  __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node,
    int *more, void *user),
  __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node,
    void *user),
  void *user)
{
  int more;
  isl_bool has_else;
  isl_ast_node *child;
  isl_ast_node_list *children;
 
  node = enter(node, &more, user);
  if (!node)
    return NULL;
  if (!more)
    return node;
 
  switch (node->type) {
  case isl_ast_node_for:
    child = isl_ast_node_for_take_body(node);
    child = traverse(child, enter, leave, user);
    node = isl_ast_node_for_restore_body(node, child);
    return leave(node, user);
  case isl_ast_node_if:
    child = isl_ast_node_if_take_then_node(node);
    child = traverse(child, enter, leave, user);
    node = isl_ast_node_if_restore_then_node(node, child);
    has_else = isl_ast_node_if_has_else_node(node);
    if (has_else < 0)
      return isl_ast_node_free(node);
    if (!has_else)
      return leave(node, user);
    child = isl_ast_node_if_take_else_node(node);
    child = traverse(child, enter, leave, user);
    node = isl_ast_node_if_restore_else_node(node, child);
    return leave(node, user);
  case isl_ast_node_block:
    children = isl_ast_node_block_take_children(node);
    children = traverse_list(children, enter, leave, user);
    node = isl_ast_node_block_restore_children(node, children);
    return leave(node, user);
  case isl_ast_node_mark:
    child = isl_ast_node_mark_take_node(node);
    child = traverse(child, enter, leave, user);
    node = isl_ast_node_mark_restore_node(node, child);
    return leave(node, user);
  case isl_ast_node_user:
    return leave(node, user);
  case isl_ast_node_error:
    return isl_ast_node_free(node);
  }
 
  return node;
}
 
/* Internal data structure storing the arguments of
 * isl_ast_node_foreach_descendant_top_down.
 */
struct isl_ast_node_preorder_data {
  isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user);
  void *user;
};
 
/* Enter "node" and set *more to continue traversing its descendants.
 *
 * In the case of a depth first preorder traversal, call data->fn and
 * let it decide whether to continue.
 */
static __isl_give isl_ast_node *preorder_enter(__isl_take isl_ast_node *node,
  int *more, void *user)
{
  struct isl_ast_node_preorder_data *data = user;
  isl_bool m;
 
  if (!node)
    return NULL;
  m = data->fn(node, data->user);
  if (m < 0)
    return isl_ast_node_free(node);
  *more = m;
  return node;
}
 
/* Leave "node".
 *
 * In the case of a depth first preorder traversal, nothing needs to be done.
 */
static __isl_give isl_ast_node *preorder_leave(__isl_take isl_ast_node *node,
  void *user)
{
  return node;
}
 
/* Traverse the descendants of "node" (including the node itself)
 * in depth first preorder.
 *
 * If "fn" returns isl_bool_error on any of the nodes, then the traversal
 * is aborted.
 * If "fn" returns isl_bool_false on any of the nodes, then the subtree rooted
 * at that node is skipped.
 *
 * Return isl_stat_ok on success and isl_stat_error on failure.
 */
isl_stat isl_ast_node_foreach_descendant_top_down(
  __isl_keep isl_ast_node *node,
  isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user), void *user)
{
  struct isl_ast_node_preorder_data data = { fn, user };
 
  node = isl_ast_node_copy(node);
  node = traverse(node, &preorder_enter, &preorder_leave, &data);
  isl_ast_node_free(node);
 
  return isl_stat_non_null(node);
}
 
/* Internal data structure storing the arguments of
 * isl_ast_node_map_descendant_bottom_up.
 */
struct isl_ast_node_postorder_data {
  __isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
    void *user);
  void *user;
};
 
/* Enter "node" and set *more to continue traversing its descendants.
 *
 * In the case of a depth-first post-order traversal,
 * nothing needs to be done and traversal always continues.
 */
static __isl_give isl_ast_node *postorder_enter(__isl_take isl_ast_node *node,
  int *more, void *user)
{
  *more = 1;
  return node;
}
 
/* Leave "node".
 *
 * In the case of a depth-first post-order traversal, call data->fn.
 */
static __isl_give isl_ast_node *postorder_leave(__isl_take isl_ast_node *node,
  void *user)
{
  struct isl_ast_node_postorder_data *data = user;
 
  if (!node)
    return NULL;
 
  node = data->fn(node, data->user);
  return node;
}
 
/* Traverse the descendants of "node" (including the node itself)
 * in depth-first post-order, where the user callback is allowed to modify the
 * visited node.
 *
 * Return the updated node.
 */
__isl_give isl_ast_node *isl_ast_node_map_descendant_bottom_up(
  __isl_take isl_ast_node *node,
  __isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
    void *user), void *user)
{
  struct isl_ast_node_postorder_data data = { fn, user };
 
  return traverse(node, &postorder_enter, &postorder_leave, &data);
}
 
/* Textual C representation of the various operators.
 */
static char *op_str_c[] = {
  [isl_ast_expr_op_and] = "&&",
  [isl_ast_expr_op_and_then] = "&&",
  [isl_ast_expr_op_or] = "||",
  [isl_ast_expr_op_or_else] = "||",
  [isl_ast_expr_op_max] = "max",
  [isl_ast_expr_op_min] = "min",
  [isl_ast_expr_op_minus] = "-",
  [isl_ast_expr_op_add] = "+",
  [isl_ast_expr_op_sub] = "-",
  [isl_ast_expr_op_mul] = "*",
  [isl_ast_expr_op_fdiv_q] = "floord",
  [isl_ast_expr_op_pdiv_q] = "/",
  [isl_ast_expr_op_pdiv_r] = "%",
  [isl_ast_expr_op_zdiv_r] = "%",
  [isl_ast_expr_op_div] = "/",
  [isl_ast_expr_op_eq] = "==",
  [isl_ast_expr_op_le] = "<=",
  [isl_ast_expr_op_ge] = ">=",
  [isl_ast_expr_op_lt] = "<",
  [isl_ast_expr_op_gt] = ">",
  [isl_ast_expr_op_member] = ".",
  [isl_ast_expr_op_address_of] = "&"
};
 
/* Precedence in C of the various operators.
 * Based on http://en.wikipedia.org/wiki/Operators_in_C_and_C++
 * Lowest value means highest precedence.
 */
static int op_prec[] = {
  [isl_ast_expr_op_and] = 13,
  [isl_ast_expr_op_and_then] = 13,
  [isl_ast_expr_op_or] = 14,
  [isl_ast_expr_op_or_else] = 14,
  [isl_ast_expr_op_max] = 2,
  [isl_ast_expr_op_min] = 2,
  [isl_ast_expr_op_minus] = 3,
  [isl_ast_expr_op_add] = 6,
  [isl_ast_expr_op_sub] = 6,
  [isl_ast_expr_op_mul] = 5,
  [isl_ast_expr_op_div] = 5,
  [isl_ast_expr_op_fdiv_q] = 2,
  [isl_ast_expr_op_pdiv_q] = 5,
  [isl_ast_expr_op_pdiv_r] = 5,
  [isl_ast_expr_op_zdiv_r] = 5,
  [isl_ast_expr_op_cond] = 15,
  [isl_ast_expr_op_select] = 15,
  [isl_ast_expr_op_eq] = 9,
  [isl_ast_expr_op_le] = 8,
  [isl_ast_expr_op_ge] = 8,
  [isl_ast_expr_op_lt] = 8,
  [isl_ast_expr_op_gt] = 8,
  [isl_ast_expr_op_call] = 2,
  [isl_ast_expr_op_access] = 2,
  [isl_ast_expr_op_member] = 2,
  [isl_ast_expr_op_address_of] = 3
};
 
/* Is the operator left-to-right associative?
 */
static int op_left[] = {
  [isl_ast_expr_op_and] = 1,
  [isl_ast_expr_op_and_then] = 1,
  [isl_ast_expr_op_or] = 1,
  [isl_ast_expr_op_or_else] = 1,
  [isl_ast_expr_op_max] = 1,
  [isl_ast_expr_op_min] = 1,
  [isl_ast_expr_op_minus] = 0,
  [isl_ast_expr_op_add] = 1,
  [isl_ast_expr_op_sub] = 1,
  [isl_ast_expr_op_mul] = 1,
  [isl_ast_expr_op_div] = 1,
  [isl_ast_expr_op_fdiv_q] = 1,
  [isl_ast_expr_op_pdiv_q] = 1,
  [isl_ast_expr_op_pdiv_r] = 1,
  [isl_ast_expr_op_zdiv_r] = 1,
  [isl_ast_expr_op_cond] = 0,
  [isl_ast_expr_op_select] = 0,
  [isl_ast_expr_op_eq] = 1,
  [isl_ast_expr_op_le] = 1,
  [isl_ast_expr_op_ge] = 1,
  [isl_ast_expr_op_lt] = 1,
  [isl_ast_expr_op_gt] = 1,
  [isl_ast_expr_op_call] = 1,
  [isl_ast_expr_op_access] = 1,
  [isl_ast_expr_op_member] = 1,
  [isl_ast_expr_op_address_of] = 0
};
 
static int is_and(enum isl_ast_expr_op_type op)
{
  return op == isl_ast_expr_op_and || op == isl_ast_expr_op_and_then;
}
 
static int is_or(enum isl_ast_expr_op_type op)
{
  return op == isl_ast_expr_op_or || op == isl_ast_expr_op_or_else;
}
 
static int is_add_sub(enum isl_ast_expr_op_type op)
{
  return op == isl_ast_expr_op_add || op == isl_ast_expr_op_sub;
}
 
static int is_div_mod(enum isl_ast_expr_op_type op)
{
  return op == isl_ast_expr_op_div ||
         op == isl_ast_expr_op_pdiv_r ||
         op == isl_ast_expr_op_zdiv_r;
}
 
static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr);
 
/* Do we need/want parentheses around "expr" as a subexpression of
 * an "op" operation?  If "left" is set, then "expr" is the left-most
 * operand.
 *
 * We only need parentheses if "expr" represents an operation.
 *
 * If op has a higher precedence than expr->u.op.op, then we need
 * parentheses.
 * If op and expr->u.op.op have the same precedence, but the operations
 * are performed in an order that is different from the associativity,
 * then we need parentheses.
 *
 * An and inside an or technically does not require parentheses,
 * but some compilers complain about that, so we add them anyway.
 *
 * Computations such as "a / b * c" and "a % b + c" can be somewhat
 * difficult to read, so we add parentheses for those as well.
 */
static int sub_expr_need_parens(enum isl_ast_expr_op_type op,
  __isl_keep isl_ast_expr *expr, int left)
{
  if (expr->type != isl_ast_expr_op)
    return 0;
 
  if (op_prec[expr->u.op.op] > op_prec[op])
    return 1;
  if (op_prec[expr->u.op.op] == op_prec[op] && left != op_left[op])
    return 1;
 
  if (is_or(op) && is_and(expr->u.op.op))
    return 1;
  if (op == isl_ast_expr_op_mul && expr->u.op.op != isl_ast_expr_op_mul &&
      op_prec[expr->u.op.op] == op_prec[op])
    return 1;
  if (is_add_sub(op) && is_div_mod(expr->u.op.op))
    return 1;
 
  return 0;
}
 
/* Print the subexpression at position "pos" of operation expression "expr"
 * in C format.
 * If "left" is set, then "expr" is the left-most operand.
 */
static __isl_give isl_printer *print_sub_expr_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr, int pos, int left)
{
  int need_parens;
  isl_ast_expr *arg;
 
  if (!expr)
    return isl_printer_free(p);
 
  arg = isl_ast_expr_list_get_at(expr->u.op.args, pos);
  need_parens = sub_expr_need_parens(expr->u.op.op, arg, left);
 
  if (need_parens)
    p = isl_printer_print_str(p, "(");
  p = print_ast_expr_c(p, arg);
  if (need_parens)
    p = isl_printer_print_str(p, ")");
 
  isl_ast_expr_free(arg);
 
  return p;
}
 
#define isl_ast_expr_op_last  isl_ast_expr_op_address_of
 
/* Data structure that holds the user-specified textual
 * representations for the operators in C format.
 * The entries are either NULL or copies of strings.
 * A NULL entry means that the default name should be used.
 */
struct isl_ast_expr_op_names {
  char *op_str[isl_ast_expr_op_last + 1];
};
 
/* Create an empty struct isl_ast_expr_op_names.
 */
static void *create_names(isl_ctx *ctx)
{
  return isl_calloc_type(ctx, struct isl_ast_expr_op_names);
}
 
/* Free a struct isl_ast_expr_op_names along with all memory
 * owned by the struct.
 */
static void free_names(void *user)
{
  int i;
  struct isl_ast_expr_op_names *names = user;
 
  if (!user)
    return;
 
  for (i = 0; i <= isl_ast_expr_op_last; ++i)
    free(names->op_str[i]);
  free(user);
}
 
/* Create an identifier that is used to store
 * an isl_ast_expr_op_names note.
 */
static __isl_give isl_id *names_id(isl_ctx *ctx)
{
  return isl_id_alloc(ctx, "isl_ast_expr_op_type_names", NULL);
}
 
/* Ensure that "p" has a note identified by "id".
 * If there is no such note yet, then it is created by "note_create" and
 * scheduled do be freed by "note_free".
 */
static __isl_give isl_printer *alloc_note(__isl_take isl_printer *p,
  __isl_keep isl_id *id, void *(*note_create)(isl_ctx *),
  void (*note_free)(void *))
{
  isl_ctx *ctx;
  isl_id *note_id;
  isl_bool has_note;
  void *note;
 
  has_note = isl_printer_has_note(p, id);
  if (has_note < 0)
    return isl_printer_free(p);
  if (has_note)
    return p;
 
  ctx = isl_printer_get_ctx(p);
  note = note_create(ctx);
  if (!note)
    return isl_printer_free(p);
  note_id = isl_id_alloc(ctx, NULL, note);
  if (!note_id)
    note_free(note);
  else
    note_id = isl_id_set_free_user(note_id, note_free);
 
  p = isl_printer_set_note(p, isl_id_copy(id), note_id);
 
  return p;
}
 
/* Ensure that "p" has an isl_ast_expr_op_names note identified by "id".
 */
static __isl_give isl_printer *alloc_names(__isl_take isl_printer *p,
  __isl_keep isl_id *id)
{
  return alloc_note(p, id, &create_names, &free_names);
}
 
/* Retrieve the note identified by "id" from "p".
 * The note is assumed to exist.
 */
static void *get_note(__isl_keep isl_printer *p, __isl_keep isl_id *id)
{
  void *note;
 
  id = isl_printer_get_note(p, isl_id_copy(id));
  note = isl_id_get_user(id);
  isl_id_free(id);
 
  return note;
}
 
/* Use "name" to print operations of type "type" to "p".
 *
 * Store the name in an isl_ast_expr_op_names note attached to "p", such that
 * it can be retrieved by get_op_str.
 */
__isl_give isl_printer *isl_ast_expr_op_type_set_print_name(
  __isl_take isl_printer *p, enum isl_ast_expr_op_type type,
  __isl_keep const char *name)
{
  isl_id *id;
  struct isl_ast_expr_op_names *names;
 
  if (!p)
    return NULL;
  if (type > isl_ast_expr_op_last)
    isl_die(isl_printer_get_ctx(p), isl_error_invalid,
      "invalid type", return isl_printer_free(p));
 
  id = names_id(isl_printer_get_ctx(p));
  p = alloc_names(p, id);
  names = get_note(p, id);
  isl_id_free(id);
  if (!names)
    return isl_printer_free(p);
  free(names->op_str[type]);
  names->op_str[type] = strdup(name);
 
  return p;
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_printer *isl_ast_op_type_set_print_name(
  __isl_take isl_printer *p, enum isl_ast_expr_op_type type,
  __isl_keep const char *name)
{
  return isl_ast_expr_op_type_set_print_name(p, type, name);
}
 
/* Return the textual representation of "type" in C format.
 *
 * If there is a user-specified name in an isl_ast_expr_op_names note
 * associated to "p", then return that.
 * Otherwise, return the default name in op_str_c.
 */
static const char *get_op_str_c(__isl_keep isl_printer *p,
  enum isl_ast_expr_op_type type)
{
  isl_id *id;
  isl_bool has_names;
  struct isl_ast_expr_op_names *names = NULL;
 
  id = names_id(isl_printer_get_ctx(p));
  has_names = isl_printer_has_note(p, id);
  if (has_names >= 0 && has_names)
    names = get_note(p, id);
  isl_id_free(id);
  if (names && names->op_str[type])
    return names->op_str[type];
  return op_str_c[type];
}
 
/* Print the expression at position "pos" in "list" in C format.
 */
static __isl_give isl_printer *print_at_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr_list *list, int pos)
{
  isl_ast_expr *expr;
 
  expr = isl_ast_expr_list_get_at(list, pos);
  p = print_ast_expr_c(p, expr);
  isl_ast_expr_free(expr);
 
  return p;
}
 
/* Print a min or max reduction "expr" in C format.
 */
static __isl_give isl_printer *print_min_max_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  int i = 0;
  isl_size n;
 
  n = isl_ast_expr_list_size(expr->u.op.args);
  if (n < 0)
    return isl_printer_free(p);
 
  for (i = 1; i < n; ++i) {
    p = isl_printer_print_str(p, get_op_str_c(p, expr->u.op.op));
    p = isl_printer_print_str(p, "(");
  }
  p = print_at_c(p, expr->u.op.args, 0);
  for (i = 1; i < n; ++i) {
    p = isl_printer_print_str(p, ", ");
    p = print_at_c(p, expr->u.op.args, i);
    p = isl_printer_print_str(p, ")");
  }
 
  return p;
}
 
/* Print a function call "expr" in C format.
 *
 * The first argument represents the function to be called.
 */
static __isl_give isl_printer *print_call_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  int i = 0;
  isl_size n;
 
  n = isl_ast_expr_list_size(expr->u.op.args);
  if (n < 0)
    return isl_printer_free(p);
 
  p = print_at_c(p, expr->u.op.args, 0);
  p = isl_printer_print_str(p, "(");
  for (i = 1; i < n; ++i) {
    if (i != 1)
      p = isl_printer_print_str(p, ", ");
    p = print_at_c(p, expr->u.op.args, i);
  }
  p = isl_printer_print_str(p, ")");
 
  return p;
}
 
/* Print an array access "expr" in C format.
 *
 * The first argument represents the array being accessed.
 */
static __isl_give isl_printer *print_access_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  int i = 0;
  isl_size n;
 
  n = isl_ast_expr_list_size(expr->u.op.args);
  if (n < 0)
    return isl_printer_free(p);
 
  p = print_at_c(p, expr->u.op.args, 0);
  for (i = 1; i < n; ++i) {
    p = isl_printer_print_str(p, "[");
    p = print_at_c(p, expr->u.op.args, i);
    p = isl_printer_print_str(p, "]");
  }
 
  return p;
}
 
/* Print "expr" to "p" in C format.
 */
static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  isl_size n;
 
  if (!p)
    return NULL;
  if (!expr)
    return isl_printer_free(p);
 
  switch (expr->type) {
  case isl_ast_expr_op:
    if (expr->u.op.op == isl_ast_expr_op_call) {
      p = print_call_c(p, expr);
      break;
    }
    if (expr->u.op.op == isl_ast_expr_op_access) {
      p = print_access_c(p, expr);
      break;
    }
    n = isl_ast_expr_list_size(expr->u.op.args);
    if (n < 0)
      return isl_printer_free(p);
    if (n == 1) {
      p = isl_printer_print_str(p,
            get_op_str_c(p, expr->u.op.op));
      p = print_sub_expr_c(p, expr, 0, 0);
      break;
    }
    if (expr->u.op.op == isl_ast_expr_op_fdiv_q) {
      const char *name;
 
      name = get_op_str_c(p, isl_ast_expr_op_fdiv_q);
      p = isl_printer_print_str(p, name);
      p = isl_printer_print_str(p, "(");
      p = print_at_c(p, expr->u.op.args, 0);
      p = isl_printer_print_str(p, ", ");
      p = print_at_c(p, expr->u.op.args, 1);
      p = isl_printer_print_str(p, ")");
      break;
    }
    if (expr->u.op.op == isl_ast_expr_op_max ||
        expr->u.op.op == isl_ast_expr_op_min) {
      p = print_min_max_c(p, expr);
      break;
    }
    if (expr->u.op.op == isl_ast_expr_op_cond ||
        expr->u.op.op == isl_ast_expr_op_select) {
      p = print_at_c(p, expr->u.op.args, 0);
      p = isl_printer_print_str(p, " ? ");
      p = print_at_c(p, expr->u.op.args, 1);
      p = isl_printer_print_str(p, " : ");
      p = print_at_c(p, expr->u.op.args, 2);
      break;
    }
    if (n != 2)
      isl_die(isl_printer_get_ctx(p), isl_error_internal,
        "operation should have two arguments",
        return isl_printer_free(p));
    p = print_sub_expr_c(p, expr, 0, 1);
    if (expr->u.op.op != isl_ast_expr_op_member)
      p = isl_printer_print_str(p, " ");
    p = isl_printer_print_str(p, get_op_str_c(p, expr->u.op.op));
    if (expr->u.op.op != isl_ast_expr_op_member)
      p = isl_printer_print_str(p, " ");
    p = print_sub_expr_c(p, expr, 1, 0);
    break;
  case isl_ast_expr_id:
    p = isl_printer_print_str(p, isl_id_get_name(expr->u.id));
    break;
  case isl_ast_expr_int:
    p = isl_printer_print_val(p, expr->u.v);
    break;
  case isl_ast_expr_error:
    break;
  }
 
  return p;
}
 
/* Textual representation of the isl_ast_expr_op_type elements
 * for use in a YAML representation of an isl_ast_expr.
 */
static char *op_str[] = {
  [isl_ast_expr_op_and] = "and",
  [isl_ast_expr_op_and_then] = "and_then",
  [isl_ast_expr_op_or] = "or",
  [isl_ast_expr_op_or_else] = "or_else",
  [isl_ast_expr_op_max] = "max",
  [isl_ast_expr_op_min] = "min",
  [isl_ast_expr_op_minus] = "minus",
  [isl_ast_expr_op_add] = "add",
  [isl_ast_expr_op_sub] = "sub",
  [isl_ast_expr_op_mul] = "mul",
  [isl_ast_expr_op_div] = "div",
  [isl_ast_expr_op_fdiv_q] = "fdiv_q",
  [isl_ast_expr_op_pdiv_q] = "pdiv_q",
  [isl_ast_expr_op_pdiv_r] = "pdiv_r",
  [isl_ast_expr_op_zdiv_r] = "zdiv_r",
  [isl_ast_expr_op_cond] = "cond",
  [isl_ast_expr_op_select] = "select",
  [isl_ast_expr_op_eq] = "eq",
  [isl_ast_expr_op_le] = "le",
  [isl_ast_expr_op_lt] = "lt",
  [isl_ast_expr_op_ge] = "ge",
  [isl_ast_expr_op_gt] = "gt",
  [isl_ast_expr_op_call] = "call",
  [isl_ast_expr_op_access] = "access",
  [isl_ast_expr_op_member] = "member",
  [isl_ast_expr_op_address_of] = "address_of"
};
 
static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr);
 
/* Print the arguments of "expr" to "p" in isl format.
 *
 * If there are no arguments, then nothing needs to be printed.
 * Otherwise add an "args" key to the current mapping with as value
 * the list of arguments of "expr".
 */
static __isl_give isl_printer *print_arguments(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  int i;
  isl_size n;
 
  n = isl_ast_expr_get_op_n_arg(expr);
  if (n < 0)
    return isl_printer_free(p);
  if (n == 0)
    return p;
 
  p = isl_printer_print_str(p, "args");
  p = isl_printer_yaml_next(p);
  p = isl_printer_yaml_start_sequence(p);
  for (i = 0; i < n; ++i) {
    isl_ast_expr *arg;
 
    arg = isl_ast_expr_get_op_arg(expr, i);
    p = print_ast_expr_isl(p, arg);
    isl_ast_expr_free(arg);
    p = isl_printer_yaml_next(p);
  }
  p = isl_printer_yaml_end_sequence(p);
 
  return p;
}
 
/* Textual representations of the YAML keys for an isl_ast_expr object.
 */
static char *expr_str[] = {
  [isl_ast_expr_op] = "op",
  [isl_ast_expr_id] = "id",
  [isl_ast_expr_int] = "val",
};
 
/* Print "expr" to "p" in isl format.
 *
 * In particular, print the isl_ast_expr as a YAML document.
 */
static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  enum isl_ast_expr_type type;
  enum isl_ast_expr_op_type op;
  isl_id *id;
  isl_val *v;
 
  if (!expr)
    return isl_printer_free(p);
 
  p = isl_printer_yaml_start_mapping(p);
  type = isl_ast_expr_get_type(expr);
  switch (type) {
  case isl_ast_expr_error:
    return isl_printer_free(p);
  case isl_ast_expr_op:
    op = isl_ast_expr_get_op_type(expr);
    if (op == isl_ast_expr_op_error)
      return isl_printer_free(p);
    p = isl_printer_print_str(p, expr_str[type]);
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_str(p, op_str[op]);
    p = isl_printer_yaml_next(p);
    p = print_arguments(p, expr);
    break;
  case isl_ast_expr_id:
    p = isl_printer_print_str(p, expr_str[type]);
    p = isl_printer_yaml_next(p);
    id = isl_ast_expr_get_id(expr);
    p = isl_printer_print_id(p, id);
    isl_id_free(id);
    break;
  case isl_ast_expr_int:
    p = isl_printer_print_str(p, expr_str[type]);
    p = isl_printer_yaml_next(p);
    v = isl_ast_expr_get_val(expr);
    p = isl_printer_print_val(p, v);
    isl_val_free(v);
    break;
  }
  p = isl_printer_yaml_end_mapping(p);
 
  return p;
}
 
/* Print "expr" to "p".
 *
 * Only an isl and a C format are supported.
 */
__isl_give isl_printer *isl_printer_print_ast_expr(__isl_take isl_printer *p,
  __isl_keep isl_ast_expr *expr)
{
  int format;
 
  if (!p)
    return NULL;
 
  format = isl_printer_get_output_format(p);
  switch (format) {
  case ISL_FORMAT_ISL:
    p = print_ast_expr_isl(p, expr);
    break;
  case ISL_FORMAT_C:
    p = print_ast_expr_c(p, expr);
    break;
  default:
    isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
      "output format not supported for ast_expr",
      return isl_printer_free(p));
  }
 
  return p;
}
 
#undef KEY
#define KEY   enum isl_ast_expr_op_type
#undef KEY_ERROR
#define KEY_ERROR isl_ast_expr_op_error
#undef KEY_END
#define KEY_END   (isl_ast_expr_op_address_of + 1)
#undef KEY_STR
#define KEY_STR   op_str
#undef KEY_EXTRACT
#define KEY_EXTRACT extract_op_type
#undef KEY_GET
#define KEY_GET   get_op_type
#include "extract_key.c"
 
/* Return the next token, which is assumed to be a key in a YAML mapping,
 * from "s" as a string.
 */
static __isl_give char *next_key(__isl_keep isl_stream *s)
{
  struct isl_token *tok;
  char *str;
  isl_ctx *ctx;
 
  if (!s)
    return NULL;
  tok = isl_stream_next_token(s);
  if (!tok) {
    isl_stream_error(s, NULL, "unexpected EOF");
    return NULL;
  }
  ctx = isl_stream_get_ctx(s);
  str = isl_token_get_str(ctx, tok);
  isl_token_free(tok);
  return str;
}
 
/* Remove the next token, which is assumed to be the key "expected"
 * in a YAML mapping, from "s" and move to the corresponding value.
 */
static isl_stat eat_key(__isl_keep isl_stream *s, const char *expected)
{
  char *str;
  int ok;
 
  str = next_key(s);
  if (!str)
    return isl_stat_error;
  ok = !strcmp(str, expected);
  free(str);
 
  if (!ok) {
    isl_stream_error(s, NULL, "expecting different key");
    return isl_stat_error;
  }
 
  if (isl_stream_yaml_next(s) < 0)
    return isl_stat_error;
 
  return isl_stat_ok;
}
 
#undef EL_BASE
#define EL_BASE ast_expr
 
#include <isl_list_read_yaml_templ.c>
 
/* Read an isl_ast_expr object of type isl_ast_expr_op from "s",
 * where the "op" key has already been read by the caller.
 *
 * Read the operation type and the arguments and
 * return the corresponding isl_ast_expr object.
 */
static __isl_give isl_ast_expr *read_op(__isl_keep isl_stream *s)
{
  enum isl_ast_expr_op_type op;
  isl_ast_expr_list *list;
 
  op = get_op_type(s);
  if (op < 0)
    return NULL;
  if (isl_stream_yaml_next(s) < 0)
    return NULL;
  if (eat_key(s, "args") < 0)
    return NULL;
 
  list = isl_stream_yaml_read_ast_expr_list(s);
 
  return alloc_op(op, list);
}
 
/* Read an isl_ast_expr object of type isl_ast_expr_id from "s",
 * where the "id" key has already been read by the caller.
 */
static __isl_give isl_ast_expr *read_id(__isl_keep isl_stream *s)
{
  return isl_ast_expr_from_id(isl_stream_read_id(s));
}
 
/* Read an isl_ast_expr object of type isl_ast_expr_int from "s",
 * where the "val" key has already been read by the caller.
 */
static __isl_give isl_ast_expr *read_int(__isl_keep isl_stream *s)
{
  return isl_ast_expr_from_val(isl_stream_read_val(s));
}
 
#undef KEY
#define KEY   enum isl_ast_expr_type
#undef KEY_ERROR
#define KEY_ERROR isl_ast_expr_error
#undef KEY_END
#define KEY_END   (isl_ast_expr_int + 1)
#undef KEY_STR
#define KEY_STR   expr_str
#undef KEY_EXTRACT
#define KEY_EXTRACT extract_expr_type
#undef KEY_GET
#define KEY_GET   get_expr_type
#include "extract_key.c"
 
/* Read an isl_ast_expr object from "s".
 *
 * The keys in the YAML mapping are assumed to appear
 * in the same order as the one in which they are printed
 * by print_ast_expr_isl.
 * In particular, the isl_ast_expr_op type, which is the only one
 * with more than one element, is identified by the "op" key and
 * not by the "args" key.
 */
__isl_give isl_ast_expr *isl_stream_read_ast_expr(__isl_keep isl_stream *s)
{
  enum isl_ast_expr_type type;
  isl_bool more;
  isl_ast_expr *expr;
 
  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;
  }
 
  type = get_expr_type(s);
  if (type < 0)
    return NULL;
  if (isl_stream_yaml_next(s) < 0)
    return NULL;
  switch (type) {
  case isl_ast_expr_op:
    expr = read_op(s);
    break;
  case isl_ast_expr_id:
    expr = read_id(s);
    break;
  case isl_ast_expr_int:
    expr = read_int(s);
    break;
  case isl_ast_expr_error:
    return NULL;
  }
 
  if (isl_stream_yaml_read_end_mapping(s) < 0)
    return isl_ast_expr_free(expr);
 
  return expr;
}
 
static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node);
 
/* Print a YAML sequence containing the entries in "list" to "p".
 */
static __isl_give isl_printer *print_ast_node_list(__isl_take isl_printer *p,
  __isl_keep isl_ast_node_list *list)
{
  int i;
  isl_size n;
 
  n = isl_ast_node_list_n_ast_node(list);
  if (n < 0)
    return isl_printer_free(p);
 
  p = isl_printer_yaml_start_sequence(p);
  for (i = 0; i < n; ++i) {
    isl_ast_node *node;
 
    node = isl_ast_node_list_get_ast_node(list, i);
    p = print_ast_node_isl(p, node);
    isl_ast_node_free(node);
    p = isl_printer_yaml_next(p);
  }
  p = isl_printer_yaml_end_sequence(p);
 
  return p;
}
 
/* Print "node" to "p" in "isl format".
 *
 * In particular, print the isl_ast_node as a YAML document.
 */
static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node)
{
  switch (node->type) {
  case isl_ast_node_for:
    p = isl_printer_yaml_start_mapping(p);
    p = isl_printer_print_str(p, "iterator");
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_ast_expr(p, node->u.f.iterator);
    p = isl_printer_yaml_next(p);
    if (node->u.f.degenerate) {
      p = isl_printer_print_str(p, "value");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_expr(p, node->u.f.init);
      p = isl_printer_yaml_next(p);
    } else {
      p = isl_printer_print_str(p, "init");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_expr(p, node->u.f.init);
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_str(p, "cond");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_expr(p, node->u.f.cond);
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_str(p, "inc");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_expr(p, node->u.f.inc);
      p = isl_printer_yaml_next(p);
    }
    if (node->u.f.body) {
      p = isl_printer_print_str(p, "body");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_node(p, node->u.f.body);
      p = isl_printer_yaml_next(p);
    }
    p = isl_printer_yaml_end_mapping(p);
    break;
  case isl_ast_node_mark:
    p = isl_printer_yaml_start_mapping(p);
    p = isl_printer_print_str(p, "mark");
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_id(p, node->u.m.mark);
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_str(p, "node");
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_ast_node(p, node->u.m.node);
    p = isl_printer_yaml_end_mapping(p);
    break;
  case isl_ast_node_user:
    p = isl_printer_yaml_start_mapping(p);
    p = isl_printer_print_str(p, "user");
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_ast_expr(p, node->u.e.expr);
    p = isl_printer_yaml_end_mapping(p);
    break;
  case isl_ast_node_if:
    p = isl_printer_yaml_start_mapping(p);
    p = isl_printer_print_str(p, "guard");
    p = isl_printer_yaml_next(p);
    p = isl_printer_print_ast_expr(p, node->u.i.guard);
    p = isl_printer_yaml_next(p);
    if (node->u.i.then) {
      p = isl_printer_print_str(p, "then");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_node(p, node->u.i.then);
      p = isl_printer_yaml_next(p);
    }
    if (node->u.i.else_node) {
      p = isl_printer_print_str(p, "else");
      p = isl_printer_yaml_next(p);
      p = isl_printer_print_ast_node(p, node->u.i.else_node);
    }
    p = isl_printer_yaml_end_mapping(p);
    break;
  case isl_ast_node_block:
    p = print_ast_node_list(p, node->u.b.children);
    break;
  case isl_ast_node_error:
    break;
  }
  return p;
}
 
/* Do we need to print a block around the body "node" of a for or if node?
 *
 * If the node is a block, then we need to print a block.
 * Also if the node is a degenerate for then we will print it as
 * an assignment followed by the body of the for loop, so we need a block
 * as well.
 * If the node is an if node with an else, then we print a block
 * to avoid spurious dangling else warnings emitted by some compilers.
 * If the node is a mark, then in principle, we would have to check
 * the child of the mark node.  However, even if the child would not
 * require us to print a block, for readability it is probably best
 * to print a block anyway.
 * If the ast_always_print_block option has been set, then we print a block.
 */
static int need_block(__isl_keep isl_ast_node *node)
{
  isl_ctx *ctx;
 
  if (node->type == isl_ast_node_block)
    return 1;
  if (node->type == isl_ast_node_for && node->u.f.degenerate)
    return 1;
  if (node->type == isl_ast_node_if && node->u.i.else_node)
    return 1;
  if (node->type == isl_ast_node_mark)
    return 1;
 
  ctx = isl_ast_node_get_ctx(node);
  return isl_options_get_ast_always_print_block(ctx);
}
 
static __isl_give isl_printer *print_ast_node_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node,
  __isl_keep isl_ast_print_options *options, int in_block, int in_list);
static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node,
  __isl_keep isl_ast_print_options *options, int new_line,
  int force_block);
 
/* Print the body "node" of a for or if node.
 * If "else_node" is set, then it is printed as well.
 * If "force_block" is set, then print out the body as a block.
 *
 * We first check if we need to print out a block.
 * We always print out a block if there is an else node to make
 * sure that the else node is matched to the correct if node.
 * For consistency, the corresponding else node is also printed as a block.
 *
 * If the else node is itself an if, then we print it as
 *
 *  } else if (..) {
 *  }
 *
 * Otherwise the else node is printed as
 *
 *  } else {
 *    node
 *  }
 */
static __isl_give isl_printer *print_body_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node, __isl_keep isl_ast_node *else_node,
  __isl_keep isl_ast_print_options *options, int force_block)
{
  if (!node)
    return isl_printer_free(p);
 
  if (!force_block && !else_node && !need_block(node)) {
    p = isl_printer_end_line(p);
    p = isl_printer_indent(p, 2);
    p = isl_ast_node_print(node, p,
          isl_ast_print_options_copy(options));
    p = isl_printer_indent(p, -2);
    return p;
  }
 
  p = isl_printer_print_str(p, " {");
  p = isl_printer_end_line(p);
  p = isl_printer_indent(p, 2);
  p = print_ast_node_c(p, node, options, 1, 0);
  p = isl_printer_indent(p, -2);
  p = isl_printer_start_line(p);
  p = isl_printer_print_str(p, "}");
  if (else_node) {
    if (else_node->type == isl_ast_node_if) {
      p = isl_printer_print_str(p, " else ");
      p = print_if_c(p, else_node, options, 0, 1);
    } else {
      p = isl_printer_print_str(p, " else");
      p = print_body_c(p, else_node, NULL, options, 1);
    }
  } else
    p = isl_printer_end_line(p);
 
  return p;
}
 
/* Print the start of a compound statement.
 */
static __isl_give isl_printer *start_block(__isl_take isl_printer *p)
{
  p = isl_printer_start_line(p);
  p = isl_printer_print_str(p, "{");
  p = isl_printer_end_line(p);
  p = isl_printer_indent(p, 2);
 
  return p;
}
 
/* Print the end of a compound statement.
 */
static __isl_give isl_printer *end_block(__isl_take isl_printer *p)
{
  p = isl_printer_indent(p, -2);
  p = isl_printer_start_line(p);
  p = isl_printer_print_str(p, "}");
  p = isl_printer_end_line(p);
 
  return p;
}
 
/* Print the for node "node".
 *
 * If the for node is degenerate, it is printed as
 *
 *  type iterator = init;
 *  body
 *
 * Otherwise, it is printed as
 *
 *  for (type iterator = init; cond; iterator += inc)
 *    body
 *
 * "in_block" is set if we are currently inside a block.
 * "in_list" is set if the current node is not alone in the block.
 * If we are not in a block or if the current not is not alone in the block
 * then we print a block around a degenerate for loop such that the variable
 * declaration will not conflict with any potential other declaration
 * of the same variable.
 */
static __isl_give isl_printer *print_for_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node,
  __isl_keep isl_ast_print_options *options, int in_block, int in_list)
{
  isl_id *id;
  const char *name;
  const char *type;
 
  type = isl_options_get_ast_iterator_type(isl_printer_get_ctx(p));
  if (!node->u.f.degenerate) {
    id = isl_ast_expr_get_id(node->u.f.iterator);
    name = isl_id_get_name(id);
    isl_id_free(id);
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, "for (");
    p = isl_printer_print_str(p, type);
    p = isl_printer_print_str(p, " ");
    p = isl_printer_print_str(p, name);
    p = isl_printer_print_str(p, " = ");
    p = isl_printer_print_ast_expr(p, node->u.f.init);
    p = isl_printer_print_str(p, "; ");
    p = isl_printer_print_ast_expr(p, node->u.f.cond);
    p = isl_printer_print_str(p, "; ");
    p = isl_printer_print_str(p, name);
    p = isl_printer_print_str(p, " += ");
    p = isl_printer_print_ast_expr(p, node->u.f.inc);
    p = isl_printer_print_str(p, ")");
    p = print_body_c(p, node->u.f.body, NULL, options, 0);
  } else {
    id = isl_ast_expr_get_id(node->u.f.iterator);
    name = isl_id_get_name(id);
    isl_id_free(id);
    if (!in_block || in_list)
      p = start_block(p);
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, type);
    p = isl_printer_print_str(p, " ");
    p = isl_printer_print_str(p, name);
    p = isl_printer_print_str(p, " = ");
    p = isl_printer_print_ast_expr(p, node->u.f.init);
    p = isl_printer_print_str(p, ";");
    p = isl_printer_end_line(p);
    p = print_ast_node_c(p, node->u.f.body, options, 1, 0);
    if (!in_block || in_list)
      p = end_block(p);
  }
 
  return p;
}
 
/* Print the if node "node".
 * If "new_line" is set then the if node should be printed on a new line.
 * If "force_block" is set, then print out the body as a block.
 */
static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node,
  __isl_keep isl_ast_print_options *options, int new_line,
  int force_block)
{
  if (new_line)
    p = isl_printer_start_line(p);
  p = isl_printer_print_str(p, "if (");
  p = isl_printer_print_ast_expr(p, node->u.i.guard);
  p = isl_printer_print_str(p, ")");
  p = print_body_c(p, node->u.i.then, node->u.i.else_node, options,
      force_block);
 
  return p;
}
 
/* Print the "node" to "p".
 *
 * "in_block" is set if we are currently inside a block.
 * If so, we do not print a block around the children of a block node.
 * We do this to avoid an extra block around the body of a degenerate
 * for node.
 *
 * "in_list" is set if the current node is not alone in the block.
 */
static __isl_give isl_printer *print_ast_node_c(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node,
  __isl_keep isl_ast_print_options *options, int in_block, int in_list)
{
  switch (node->type) {
  case isl_ast_node_for:
    if (options->print_for)
      return options->print_for(p,
          isl_ast_print_options_copy(options),
          node, options->print_for_user);
    p = print_for_c(p, node, options, in_block, in_list);
    break;
  case isl_ast_node_if:
    p = print_if_c(p, node, options, 1, 0);
    break;
  case isl_ast_node_block:
    if (!in_block)
      p = start_block(p);
    p = isl_ast_node_list_print(node->u.b.children, p, options);
    if (!in_block)
      p = end_block(p);
    break;
  case isl_ast_node_mark:
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, "// ");
    p = isl_printer_print_str(p, isl_id_get_name(node->u.m.mark));
    p = isl_printer_end_line(p);
    p = print_ast_node_c(p, node->u.m.node, options, 0, in_list);
    break;
  case isl_ast_node_user:
    if (options->print_user)
      return options->print_user(p,
          isl_ast_print_options_copy(options),
          node, options->print_user_user);
    p = isl_printer_start_line(p);
    p = isl_printer_print_ast_expr(p, node->u.e.expr);
    p = isl_printer_print_str(p, ";");
    p = isl_printer_end_line(p);
    break;
  case isl_ast_node_error:
    break;
  }
  return p;
}
 
/* Print the for node "node" to "p".
 */
__isl_give isl_printer *isl_ast_node_for_print(__isl_keep isl_ast_node *node,
  __isl_take isl_printer *p, __isl_take isl_ast_print_options *options)
{
  if (isl_ast_node_check_for(node) < 0 || !options)
    goto error;
  p = print_for_c(p, node, options, 0, 0);
  isl_ast_print_options_free(options);
  return p;
error:
  isl_ast_print_options_free(options);
  isl_printer_free(p);
  return NULL;
}
 
/* Print the if node "node" to "p".
 */
__isl_give isl_printer *isl_ast_node_if_print(__isl_keep isl_ast_node *node,
  __isl_take isl_printer *p, __isl_take isl_ast_print_options *options)
{
  if (isl_ast_node_check_if(node) < 0 || !options)
    goto error;
  p = print_if_c(p, node, options, 1, 0);
  isl_ast_print_options_free(options);
  return p;
error:
  isl_ast_print_options_free(options);
  isl_printer_free(p);
  return NULL;
}
 
/* Print "node" to "p".
 *
 * "node" is assumed to be either the outermost node in an AST or
 * a node that is known not to be a block.
 * If "node" is a block (and is therefore outermost) and
 * if the ast_print_outermost_block options is not set,
 * then act as if the printing occurs inside a block, such
 * that no "extra" block will get printed.
 */
__isl_give isl_printer *isl_ast_node_print(__isl_keep isl_ast_node *node,
  __isl_take isl_printer *p, __isl_take isl_ast_print_options *options)
{
  int in_block = 0;
 
  if (!options || !node)
    goto error;
  if (node->type == isl_ast_node_block) {
    isl_ctx *ctx;
 
    ctx = isl_ast_node_get_ctx(node);
    in_block = !isl_options_get_ast_print_outermost_block(ctx);
  }
  p = print_ast_node_c(p, node, options, in_block, 0);
  isl_ast_print_options_free(options);
  return p;
error:
  isl_ast_print_options_free(options);
  isl_printer_free(p);
  return NULL;
}
 
/* Print "node" to "p".
 */
__isl_give isl_printer *isl_printer_print_ast_node(__isl_take isl_printer *p,
  __isl_keep isl_ast_node *node)
{
  int format;
  isl_ast_print_options *options;
 
  if (!p)
    return NULL;
 
  format = isl_printer_get_output_format(p);
  switch (format) {
  case ISL_FORMAT_ISL:
    p = print_ast_node_isl(p, node);
    break;
  case ISL_FORMAT_C:
    options = isl_ast_print_options_alloc(isl_printer_get_ctx(p));
    p = isl_ast_node_print(node, p, options);
    break;
  default:
    isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
      "output format not supported for ast_node",
      return isl_printer_free(p));
  }
 
  return p;
}
 
/* Print the list of nodes "list" to "p".
 */
__isl_give isl_printer *isl_ast_node_list_print(
  __isl_keep isl_ast_node_list *list, __isl_take isl_printer *p,
  __isl_keep isl_ast_print_options *options)
{
  int i;
 
  if (!p || !list || !options)
    return isl_printer_free(p);
 
  for (i = 0; i < list->n; ++i)
    p = print_ast_node_c(p, list->p[i], options, 1, 1);
 
  return p;
}
 
/* Is the next token on "s" the start of a YAML sequence
 * (rather than a YAML mapping)?
 *
 * A YAML sequence starts with either a '[' or a '-', depending on the format.
 */
static isl_bool next_is_sequence(__isl_keep isl_stream *s)
{
  struct isl_token *tok;
  int type;
  int seq;
 
  tok = isl_stream_next_token(s);
  if (!tok)
    return isl_bool_error;
  type = isl_token_get_type(tok);
  seq = type == '[' || type == '-';
  isl_stream_push_token(s, tok);
 
  return isl_bool_ok(seq);
}
 
#undef EL_BASE
#define EL_BASE ast_node
 
#include <isl_list_read_yaml_templ.c>
 
/* Read an isl_ast_node object of type isl_ast_node_block from "s".
 */
static __isl_give isl_ast_node *read_block(__isl_keep isl_stream *s)
{
  isl_ast_node_list *children;
 
  children = isl_stream_yaml_read_ast_node_list(s);
  return isl_ast_node_block_from_children(children);
}
 
/* Textual representation of the first YAML key used
 * while printing an isl_ast_node of a given type.
 *
 * An isl_ast_node of type isl_ast_node_block is not printed
 * as a YAML mapping and is therefore assigned a dummy key.
 */
static char *node_first_str[] = {
  [isl_ast_node_for] = "iterator",
  [isl_ast_node_mark] = "mark",
  [isl_ast_node_user] = "user",
  [isl_ast_node_if] = "guard",
  [isl_ast_node_block] = "",
};
 
#undef KEY
#define KEY   enum isl_ast_node_type
#undef KEY_ERROR
#define KEY_ERROR isl_ast_node_error
#undef KEY_END
#define KEY_END   (isl_ast_node_user + 1)
#undef KEY_STR
#define KEY_STR   node_first_str
#undef KEY_EXTRACT
#define KEY_EXTRACT extract_node_type
#undef KEY_GET
#define KEY_GET   get_node_type
#include "extract_key.c"
 
static __isl_give isl_ast_node *read_body(__isl_keep isl_stream *s,
  __isl_take isl_ast_node *node)
{
  if (eat_key(s, "body") < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_for_set_body(node, isl_stream_read_ast_node(s));
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
  return node;
}
 
/* Read an isl_ast_node object of type isl_ast_node_for from "s",
 * where the initial "iterator" key has already been read by the caller.
 *
 * If the initial value is printed as the value of the key "value",
 * then the for-loop is degenerate and can at most have
 * a further "body" element.
 * Otherwise, the for-loop also has "cond" and "inc" elements.
 */
static __isl_give isl_ast_node *read_for(__isl_keep isl_stream *s)
{
  isl_id *id;
  isl_ast_expr *expr;
  isl_ast_node *node;
  char *key;
  isl_bool more;
  int is_value, is_init;
 
  expr = isl_stream_read_ast_expr(s);
  id = isl_ast_expr_id_get_id(expr);
  isl_ast_expr_free(expr);
  if (!id)
    return NULL;
  if (isl_stream_yaml_next(s) < 0)
    id = isl_id_free(id);
 
  node = isl_ast_node_alloc_for(id);
 
  key = next_key(s);
  if (!key)
    return isl_ast_node_free(node);
  is_value = !strcmp(key, "value");
  is_init = !strcmp(key, "init");
  free(key);
  if (!is_value && !is_init)
    isl_die(isl_stream_get_ctx(s), isl_error_invalid,
      "unexpected key", return isl_ast_node_free(node));
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_for_set_init(node, isl_stream_read_ast_expr(s));
  if ((more = isl_stream_yaml_next(s)) < 0)
    return isl_ast_node_free(node);
  if (is_value) {
    node = isl_ast_node_for_mark_degenerate(node);
    if (more)
      node = read_body(s, node);
    return node;
  }
 
  if (eat_key(s, "cond") < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_for_set_cond(node, isl_stream_read_ast_expr(s));
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
  if (eat_key(s, "inc") < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_for_set_inc(node, isl_stream_read_ast_expr(s));
  if ((more = isl_stream_yaml_next(s)) < 0)
    return isl_ast_node_free(node);
 
  if (more)
    node = read_body(s, node);
 
  return node;
}
 
/* Read an isl_ast_node object of type isl_ast_node_mark from "s",
 * where the initial "mark" key has already been read by the caller.
 */
static __isl_give isl_ast_node *read_mark(__isl_keep isl_stream *s)
{
  isl_id *id;
  isl_ast_node *node;
 
  id = isl_stream_read_id(s);
  if (!id)
    return NULL;
  if (isl_stream_yaml_next(s) < 0)
    goto error;
  if (eat_key(s, "node") < 0)
    goto error;
  node = isl_stream_read_ast_node(s);
  node = isl_ast_node_alloc_mark(id, node);
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
  return node;
error:
  isl_id_free(id);
  return NULL;
}
 
/* Read an isl_ast_node object of type isl_ast_node_user from "s",
 * where the "user" key has already been read by the caller.
 */
static __isl_give isl_ast_node *read_user(__isl_keep isl_stream *s)
{
  isl_ast_node *node;
 
  node = isl_ast_node_alloc_user(isl_stream_read_ast_expr(s));
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
  return node;
}
 
/* Read an isl_ast_node object of type isl_ast_node_if from "s",
 * where the initial "guard" key has already been read by the caller.
 */
static __isl_give isl_ast_node *read_if(__isl_keep isl_stream *s)
{
  isl_bool more;
  isl_ast_node *node;
 
  node = isl_ast_node_alloc_if(isl_stream_read_ast_expr(s));
  if ((more = isl_stream_yaml_next(s)) < 0)
    return isl_ast_node_free(node);
  if (!more)
    return node;
 
  if (eat_key(s, "then") < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_if_set_then(node, isl_stream_read_ast_node(s));
  if ((more = isl_stream_yaml_next(s)) < 0)
    return isl_ast_node_free(node);
  if (!more)
    return node;
 
  if (eat_key(s, "else") < 0)
    return isl_ast_node_free(node);
  node = isl_ast_node_if_set_else_node(node, isl_stream_read_ast_node(s));
  if (isl_stream_yaml_next(s) < 0)
    return isl_ast_node_free(node);
 
  return node;
}
 
/* Read an isl_ast_node object from "s".
 *
 * A block node is printed as a YAML sequence by print_ast_node_isl.
 * Every other node type is printed as a YAML mapping.
 *
 * First check if the next element is a sequence and if so,
 * read a block node.
 * Otherwise, read a node based on the first mapping key
 * that is used to print a node type.
 * Note that the keys in the YAML mapping are assumed to appear
 * in the same order as the one in which they are printed
 * by print_ast_node_isl.
 */
__isl_give isl_ast_node *isl_stream_read_ast_node(__isl_keep isl_stream *s)
{
  enum isl_ast_node_type type;
  isl_bool more;
  isl_bool seq;
  isl_ast_node *node;
 
  seq = next_is_sequence(s);
  if (seq < 0)
    return NULL;
  if (seq)
    return read_block(s);
 
  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;
  }
 
  type = get_node_type(s);
  if (type < 0)
    return NULL;
  if (isl_stream_yaml_next(s) < 0)
    return NULL;
 
  switch (type) {
  case isl_ast_node_block:
    isl_die(isl_stream_get_ctx(s), isl_error_internal,
      "block cannot be detected as mapping",
      return NULL);
  case isl_ast_node_for:
    node = read_for(s);
    break;
  case isl_ast_node_mark:
    node = read_mark(s);
    break;
  case isl_ast_node_user:
    node = read_user(s);
    break;
  case isl_ast_node_if:
    node = read_if(s);
    break;
  case isl_ast_node_error:
    return NULL;
  }
 
  if (isl_stream_yaml_read_end_mapping(s) < 0)
    return isl_ast_node_free(node);
 
  return node;
}
 
#define ISL_AST_MACRO_FDIV_Q  (1 << 0)
#define ISL_AST_MACRO_MIN (1 << 1)
#define ISL_AST_MACRO_MAX (1 << 2)
#define ISL_AST_MACRO_ALL (ISL_AST_MACRO_FDIV_Q | \
         ISL_AST_MACRO_MIN | \
         ISL_AST_MACRO_MAX)
 
static int ast_expr_required_macros(__isl_keep isl_ast_expr *expr, int macros);
 
/* Wrapper around ast_expr_required_macros for use
 * as an isl_ast_expr_list_foreach callback.
 */
static isl_stat entry_required_macros(__isl_take isl_ast_expr *expr, void *user)
{
  int *macros = user;
 
  *macros = ast_expr_required_macros(expr, *macros);
  isl_ast_expr_free(expr);
 
  return isl_stat_ok;
}
 
/* If "expr" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
 * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
 */
static int ast_expr_required_macros(__isl_keep isl_ast_expr *expr, int macros)
{
  if (macros == ISL_AST_MACRO_ALL)
    return macros;
 
  if (expr->type != isl_ast_expr_op)
    return macros;
 
  if (expr->u.op.op == isl_ast_expr_op_min)
    macros |= ISL_AST_MACRO_MIN;
  if (expr->u.op.op == isl_ast_expr_op_max)
    macros |= ISL_AST_MACRO_MAX;
  if (expr->u.op.op == isl_ast_expr_op_fdiv_q)
    macros |= ISL_AST_MACRO_FDIV_Q;
 
  isl_ast_expr_list_foreach(expr->u.op.args,
        &entry_required_macros, &macros);
 
  return macros;
}
 
static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list,
  int macros);
 
/* If "node" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
 * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
 */
static int ast_node_required_macros(__isl_keep isl_ast_node *node, int macros)
{
  if (macros == ISL_AST_MACRO_ALL)
    return macros;
 
  switch (node->type) {
  case isl_ast_node_for:
    macros = ast_expr_required_macros(node->u.f.init, macros);
    if (!node->u.f.degenerate) {
      macros = ast_expr_required_macros(node->u.f.cond,
                macros);
      macros = ast_expr_required_macros(node->u.f.inc,
                macros);
    }
    macros = ast_node_required_macros(node->u.f.body, macros);
    break;
  case isl_ast_node_if:
    macros = ast_expr_required_macros(node->u.i.guard, macros);
    macros = ast_node_required_macros(node->u.i.then, macros);
    if (node->u.i.else_node)
      macros = ast_node_required_macros(node->u.i.else_node,
                macros);
    break;
  case isl_ast_node_block:
    macros = ast_node_list_required_macros(node->u.b.children,
              macros);
    break;
  case isl_ast_node_mark:
    macros = ast_node_required_macros(node->u.m.node, macros);
    break;
  case isl_ast_node_user:
    macros = ast_expr_required_macros(node->u.e.expr, macros);
    break;
  case isl_ast_node_error:
    break;
  }
 
  return macros;
}
 
/* If "list" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
 * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
 */
static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list,
  int macros)
{
  int i;
 
  for (i = 0; i < list->n; ++i)
    macros = ast_node_required_macros(list->p[i], macros);
 
  return macros;
}
 
/* Data structure for keeping track of whether a macro definition
 * for a given type has already been printed.
 * The value is zero if no definition has been printed and non-zero otherwise.
 */
struct isl_ast_expr_op_printed {
  char printed[isl_ast_expr_op_last + 1];
};
 
/* Create an empty struct isl_ast_expr_op_printed.
 */
static void *create_printed(isl_ctx *ctx)
{
  return isl_calloc_type(ctx, struct isl_ast_expr_op_printed);
}
 
/* Free a struct isl_ast_expr_op_printed.
 */
static void free_printed(void *user)
{
  free(user);
}
 
/* Ensure that "p" has an isl_ast_expr_op_printed note identified by "id".
 */
static __isl_give isl_printer *alloc_printed(__isl_take isl_printer *p,
  __isl_keep isl_id *id)
{
  return alloc_note(p, id, &create_printed, &free_printed);
}
 
/* Create an identifier that is used to store
 * an isl_ast_expr_op_printed note.
 */
static __isl_give isl_id *printed_id(isl_ctx *ctx)
{
  return isl_id_alloc(ctx, "isl_ast_expr_op_type_printed", NULL);
}
 
/* Did the user specify that a macro definition should only be
 * printed once and has a macro definition for "type" already
 * been printed to "p"?
 * If definitions should only be printed once, but a definition
 * for "p" has not yet been printed, then mark it as having been
 * printed so that it will not printed again.
 * The actual printing is taken care of by the caller.
 */
static isl_bool already_printed_once(__isl_keep isl_printer *p,
  enum isl_ast_expr_op_type type)
{
  isl_ctx *ctx;
  isl_id *id;
  struct isl_ast_expr_op_printed *printed;
 
  if (!p)
    return isl_bool_error;
 
  ctx = isl_printer_get_ctx(p);
  if (!isl_options_get_ast_print_macro_once(ctx))
    return isl_bool_false;
 
  if (type > isl_ast_expr_op_last)
    isl_die(isl_printer_get_ctx(p), isl_error_invalid,
      "invalid type", return isl_bool_error);
 
  id = printed_id(isl_printer_get_ctx(p));
  p = alloc_printed(p, id);
  printed = get_note(p, id);
  isl_id_free(id);
  if (!printed)
    return isl_bool_error;
 
  if (printed->printed[type])
    return isl_bool_true;
 
  printed->printed[type] = 1;
  return isl_bool_false;
}
 
/* Print a macro definition for the operator "type".
 *
 * If the user has specified that a macro definition should
 * only be printed once to any given printer and if the macro definition
 * has already been printed to "p", then do not print the definition.
 */
__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
  enum isl_ast_expr_op_type type, __isl_take isl_printer *p)
{
  isl_bool skip;
 
  skip = already_printed_once(p, type);
  if (skip < 0)
    return isl_printer_free(p);
  if (skip)
    return p;
 
  switch (type) {
  case isl_ast_expr_op_min:
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, "#define ");
    p = isl_printer_print_str(p, get_op_str_c(p, type));
    p = isl_printer_print_str(p,
      "(x,y)    ((x) < (y) ? (x) : (y))");
    p = isl_printer_end_line(p);
    break;
  case isl_ast_expr_op_max:
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, "#define ");
    p = isl_printer_print_str(p, get_op_str_c(p, type));
    p = isl_printer_print_str(p,
      "(x,y)    ((x) > (y) ? (x) : (y))");
    p = isl_printer_end_line(p);
    break;
  case isl_ast_expr_op_fdiv_q:
    p = isl_printer_start_line(p);
    p = isl_printer_print_str(p, "#define ");
    p = isl_printer_print_str(p, get_op_str_c(p, type));
    p = isl_printer_print_str(p,
      "(n,d) "
      "(((n)<0) ? -((-(n)+(d)-1)/(d)) : (n)/(d))");
    p = isl_printer_end_line(p);
    break;
  default:
    break;
  }
 
  return p;
}
 
/* This is an alternative name for the function above.
 */
__isl_give isl_printer *isl_ast_op_type_print_macro(
  enum isl_ast_expr_op_type type, __isl_take isl_printer *p)
{
  return isl_ast_expr_op_type_print_macro(type, p);
}
 
/* Call "fn" for each type of operation represented in the "macros"
 * bit vector.
 */
static isl_stat foreach_ast_expr_op_type(int macros,
  isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
{
  if (macros & ISL_AST_MACRO_MIN && fn(isl_ast_expr_op_min, user) < 0)
    return isl_stat_error;
  if (macros & ISL_AST_MACRO_MAX && fn(isl_ast_expr_op_max, user) < 0)
    return isl_stat_error;
  if (macros & ISL_AST_MACRO_FDIV_Q &&
      fn(isl_ast_expr_op_fdiv_q, user) < 0)
    return isl_stat_error;
 
  return isl_stat_ok;
}
 
/* Call "fn" for each type of operation that appears in "expr"
 * and that requires a macro definition.
 */
isl_stat isl_ast_expr_foreach_ast_expr_op_type(__isl_keep isl_ast_expr *expr,
  isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
{
  int macros;
 
  if (!expr)
    return isl_stat_error;
 
  macros = ast_expr_required_macros(expr, 0);
  return foreach_ast_expr_op_type(macros, fn, user);
}
 
/* This is an alternative name for the function above.
 */
isl_stat isl_ast_expr_foreach_ast_op_type(__isl_keep isl_ast_expr *expr,
  isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
{
  return isl_ast_expr_foreach_ast_expr_op_type(expr, fn, user);
}
 
/* Call "fn" for each type of operation that appears in "node"
 * and that requires a macro definition.
 */
isl_stat isl_ast_node_foreach_ast_expr_op_type(__isl_keep isl_ast_node *node,
  isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
{
  int macros;
 
  if (!node)
    return isl_stat_error;
 
  macros = ast_node_required_macros(node, 0);
  return foreach_ast_expr_op_type(macros, fn, user);
}
 
/* This is an alternative name for the function above.
 */
isl_stat isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node,
  isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
{
  return isl_ast_node_foreach_ast_expr_op_type(node, fn, user);
}
 
static isl_stat ast_op_type_print_macro(enum isl_ast_expr_op_type type,
  void *user)
{
  isl_printer **p = user;
 
  *p = isl_ast_expr_op_type_print_macro(type, *p);
 
  return isl_stat_ok;
}
 
/* Print macro definitions for all the macros used in the result
 * of printing "expr".
 */
__isl_give isl_printer *isl_ast_expr_print_macros(
  __isl_keep isl_ast_expr *expr, __isl_take isl_printer *p)
{
  if (isl_ast_expr_foreach_ast_expr_op_type(expr,
              &ast_op_type_print_macro, &p) < 0)
    return isl_printer_free(p);
  return p;
}
 
/* Print macro definitions for all the macros used in the result
 * of printing "node".
 */
__isl_give isl_printer *isl_ast_node_print_macros(
  __isl_keep isl_ast_node *node, __isl_take isl_printer *p)
{
  if (isl_ast_node_foreach_ast_expr_op_type(node,
              &ast_op_type_print_macro, &p) < 0)
    return isl_printer_free(p);
  return p;
}
 
/* Return a string containing C code representing this isl_ast_expr.
 */
__isl_give char *isl_ast_expr_to_C_str(__isl_keep isl_ast_expr *expr)
{
  isl_printer *p;
  char *str;
 
  if (!expr)
    return NULL;
 
  p = isl_printer_to_str(isl_ast_expr_get_ctx(expr));
  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
  p = isl_printer_print_ast_expr(p, expr);
 
  str = isl_printer_get_str(p);
 
  isl_printer_free(p);
 
  return str;
}
 
/* Return a string containing C code representing this isl_ast_node.
 */
__isl_give char *isl_ast_node_to_C_str(__isl_keep isl_ast_node *node)
{
  isl_printer *p;
  char *str;
 
  if (!node)
    return NULL;
 
  p = isl_printer_to_str(isl_ast_node_get_ctx(node));
  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
  p = isl_printer_print_ast_node(p, node);
 
  str = isl_printer_get_str(p);
 
  isl_printer_free(p);
 
  return str;
}