isl-rs 0.3.1

// Automatically generated by isl_bindings_generator.
// LICENSE: MIT

use super::{
    ASTExprList, ASTExprOpType, ASTExprType, Context, Error, Id, IdToASTExpr, LibISLError, Printer,
    Val,
};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_ast_expr`.
pub struct ASTExpr {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_ast_expr_access(array: uintptr_t, indices: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_add(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_address_of(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_and(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_and_then(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_call(function: uintptr_t, arguments: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_copy(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_div(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_dump(expr: uintptr_t) -> ();

    fn isl_ast_expr_eq(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_free(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_from_id(id: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_from_val(v: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_ge(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_get_ctx(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_get_id(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_get_op_arg(expr: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_ast_expr_get_op_n_arg(expr: uintptr_t) -> i32;

    fn isl_ast_expr_get_op_type(expr: uintptr_t) -> i32;

    fn isl_ast_expr_get_type(expr: uintptr_t) -> i32;

    fn isl_ast_expr_get_val(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_gt(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_id_get_id(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_int_get_val(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_is_equal(expr1: uintptr_t, expr2: uintptr_t) -> i32;

    fn isl_ast_expr_le(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_lt(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_mul(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_neg(expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_op_get_arg(expr: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_ast_expr_op_get_n_arg(expr: uintptr_t) -> i32;

    fn isl_ast_expr_op_get_type(expr: uintptr_t) -> i32;

    fn isl_ast_expr_op_type_print_macro(type_: i32, p: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_op_type_set_print_name(p: uintptr_t, type_: i32, name: *const c_char)
                                           -> uintptr_t;

    fn isl_ast_expr_or(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_or_else(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_pdiv_q(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_pdiv_r(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_print_macros(expr: uintptr_t, p: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_set_op_arg(expr: uintptr_t, pos: i32, arg: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_sub(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_substitute_ids(expr: uintptr_t, id2expr: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_to_C_str(expr: uintptr_t) -> *const c_char;

    fn isl_ast_expr_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_to_str(expr: uintptr_t) -> *const c_char;

}

impl ASTExpr {
    /// Wraps `isl_ast_expr_access`.
    pub fn access(self, indices: ASTExprList) -> Result<ASTExpr, LibISLError> {
        let array = self;
        let isl_rs_ctx = array.get_ctx();
        let mut array = array;
        array.do_not_free_on_drop();
        let array = array.ptr;
        let mut indices = indices;
        indices.do_not_free_on_drop();
        let indices = indices.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_access(array, indices) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_add`.
    pub fn add(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_add(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_address_of`.
    pub fn address_of(self) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let mut expr = expr;
        expr.do_not_free_on_drop();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_address_of(expr) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_and`.
    pub fn and(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_and(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_and_then`.
    pub fn and_then(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_and_then(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_call`.
    pub fn call(self, arguments: ASTExprList) -> Result<ASTExpr, LibISLError> {
        let function = self;
        let isl_rs_ctx = function.get_ctx();
        let mut function = function;
        function.do_not_free_on_drop();
        let function = function.ptr;
        let mut arguments = arguments;
        arguments.do_not_free_on_drop();
        let arguments = arguments.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_call(function, arguments) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_copy`.
    pub fn copy(&self) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_copy(expr) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_div`.
    pub fn div(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_div(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_dump(expr) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_eq`.
    pub fn eq(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_eq(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_free`.
    pub fn free(self) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let mut expr = expr;
        expr.do_not_free_on_drop();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_free(expr) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_from_id`.
    pub fn from_id(id: Id) -> Result<ASTExpr, LibISLError> {
        let isl_rs_ctx = id.get_ctx();
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_from_id(id) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_from_val`.
    pub fn from_val(v: Val) -> Result<ASTExpr, LibISLError> {
        let isl_rs_ctx = v.get_ctx();
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_from_val(v) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_ge`.
    pub fn ge(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_ge(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let expr = self;
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_ctx(expr) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_ast_expr_get_id`.
    pub fn get_id(&self) -> Result<Id, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_id(expr) };
        let isl_rs_result = Id { ptr: isl_rs_result,
                                 should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_op_arg`.
    pub fn get_op_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_op_arg(expr, pos) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_op_n_arg`.
    pub fn get_op_n_arg(&self) -> Result<i32, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_op_n_arg(expr) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_op_type`.
    pub fn get_op_type(&self) -> Result<ASTExprOpType, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_op_type(expr) };
        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_type`.
    pub fn get_type(&self) -> Result<ASTExprType, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_type(expr) };
        let isl_rs_result = ASTExprType::from_i32(isl_rs_result);
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_get_val`.
    pub fn get_val(&self) -> Result<Val, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_get_val(expr) };
        let isl_rs_result = Val { ptr: isl_rs_result,
                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_gt`.
    pub fn gt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_gt(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_id_get_id`.
    pub fn id_get_id(&self) -> Result<Id, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_id_get_id(expr) };
        let isl_rs_result = Id { ptr: isl_rs_result,
                                 should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_int_get_val`.
    pub fn int_get_val(&self) -> Result<Val, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_int_get_val(expr) };
        let isl_rs_result = Val { ptr: isl_rs_result,
                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_is_equal`.
    pub fn is_equal(&self, expr2: &ASTExpr) -> Result<bool, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let expr1 = expr1.ptr;
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_is_equal(expr1, expr2) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_le`.
    pub fn le(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_le(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_lt`.
    pub fn lt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_lt(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_mul`.
    pub fn mul(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_mul(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_neg`.
    pub fn neg(self) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let mut expr = expr;
        expr.do_not_free_on_drop();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_neg(expr) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_op_get_arg`.
    pub fn op_get_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_op_get_arg(expr, pos) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_op_get_n_arg`.
    pub fn op_get_n_arg(&self) -> Result<i32, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_op_get_n_arg(expr) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_op_get_type`.
    pub fn op_get_type(&self) -> Result<ASTExprOpType, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_op_get_type(expr) };
        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_op_type_print_macro`.
    pub fn op_type_print_macro(type_: ASTExprOpType, p: Printer) -> Result<Printer, LibISLError> {
        let isl_rs_ctx = p.get_ctx();
        let type_ = type_.to_i32();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_op_type_print_macro(type_, p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_op_type_set_print_name`.
    pub fn op_type_set_print_name(p: Printer, type_: ASTExprOpType, name: &str)
                                  -> Result<Printer, LibISLError> {
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let type_ = type_.to_i32();
        let name = CString::new(name).unwrap();
        let name = name.as_ptr();
        let isl_rs_result = unsafe { isl_ast_expr_op_type_set_print_name(p, type_, name) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_or`.
    pub fn or(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_or(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_or_else`.
    pub fn or_else(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_or_else(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_pdiv_q`.
    pub fn pdiv_q(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_pdiv_q(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_pdiv_r`.
    pub fn pdiv_r(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_pdiv_r(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_print_macros`.
    pub fn print_macros(&self, p: Printer) -> Result<Printer, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_print_macros(expr, p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_set_op_arg`.
    pub fn set_op_arg(self, pos: i32, arg: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let mut expr = expr;
        expr.do_not_free_on_drop();
        let expr = expr.ptr;
        let mut arg = arg;
        arg.do_not_free_on_drop();
        let arg = arg.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_set_op_arg(expr, pos, arg) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_sub`.
    pub fn sub(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr1 = self;
        let isl_rs_ctx = expr1.get_ctx();
        let mut expr1 = expr1;
        expr1.do_not_free_on_drop();
        let expr1 = expr1.ptr;
        let mut expr2 = expr2;
        expr2.do_not_free_on_drop();
        let expr2 = expr2.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_sub(expr1, expr2) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_substitute_ids`.
    pub fn substitute_ids(self, id2expr: IdToASTExpr) -> Result<ASTExpr, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let mut expr = expr;
        expr.do_not_free_on_drop();
        let expr = expr.ptr;
        let mut id2expr = id2expr;
        id2expr.do_not_free_on_drop();
        let id2expr = id2expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_substitute_ids(expr, id2expr) };
        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_to_C_str`.
    pub fn to_C_str(&self) -> Result<&str, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_to_C_str(expr) };
        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
        let isl_rs_result = isl_rs_result.to_str().unwrap();
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_to_list`.
    pub fn to_list(self) -> Result<ASTExprList, LibISLError> {
        let el = self;
        let isl_rs_ctx = el.get_ctx();
        let mut el = el;
        el.do_not_free_on_drop();
        let el = el.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_to_list(el) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let expr = self;
        let isl_rs_ctx = expr.get_ctx();
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_to_str(expr) };
        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
        let isl_rs_result = isl_rs_result.to_str().unwrap();
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Does not call isl_ast_expr_free() on being dropped. (For internal use
    /// only.)
    pub fn do_not_free_on_drop(&mut self) {
        self.should_free_on_drop = false;
    }
}

impl Drop for ASTExpr {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_ast_expr_free(self.ptr);
            }
        }
    }
}