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

/* See the copyright notice in nodetypes.def */
typedef struct AST_declaration *error_decl;
typedef struct AST_tag_ref *struct_ref;
typedef struct AST_tag_ref *union_ref;
typedef struct AST_tag_ref *enum_ref;
typedef struct AST_statement *error_stmt;
typedef struct AST_conditional_stmt *while_stmt;
typedef struct AST_conditional_stmt *dowhile_stmt;
typedef struct AST_expression *error_expr;
typedef struct AST_unary *dereference;
typedef struct AST_unary *extension_expr;
typedef struct AST_unary *sizeof_expr;
typedef struct AST_unary *alignof_expr;
typedef struct AST_unary *realpart;
typedef struct AST_unary *imagpart;
typedef struct AST_unary *address_of;
typedef struct AST_unary *unary_minus;
typedef struct AST_unary *unary_plus;
typedef struct AST_unary *conjugate;
typedef struct AST_unary *preincrement;
typedef struct AST_unary *predecrement;
typedef struct AST_unary *postincrement;
typedef struct AST_unary *postdecrement;
typedef struct AST_unary *bitnot;
typedef struct AST_unary *not;
typedef struct AST_binary *plus;
typedef struct AST_binary *minus;
typedef struct AST_binary *times;
typedef struct AST_binary *divide;
typedef struct AST_binary *modulo;
typedef struct AST_binary *lshift;
typedef struct AST_binary *rshift;
typedef struct AST_binary *leq;
typedef struct AST_binary *geq;
typedef struct AST_binary *lt;
typedef struct AST_binary *gt;
typedef struct AST_binary *eq;
typedef struct AST_binary *ne;
typedef struct AST_binary *bitand;
typedef struct AST_binary *bitor;
typedef struct AST_binary *bitxor;
typedef struct AST_binary *andand;
typedef struct AST_binary *oror;
typedef struct AST_binary *assign;
typedef struct AST_binary *plus_assign;
typedef struct AST_binary *minus_assign;
typedef struct AST_binary *times_assign;
typedef struct AST_binary *divide_assign;
typedef struct AST_binary *modulo_assign;
typedef struct AST_binary *lshift_assign;
typedef struct AST_binary *rshift_assign;
typedef struct AST_binary *bitand_assign;
typedef struct AST_binary *bitor_assign;
typedef struct AST_binary *bitxor_assign;
typedef enum {
  kind_error_decl = nil,
  postkind_error_decl = nil,
  kind_struct_ref = nil,
  postkind_struct_ref = nil,
  kind_union_ref = nil,
  postkind_union_ref = nil,
  kind_enum_ref = nil,
  postkind_enum_ref = nil,
  kind_error_stmt = nil,
  postkind_error_stmt = nil,
  kind_while_stmt = nil,
  postkind_while_stmt = nil,
  kind_dowhile_stmt = nil,
  postkind_dowhile_stmt = nil,
  kind_error_expr = nil,
  postkind_error_expr = nil,
  kind_dereference = nil,
  postkind_dereference = nil,
  kind_extension_expr = nil,
  postkind_extension_expr = nil,
  kind_sizeof_expr = nil,
  postkind_sizeof_expr = nil,
  kind_alignof_expr = nil,
  postkind_alignof_expr = nil,
  kind_realpart = nil,
  postkind_realpart = nil,
  kind_imagpart = nil,
  postkind_imagpart = nil,
  kind_address_of = nil,
  postkind_address_of = nil,
  kind_unary_minus = nil,
  postkind_unary_minus = nil,
  kind_unary_plus = nil,
  postkind_unary_plus = nil,
  kind_conjugate = nil,
  postkind_conjugate = nil,
  kind_preincrement = nil,
  postkind_preincrement = nil,
  kind_predecrement = nil,
  postkind_predecrement = nil,
  kind_postincrement = nil,
  postkind_postincrement = nil,
  kind_postdecrement = nil,
  postkind_postdecrement = nil,
  kind_bitnot = nil,
  postkind_bitnot = nil,
  kind_not = nil,
  postkind_not = nil,
  kind_plus = nil,
  postkind_plus = nil,
  kind_minus = nil,
  postkind_minus = nil,
  kind_times = nil,
  postkind_times = nil,
  kind_divide = nil,
  postkind_divide = nil,
  kind_modulo = nil,
  postkind_modulo = nil,
  kind_lshift = nil,
  postkind_lshift = nil,
  kind_rshift = nil,
  postkind_rshift = nil,
  kind_leq = nil,
  postkind_leq = nil,
  kind_geq = nil,
  postkind_geq = nil,
  kind_lt = nil,
  postkind_lt = nil,
  kind_gt = nil,
  postkind_gt = nil,
  kind_eq = nil,
  postkind_eq = nil,
  kind_ne = nil,
  postkind_ne = nil,
  kind_bitand = nil,
  postkind_bitand = nil,
  kind_bitor = nil,
  postkind_bitor = nil,
  kind_bitxor = nil,
  postkind_bitxor = nil,
  kind_andand = nil,
  postkind_andand = nil,
  kind_oror = nil,
  postkind_oror = nil,
  kind_assign = nil,
  postkind_assign = nil,
  kind_plus_assign = nil,
  postkind_plus_assign = nil,
  kind_minus_assign = nil,
  postkind_minus_assign = nil,
  kind_times_assign = nil,
  postkind_times_assign = nil,
  kind_divide_assign = nil,
  postkind_divide_assign = nil,
  kind_modulo_assign = nil,
  postkind_modulo_assign = nil,
  kind_lshift_assign = nil,
  postkind_lshift_assign = nil,
  kind_rshift_assign = nil,
  postkind_rshift_assign = nil,
  kind_bitand_assign = nil,
  postkind_bitand_assign = nil,
  kind_bitor_assign = nil,
  postkind_bitor_assign = nil,
  kind_bitxor_assign = nil,
  postkind_bitxor_assign = nil
} ast_kind;
#define is_error_decl(x) ((x)->kind >= kind_error_decl && (x)->kind <= postkind_error_decl)
#define is_struct_ref(x) ((x)->kind >= kind_struct_ref && (x)->kind <= postkind_struct_ref)
#define is_union_ref(x) ((x)->kind >= kind_union_ref && (x)->kind <= postkind_union_ref)
#define is_enum_ref(x) ((x)->kind >= kind_enum_ref && (x)->kind <= postkind_enum_ref)
#define is_error_stmt(x) ((x)->kind >= kind_error_stmt && (x)->kind <= postkind_error_stmt)
#define is_while_stmt(x) ((x)->kind >= kind_while_stmt && (x)->kind <= postkind_while_stmt)
#define is_dowhile_stmt(x) ((x)->kind >= kind_dowhile_stmt && (x)->kind <= postkind_dowhile_stmt)
#define is_error_expr(x) ((x)->kind >= kind_error_expr && (x)->kind <= postkind_error_expr)
#define is_dereference(x) ((x)->kind >= kind_dereference && (x)->kind <= postkind_dereference)
#define is_extension_expr(x) ((x)->kind >= kind_extension_expr && (x)->kind <= postkind_extension_expr)
#define is_sizeof_expr(x) ((x)->kind >= kind_sizeof_expr && (x)->kind <= postkind_sizeof_expr)
#define is_alignof_expr(x) ((x)->kind >= kind_alignof_expr && (x)->kind <= postkind_alignof_expr)
#define is_realpart(x) ((x)->kind >= kind_realpart && (x)->kind <= postkind_realpart)
#define is_imagpart(x) ((x)->kind >= kind_imagpart && (x)->kind <= postkind_imagpart)
#define is_address_of(x) ((x)->kind >= kind_address_of && (x)->kind <= postkind_address_of)
#define is_unary_minus(x) ((x)->kind >= kind_unary_minus && (x)->kind <= postkind_unary_minus)
#define is_unary_plus(x) ((x)->kind >= kind_unary_plus && (x)->kind <= postkind_unary_plus)
#define is_conjugate(x) ((x)->kind >= kind_conjugate && (x)->kind <= postkind_conjugate)
#define is_preincrement(x) ((x)->kind >= kind_preincrement && (x)->kind <= postkind_preincrement)
#define is_predecrement(x) ((x)->kind >= kind_predecrement && (x)->kind <= postkind_predecrement)
#define is_postincrement(x) ((x)->kind >= kind_postincrement && (x)->kind <= postkind_postincrement)
#define is_postdecrement(x) ((x)->kind >= kind_postdecrement && (x)->kind <= postkind_postdecrement)
#define is_bitnot(x) ((x)->kind >= kind_bitnot && (x)->kind <= postkind_bitnot)
#define is_not(x) ((x)->kind >= kind_not && (x)->kind <= postkind_not)
#define is_plus(x) ((x)->kind >= kind_plus && (x)->kind <= postkind_plus)
#define is_minus(x) ((x)->kind >= kind_minus && (x)->kind <= postkind_minus)
#define is_times(x) ((x)->kind >= kind_times && (x)->kind <= postkind_times)
#define is_divide(x) ((x)->kind >= kind_divide && (x)->kind <= postkind_divide)
#define is_modulo(x) ((x)->kind >= kind_modulo && (x)->kind <= postkind_modulo)
#define is_lshift(x) ((x)->kind >= kind_lshift && (x)->kind <= postkind_lshift)
#define is_rshift(x) ((x)->kind >= kind_rshift && (x)->kind <= postkind_rshift)
#define is_leq(x) ((x)->kind >= kind_leq && (x)->kind <= postkind_leq)
#define is_geq(x) ((x)->kind >= kind_geq && (x)->kind <= postkind_geq)
#define is_lt(x) ((x)->kind >= kind_lt && (x)->kind <= postkind_lt)
#define is_gt(x) ((x)->kind >= kind_gt && (x)->kind <= postkind_gt)
#define is_eq(x) ((x)->kind >= kind_eq && (x)->kind <= postkind_eq)
#define is_ne(x) ((x)->kind >= kind_ne && (x)->kind <= postkind_ne)
#define is_bitand(x) ((x)->kind >= kind_bitand && (x)->kind <= postkind_bitand)
#define is_bitor(x) ((x)->kind >= kind_bitor && (x)->kind <= postkind_bitor)
#define is_bitxor(x) ((x)->kind >= kind_bitxor && (x)->kind <= postkind_bitxor)
#define is_andand(x) ((x)->kind >= kind_andand && (x)->kind <= postkind_andand)
#define is_oror(x) ((x)->kind >= kind_oror && (x)->kind <= postkind_oror)
#define is_assign(x) ((x)->kind >= kind_assign && (x)->kind <= postkind_assign)
#define is_plus_assign(x) ((x)->kind >= kind_plus_assign && (x)->kind <= postkind_plus_assign)
#define is_minus_assign(x) ((x)->kind >= kind_minus_assign && (x)->kind <= postkind_minus_assign)
#define is_times_assign(x) ((x)->kind >= kind_times_assign && (x)->kind <= postkind_times_assign)
#define is_divide_assign(x) ((x)->kind >= kind_divide_assign && (x)->kind <= postkind_divide_assign)
#define is_modulo_assign(x) ((x)->kind >= kind_modulo_assign && (x)->kind <= postkind_modulo_assign)
#define is_lshift_assign(x) ((x)->kind >= kind_lshift_assign && (x)->kind <= postkind_lshift_assign)
#define is_rshift_assign(x) ((x)->kind >= kind_rshift_assign && (x)->kind <= postkind_rshift_assign)
#define is_bitand_assign(x) ((x)->kind >= kind_bitand_assign && (x)->kind <= postkind_bitand_assign)
#define is_bitor_assign(x) ((x)->kind >= kind_bitor_assign && (x)->kind <= postkind_bitor_assign)
#define is_bitxor_assign(x) ((x)->kind >= kind_bitxor_assign && (x)->kind <= postkind_bitxor_assign)
#define error_decl_reverse(x) CAST(error_decl, ast_reverse(CAST(node, (x))))
#define struct_ref_reverse(x) CAST(struct_ref, ast_reverse(CAST(node, (x))))
#define union_ref_reverse(x) CAST(union_ref, ast_reverse(CAST(node, (x))))
#define enum_ref_reverse(x) CAST(enum_ref, ast_reverse(CAST(node, (x))))
#define error_stmt_reverse(x) CAST(error_stmt, ast_reverse(CAST(node, (x))))
#define while_stmt_reverse(x) CAST(while_stmt, ast_reverse(CAST(node, (x))))
#define dowhile_stmt_reverse(x) CAST(dowhile_stmt, ast_reverse(CAST(node, (x))))
#define error_expr_reverse(x) CAST(error_expr, ast_reverse(CAST(node, (x))))
#define dereference_reverse(x) CAST(dereference, ast_reverse(CAST(node, (x))))
#define extension_expr_reverse(x) CAST(extension_expr, ast_reverse(CAST(node, (x))))
#define sizeof_expr_reverse(x) CAST(sizeof_expr, ast_reverse(CAST(node, (x))))
#define alignof_expr_reverse(x) CAST(alignof_expr, ast_reverse(CAST(node, (x))))
#define realpart_reverse(x) CAST(realpart, ast_reverse(CAST(node, (x))))
#define imagpart_reverse(x) CAST(imagpart, ast_reverse(CAST(node, (x))))
#define address_of_reverse(x) CAST(address_of, ast_reverse(CAST(node, (x))))
#define unary_minus_reverse(x) CAST(unary_minus, ast_reverse(CAST(node, (x))))
#define unary_plus_reverse(x) CAST(unary_plus, ast_reverse(CAST(node, (x))))
#define conjugate_reverse(x) CAST(conjugate, ast_reverse(CAST(node, (x))))
#define preincrement_reverse(x) CAST(preincrement, ast_reverse(CAST(node, (x))))
#define predecrement_reverse(x) CAST(predecrement, ast_reverse(CAST(node, (x))))
#define postincrement_reverse(x) CAST(postincrement, ast_reverse(CAST(node, (x))))
#define postdecrement_reverse(x) CAST(postdecrement, ast_reverse(CAST(node, (x))))
#define bitnot_reverse(x) CAST(bitnot, ast_reverse(CAST(node, (x))))
#define not_reverse(x) CAST(not, ast_reverse(CAST(node, (x))))
#define plus_reverse(x) CAST(plus, ast_reverse(CAST(node, (x))))
#define minus_reverse(x) CAST(minus, ast_reverse(CAST(node, (x))))
#define times_reverse(x) CAST(times, ast_reverse(CAST(node, (x))))
#define divide_reverse(x) CAST(divide, ast_reverse(CAST(node, (x))))
#define modulo_reverse(x) CAST(modulo, ast_reverse(CAST(node, (x))))
#define lshift_reverse(x) CAST(lshift, ast_reverse(CAST(node, (x))))
#define rshift_reverse(x) CAST(rshift, ast_reverse(CAST(node, (x))))
#define leq_reverse(x) CAST(leq, ast_reverse(CAST(node, (x))))
#define geq_reverse(x) CAST(geq, ast_reverse(CAST(node, (x))))
#define lt_reverse(x) CAST(lt, ast_reverse(CAST(node, (x))))
#define gt_reverse(x) CAST(gt, ast_reverse(CAST(node, (x))))
#define eq_reverse(x) CAST(eq, ast_reverse(CAST(node, (x))))
#define ne_reverse(x) CAST(ne, ast_reverse(CAST(node, (x))))
#define bitand_reverse(x) CAST(bitand, ast_reverse(CAST(node, (x))))
#define bitor_reverse(x) CAST(bitor, ast_reverse(CAST(node, (x))))
#define bitxor_reverse(x) CAST(bitxor, ast_reverse(CAST(node, (x))))
#define andand_reverse(x) CAST(andand, ast_reverse(CAST(node, (x))))
#define oror_reverse(x) CAST(oror, ast_reverse(CAST(node, (x))))
#define assign_reverse(x) CAST(assign, ast_reverse(CAST(node, (x))))
#define plus_assign_reverse(x) CAST(plus_assign, ast_reverse(CAST(node, (x))))
#define minus_assign_reverse(x) CAST(minus_assign, ast_reverse(CAST(node, (x))))
#define times_assign_reverse(x) CAST(times_assign, ast_reverse(CAST(node, (x))))
#define divide_assign_reverse(x) CAST(divide_assign, ast_reverse(CAST(node, (x))))
#define modulo_assign_reverse(x) CAST(modulo_assign, ast_reverse(CAST(node, (x))))
#define lshift_assign_reverse(x) CAST(lshift_assign, ast_reverse(CAST(node, (x))))
#define rshift_assign_reverse(x) CAST(rshift_assign, ast_reverse(CAST(node, (x))))
#define bitand_assign_reverse(x) CAST(bitand_assign, ast_reverse(CAST(node, (x))))
#define bitor_assign_reverse(x) CAST(bitor_assign, ast_reverse(CAST(node, (x))))
#define bitxor_assign_reverse(x) CAST(bitxor_assign, ast_reverse(CAST(node, (x))))
