isl_rs/bindings/
ast_expr.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    ASTExprList, ASTExprOpType, ASTExprType, Context, Error, Id, IdToASTExpr, LibISLError, Printer,
6    Val,
7};
8use libc::uintptr_t;
9use std::ffi::{CStr, CString};
10use std::os::raw::c_char;
11
12/// Wraps `isl_ast_expr`.
13pub struct ASTExpr {
14    pub ptr: uintptr_t,
15    pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20    fn isl_ast_expr_access(array: uintptr_t, indices: uintptr_t) -> uintptr_t;
21
22    fn isl_ast_expr_add(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
23
24    fn isl_ast_expr_address_of(expr: uintptr_t) -> uintptr_t;
25
26    fn isl_ast_expr_and(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
27
28    fn isl_ast_expr_and_then(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
29
30    fn isl_ast_expr_call(function: uintptr_t, arguments: uintptr_t) -> uintptr_t;
31
32    fn isl_ast_expr_copy(expr: uintptr_t) -> uintptr_t;
33
34    fn isl_ast_expr_div(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
35
36    fn isl_ast_expr_dump(expr: uintptr_t) -> ();
37
38    fn isl_ast_expr_eq(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
39
40    fn isl_ast_expr_free(expr: uintptr_t) -> uintptr_t;
41
42    fn isl_ast_expr_from_id(id: uintptr_t) -> uintptr_t;
43
44    fn isl_ast_expr_from_val(v: uintptr_t) -> uintptr_t;
45
46    fn isl_ast_expr_ge(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
47
48    fn isl_ast_expr_get_ctx(expr: uintptr_t) -> uintptr_t;
49
50    fn isl_ast_expr_get_id(expr: uintptr_t) -> uintptr_t;
51
52    fn isl_ast_expr_get_op_arg(expr: uintptr_t, pos: i32) -> uintptr_t;
53
54    fn isl_ast_expr_get_op_n_arg(expr: uintptr_t) -> i32;
55
56    fn isl_ast_expr_get_op_type(expr: uintptr_t) -> i32;
57
58    fn isl_ast_expr_get_type(expr: uintptr_t) -> i32;
59
60    fn isl_ast_expr_get_val(expr: uintptr_t) -> uintptr_t;
61
62    fn isl_ast_expr_gt(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
63
64    fn isl_ast_expr_id_get_id(expr: uintptr_t) -> uintptr_t;
65
66    fn isl_ast_expr_int_get_val(expr: uintptr_t) -> uintptr_t;
67
68    fn isl_ast_expr_is_equal(expr1: uintptr_t, expr2: uintptr_t) -> i32;
69
70    fn isl_ast_expr_le(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
71
72    fn isl_ast_expr_lt(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
73
74    fn isl_ast_expr_mul(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
75
76    fn isl_ast_expr_neg(expr: uintptr_t) -> uintptr_t;
77
78    fn isl_ast_expr_op_get_arg(expr: uintptr_t, pos: i32) -> uintptr_t;
79
80    fn isl_ast_expr_op_get_n_arg(expr: uintptr_t) -> i32;
81
82    fn isl_ast_expr_op_get_type(expr: uintptr_t) -> i32;
83
84    fn isl_ast_expr_op_type_print_macro(type_: i32, p: uintptr_t) -> uintptr_t;
85
86    fn isl_ast_expr_op_type_set_print_name(p: uintptr_t, type_: i32, name: *const c_char)
87                                           -> uintptr_t;
88
89    fn isl_ast_expr_or(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
90
91    fn isl_ast_expr_or_else(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
92
93    fn isl_ast_expr_pdiv_q(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
94
95    fn isl_ast_expr_pdiv_r(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
96
97    fn isl_ast_expr_print_macros(expr: uintptr_t, p: uintptr_t) -> uintptr_t;
98
99    fn isl_ast_expr_set_op_arg(expr: uintptr_t, pos: i32, arg: uintptr_t) -> uintptr_t;
100
101    fn isl_ast_expr_sub(expr1: uintptr_t, expr2: uintptr_t) -> uintptr_t;
102
103    fn isl_ast_expr_substitute_ids(expr: uintptr_t, id2expr: uintptr_t) -> uintptr_t;
104
105    fn isl_ast_expr_to_C_str(expr: uintptr_t) -> *const c_char;
106
107    fn isl_ast_expr_to_list(el: uintptr_t) -> uintptr_t;
108
109    fn isl_ast_expr_to_str(expr: uintptr_t) -> *const c_char;
110
111}
112
113impl ASTExpr {
114    /// Wraps `isl_ast_expr_access`.
115    pub fn access(self, indices: ASTExprList) -> Result<ASTExpr, LibISLError> {
116        let array = self;
117        let isl_rs_ctx = array.get_ctx();
118        let mut array = array;
119        array.do_not_free_on_drop();
120        let array = array.ptr;
121        let mut indices = indices;
122        indices.do_not_free_on_drop();
123        let indices = indices.ptr;
124        let isl_rs_result = unsafe { isl_ast_expr_access(array, indices) };
125        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
126                                      should_free_on_drop: true };
127        let err = isl_rs_ctx.last_error();
128        if err != Error::None_ {
129            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
130        }
131        Ok(isl_rs_result)
132    }
133
134    /// Wraps `isl_ast_expr_add`.
135    pub fn add(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
136        let expr1 = self;
137        let isl_rs_ctx = expr1.get_ctx();
138        let mut expr1 = expr1;
139        expr1.do_not_free_on_drop();
140        let expr1 = expr1.ptr;
141        let mut expr2 = expr2;
142        expr2.do_not_free_on_drop();
143        let expr2 = expr2.ptr;
144        let isl_rs_result = unsafe { isl_ast_expr_add(expr1, expr2) };
145        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
146                                      should_free_on_drop: true };
147        let err = isl_rs_ctx.last_error();
148        if err != Error::None_ {
149            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
150        }
151        Ok(isl_rs_result)
152    }
153
154    /// Wraps `isl_ast_expr_address_of`.
155    pub fn address_of(self) -> Result<ASTExpr, LibISLError> {
156        let expr = self;
157        let isl_rs_ctx = expr.get_ctx();
158        let mut expr = expr;
159        expr.do_not_free_on_drop();
160        let expr = expr.ptr;
161        let isl_rs_result = unsafe { isl_ast_expr_address_of(expr) };
162        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
163                                      should_free_on_drop: true };
164        let err = isl_rs_ctx.last_error();
165        if err != Error::None_ {
166            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
167        }
168        Ok(isl_rs_result)
169    }
170
171    /// Wraps `isl_ast_expr_and`.
172    pub fn and(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
173        let expr1 = self;
174        let isl_rs_ctx = expr1.get_ctx();
175        let mut expr1 = expr1;
176        expr1.do_not_free_on_drop();
177        let expr1 = expr1.ptr;
178        let mut expr2 = expr2;
179        expr2.do_not_free_on_drop();
180        let expr2 = expr2.ptr;
181        let isl_rs_result = unsafe { isl_ast_expr_and(expr1, expr2) };
182        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
183                                      should_free_on_drop: true };
184        let err = isl_rs_ctx.last_error();
185        if err != Error::None_ {
186            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
187        }
188        Ok(isl_rs_result)
189    }
190
191    /// Wraps `isl_ast_expr_and_then`.
192    pub fn and_then(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
193        let expr1 = self;
194        let isl_rs_ctx = expr1.get_ctx();
195        let mut expr1 = expr1;
196        expr1.do_not_free_on_drop();
197        let expr1 = expr1.ptr;
198        let mut expr2 = expr2;
199        expr2.do_not_free_on_drop();
200        let expr2 = expr2.ptr;
201        let isl_rs_result = unsafe { isl_ast_expr_and_then(expr1, expr2) };
202        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
203                                      should_free_on_drop: true };
204        let err = isl_rs_ctx.last_error();
205        if err != Error::None_ {
206            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
207        }
208        Ok(isl_rs_result)
209    }
210
211    /// Wraps `isl_ast_expr_call`.
212    pub fn call(self, arguments: ASTExprList) -> Result<ASTExpr, LibISLError> {
213        let function = self;
214        let isl_rs_ctx = function.get_ctx();
215        let mut function = function;
216        function.do_not_free_on_drop();
217        let function = function.ptr;
218        let mut arguments = arguments;
219        arguments.do_not_free_on_drop();
220        let arguments = arguments.ptr;
221        let isl_rs_result = unsafe { isl_ast_expr_call(function, arguments) };
222        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
223                                      should_free_on_drop: true };
224        let err = isl_rs_ctx.last_error();
225        if err != Error::None_ {
226            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
227        }
228        Ok(isl_rs_result)
229    }
230
231    /// Wraps `isl_ast_expr_copy`.
232    pub fn copy(&self) -> Result<ASTExpr, LibISLError> {
233        let expr = self;
234        let isl_rs_ctx = expr.get_ctx();
235        let expr = expr.ptr;
236        let isl_rs_result = unsafe { isl_ast_expr_copy(expr) };
237        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
238                                      should_free_on_drop: true };
239        let err = isl_rs_ctx.last_error();
240        if err != Error::None_ {
241            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
242        }
243        Ok(isl_rs_result)
244    }
245
246    /// Wraps `isl_ast_expr_div`.
247    pub fn div(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
248        let expr1 = self;
249        let isl_rs_ctx = expr1.get_ctx();
250        let mut expr1 = expr1;
251        expr1.do_not_free_on_drop();
252        let expr1 = expr1.ptr;
253        let mut expr2 = expr2;
254        expr2.do_not_free_on_drop();
255        let expr2 = expr2.ptr;
256        let isl_rs_result = unsafe { isl_ast_expr_div(expr1, expr2) };
257        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
258                                      should_free_on_drop: true };
259        let err = isl_rs_ctx.last_error();
260        if err != Error::None_ {
261            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
262        }
263        Ok(isl_rs_result)
264    }
265
266    /// Wraps `isl_ast_expr_dump`.
267    pub fn dump(&self) -> Result<(), LibISLError> {
268        let expr = self;
269        let isl_rs_ctx = expr.get_ctx();
270        let expr = expr.ptr;
271        let isl_rs_result = unsafe { isl_ast_expr_dump(expr) };
272        let err = isl_rs_ctx.last_error();
273        if err != Error::None_ {
274            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
275        }
276        Ok(isl_rs_result)
277    }
278
279    /// Wraps `isl_ast_expr_eq`.
280    pub fn eq(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
281        let expr1 = self;
282        let isl_rs_ctx = expr1.get_ctx();
283        let mut expr1 = expr1;
284        expr1.do_not_free_on_drop();
285        let expr1 = expr1.ptr;
286        let mut expr2 = expr2;
287        expr2.do_not_free_on_drop();
288        let expr2 = expr2.ptr;
289        let isl_rs_result = unsafe { isl_ast_expr_eq(expr1, expr2) };
290        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
291                                      should_free_on_drop: true };
292        let err = isl_rs_ctx.last_error();
293        if err != Error::None_ {
294            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
295        }
296        Ok(isl_rs_result)
297    }
298
299    /// Wraps `isl_ast_expr_free`.
300    pub fn free(self) -> Result<ASTExpr, LibISLError> {
301        let expr = self;
302        let isl_rs_ctx = expr.get_ctx();
303        let mut expr = expr;
304        expr.do_not_free_on_drop();
305        let expr = expr.ptr;
306        let isl_rs_result = unsafe { isl_ast_expr_free(expr) };
307        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
308                                      should_free_on_drop: true };
309        let err = isl_rs_ctx.last_error();
310        if err != Error::None_ {
311            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
312        }
313        Ok(isl_rs_result)
314    }
315
316    /// Wraps `isl_ast_expr_from_id`.
317    pub fn from_id(id: Id) -> Result<ASTExpr, LibISLError> {
318        let isl_rs_ctx = id.get_ctx();
319        let mut id = id;
320        id.do_not_free_on_drop();
321        let id = id.ptr;
322        let isl_rs_result = unsafe { isl_ast_expr_from_id(id) };
323        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
324                                      should_free_on_drop: true };
325        let err = isl_rs_ctx.last_error();
326        if err != Error::None_ {
327            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
328        }
329        Ok(isl_rs_result)
330    }
331
332    /// Wraps `isl_ast_expr_from_val`.
333    pub fn from_val(v: Val) -> Result<ASTExpr, LibISLError> {
334        let isl_rs_ctx = v.get_ctx();
335        let mut v = v;
336        v.do_not_free_on_drop();
337        let v = v.ptr;
338        let isl_rs_result = unsafe { isl_ast_expr_from_val(v) };
339        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
340                                      should_free_on_drop: true };
341        let err = isl_rs_ctx.last_error();
342        if err != Error::None_ {
343            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
344        }
345        Ok(isl_rs_result)
346    }
347
348    /// Wraps `isl_ast_expr_ge`.
349    pub fn ge(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
350        let expr1 = self;
351        let isl_rs_ctx = expr1.get_ctx();
352        let mut expr1 = expr1;
353        expr1.do_not_free_on_drop();
354        let expr1 = expr1.ptr;
355        let mut expr2 = expr2;
356        expr2.do_not_free_on_drop();
357        let expr2 = expr2.ptr;
358        let isl_rs_result = unsafe { isl_ast_expr_ge(expr1, expr2) };
359        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
360                                      should_free_on_drop: true };
361        let err = isl_rs_ctx.last_error();
362        if err != Error::None_ {
363            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
364        }
365        Ok(isl_rs_result)
366    }
367
368    /// Wraps `isl_ast_expr_get_ctx`.
369    pub fn get_ctx(&self) -> Context {
370        let expr = self;
371        let expr = expr.ptr;
372        let isl_rs_result = unsafe { isl_ast_expr_get_ctx(expr) };
373        let isl_rs_result = Context { ptr: isl_rs_result,
374                                      should_free_on_drop: false };
375        isl_rs_result
376    }
377
378    /// Wraps `isl_ast_expr_get_id`.
379    pub fn get_id(&self) -> Result<Id, LibISLError> {
380        let expr = self;
381        let isl_rs_ctx = expr.get_ctx();
382        let expr = expr.ptr;
383        let isl_rs_result = unsafe { isl_ast_expr_get_id(expr) };
384        let isl_rs_result = Id { ptr: isl_rs_result,
385                                 should_free_on_drop: true };
386        let err = isl_rs_ctx.last_error();
387        if err != Error::None_ {
388            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
389        }
390        Ok(isl_rs_result)
391    }
392
393    /// Wraps `isl_ast_expr_get_op_arg`.
394    pub fn get_op_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
395        let expr = self;
396        let isl_rs_ctx = expr.get_ctx();
397        let expr = expr.ptr;
398        let isl_rs_result = unsafe { isl_ast_expr_get_op_arg(expr, pos) };
399        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
400                                      should_free_on_drop: true };
401        let err = isl_rs_ctx.last_error();
402        if err != Error::None_ {
403            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
404        }
405        Ok(isl_rs_result)
406    }
407
408    /// Wraps `isl_ast_expr_get_op_n_arg`.
409    pub fn get_op_n_arg(&self) -> Result<i32, LibISLError> {
410        let expr = self;
411        let isl_rs_ctx = expr.get_ctx();
412        let expr = expr.ptr;
413        let isl_rs_result = unsafe { isl_ast_expr_get_op_n_arg(expr) };
414        let err = isl_rs_ctx.last_error();
415        if err != Error::None_ {
416            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
417        }
418        Ok(isl_rs_result)
419    }
420
421    /// Wraps `isl_ast_expr_get_op_type`.
422    pub fn get_op_type(&self) -> Result<ASTExprOpType, LibISLError> {
423        let expr = self;
424        let isl_rs_ctx = expr.get_ctx();
425        let expr = expr.ptr;
426        let isl_rs_result = unsafe { isl_ast_expr_get_op_type(expr) };
427        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
428        let err = isl_rs_ctx.last_error();
429        if err != Error::None_ {
430            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
431        }
432        Ok(isl_rs_result)
433    }
434
435    /// Wraps `isl_ast_expr_get_type`.
436    pub fn get_type(&self) -> Result<ASTExprType, LibISLError> {
437        let expr = self;
438        let isl_rs_ctx = expr.get_ctx();
439        let expr = expr.ptr;
440        let isl_rs_result = unsafe { isl_ast_expr_get_type(expr) };
441        let isl_rs_result = ASTExprType::from_i32(isl_rs_result);
442        let err = isl_rs_ctx.last_error();
443        if err != Error::None_ {
444            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
445        }
446        Ok(isl_rs_result)
447    }
448
449    /// Wraps `isl_ast_expr_get_val`.
450    pub fn get_val(&self) -> Result<Val, LibISLError> {
451        let expr = self;
452        let isl_rs_ctx = expr.get_ctx();
453        let expr = expr.ptr;
454        let isl_rs_result = unsafe { isl_ast_expr_get_val(expr) };
455        let isl_rs_result = Val { ptr: isl_rs_result,
456                                  should_free_on_drop: true };
457        let err = isl_rs_ctx.last_error();
458        if err != Error::None_ {
459            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
460        }
461        Ok(isl_rs_result)
462    }
463
464    /// Wraps `isl_ast_expr_gt`.
465    pub fn gt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
466        let expr1 = self;
467        let isl_rs_ctx = expr1.get_ctx();
468        let mut expr1 = expr1;
469        expr1.do_not_free_on_drop();
470        let expr1 = expr1.ptr;
471        let mut expr2 = expr2;
472        expr2.do_not_free_on_drop();
473        let expr2 = expr2.ptr;
474        let isl_rs_result = unsafe { isl_ast_expr_gt(expr1, expr2) };
475        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
476                                      should_free_on_drop: true };
477        let err = isl_rs_ctx.last_error();
478        if err != Error::None_ {
479            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
480        }
481        Ok(isl_rs_result)
482    }
483
484    /// Wraps `isl_ast_expr_id_get_id`.
485    pub fn id_get_id(&self) -> Result<Id, LibISLError> {
486        let expr = self;
487        let isl_rs_ctx = expr.get_ctx();
488        let expr = expr.ptr;
489        let isl_rs_result = unsafe { isl_ast_expr_id_get_id(expr) };
490        let isl_rs_result = Id { ptr: isl_rs_result,
491                                 should_free_on_drop: true };
492        let err = isl_rs_ctx.last_error();
493        if err != Error::None_ {
494            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
495        }
496        Ok(isl_rs_result)
497    }
498
499    /// Wraps `isl_ast_expr_int_get_val`.
500    pub fn int_get_val(&self) -> Result<Val, LibISLError> {
501        let expr = self;
502        let isl_rs_ctx = expr.get_ctx();
503        let expr = expr.ptr;
504        let isl_rs_result = unsafe { isl_ast_expr_int_get_val(expr) };
505        let isl_rs_result = Val { ptr: isl_rs_result,
506                                  should_free_on_drop: true };
507        let err = isl_rs_ctx.last_error();
508        if err != Error::None_ {
509            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
510        }
511        Ok(isl_rs_result)
512    }
513
514    /// Wraps `isl_ast_expr_is_equal`.
515    pub fn is_equal(&self, expr2: &ASTExpr) -> Result<bool, LibISLError> {
516        let expr1 = self;
517        let isl_rs_ctx = expr1.get_ctx();
518        let expr1 = expr1.ptr;
519        let expr2 = expr2.ptr;
520        let isl_rs_result = unsafe { isl_ast_expr_is_equal(expr1, expr2) };
521        let isl_rs_result = match isl_rs_result {
522            0 => false,
523            1 => true,
524            _ => panic!("Got isl_bool = -1"),
525        };
526        let err = isl_rs_ctx.last_error();
527        if err != Error::None_ {
528            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
529        }
530        Ok(isl_rs_result)
531    }
532
533    /// Wraps `isl_ast_expr_le`.
534    pub fn le(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
535        let expr1 = self;
536        let isl_rs_ctx = expr1.get_ctx();
537        let mut expr1 = expr1;
538        expr1.do_not_free_on_drop();
539        let expr1 = expr1.ptr;
540        let mut expr2 = expr2;
541        expr2.do_not_free_on_drop();
542        let expr2 = expr2.ptr;
543        let isl_rs_result = unsafe { isl_ast_expr_le(expr1, expr2) };
544        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
545                                      should_free_on_drop: true };
546        let err = isl_rs_ctx.last_error();
547        if err != Error::None_ {
548            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
549        }
550        Ok(isl_rs_result)
551    }
552
553    /// Wraps `isl_ast_expr_lt`.
554    pub fn lt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
555        let expr1 = self;
556        let isl_rs_ctx = expr1.get_ctx();
557        let mut expr1 = expr1;
558        expr1.do_not_free_on_drop();
559        let expr1 = expr1.ptr;
560        let mut expr2 = expr2;
561        expr2.do_not_free_on_drop();
562        let expr2 = expr2.ptr;
563        let isl_rs_result = unsafe { isl_ast_expr_lt(expr1, expr2) };
564        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
565                                      should_free_on_drop: true };
566        let err = isl_rs_ctx.last_error();
567        if err != Error::None_ {
568            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
569        }
570        Ok(isl_rs_result)
571    }
572
573    /// Wraps `isl_ast_expr_mul`.
574    pub fn mul(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
575        let expr1 = self;
576        let isl_rs_ctx = expr1.get_ctx();
577        let mut expr1 = expr1;
578        expr1.do_not_free_on_drop();
579        let expr1 = expr1.ptr;
580        let mut expr2 = expr2;
581        expr2.do_not_free_on_drop();
582        let expr2 = expr2.ptr;
583        let isl_rs_result = unsafe { isl_ast_expr_mul(expr1, expr2) };
584        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
585                                      should_free_on_drop: true };
586        let err = isl_rs_ctx.last_error();
587        if err != Error::None_ {
588            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
589        }
590        Ok(isl_rs_result)
591    }
592
593    /// Wraps `isl_ast_expr_neg`.
594    pub fn neg(self) -> Result<ASTExpr, LibISLError> {
595        let expr = self;
596        let isl_rs_ctx = expr.get_ctx();
597        let mut expr = expr;
598        expr.do_not_free_on_drop();
599        let expr = expr.ptr;
600        let isl_rs_result = unsafe { isl_ast_expr_neg(expr) };
601        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
602                                      should_free_on_drop: true };
603        let err = isl_rs_ctx.last_error();
604        if err != Error::None_ {
605            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
606        }
607        Ok(isl_rs_result)
608    }
609
610    /// Wraps `isl_ast_expr_op_get_arg`.
611    pub fn op_get_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
612        let expr = self;
613        let isl_rs_ctx = expr.get_ctx();
614        let expr = expr.ptr;
615        let isl_rs_result = unsafe { isl_ast_expr_op_get_arg(expr, pos) };
616        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
617                                      should_free_on_drop: true };
618        let err = isl_rs_ctx.last_error();
619        if err != Error::None_ {
620            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
621        }
622        Ok(isl_rs_result)
623    }
624
625    /// Wraps `isl_ast_expr_op_get_n_arg`.
626    pub fn op_get_n_arg(&self) -> Result<i32, LibISLError> {
627        let expr = self;
628        let isl_rs_ctx = expr.get_ctx();
629        let expr = expr.ptr;
630        let isl_rs_result = unsafe { isl_ast_expr_op_get_n_arg(expr) };
631        let err = isl_rs_ctx.last_error();
632        if err != Error::None_ {
633            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
634        }
635        Ok(isl_rs_result)
636    }
637
638    /// Wraps `isl_ast_expr_op_get_type`.
639    pub fn op_get_type(&self) -> Result<ASTExprOpType, LibISLError> {
640        let expr = self;
641        let isl_rs_ctx = expr.get_ctx();
642        let expr = expr.ptr;
643        let isl_rs_result = unsafe { isl_ast_expr_op_get_type(expr) };
644        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
645        let err = isl_rs_ctx.last_error();
646        if err != Error::None_ {
647            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
648        }
649        Ok(isl_rs_result)
650    }
651
652    /// Wraps `isl_ast_expr_op_type_print_macro`.
653    pub fn op_type_print_macro(type_: ASTExprOpType, p: Printer) -> Result<Printer, LibISLError> {
654        let isl_rs_ctx = p.get_ctx();
655        let type_ = type_.to_i32();
656        let mut p = p;
657        p.do_not_free_on_drop();
658        let p = p.ptr;
659        let isl_rs_result = unsafe { isl_ast_expr_op_type_print_macro(type_, p) };
660        let isl_rs_result = Printer { ptr: isl_rs_result,
661                                      should_free_on_drop: true };
662        let err = isl_rs_ctx.last_error();
663        if err != Error::None_ {
664            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
665        }
666        Ok(isl_rs_result)
667    }
668
669    /// Wraps `isl_ast_expr_op_type_set_print_name`.
670    pub fn op_type_set_print_name(p: Printer, type_: ASTExprOpType, name: &str)
671                                  -> Result<Printer, LibISLError> {
672        let isl_rs_ctx = p.get_ctx();
673        let mut p = p;
674        p.do_not_free_on_drop();
675        let p = p.ptr;
676        let type_ = type_.to_i32();
677        let name = CString::new(name).unwrap();
678        let name = name.as_ptr();
679        let isl_rs_result = unsafe { isl_ast_expr_op_type_set_print_name(p, type_, name) };
680        let isl_rs_result = Printer { ptr: isl_rs_result,
681                                      should_free_on_drop: true };
682        let err = isl_rs_ctx.last_error();
683        if err != Error::None_ {
684            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
685        }
686        Ok(isl_rs_result)
687    }
688
689    /// Wraps `isl_ast_expr_or`.
690    pub fn or(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
691        let expr1 = self;
692        let isl_rs_ctx = expr1.get_ctx();
693        let mut expr1 = expr1;
694        expr1.do_not_free_on_drop();
695        let expr1 = expr1.ptr;
696        let mut expr2 = expr2;
697        expr2.do_not_free_on_drop();
698        let expr2 = expr2.ptr;
699        let isl_rs_result = unsafe { isl_ast_expr_or(expr1, expr2) };
700        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
701                                      should_free_on_drop: true };
702        let err = isl_rs_ctx.last_error();
703        if err != Error::None_ {
704            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
705        }
706        Ok(isl_rs_result)
707    }
708
709    /// Wraps `isl_ast_expr_or_else`.
710    pub fn or_else(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
711        let expr1 = self;
712        let isl_rs_ctx = expr1.get_ctx();
713        let mut expr1 = expr1;
714        expr1.do_not_free_on_drop();
715        let expr1 = expr1.ptr;
716        let mut expr2 = expr2;
717        expr2.do_not_free_on_drop();
718        let expr2 = expr2.ptr;
719        let isl_rs_result = unsafe { isl_ast_expr_or_else(expr1, expr2) };
720        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
721                                      should_free_on_drop: true };
722        let err = isl_rs_ctx.last_error();
723        if err != Error::None_ {
724            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
725        }
726        Ok(isl_rs_result)
727    }
728
729    /// Wraps `isl_ast_expr_pdiv_q`.
730    pub fn pdiv_q(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
731        let expr1 = self;
732        let isl_rs_ctx = expr1.get_ctx();
733        let mut expr1 = expr1;
734        expr1.do_not_free_on_drop();
735        let expr1 = expr1.ptr;
736        let mut expr2 = expr2;
737        expr2.do_not_free_on_drop();
738        let expr2 = expr2.ptr;
739        let isl_rs_result = unsafe { isl_ast_expr_pdiv_q(expr1, expr2) };
740        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
741                                      should_free_on_drop: true };
742        let err = isl_rs_ctx.last_error();
743        if err != Error::None_ {
744            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
745        }
746        Ok(isl_rs_result)
747    }
748
749    /// Wraps `isl_ast_expr_pdiv_r`.
750    pub fn pdiv_r(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
751        let expr1 = self;
752        let isl_rs_ctx = expr1.get_ctx();
753        let mut expr1 = expr1;
754        expr1.do_not_free_on_drop();
755        let expr1 = expr1.ptr;
756        let mut expr2 = expr2;
757        expr2.do_not_free_on_drop();
758        let expr2 = expr2.ptr;
759        let isl_rs_result = unsafe { isl_ast_expr_pdiv_r(expr1, expr2) };
760        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
761                                      should_free_on_drop: true };
762        let err = isl_rs_ctx.last_error();
763        if err != Error::None_ {
764            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
765        }
766        Ok(isl_rs_result)
767    }
768
769    /// Wraps `isl_ast_expr_print_macros`.
770    pub fn print_macros(&self, p: Printer) -> Result<Printer, LibISLError> {
771        let expr = self;
772        let isl_rs_ctx = expr.get_ctx();
773        let expr = expr.ptr;
774        let mut p = p;
775        p.do_not_free_on_drop();
776        let p = p.ptr;
777        let isl_rs_result = unsafe { isl_ast_expr_print_macros(expr, p) };
778        let isl_rs_result = Printer { ptr: isl_rs_result,
779                                      should_free_on_drop: true };
780        let err = isl_rs_ctx.last_error();
781        if err != Error::None_ {
782            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
783        }
784        Ok(isl_rs_result)
785    }
786
787    /// Wraps `isl_ast_expr_set_op_arg`.
788    pub fn set_op_arg(self, pos: i32, arg: ASTExpr) -> Result<ASTExpr, LibISLError> {
789        let expr = self;
790        let isl_rs_ctx = expr.get_ctx();
791        let mut expr = expr;
792        expr.do_not_free_on_drop();
793        let expr = expr.ptr;
794        let mut arg = arg;
795        arg.do_not_free_on_drop();
796        let arg = arg.ptr;
797        let isl_rs_result = unsafe { isl_ast_expr_set_op_arg(expr, pos, arg) };
798        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
799                                      should_free_on_drop: true };
800        let err = isl_rs_ctx.last_error();
801        if err != Error::None_ {
802            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
803        }
804        Ok(isl_rs_result)
805    }
806
807    /// Wraps `isl_ast_expr_sub`.
808    pub fn sub(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
809        let expr1 = self;
810        let isl_rs_ctx = expr1.get_ctx();
811        let mut expr1 = expr1;
812        expr1.do_not_free_on_drop();
813        let expr1 = expr1.ptr;
814        let mut expr2 = expr2;
815        expr2.do_not_free_on_drop();
816        let expr2 = expr2.ptr;
817        let isl_rs_result = unsafe { isl_ast_expr_sub(expr1, expr2) };
818        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
819                                      should_free_on_drop: true };
820        let err = isl_rs_ctx.last_error();
821        if err != Error::None_ {
822            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
823        }
824        Ok(isl_rs_result)
825    }
826
827    /// Wraps `isl_ast_expr_substitute_ids`.
828    pub fn substitute_ids(self, id2expr: IdToASTExpr) -> Result<ASTExpr, LibISLError> {
829        let expr = self;
830        let isl_rs_ctx = expr.get_ctx();
831        let mut expr = expr;
832        expr.do_not_free_on_drop();
833        let expr = expr.ptr;
834        let mut id2expr = id2expr;
835        id2expr.do_not_free_on_drop();
836        let id2expr = id2expr.ptr;
837        let isl_rs_result = unsafe { isl_ast_expr_substitute_ids(expr, id2expr) };
838        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
839                                      should_free_on_drop: true };
840        let err = isl_rs_ctx.last_error();
841        if err != Error::None_ {
842            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
843        }
844        Ok(isl_rs_result)
845    }
846
847    /// Wraps `isl_ast_expr_to_C_str`.
848    pub fn to_C_str(&self) -> Result<&str, LibISLError> {
849        let expr = self;
850        let isl_rs_ctx = expr.get_ctx();
851        let expr = expr.ptr;
852        let isl_rs_result = unsafe { isl_ast_expr_to_C_str(expr) };
853        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
854        let isl_rs_result = isl_rs_result.to_str().unwrap();
855        let err = isl_rs_ctx.last_error();
856        if err != Error::None_ {
857            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
858        }
859        Ok(isl_rs_result)
860    }
861
862    /// Wraps `isl_ast_expr_to_list`.
863    pub fn to_list(self) -> Result<ASTExprList, LibISLError> {
864        let el = self;
865        let isl_rs_ctx = el.get_ctx();
866        let mut el = el;
867        el.do_not_free_on_drop();
868        let el = el.ptr;
869        let isl_rs_result = unsafe { isl_ast_expr_to_list(el) };
870        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
871                                          should_free_on_drop: true };
872        let err = isl_rs_ctx.last_error();
873        if err != Error::None_ {
874            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
875        }
876        Ok(isl_rs_result)
877    }
878
879    /// Wraps `isl_ast_expr_to_str`.
880    pub fn to_str(&self) -> Result<&str, LibISLError> {
881        let expr = self;
882        let isl_rs_ctx = expr.get_ctx();
883        let expr = expr.ptr;
884        let isl_rs_result = unsafe { isl_ast_expr_to_str(expr) };
885        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
886        let isl_rs_result = isl_rs_result.to_str().unwrap();
887        let err = isl_rs_ctx.last_error();
888        if err != Error::None_ {
889            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
890        }
891        Ok(isl_rs_result)
892    }
893
894    /// Does not call isl_ast_expr_free() on being dropped. (For internal use
895    /// only.)
896    pub fn do_not_free_on_drop(&mut self) {
897        self.should_free_on_drop = false;
898    }
899}
900
901impl Drop for ASTExpr {
902    fn drop(&mut self) {
903        if self.should_free_on_drop {
904            unsafe {
905                isl_ast_expr_free(self.ptr);
906            }
907        }
908    }
909}
isl_rs/bindings/ast_expr.rs

isl_rs/bindings/
ast_expr.rs
