/* Automatically generated from nodetypes.def, do not edit. */

/* See the copyright notice in nodetypes.def */
error_decl new_error_decl(region r)
{
  error_decl obj = ralloc(r, struct AST_nil);

  obj->kind = kind_error_decl;

  return obj;
}

struct_ref new_struct_ref(region r)
{
  struct_ref obj = ralloc(r, struct AST_nil);

  obj->kind = kind_struct_ref;

  return obj;
}

union_ref new_union_ref(region r)
{
  union_ref obj = ralloc(r, struct AST_nil);

  obj->kind = kind_union_ref;

  return obj;
}

enum_ref new_enum_ref(region r)
{
  enum_ref obj = ralloc(r, struct AST_nil);

  obj->kind = kind_enum_ref;

  return obj;
}

error_stmt new_error_stmt(region r)
{
  error_stmt obj = ralloc(r, struct AST_nil);

  obj->kind = kind_error_stmt;

  return obj;
}

while_stmt new_while_stmt(region r)
{
  while_stmt obj = ralloc(r, struct AST_nil);

  obj->kind = kind_while_stmt;

  return obj;
}

dowhile_stmt new_dowhile_stmt(region r)
{
  dowhile_stmt obj = ralloc(r, struct AST_nil);

  obj->kind = kind_dowhile_stmt;

  return obj;
}

error_expr new_error_expr(region r)
{
  error_expr obj = ralloc(r, struct AST_nil);

  obj->kind = kind_error_expr;

  return obj;
}

dereference new_dereference(region r)
{
  dereference obj = ralloc(r, struct AST_nil);

  obj->kind = kind_dereference;

  return obj;
}

extension_expr new_extension_expr(region r)
{
  extension_expr obj = ralloc(r, struct AST_nil);

  obj->kind = kind_extension_expr;

  return obj;
}

sizeof_expr new_sizeof_expr(region r)
{
  sizeof_expr obj = ralloc(r, struct AST_nil);

  obj->kind = kind_sizeof_expr;

  return obj;
}

alignof_expr new_alignof_expr(region r)
{
  alignof_expr obj = ralloc(r, struct AST_nil);

  obj->kind = kind_alignof_expr;

  return obj;
}

realpart new_realpart(region r)
{
  realpart obj = ralloc(r, struct AST_nil);

  obj->kind = kind_realpart;

  return obj;
}

imagpart new_imagpart(region r)
{
  imagpart obj = ralloc(r, struct AST_nil);

  obj->kind = kind_imagpart;

  return obj;
}

address_of new_address_of(region r)
{
  address_of obj = ralloc(r, struct AST_nil);

  obj->kind = kind_address_of;

  return obj;
}

unary_minus new_unary_minus(region r)
{
  unary_minus obj = ralloc(r, struct AST_nil);

  obj->kind = kind_unary_minus;

  return obj;
}

unary_plus new_unary_plus(region r)
{
  unary_plus obj = ralloc(r, struct AST_nil);

  obj->kind = kind_unary_plus;

  return obj;
}

conjugate new_conjugate(region r)
{
  conjugate obj = ralloc(r, struct AST_nil);

  obj->kind = kind_conjugate;

  return obj;
}

preincrement new_preincrement(region r)
{
  preincrement obj = ralloc(r, struct AST_nil);

  obj->kind = kind_preincrement;

  return obj;
}

predecrement new_predecrement(region r)
{
  predecrement obj = ralloc(r, struct AST_nil);

  obj->kind = kind_predecrement;

  return obj;
}

postincrement new_postincrement(region r)
{
  postincrement obj = ralloc(r, struct AST_nil);

  obj->kind = kind_postincrement;

  return obj;
}

postdecrement new_postdecrement(region r)
{
  postdecrement obj = ralloc(r, struct AST_nil);

  obj->kind = kind_postdecrement;

  return obj;
}

bitnot new_bitnot(region r)
{
  bitnot obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitnot;

  return obj;
}

not new_not(region r)
{
  not obj = ralloc(r, struct AST_nil);

  obj->kind = kind_not;

  return obj;
}

plus new_plus(region r)
{
  plus obj = ralloc(r, struct AST_nil);

  obj->kind = kind_plus;

  return obj;
}

minus new_minus(region r)
{
  minus obj = ralloc(r, struct AST_nil);

  obj->kind = kind_minus;

  return obj;
}

times new_times(region r)
{
  times obj = ralloc(r, struct AST_nil);

  obj->kind = kind_times;

  return obj;
}

divide new_divide(region r)
{
  divide obj = ralloc(r, struct AST_nil);

  obj->kind = kind_divide;

  return obj;
}

modulo new_modulo(region r)
{
  modulo obj = ralloc(r, struct AST_nil);

  obj->kind = kind_modulo;

  return obj;
}

lshift new_lshift(region r)
{
  lshift obj = ralloc(r, struct AST_nil);

  obj->kind = kind_lshift;

  return obj;
}

rshift new_rshift(region r)
{
  rshift obj = ralloc(r, struct AST_nil);

  obj->kind = kind_rshift;

  return obj;
}

leq new_leq(region r)
{
  leq obj = ralloc(r, struct AST_nil);

  obj->kind = kind_leq;

  return obj;
}

geq new_geq(region r)
{
  geq obj = ralloc(r, struct AST_nil);

  obj->kind = kind_geq;

  return obj;
}

lt new_lt(region r)
{
  lt obj = ralloc(r, struct AST_nil);

  obj->kind = kind_lt;

  return obj;
}

gt new_gt(region r)
{
  gt obj = ralloc(r, struct AST_nil);

  obj->kind = kind_gt;

  return obj;
}

eq new_eq(region r)
{
  eq obj = ralloc(r, struct AST_nil);

  obj->kind = kind_eq;

  return obj;
}

ne new_ne(region r)
{
  ne obj = ralloc(r, struct AST_nil);

  obj->kind = kind_ne;

  return obj;
}

bitand new_bitand(region r)
{
  bitand obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitand;

  return obj;
}

bitor new_bitor(region r)
{
  bitor obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitor;

  return obj;
}

bitxor new_bitxor(region r)
{
  bitxor obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitxor;

  return obj;
}

andand new_andand(region r)
{
  andand obj = ralloc(r, struct AST_nil);

  obj->kind = kind_andand;

  return obj;
}

oror new_oror(region r)
{
  oror obj = ralloc(r, struct AST_nil);

  obj->kind = kind_oror;

  return obj;
}

assign new_assign(region r)
{
  assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_assign;

  return obj;
}

plus_assign new_plus_assign(region r)
{
  plus_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_plus_assign;

  return obj;
}

minus_assign new_minus_assign(region r)
{
  minus_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_minus_assign;

  return obj;
}

times_assign new_times_assign(region r)
{
  times_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_times_assign;

  return obj;
}

divide_assign new_divide_assign(region r)
{
  divide_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_divide_assign;

  return obj;
}

modulo_assign new_modulo_assign(region r)
{
  modulo_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_modulo_assign;

  return obj;
}

lshift_assign new_lshift_assign(region r)
{
  lshift_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_lshift_assign;

  return obj;
}

rshift_assign new_rshift_assign(region r)
{
  rshift_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_rshift_assign;

  return obj;
}

bitand_assign new_bitand_assign(region r)
{
  bitand_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitand_assign;

  return obj;
}

bitor_assign new_bitor_assign(region r)
{
  bitor_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitor_assign;

  return obj;
}

bitxor_assign new_bitxor_assign(region r)
{
  bitxor_assign obj = ralloc(r, struct AST_nil);

  obj->kind = kind_bitxor_assign;

  return obj;
}



error_decl error_decl_chain(error_decl l1, error_decl l2)
{ return CAST(error_decl, ast_chain(CAST(node, l1), CAST(node, l2))); }

struct_ref struct_ref_chain(struct_ref l1, struct_ref l2)
{ return CAST(struct_ref, ast_chain(CAST(node, l1), CAST(node, l2))); }

union_ref union_ref_chain(union_ref l1, union_ref l2)
{ return CAST(union_ref, ast_chain(CAST(node, l1), CAST(node, l2))); }

enum_ref enum_ref_chain(enum_ref l1, enum_ref l2)
{ return CAST(enum_ref, ast_chain(CAST(node, l1), CAST(node, l2))); }

error_stmt error_stmt_chain(error_stmt l1, error_stmt l2)
{ return CAST(error_stmt, ast_chain(CAST(node, l1), CAST(node, l2))); }

while_stmt while_stmt_chain(while_stmt l1, while_stmt l2)
{ return CAST(while_stmt, ast_chain(CAST(node, l1), CAST(node, l2))); }

dowhile_stmt dowhile_stmt_chain(dowhile_stmt l1, dowhile_stmt l2)
{ return CAST(dowhile_stmt, ast_chain(CAST(node, l1), CAST(node, l2))); }

error_expr error_expr_chain(error_expr l1, error_expr l2)
{ return CAST(error_expr, ast_chain(CAST(node, l1), CAST(node, l2))); }

dereference dereference_chain(dereference l1, dereference l2)
{ return CAST(dereference, ast_chain(CAST(node, l1), CAST(node, l2))); }

extension_expr extension_expr_chain(extension_expr l1, extension_expr l2)
{ return CAST(extension_expr, ast_chain(CAST(node, l1), CAST(node, l2))); }

sizeof_expr sizeof_expr_chain(sizeof_expr l1, sizeof_expr l2)
{ return CAST(sizeof_expr, ast_chain(CAST(node, l1), CAST(node, l2))); }

alignof_expr alignof_expr_chain(alignof_expr l1, alignof_expr l2)
{ return CAST(alignof_expr, ast_chain(CAST(node, l1), CAST(node, l2))); }

realpart realpart_chain(realpart l1, realpart l2)
{ return CAST(realpart, ast_chain(CAST(node, l1), CAST(node, l2))); }

imagpart imagpart_chain(imagpart l1, imagpart l2)
{ return CAST(imagpart, ast_chain(CAST(node, l1), CAST(node, l2))); }

address_of address_of_chain(address_of l1, address_of l2)
{ return CAST(address_of, ast_chain(CAST(node, l1), CAST(node, l2))); }

unary_minus unary_minus_chain(unary_minus l1, unary_minus l2)
{ return CAST(unary_minus, ast_chain(CAST(node, l1), CAST(node, l2))); }

unary_plus unary_plus_chain(unary_plus l1, unary_plus l2)
{ return CAST(unary_plus, ast_chain(CAST(node, l1), CAST(node, l2))); }

conjugate conjugate_chain(conjugate l1, conjugate l2)
{ return CAST(conjugate, ast_chain(CAST(node, l1), CAST(node, l2))); }

preincrement preincrement_chain(preincrement l1, preincrement l2)
{ return CAST(preincrement, ast_chain(CAST(node, l1), CAST(node, l2))); }

predecrement predecrement_chain(predecrement l1, predecrement l2)
{ return CAST(predecrement, ast_chain(CAST(node, l1), CAST(node, l2))); }

postincrement postincrement_chain(postincrement l1, postincrement l2)
{ return CAST(postincrement, ast_chain(CAST(node, l1), CAST(node, l2))); }

postdecrement postdecrement_chain(postdecrement l1, postdecrement l2)
{ return CAST(postdecrement, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitnot bitnot_chain(bitnot l1, bitnot l2)
{ return CAST(bitnot, ast_chain(CAST(node, l1), CAST(node, l2))); }

not not_chain(not l1, not l2)
{ return CAST(not, ast_chain(CAST(node, l1), CAST(node, l2))); }

plus plus_chain(plus l1, plus l2)
{ return CAST(plus, ast_chain(CAST(node, l1), CAST(node, l2))); }

minus minus_chain(minus l1, minus l2)
{ return CAST(minus, ast_chain(CAST(node, l1), CAST(node, l2))); }

times times_chain(times l1, times l2)
{ return CAST(times, ast_chain(CAST(node, l1), CAST(node, l2))); }

divide divide_chain(divide l1, divide l2)
{ return CAST(divide, ast_chain(CAST(node, l1), CAST(node, l2))); }

modulo modulo_chain(modulo l1, modulo l2)
{ return CAST(modulo, ast_chain(CAST(node, l1), CAST(node, l2))); }

lshift lshift_chain(lshift l1, lshift l2)
{ return CAST(lshift, ast_chain(CAST(node, l1), CAST(node, l2))); }

rshift rshift_chain(rshift l1, rshift l2)
{ return CAST(rshift, ast_chain(CAST(node, l1), CAST(node, l2))); }

leq leq_chain(leq l1, leq l2)
{ return CAST(leq, ast_chain(CAST(node, l1), CAST(node, l2))); }

geq geq_chain(geq l1, geq l2)
{ return CAST(geq, ast_chain(CAST(node, l1), CAST(node, l2))); }

lt lt_chain(lt l1, lt l2)
{ return CAST(lt, ast_chain(CAST(node, l1), CAST(node, l2))); }

gt gt_chain(gt l1, gt l2)
{ return CAST(gt, ast_chain(CAST(node, l1), CAST(node, l2))); }

eq eq_chain(eq l1, eq l2)
{ return CAST(eq, ast_chain(CAST(node, l1), CAST(node, l2))); }

ne ne_chain(ne l1, ne l2)
{ return CAST(ne, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitand bitand_chain(bitand l1, bitand l2)
{ return CAST(bitand, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitor bitor_chain(bitor l1, bitor l2)
{ return CAST(bitor, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitxor bitxor_chain(bitxor l1, bitxor l2)
{ return CAST(bitxor, ast_chain(CAST(node, l1), CAST(node, l2))); }

andand andand_chain(andand l1, andand l2)
{ return CAST(andand, ast_chain(CAST(node, l1), CAST(node, l2))); }

oror oror_chain(oror l1, oror l2)
{ return CAST(oror, ast_chain(CAST(node, l1), CAST(node, l2))); }

assign assign_chain(assign l1, assign l2)
{ return CAST(assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

plus_assign plus_assign_chain(plus_assign l1, plus_assign l2)
{ return CAST(plus_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

minus_assign minus_assign_chain(minus_assign l1, minus_assign l2)
{ return CAST(minus_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

times_assign times_assign_chain(times_assign l1, times_assign l2)
{ return CAST(times_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

divide_assign divide_assign_chain(divide_assign l1, divide_assign l2)
{ return CAST(divide_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

modulo_assign modulo_assign_chain(modulo_assign l1, modulo_assign l2)
{ return CAST(modulo_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

lshift_assign lshift_assign_chain(lshift_assign l1, lshift_assign l2)
{ return CAST(lshift_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

rshift_assign rshift_assign_chain(rshift_assign l1, rshift_assign l2)
{ return CAST(rshift_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitand_assign bitand_assign_chain(bitand_assign l1, bitand_assign l2)
{ return CAST(bitand_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitor_assign bitor_assign_chain(bitor_assign l1, bitor_assign l2)
{ return CAST(bitor_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

bitxor_assign bitxor_assign_chain(bitxor_assign l1, bitxor_assign l2)
{ return CAST(bitxor_assign, ast_chain(CAST(node, l1), CAST(node, l2))); }

