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            let err_msg = isl_rs_ctx.last_error_msg();
130            isl_rs_ctx.reset_error();
131            return Err(LibISLError::new(err, err_msg));
132        }
133        Ok(isl_rs_result)
134    }
135
136    /// Wraps `isl_ast_expr_add`.
137    pub fn add(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
138        let expr1 = self;
139        let isl_rs_ctx = expr1.get_ctx();
140        let mut expr1 = expr1;
141        expr1.do_not_free_on_drop();
142        let expr1 = expr1.ptr;
143        let mut expr2 = expr2;
144        expr2.do_not_free_on_drop();
145        let expr2 = expr2.ptr;
146        let isl_rs_result = unsafe { isl_ast_expr_add(expr1, expr2) };
147        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
148                                      should_free_on_drop: true };
149        let err = isl_rs_ctx.last_error();
150        if err != Error::None_ {
151            let err_msg = isl_rs_ctx.last_error_msg();
152            isl_rs_ctx.reset_error();
153            return Err(LibISLError::new(err, err_msg));
154        }
155        Ok(isl_rs_result)
156    }
157
158    /// Wraps `isl_ast_expr_address_of`.
159    pub fn address_of(self) -> Result<ASTExpr, LibISLError> {
160        let expr = self;
161        let isl_rs_ctx = expr.get_ctx();
162        let mut expr = expr;
163        expr.do_not_free_on_drop();
164        let expr = expr.ptr;
165        let isl_rs_result = unsafe { isl_ast_expr_address_of(expr) };
166        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
167                                      should_free_on_drop: true };
168        let err = isl_rs_ctx.last_error();
169        if err != Error::None_ {
170            let err_msg = isl_rs_ctx.last_error_msg();
171            isl_rs_ctx.reset_error();
172            return Err(LibISLError::new(err, err_msg));
173        }
174        Ok(isl_rs_result)
175    }
176
177    /// Wraps `isl_ast_expr_and`.
178    pub fn and(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
179        let expr1 = self;
180        let isl_rs_ctx = expr1.get_ctx();
181        let mut expr1 = expr1;
182        expr1.do_not_free_on_drop();
183        let expr1 = expr1.ptr;
184        let mut expr2 = expr2;
185        expr2.do_not_free_on_drop();
186        let expr2 = expr2.ptr;
187        let isl_rs_result = unsafe { isl_ast_expr_and(expr1, expr2) };
188        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
189                                      should_free_on_drop: true };
190        let err = isl_rs_ctx.last_error();
191        if err != Error::None_ {
192            let err_msg = isl_rs_ctx.last_error_msg();
193            isl_rs_ctx.reset_error();
194            return Err(LibISLError::new(err, err_msg));
195        }
196        Ok(isl_rs_result)
197    }
198
199    /// Wraps `isl_ast_expr_and_then`.
200    pub fn and_then(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
201        let expr1 = self;
202        let isl_rs_ctx = expr1.get_ctx();
203        let mut expr1 = expr1;
204        expr1.do_not_free_on_drop();
205        let expr1 = expr1.ptr;
206        let mut expr2 = expr2;
207        expr2.do_not_free_on_drop();
208        let expr2 = expr2.ptr;
209        let isl_rs_result = unsafe { isl_ast_expr_and_then(expr1, expr2) };
210        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
211                                      should_free_on_drop: true };
212        let err = isl_rs_ctx.last_error();
213        if err != Error::None_ {
214            let err_msg = isl_rs_ctx.last_error_msg();
215            isl_rs_ctx.reset_error();
216            return Err(LibISLError::new(err, err_msg));
217        }
218        Ok(isl_rs_result)
219    }
220
221    /// Wraps `isl_ast_expr_call`.
222    pub fn call(self, arguments: ASTExprList) -> Result<ASTExpr, LibISLError> {
223        let function = self;
224        let isl_rs_ctx = function.get_ctx();
225        let mut function = function;
226        function.do_not_free_on_drop();
227        let function = function.ptr;
228        let mut arguments = arguments;
229        arguments.do_not_free_on_drop();
230        let arguments = arguments.ptr;
231        let isl_rs_result = unsafe { isl_ast_expr_call(function, arguments) };
232        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
233                                      should_free_on_drop: true };
234        let err = isl_rs_ctx.last_error();
235        if err != Error::None_ {
236            let err_msg = isl_rs_ctx.last_error_msg();
237            isl_rs_ctx.reset_error();
238            return Err(LibISLError::new(err, err_msg));
239        }
240        Ok(isl_rs_result)
241    }
242
243    /// Wraps `isl_ast_expr_copy`.
244    pub fn copy(&self) -> Result<ASTExpr, LibISLError> {
245        let expr = self;
246        let isl_rs_ctx = expr.get_ctx();
247        let expr = expr.ptr;
248        let isl_rs_result = unsafe { isl_ast_expr_copy(expr) };
249        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
250                                      should_free_on_drop: true };
251        let err = isl_rs_ctx.last_error();
252        if err != Error::None_ {
253            let err_msg = isl_rs_ctx.last_error_msg();
254            isl_rs_ctx.reset_error();
255            return Err(LibISLError::new(err, err_msg));
256        }
257        Ok(isl_rs_result)
258    }
259
260    /// Wraps `isl_ast_expr_div`.
261    pub fn div(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
262        let expr1 = self;
263        let isl_rs_ctx = expr1.get_ctx();
264        let mut expr1 = expr1;
265        expr1.do_not_free_on_drop();
266        let expr1 = expr1.ptr;
267        let mut expr2 = expr2;
268        expr2.do_not_free_on_drop();
269        let expr2 = expr2.ptr;
270        let isl_rs_result = unsafe { isl_ast_expr_div(expr1, expr2) };
271        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
272                                      should_free_on_drop: true };
273        let err = isl_rs_ctx.last_error();
274        if err != Error::None_ {
275            let err_msg = isl_rs_ctx.last_error_msg();
276            isl_rs_ctx.reset_error();
277            return Err(LibISLError::new(err, err_msg));
278        }
279        Ok(isl_rs_result)
280    }
281
282    /// Wraps `isl_ast_expr_dump`.
283    pub fn dump(&self) -> Result<(), LibISLError> {
284        let expr = self;
285        let isl_rs_ctx = expr.get_ctx();
286        let expr = expr.ptr;
287        let isl_rs_result = unsafe { isl_ast_expr_dump(expr) };
288        let err = isl_rs_ctx.last_error();
289        if err != Error::None_ {
290            let err_msg = isl_rs_ctx.last_error_msg();
291            isl_rs_ctx.reset_error();
292            return Err(LibISLError::new(err, err_msg));
293        }
294        Ok(isl_rs_result)
295    }
296
297    /// Wraps `isl_ast_expr_eq`.
298    pub fn eq(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
299        let expr1 = self;
300        let isl_rs_ctx = expr1.get_ctx();
301        let mut expr1 = expr1;
302        expr1.do_not_free_on_drop();
303        let expr1 = expr1.ptr;
304        let mut expr2 = expr2;
305        expr2.do_not_free_on_drop();
306        let expr2 = expr2.ptr;
307        let isl_rs_result = unsafe { isl_ast_expr_eq(expr1, expr2) };
308        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
309                                      should_free_on_drop: true };
310        let err = isl_rs_ctx.last_error();
311        if err != Error::None_ {
312            let err_msg = isl_rs_ctx.last_error_msg();
313            isl_rs_ctx.reset_error();
314            return Err(LibISLError::new(err, err_msg));
315        }
316        Ok(isl_rs_result)
317    }
318
319    /// Wraps `isl_ast_expr_free`.
320    pub fn free(self) -> Result<ASTExpr, LibISLError> {
321        let expr = self;
322        let isl_rs_ctx = expr.get_ctx();
323        let mut expr = expr;
324        expr.do_not_free_on_drop();
325        let expr = expr.ptr;
326        let isl_rs_result = unsafe { isl_ast_expr_free(expr) };
327        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
328                                      should_free_on_drop: true };
329        let err = isl_rs_ctx.last_error();
330        if err != Error::None_ {
331            let err_msg = isl_rs_ctx.last_error_msg();
332            isl_rs_ctx.reset_error();
333            return Err(LibISLError::new(err, err_msg));
334        }
335        Ok(isl_rs_result)
336    }
337
338    /// Wraps `isl_ast_expr_from_id`.
339    pub fn from_id(id: Id) -> Result<ASTExpr, LibISLError> {
340        let isl_rs_ctx = id.get_ctx();
341        let mut id = id;
342        id.do_not_free_on_drop();
343        let id = id.ptr;
344        let isl_rs_result = unsafe { isl_ast_expr_from_id(id) };
345        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
346                                      should_free_on_drop: true };
347        let err = isl_rs_ctx.last_error();
348        if err != Error::None_ {
349            let err_msg = isl_rs_ctx.last_error_msg();
350            isl_rs_ctx.reset_error();
351            return Err(LibISLError::new(err, err_msg));
352        }
353        Ok(isl_rs_result)
354    }
355
356    /// Wraps `isl_ast_expr_from_val`.
357    pub fn from_val(v: Val) -> Result<ASTExpr, LibISLError> {
358        let isl_rs_ctx = v.get_ctx();
359        let mut v = v;
360        v.do_not_free_on_drop();
361        let v = v.ptr;
362        let isl_rs_result = unsafe { isl_ast_expr_from_val(v) };
363        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
364                                      should_free_on_drop: true };
365        let err = isl_rs_ctx.last_error();
366        if err != Error::None_ {
367            let err_msg = isl_rs_ctx.last_error_msg();
368            isl_rs_ctx.reset_error();
369            return Err(LibISLError::new(err, err_msg));
370        }
371        Ok(isl_rs_result)
372    }
373
374    /// Wraps `isl_ast_expr_ge`.
375    pub fn ge(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
376        let expr1 = self;
377        let isl_rs_ctx = expr1.get_ctx();
378        let mut expr1 = expr1;
379        expr1.do_not_free_on_drop();
380        let expr1 = expr1.ptr;
381        let mut expr2 = expr2;
382        expr2.do_not_free_on_drop();
383        let expr2 = expr2.ptr;
384        let isl_rs_result = unsafe { isl_ast_expr_ge(expr1, expr2) };
385        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
386                                      should_free_on_drop: true };
387        let err = isl_rs_ctx.last_error();
388        if err != Error::None_ {
389            let err_msg = isl_rs_ctx.last_error_msg();
390            isl_rs_ctx.reset_error();
391            return Err(LibISLError::new(err, err_msg));
392        }
393        Ok(isl_rs_result)
394    }
395
396    /// Wraps `isl_ast_expr_get_ctx`.
397    pub fn get_ctx(&self) -> Context {
398        let expr = self;
399        let expr = expr.ptr;
400        let isl_rs_result = unsafe { isl_ast_expr_get_ctx(expr) };
401        let isl_rs_result = Context { ptr: isl_rs_result,
402                                      should_free_on_drop: false };
403        isl_rs_result
404    }
405
406    /// Wraps `isl_ast_expr_get_id`.
407    pub fn get_id(&self) -> Result<Id, LibISLError> {
408        let expr = self;
409        let isl_rs_ctx = expr.get_ctx();
410        let expr = expr.ptr;
411        let isl_rs_result = unsafe { isl_ast_expr_get_id(expr) };
412        let isl_rs_result = Id { ptr: isl_rs_result,
413                                 should_free_on_drop: true };
414        let err = isl_rs_ctx.last_error();
415        if err != Error::None_ {
416            let err_msg = isl_rs_ctx.last_error_msg();
417            isl_rs_ctx.reset_error();
418            return Err(LibISLError::new(err, err_msg));
419        }
420        Ok(isl_rs_result)
421    }
422
423    /// Wraps `isl_ast_expr_get_op_arg`.
424    pub fn get_op_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
425        let expr = self;
426        let isl_rs_ctx = expr.get_ctx();
427        let expr = expr.ptr;
428        let isl_rs_result = unsafe { isl_ast_expr_get_op_arg(expr, pos) };
429        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
430                                      should_free_on_drop: true };
431        let err = isl_rs_ctx.last_error();
432        if err != Error::None_ {
433            let err_msg = isl_rs_ctx.last_error_msg();
434            isl_rs_ctx.reset_error();
435            return Err(LibISLError::new(err, err_msg));
436        }
437        Ok(isl_rs_result)
438    }
439
440    /// Wraps `isl_ast_expr_get_op_n_arg`.
441    pub fn get_op_n_arg(&self) -> Result<i32, LibISLError> {
442        let expr = self;
443        let isl_rs_ctx = expr.get_ctx();
444        let expr = expr.ptr;
445        let isl_rs_result = unsafe { isl_ast_expr_get_op_n_arg(expr) };
446        let err = isl_rs_ctx.last_error();
447        if err != Error::None_ {
448            let err_msg = isl_rs_ctx.last_error_msg();
449            isl_rs_ctx.reset_error();
450            return Err(LibISLError::new(err, err_msg));
451        }
452        Ok(isl_rs_result)
453    }
454
455    /// Wraps `isl_ast_expr_get_op_type`.
456    pub fn get_op_type(&self) -> Result<ASTExprOpType, LibISLError> {
457        let expr = self;
458        let isl_rs_ctx = expr.get_ctx();
459        let expr = expr.ptr;
460        let isl_rs_result = unsafe { isl_ast_expr_get_op_type(expr) };
461        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
462        let err = isl_rs_ctx.last_error();
463        if err != Error::None_ {
464            let err_msg = isl_rs_ctx.last_error_msg();
465            isl_rs_ctx.reset_error();
466            return Err(LibISLError::new(err, err_msg));
467        }
468        Ok(isl_rs_result)
469    }
470
471    /// Wraps `isl_ast_expr_get_type`.
472    pub fn get_type(&self) -> Result<ASTExprType, LibISLError> {
473        let expr = self;
474        let isl_rs_ctx = expr.get_ctx();
475        let expr = expr.ptr;
476        let isl_rs_result = unsafe { isl_ast_expr_get_type(expr) };
477        let isl_rs_result = ASTExprType::from_i32(isl_rs_result);
478        let err = isl_rs_ctx.last_error();
479        if err != Error::None_ {
480            let err_msg = isl_rs_ctx.last_error_msg();
481            isl_rs_ctx.reset_error();
482            return Err(LibISLError::new(err, err_msg));
483        }
484        Ok(isl_rs_result)
485    }
486
487    /// Wraps `isl_ast_expr_get_val`.
488    pub fn get_val(&self) -> Result<Val, LibISLError> {
489        let expr = self;
490        let isl_rs_ctx = expr.get_ctx();
491        let expr = expr.ptr;
492        let isl_rs_result = unsafe { isl_ast_expr_get_val(expr) };
493        let isl_rs_result = Val { ptr: isl_rs_result,
494                                  should_free_on_drop: true };
495        let err = isl_rs_ctx.last_error();
496        if err != Error::None_ {
497            let err_msg = isl_rs_ctx.last_error_msg();
498            isl_rs_ctx.reset_error();
499            return Err(LibISLError::new(err, err_msg));
500        }
501        Ok(isl_rs_result)
502    }
503
504    /// Wraps `isl_ast_expr_gt`.
505    pub fn gt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
506        let expr1 = self;
507        let isl_rs_ctx = expr1.get_ctx();
508        let mut expr1 = expr1;
509        expr1.do_not_free_on_drop();
510        let expr1 = expr1.ptr;
511        let mut expr2 = expr2;
512        expr2.do_not_free_on_drop();
513        let expr2 = expr2.ptr;
514        let isl_rs_result = unsafe { isl_ast_expr_gt(expr1, expr2) };
515        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
516                                      should_free_on_drop: true };
517        let err = isl_rs_ctx.last_error();
518        if err != Error::None_ {
519            let err_msg = isl_rs_ctx.last_error_msg();
520            isl_rs_ctx.reset_error();
521            return Err(LibISLError::new(err, err_msg));
522        }
523        Ok(isl_rs_result)
524    }
525
526    /// Wraps `isl_ast_expr_id_get_id`.
527    pub fn id_get_id(&self) -> Result<Id, LibISLError> {
528        let expr = self;
529        let isl_rs_ctx = expr.get_ctx();
530        let expr = expr.ptr;
531        let isl_rs_result = unsafe { isl_ast_expr_id_get_id(expr) };
532        let isl_rs_result = Id { ptr: isl_rs_result,
533                                 should_free_on_drop: true };
534        let err = isl_rs_ctx.last_error();
535        if err != Error::None_ {
536            let err_msg = isl_rs_ctx.last_error_msg();
537            isl_rs_ctx.reset_error();
538            return Err(LibISLError::new(err, err_msg));
539        }
540        Ok(isl_rs_result)
541    }
542
543    /// Wraps `isl_ast_expr_int_get_val`.
544    pub fn int_get_val(&self) -> Result<Val, LibISLError> {
545        let expr = self;
546        let isl_rs_ctx = expr.get_ctx();
547        let expr = expr.ptr;
548        let isl_rs_result = unsafe { isl_ast_expr_int_get_val(expr) };
549        let isl_rs_result = Val { ptr: isl_rs_result,
550                                  should_free_on_drop: true };
551        let err = isl_rs_ctx.last_error();
552        if err != Error::None_ {
553            let err_msg = isl_rs_ctx.last_error_msg();
554            isl_rs_ctx.reset_error();
555            return Err(LibISLError::new(err, err_msg));
556        }
557        Ok(isl_rs_result)
558    }
559
560    /// Wraps `isl_ast_expr_is_equal`.
561    pub fn is_equal(&self, expr2: &ASTExpr) -> Result<bool, LibISLError> {
562        let expr1 = self;
563        let isl_rs_ctx = expr1.get_ctx();
564        let expr1 = expr1.ptr;
565        let expr2 = expr2.ptr;
566        let isl_rs_result = unsafe { isl_ast_expr_is_equal(expr1, expr2) };
567        let isl_rs_result = match isl_rs_result {
568            0 => false,
569            1 => true,
570            _ => {
571                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
572            }
573        };
574        let err = isl_rs_ctx.last_error();
575        if err != Error::None_ {
576            let err_msg = isl_rs_ctx.last_error_msg();
577            isl_rs_ctx.reset_error();
578            return Err(LibISLError::new(err, err_msg));
579        }
580        Ok(isl_rs_result)
581    }
582
583    /// Wraps `isl_ast_expr_le`.
584    pub fn le(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
585        let expr1 = self;
586        let isl_rs_ctx = expr1.get_ctx();
587        let mut expr1 = expr1;
588        expr1.do_not_free_on_drop();
589        let expr1 = expr1.ptr;
590        let mut expr2 = expr2;
591        expr2.do_not_free_on_drop();
592        let expr2 = expr2.ptr;
593        let isl_rs_result = unsafe { isl_ast_expr_le(expr1, expr2) };
594        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
595                                      should_free_on_drop: true };
596        let err = isl_rs_ctx.last_error();
597        if err != Error::None_ {
598            let err_msg = isl_rs_ctx.last_error_msg();
599            isl_rs_ctx.reset_error();
600            return Err(LibISLError::new(err, err_msg));
601        }
602        Ok(isl_rs_result)
603    }
604
605    /// Wraps `isl_ast_expr_lt`.
606    pub fn lt(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
607        let expr1 = self;
608        let isl_rs_ctx = expr1.get_ctx();
609        let mut expr1 = expr1;
610        expr1.do_not_free_on_drop();
611        let expr1 = expr1.ptr;
612        let mut expr2 = expr2;
613        expr2.do_not_free_on_drop();
614        let expr2 = expr2.ptr;
615        let isl_rs_result = unsafe { isl_ast_expr_lt(expr1, expr2) };
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            let err_msg = isl_rs_ctx.last_error_msg();
621            isl_rs_ctx.reset_error();
622            return Err(LibISLError::new(err, err_msg));
623        }
624        Ok(isl_rs_result)
625    }
626
627    /// Wraps `isl_ast_expr_mul`.
628    pub fn mul(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
629        let expr1 = self;
630        let isl_rs_ctx = expr1.get_ctx();
631        let mut expr1 = expr1;
632        expr1.do_not_free_on_drop();
633        let expr1 = expr1.ptr;
634        let mut expr2 = expr2;
635        expr2.do_not_free_on_drop();
636        let expr2 = expr2.ptr;
637        let isl_rs_result = unsafe { isl_ast_expr_mul(expr1, expr2) };
638        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
639                                      should_free_on_drop: true };
640        let err = isl_rs_ctx.last_error();
641        if err != Error::None_ {
642            let err_msg = isl_rs_ctx.last_error_msg();
643            isl_rs_ctx.reset_error();
644            return Err(LibISLError::new(err, err_msg));
645        }
646        Ok(isl_rs_result)
647    }
648
649    /// Wraps `isl_ast_expr_neg`.
650    pub fn neg(self) -> Result<ASTExpr, LibISLError> {
651        let expr = self;
652        let isl_rs_ctx = expr.get_ctx();
653        let mut expr = expr;
654        expr.do_not_free_on_drop();
655        let expr = expr.ptr;
656        let isl_rs_result = unsafe { isl_ast_expr_neg(expr) };
657        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
658                                      should_free_on_drop: true };
659        let err = isl_rs_ctx.last_error();
660        if err != Error::None_ {
661            let err_msg = isl_rs_ctx.last_error_msg();
662            isl_rs_ctx.reset_error();
663            return Err(LibISLError::new(err, err_msg));
664        }
665        Ok(isl_rs_result)
666    }
667
668    /// Wraps `isl_ast_expr_op_get_arg`.
669    pub fn op_get_arg(&self, pos: i32) -> Result<ASTExpr, LibISLError> {
670        let expr = self;
671        let isl_rs_ctx = expr.get_ctx();
672        let expr = expr.ptr;
673        let isl_rs_result = unsafe { isl_ast_expr_op_get_arg(expr, pos) };
674        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
675                                      should_free_on_drop: true };
676        let err = isl_rs_ctx.last_error();
677        if err != Error::None_ {
678            let err_msg = isl_rs_ctx.last_error_msg();
679            isl_rs_ctx.reset_error();
680            return Err(LibISLError::new(err, err_msg));
681        }
682        Ok(isl_rs_result)
683    }
684
685    /// Wraps `isl_ast_expr_op_get_n_arg`.
686    pub fn op_get_n_arg(&self) -> Result<i32, LibISLError> {
687        let expr = self;
688        let isl_rs_ctx = expr.get_ctx();
689        let expr = expr.ptr;
690        let isl_rs_result = unsafe { isl_ast_expr_op_get_n_arg(expr) };
691        let err = isl_rs_ctx.last_error();
692        if err != Error::None_ {
693            let err_msg = isl_rs_ctx.last_error_msg();
694            isl_rs_ctx.reset_error();
695            return Err(LibISLError::new(err, err_msg));
696        }
697        Ok(isl_rs_result)
698    }
699
700    /// Wraps `isl_ast_expr_op_get_type`.
701    pub fn op_get_type(&self) -> Result<ASTExprOpType, LibISLError> {
702        let expr = self;
703        let isl_rs_ctx = expr.get_ctx();
704        let expr = expr.ptr;
705        let isl_rs_result = unsafe { isl_ast_expr_op_get_type(expr) };
706        let isl_rs_result = ASTExprOpType::from_i32(isl_rs_result);
707        let err = isl_rs_ctx.last_error();
708        if err != Error::None_ {
709            let err_msg = isl_rs_ctx.last_error_msg();
710            isl_rs_ctx.reset_error();
711            return Err(LibISLError::new(err, err_msg));
712        }
713        Ok(isl_rs_result)
714    }
715
716    /// Wraps `isl_ast_expr_op_type_print_macro`.
717    pub fn op_type_print_macro(type_: ASTExprOpType, p: Printer) -> Result<Printer, LibISLError> {
718        let isl_rs_ctx = p.get_ctx();
719        let type_ = type_.to_i32();
720        let mut p = p;
721        p.do_not_free_on_drop();
722        let p = p.ptr;
723        let isl_rs_result = unsafe { isl_ast_expr_op_type_print_macro(type_, p) };
724        let isl_rs_result = Printer { ptr: isl_rs_result,
725                                      should_free_on_drop: true };
726        let err = isl_rs_ctx.last_error();
727        if err != Error::None_ {
728            let err_msg = isl_rs_ctx.last_error_msg();
729            isl_rs_ctx.reset_error();
730            return Err(LibISLError::new(err, err_msg));
731        }
732        Ok(isl_rs_result)
733    }
734
735    /// Wraps `isl_ast_expr_op_type_set_print_name`.
736    pub fn op_type_set_print_name(p: Printer, type_: ASTExprOpType, name: &str)
737                                  -> Result<Printer, LibISLError> {
738        let isl_rs_ctx = p.get_ctx();
739        let mut p = p;
740        p.do_not_free_on_drop();
741        let p = p.ptr;
742        let type_ = type_.to_i32();
743        let name = CString::new(name).unwrap();
744        let name = name.as_ptr();
745        let isl_rs_result = unsafe { isl_ast_expr_op_type_set_print_name(p, type_, name) };
746        let isl_rs_result = Printer { ptr: isl_rs_result,
747                                      should_free_on_drop: true };
748        let err = isl_rs_ctx.last_error();
749        if err != Error::None_ {
750            let err_msg = isl_rs_ctx.last_error_msg();
751            isl_rs_ctx.reset_error();
752            return Err(LibISLError::new(err, err_msg));
753        }
754        Ok(isl_rs_result)
755    }
756
757    /// Wraps `isl_ast_expr_or`.
758    pub fn or(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
759        let expr1 = self;
760        let isl_rs_ctx = expr1.get_ctx();
761        let mut expr1 = expr1;
762        expr1.do_not_free_on_drop();
763        let expr1 = expr1.ptr;
764        let mut expr2 = expr2;
765        expr2.do_not_free_on_drop();
766        let expr2 = expr2.ptr;
767        let isl_rs_result = unsafe { isl_ast_expr_or(expr1, expr2) };
768        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
769                                      should_free_on_drop: true };
770        let err = isl_rs_ctx.last_error();
771        if err != Error::None_ {
772            let err_msg = isl_rs_ctx.last_error_msg();
773            isl_rs_ctx.reset_error();
774            return Err(LibISLError::new(err, err_msg));
775        }
776        Ok(isl_rs_result)
777    }
778
779    /// Wraps `isl_ast_expr_or_else`.
780    pub fn or_else(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
781        let expr1 = self;
782        let isl_rs_ctx = expr1.get_ctx();
783        let mut expr1 = expr1;
784        expr1.do_not_free_on_drop();
785        let expr1 = expr1.ptr;
786        let mut expr2 = expr2;
787        expr2.do_not_free_on_drop();
788        let expr2 = expr2.ptr;
789        let isl_rs_result = unsafe { isl_ast_expr_or_else(expr1, expr2) };
790        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
791                                      should_free_on_drop: true };
792        let err = isl_rs_ctx.last_error();
793        if err != Error::None_ {
794            let err_msg = isl_rs_ctx.last_error_msg();
795            isl_rs_ctx.reset_error();
796            return Err(LibISLError::new(err, err_msg));
797        }
798        Ok(isl_rs_result)
799    }
800
801    /// Wraps `isl_ast_expr_pdiv_q`.
802    pub fn pdiv_q(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
803        let expr1 = self;
804        let isl_rs_ctx = expr1.get_ctx();
805        let mut expr1 = expr1;
806        expr1.do_not_free_on_drop();
807        let expr1 = expr1.ptr;
808        let mut expr2 = expr2;
809        expr2.do_not_free_on_drop();
810        let expr2 = expr2.ptr;
811        let isl_rs_result = unsafe { isl_ast_expr_pdiv_q(expr1, expr2) };
812        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
813                                      should_free_on_drop: true };
814        let err = isl_rs_ctx.last_error();
815        if err != Error::None_ {
816            let err_msg = isl_rs_ctx.last_error_msg();
817            isl_rs_ctx.reset_error();
818            return Err(LibISLError::new(err, err_msg));
819        }
820        Ok(isl_rs_result)
821    }
822
823    /// Wraps `isl_ast_expr_pdiv_r`.
824    pub fn pdiv_r(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
825        let expr1 = self;
826        let isl_rs_ctx = expr1.get_ctx();
827        let mut expr1 = expr1;
828        expr1.do_not_free_on_drop();
829        let expr1 = expr1.ptr;
830        let mut expr2 = expr2;
831        expr2.do_not_free_on_drop();
832        let expr2 = expr2.ptr;
833        let isl_rs_result = unsafe { isl_ast_expr_pdiv_r(expr1, expr2) };
834        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
835                                      should_free_on_drop: true };
836        let err = isl_rs_ctx.last_error();
837        if err != Error::None_ {
838            let err_msg = isl_rs_ctx.last_error_msg();
839            isl_rs_ctx.reset_error();
840            return Err(LibISLError::new(err, err_msg));
841        }
842        Ok(isl_rs_result)
843    }
844
845    /// Wraps `isl_ast_expr_print_macros`.
846    pub fn print_macros(&self, p: Printer) -> Result<Printer, LibISLError> {
847        let expr = self;
848        let isl_rs_ctx = expr.get_ctx();
849        let expr = expr.ptr;
850        let mut p = p;
851        p.do_not_free_on_drop();
852        let p = p.ptr;
853        let isl_rs_result = unsafe { isl_ast_expr_print_macros(expr, p) };
854        let isl_rs_result = Printer { ptr: isl_rs_result,
855                                      should_free_on_drop: true };
856        let err = isl_rs_ctx.last_error();
857        if err != Error::None_ {
858            let err_msg = isl_rs_ctx.last_error_msg();
859            isl_rs_ctx.reset_error();
860            return Err(LibISLError::new(err, err_msg));
861        }
862        Ok(isl_rs_result)
863    }
864
865    /// Wraps `isl_ast_expr_set_op_arg`.
866    pub fn set_op_arg(self, pos: i32, arg: ASTExpr) -> Result<ASTExpr, LibISLError> {
867        let expr = self;
868        let isl_rs_ctx = expr.get_ctx();
869        let mut expr = expr;
870        expr.do_not_free_on_drop();
871        let expr = expr.ptr;
872        let mut arg = arg;
873        arg.do_not_free_on_drop();
874        let arg = arg.ptr;
875        let isl_rs_result = unsafe { isl_ast_expr_set_op_arg(expr, pos, arg) };
876        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
877                                      should_free_on_drop: true };
878        let err = isl_rs_ctx.last_error();
879        if err != Error::None_ {
880            let err_msg = isl_rs_ctx.last_error_msg();
881            isl_rs_ctx.reset_error();
882            return Err(LibISLError::new(err, err_msg));
883        }
884        Ok(isl_rs_result)
885    }
886
887    /// Wraps `isl_ast_expr_sub`.
888    pub fn sub(self, expr2: ASTExpr) -> Result<ASTExpr, LibISLError> {
889        let expr1 = self;
890        let isl_rs_ctx = expr1.get_ctx();
891        let mut expr1 = expr1;
892        expr1.do_not_free_on_drop();
893        let expr1 = expr1.ptr;
894        let mut expr2 = expr2;
895        expr2.do_not_free_on_drop();
896        let expr2 = expr2.ptr;
897        let isl_rs_result = unsafe { isl_ast_expr_sub(expr1, expr2) };
898        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
899                                      should_free_on_drop: true };
900        let err = isl_rs_ctx.last_error();
901        if err != Error::None_ {
902            let err_msg = isl_rs_ctx.last_error_msg();
903            isl_rs_ctx.reset_error();
904            return Err(LibISLError::new(err, err_msg));
905        }
906        Ok(isl_rs_result)
907    }
908
909    /// Wraps `isl_ast_expr_substitute_ids`.
910    pub fn substitute_ids(self, id2expr: IdToASTExpr) -> Result<ASTExpr, LibISLError> {
911        let expr = self;
912        let isl_rs_ctx = expr.get_ctx();
913        let mut expr = expr;
914        expr.do_not_free_on_drop();
915        let expr = expr.ptr;
916        let mut id2expr = id2expr;
917        id2expr.do_not_free_on_drop();
918        let id2expr = id2expr.ptr;
919        let isl_rs_result = unsafe { isl_ast_expr_substitute_ids(expr, id2expr) };
920        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
921                                      should_free_on_drop: true };
922        let err = isl_rs_ctx.last_error();
923        if err != Error::None_ {
924            let err_msg = isl_rs_ctx.last_error_msg();
925            isl_rs_ctx.reset_error();
926            return Err(LibISLError::new(err, err_msg));
927        }
928        Ok(isl_rs_result)
929    }
930
931    /// Wraps `isl_ast_expr_to_C_str`.
932    pub fn to_C_str(&self) -> Result<&str, LibISLError> {
933        let expr = self;
934        let isl_rs_ctx = expr.get_ctx();
935        let expr = expr.ptr;
936        let isl_rs_result = unsafe { isl_ast_expr_to_C_str(expr) };
937        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
938        let isl_rs_result = isl_rs_result.to_str().unwrap();
939        let err = isl_rs_ctx.last_error();
940        if err != Error::None_ {
941            let err_msg = isl_rs_ctx.last_error_msg();
942            isl_rs_ctx.reset_error();
943            return Err(LibISLError::new(err, err_msg));
944        }
945        Ok(isl_rs_result)
946    }
947
948    /// Wraps `isl_ast_expr_to_list`.
949    pub fn to_list(self) -> Result<ASTExprList, LibISLError> {
950        let el = self;
951        let isl_rs_ctx = el.get_ctx();
952        let mut el = el;
953        el.do_not_free_on_drop();
954        let el = el.ptr;
955        let isl_rs_result = unsafe { isl_ast_expr_to_list(el) };
956        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
957                                          should_free_on_drop: true };
958        let err = isl_rs_ctx.last_error();
959        if err != Error::None_ {
960            let err_msg = isl_rs_ctx.last_error_msg();
961            isl_rs_ctx.reset_error();
962            return Err(LibISLError::new(err, err_msg));
963        }
964        Ok(isl_rs_result)
965    }
966
967    /// Wraps `isl_ast_expr_to_str`.
968    pub fn to_str(&self) -> Result<&str, LibISLError> {
969        let expr = self;
970        let isl_rs_ctx = expr.get_ctx();
971        let expr = expr.ptr;
972        let isl_rs_result = unsafe { isl_ast_expr_to_str(expr) };
973        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
974        let isl_rs_result = isl_rs_result.to_str().unwrap();
975        let err = isl_rs_ctx.last_error();
976        if err != Error::None_ {
977            let err_msg = isl_rs_ctx.last_error_msg();
978            isl_rs_ctx.reset_error();
979            return Err(LibISLError::new(err, err_msg));
980        }
981        Ok(isl_rs_result)
982    }
983
984    /// Does not call isl_ast_expr_free() on being dropped. (For internal use
985    /// only.)
986    pub fn do_not_free_on_drop(&mut self) {
987        self.should_free_on_drop = false;
988    }
989}
990
991impl Drop for ASTExpr {
992    fn drop(&mut self) {
993        if self.should_free_on_drop {
994            unsafe {
995                isl_ast_expr_free(self.ptr);
996            }
997        }
998    }
999}
isl_rs/bindings/ast_expr.rs

isl_rs/bindings/
ast_expr.rs
