isl_rs/bindings/
val.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, ValList};
5use libc::uintptr_t;
6use std::ffi::{CStr, CString};
7use std::os::raw::c_char;
8
9/// Wraps `isl_val`.
10pub struct Val {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_val_2exp(v: uintptr_t) -> uintptr_t;
18
19    fn isl_val_abs(v: uintptr_t) -> uintptr_t;
20
21    fn isl_val_abs_eq(v1: uintptr_t, v2: uintptr_t) -> i32;
22
23    fn isl_val_add(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
24
25    fn isl_val_add_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
26
27    fn isl_val_ceil(v: uintptr_t) -> uintptr_t;
28
29    fn isl_val_cmp_si(v: uintptr_t, i: i64) -> i32;
30
31    fn isl_val_copy(v: uintptr_t) -> uintptr_t;
32
33    fn isl_val_div(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
34
35    fn isl_val_div_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
36
37    fn isl_val_dump(v: uintptr_t) -> ();
38
39    fn isl_val_eq(v1: uintptr_t, v2: uintptr_t) -> i32;
40
41    fn isl_val_eq_si(v: uintptr_t, i: i64) -> i32;
42
43    fn isl_val_floor(v: uintptr_t) -> uintptr_t;
44
45    fn isl_val_free(v: uintptr_t) -> uintptr_t;
46
47    fn isl_val_gcd(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
48
49    fn isl_val_ge(v1: uintptr_t, v2: uintptr_t) -> i32;
50
51    fn isl_val_get_ctx(val: uintptr_t) -> uintptr_t;
52
53    fn isl_val_get_d(v: uintptr_t) -> f64;
54
55    fn isl_val_get_den_si(v: uintptr_t) -> i64;
56
57    fn isl_val_get_den_val(v: uintptr_t) -> uintptr_t;
58
59    fn isl_val_get_hash(val: uintptr_t) -> u32;
60
61    fn isl_val_get_num_si(v: uintptr_t) -> i64;
62
63    fn isl_val_gt(v1: uintptr_t, v2: uintptr_t) -> i32;
64
65    fn isl_val_gt_si(v: uintptr_t, i: i64) -> i32;
66
67    fn isl_val_infty(ctx: uintptr_t) -> uintptr_t;
68
69    fn isl_val_int_from_si(ctx: uintptr_t, i: i64) -> uintptr_t;
70
71    fn isl_val_int_from_ui(ctx: uintptr_t, u: u64) -> uintptr_t;
72
73    fn isl_val_inv(v: uintptr_t) -> uintptr_t;
74
75    fn isl_val_is_divisible_by(v1: uintptr_t, v2: uintptr_t) -> i32;
76
77    fn isl_val_is_infty(v: uintptr_t) -> i32;
78
79    fn isl_val_is_int(v: uintptr_t) -> i32;
80
81    fn isl_val_is_nan(v: uintptr_t) -> i32;
82
83    fn isl_val_is_neg(v: uintptr_t) -> i32;
84
85    fn isl_val_is_neginfty(v: uintptr_t) -> i32;
86
87    fn isl_val_is_negone(v: uintptr_t) -> i32;
88
89    fn isl_val_is_nonneg(v: uintptr_t) -> i32;
90
91    fn isl_val_is_nonpos(v: uintptr_t) -> i32;
92
93    fn isl_val_is_one(v: uintptr_t) -> i32;
94
95    fn isl_val_is_pos(v: uintptr_t) -> i32;
96
97    fn isl_val_is_rat(v: uintptr_t) -> i32;
98
99    fn isl_val_is_zero(v: uintptr_t) -> i32;
100
101    fn isl_val_le(v1: uintptr_t, v2: uintptr_t) -> i32;
102
103    fn isl_val_lt(v1: uintptr_t, v2: uintptr_t) -> i32;
104
105    fn isl_val_max(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
106
107    fn isl_val_min(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
108
109    fn isl_val_mod(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
110
111    fn isl_val_mul(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
112
113    fn isl_val_mul_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
114
115    fn isl_val_n_abs_num_chunks(v: uintptr_t, size: usize) -> i32;
116
117    fn isl_val_nan(ctx: uintptr_t) -> uintptr_t;
118
119    fn isl_val_ne(v1: uintptr_t, v2: uintptr_t) -> i32;
120
121    fn isl_val_neg(v: uintptr_t) -> uintptr_t;
122
123    fn isl_val_neginfty(ctx: uintptr_t) -> uintptr_t;
124
125    fn isl_val_negone(ctx: uintptr_t) -> uintptr_t;
126
127    fn isl_val_one(ctx: uintptr_t) -> uintptr_t;
128
129    fn isl_val_pow2(v: uintptr_t) -> uintptr_t;
130
131    fn isl_val_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
132
133    fn isl_val_set_si(v: uintptr_t, i: i64) -> uintptr_t;
134
135    fn isl_val_sgn(v: uintptr_t) -> i32;
136
137    fn isl_val_sub(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
138
139    fn isl_val_sub_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
140
141    fn isl_val_to_list(el: uintptr_t) -> uintptr_t;
142
143    fn isl_val_to_str(v: uintptr_t) -> *const c_char;
144
145    fn isl_val_trunc(v: uintptr_t) -> uintptr_t;
146
147    fn isl_val_zero(ctx: uintptr_t) -> uintptr_t;
148
149}
150
151impl Val {
152    /// Wraps `isl_val_2exp`.
153    pub fn to_exp(self) -> Result<Val, LibISLError> {
154        let v = self;
155        let isl_rs_ctx = v.get_ctx();
156        let mut v = v;
157        v.do_not_free_on_drop();
158        let v = v.ptr;
159        let isl_rs_result = unsafe { isl_val_2exp(v) };
160        let isl_rs_result = Val { ptr: isl_rs_result,
161                                  should_free_on_drop: true };
162        let err = isl_rs_ctx.last_error();
163        if err != Error::None_ {
164            let err_msg = isl_rs_ctx.last_error_msg();
165            isl_rs_ctx.reset_error();
166            return Err(LibISLError::new(err, err_msg));
167        }
168        Ok(isl_rs_result)
169    }
170
171    /// Wraps `isl_val_abs`.
172    pub fn abs(self) -> Result<Val, LibISLError> {
173        let v = self;
174        let isl_rs_ctx = v.get_ctx();
175        let mut v = v;
176        v.do_not_free_on_drop();
177        let v = v.ptr;
178        let isl_rs_result = unsafe { isl_val_abs(v) };
179        let isl_rs_result = Val { ptr: isl_rs_result,
180                                  should_free_on_drop: true };
181        let err = isl_rs_ctx.last_error();
182        if err != Error::None_ {
183            let err_msg = isl_rs_ctx.last_error_msg();
184            isl_rs_ctx.reset_error();
185            return Err(LibISLError::new(err, err_msg));
186        }
187        Ok(isl_rs_result)
188    }
189
190    /// Wraps `isl_val_abs_eq`.
191    pub fn abs_eq(&self, v2: &Val) -> Result<bool, LibISLError> {
192        let v1 = self;
193        let isl_rs_ctx = v1.get_ctx();
194        let v1 = v1.ptr;
195        let v2 = v2.ptr;
196        let isl_rs_result = unsafe { isl_val_abs_eq(v1, v2) };
197        let isl_rs_result = match isl_rs_result {
198            0 => false,
199            1 => true,
200            _ => {
201                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
202            }
203        };
204        let err = isl_rs_ctx.last_error();
205        if err != Error::None_ {
206            let err_msg = isl_rs_ctx.last_error_msg();
207            isl_rs_ctx.reset_error();
208            return Err(LibISLError::new(err, err_msg));
209        }
210        Ok(isl_rs_result)
211    }
212
213    /// Wraps `isl_val_add`.
214    pub fn add(self, v2: Val) -> Result<Val, LibISLError> {
215        let v1 = self;
216        let isl_rs_ctx = v1.get_ctx();
217        let mut v1 = v1;
218        v1.do_not_free_on_drop();
219        let v1 = v1.ptr;
220        let mut v2 = v2;
221        v2.do_not_free_on_drop();
222        let v2 = v2.ptr;
223        let isl_rs_result = unsafe { isl_val_add(v1, v2) };
224        let isl_rs_result = Val { ptr: isl_rs_result,
225                                  should_free_on_drop: true };
226        let err = isl_rs_ctx.last_error();
227        if err != Error::None_ {
228            let err_msg = isl_rs_ctx.last_error_msg();
229            isl_rs_ctx.reset_error();
230            return Err(LibISLError::new(err, err_msg));
231        }
232        Ok(isl_rs_result)
233    }
234
235    /// Wraps `isl_val_add_ui`.
236    pub fn add_ui(self, v2: u64) -> Result<Val, LibISLError> {
237        let v1 = self;
238        let isl_rs_ctx = v1.get_ctx();
239        let mut v1 = v1;
240        v1.do_not_free_on_drop();
241        let v1 = v1.ptr;
242        let isl_rs_result = unsafe { isl_val_add_ui(v1, v2) };
243        let isl_rs_result = Val { ptr: isl_rs_result,
244                                  should_free_on_drop: true };
245        let err = isl_rs_ctx.last_error();
246        if err != Error::None_ {
247            let err_msg = isl_rs_ctx.last_error_msg();
248            isl_rs_ctx.reset_error();
249            return Err(LibISLError::new(err, err_msg));
250        }
251        Ok(isl_rs_result)
252    }
253
254    /// Wraps `isl_val_ceil`.
255    pub fn ceil(self) -> Result<Val, LibISLError> {
256        let v = self;
257        let isl_rs_ctx = v.get_ctx();
258        let mut v = v;
259        v.do_not_free_on_drop();
260        let v = v.ptr;
261        let isl_rs_result = unsafe { isl_val_ceil(v) };
262        let isl_rs_result = Val { ptr: isl_rs_result,
263                                  should_free_on_drop: true };
264        let err = isl_rs_ctx.last_error();
265        if err != Error::None_ {
266            let err_msg = isl_rs_ctx.last_error_msg();
267            isl_rs_ctx.reset_error();
268            return Err(LibISLError::new(err, err_msg));
269        }
270        Ok(isl_rs_result)
271    }
272
273    /// Wraps `isl_val_cmp_si`.
274    pub fn cmp_si(&self, i: i64) -> Result<i32, LibISLError> {
275        let v = self;
276        let isl_rs_ctx = v.get_ctx();
277        let v = v.ptr;
278        let isl_rs_result = unsafe { isl_val_cmp_si(v, i) };
279        let err = isl_rs_ctx.last_error();
280        if err != Error::None_ {
281            let err_msg = isl_rs_ctx.last_error_msg();
282            isl_rs_ctx.reset_error();
283            return Err(LibISLError::new(err, err_msg));
284        }
285        Ok(isl_rs_result)
286    }
287
288    /// Wraps `isl_val_copy`.
289    pub fn copy(&self) -> Result<Val, LibISLError> {
290        let v = self;
291        let isl_rs_ctx = v.get_ctx();
292        let v = v.ptr;
293        let isl_rs_result = unsafe { isl_val_copy(v) };
294        let isl_rs_result = Val { ptr: isl_rs_result,
295                                  should_free_on_drop: true };
296        let err = isl_rs_ctx.last_error();
297        if err != Error::None_ {
298            let err_msg = isl_rs_ctx.last_error_msg();
299            isl_rs_ctx.reset_error();
300            return Err(LibISLError::new(err, err_msg));
301        }
302        Ok(isl_rs_result)
303    }
304
305    /// Wraps `isl_val_div`.
306    pub fn div(self, v2: Val) -> Result<Val, LibISLError> {
307        let v1 = self;
308        let isl_rs_ctx = v1.get_ctx();
309        let mut v1 = v1;
310        v1.do_not_free_on_drop();
311        let v1 = v1.ptr;
312        let mut v2 = v2;
313        v2.do_not_free_on_drop();
314        let v2 = v2.ptr;
315        let isl_rs_result = unsafe { isl_val_div(v1, v2) };
316        let isl_rs_result = Val { ptr: isl_rs_result,
317                                  should_free_on_drop: true };
318        let err = isl_rs_ctx.last_error();
319        if err != Error::None_ {
320            let err_msg = isl_rs_ctx.last_error_msg();
321            isl_rs_ctx.reset_error();
322            return Err(LibISLError::new(err, err_msg));
323        }
324        Ok(isl_rs_result)
325    }
326
327    /// Wraps `isl_val_div_ui`.
328    pub fn div_ui(self, v2: u64) -> Result<Val, LibISLError> {
329        let v1 = self;
330        let isl_rs_ctx = v1.get_ctx();
331        let mut v1 = v1;
332        v1.do_not_free_on_drop();
333        let v1 = v1.ptr;
334        let isl_rs_result = unsafe { isl_val_div_ui(v1, v2) };
335        let isl_rs_result = Val { ptr: isl_rs_result,
336                                  should_free_on_drop: true };
337        let err = isl_rs_ctx.last_error();
338        if err != Error::None_ {
339            let err_msg = isl_rs_ctx.last_error_msg();
340            isl_rs_ctx.reset_error();
341            return Err(LibISLError::new(err, err_msg));
342        }
343        Ok(isl_rs_result)
344    }
345
346    /// Wraps `isl_val_dump`.
347    pub fn dump(&self) -> Result<(), LibISLError> {
348        let v = self;
349        let isl_rs_ctx = v.get_ctx();
350        let v = v.ptr;
351        let isl_rs_result = unsafe { isl_val_dump(v) };
352        let err = isl_rs_ctx.last_error();
353        if err != Error::None_ {
354            let err_msg = isl_rs_ctx.last_error_msg();
355            isl_rs_ctx.reset_error();
356            return Err(LibISLError::new(err, err_msg));
357        }
358        Ok(isl_rs_result)
359    }
360
361    /// Wraps `isl_val_eq`.
362    pub fn eq(&self, v2: &Val) -> Result<bool, LibISLError> {
363        let v1 = self;
364        let isl_rs_ctx = v1.get_ctx();
365        let v1 = v1.ptr;
366        let v2 = v2.ptr;
367        let isl_rs_result = unsafe { isl_val_eq(v1, v2) };
368        let isl_rs_result = match isl_rs_result {
369            0 => false,
370            1 => true,
371            _ => {
372                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
373            }
374        };
375        let err = isl_rs_ctx.last_error();
376        if err != Error::None_ {
377            let err_msg = isl_rs_ctx.last_error_msg();
378            isl_rs_ctx.reset_error();
379            return Err(LibISLError::new(err, err_msg));
380        }
381        Ok(isl_rs_result)
382    }
383
384    /// Wraps `isl_val_eq_si`.
385    pub fn eq_si(&self, i: i64) -> Result<bool, LibISLError> {
386        let v = self;
387        let isl_rs_ctx = v.get_ctx();
388        let v = v.ptr;
389        let isl_rs_result = unsafe { isl_val_eq_si(v, i) };
390        let isl_rs_result = match isl_rs_result {
391            0 => false,
392            1 => true,
393            _ => {
394                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
395            }
396        };
397        let err = isl_rs_ctx.last_error();
398        if err != Error::None_ {
399            let err_msg = isl_rs_ctx.last_error_msg();
400            isl_rs_ctx.reset_error();
401            return Err(LibISLError::new(err, err_msg));
402        }
403        Ok(isl_rs_result)
404    }
405
406    /// Wraps `isl_val_floor`.
407    pub fn floor(self) -> Result<Val, LibISLError> {
408        let v = self;
409        let isl_rs_ctx = v.get_ctx();
410        let mut v = v;
411        v.do_not_free_on_drop();
412        let v = v.ptr;
413        let isl_rs_result = unsafe { isl_val_floor(v) };
414        let isl_rs_result = Val { ptr: isl_rs_result,
415                                  should_free_on_drop: true };
416        let err = isl_rs_ctx.last_error();
417        if err != Error::None_ {
418            let err_msg = isl_rs_ctx.last_error_msg();
419            isl_rs_ctx.reset_error();
420            return Err(LibISLError::new(err, err_msg));
421        }
422        Ok(isl_rs_result)
423    }
424
425    /// Wraps `isl_val_free`.
426    pub fn free(self) -> Result<Val, LibISLError> {
427        let v = self;
428        let isl_rs_ctx = v.get_ctx();
429        let mut v = v;
430        v.do_not_free_on_drop();
431        let v = v.ptr;
432        let isl_rs_result = unsafe { isl_val_free(v) };
433        let isl_rs_result = Val { ptr: isl_rs_result,
434                                  should_free_on_drop: true };
435        let err = isl_rs_ctx.last_error();
436        if err != Error::None_ {
437            let err_msg = isl_rs_ctx.last_error_msg();
438            isl_rs_ctx.reset_error();
439            return Err(LibISLError::new(err, err_msg));
440        }
441        Ok(isl_rs_result)
442    }
443
444    /// Wraps `isl_val_gcd`.
445    pub fn gcd(self, v2: Val) -> Result<Val, LibISLError> {
446        let v1 = self;
447        let isl_rs_ctx = v1.get_ctx();
448        let mut v1 = v1;
449        v1.do_not_free_on_drop();
450        let v1 = v1.ptr;
451        let mut v2 = v2;
452        v2.do_not_free_on_drop();
453        let v2 = v2.ptr;
454        let isl_rs_result = unsafe { isl_val_gcd(v1, v2) };
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            let err_msg = isl_rs_ctx.last_error_msg();
460            isl_rs_ctx.reset_error();
461            return Err(LibISLError::new(err, err_msg));
462        }
463        Ok(isl_rs_result)
464    }
465
466    /// Wraps `isl_val_ge`.
467    pub fn ge(&self, v2: &Val) -> Result<bool, LibISLError> {
468        let v1 = self;
469        let isl_rs_ctx = v1.get_ctx();
470        let v1 = v1.ptr;
471        let v2 = v2.ptr;
472        let isl_rs_result = unsafe { isl_val_ge(v1, v2) };
473        let isl_rs_result = match isl_rs_result {
474            0 => false,
475            1 => true,
476            _ => {
477                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
478            }
479        };
480        let err = isl_rs_ctx.last_error();
481        if err != Error::None_ {
482            let err_msg = isl_rs_ctx.last_error_msg();
483            isl_rs_ctx.reset_error();
484            return Err(LibISLError::new(err, err_msg));
485        }
486        Ok(isl_rs_result)
487    }
488
489    /// Wraps `isl_val_get_ctx`.
490    pub fn get_ctx(&self) -> Context {
491        let val = self;
492        let val = val.ptr;
493        let isl_rs_result = unsafe { isl_val_get_ctx(val) };
494        let isl_rs_result = Context { ptr: isl_rs_result,
495                                      should_free_on_drop: false };
496        isl_rs_result
497    }
498
499    /// Wraps `isl_val_get_d`.
500    pub fn get_d(&self) -> Result<f64, LibISLError> {
501        let v = self;
502        let isl_rs_ctx = v.get_ctx();
503        let v = v.ptr;
504        let isl_rs_result = unsafe { isl_val_get_d(v) };
505        let err = isl_rs_ctx.last_error();
506        if err != Error::None_ {
507            let err_msg = isl_rs_ctx.last_error_msg();
508            isl_rs_ctx.reset_error();
509            return Err(LibISLError::new(err, err_msg));
510        }
511        Ok(isl_rs_result)
512    }
513
514    /// Wraps `isl_val_get_den_si`.
515    pub fn get_den_si(&self) -> Result<i64, LibISLError> {
516        let v = self;
517        let isl_rs_ctx = v.get_ctx();
518        let v = v.ptr;
519        let isl_rs_result = unsafe { isl_val_get_den_si(v) };
520        let err = isl_rs_ctx.last_error();
521        if err != Error::None_ {
522            let err_msg = isl_rs_ctx.last_error_msg();
523            isl_rs_ctx.reset_error();
524            return Err(LibISLError::new(err, err_msg));
525        }
526        Ok(isl_rs_result)
527    }
528
529    /// Wraps `isl_val_get_den_val`.
530    pub fn get_den_val(&self) -> Result<Val, LibISLError> {
531        let v = self;
532        let isl_rs_ctx = v.get_ctx();
533        let v = v.ptr;
534        let isl_rs_result = unsafe { isl_val_get_den_val(v) };
535        let isl_rs_result = Val { ptr: isl_rs_result,
536                                  should_free_on_drop: true };
537        let err = isl_rs_ctx.last_error();
538        if err != Error::None_ {
539            let err_msg = isl_rs_ctx.last_error_msg();
540            isl_rs_ctx.reset_error();
541            return Err(LibISLError::new(err, err_msg));
542        }
543        Ok(isl_rs_result)
544    }
545
546    /// Wraps `isl_val_get_hash`.
547    pub fn get_hash(&self) -> Result<u32, LibISLError> {
548        let val = self;
549        let isl_rs_ctx = val.get_ctx();
550        let val = val.ptr;
551        let isl_rs_result = unsafe { isl_val_get_hash(val) };
552        let err = isl_rs_ctx.last_error();
553        if err != Error::None_ {
554            let err_msg = isl_rs_ctx.last_error_msg();
555            isl_rs_ctx.reset_error();
556            return Err(LibISLError::new(err, err_msg));
557        }
558        Ok(isl_rs_result)
559    }
560
561    /// Wraps `isl_val_get_num_si`.
562    pub fn get_num_si(&self) -> Result<i64, LibISLError> {
563        let v = self;
564        let isl_rs_ctx = v.get_ctx();
565        let v = v.ptr;
566        let isl_rs_result = unsafe { isl_val_get_num_si(v) };
567        let err = isl_rs_ctx.last_error();
568        if err != Error::None_ {
569            let err_msg = isl_rs_ctx.last_error_msg();
570            isl_rs_ctx.reset_error();
571            return Err(LibISLError::new(err, err_msg));
572        }
573        Ok(isl_rs_result)
574    }
575
576    /// Wraps `isl_val_gt`.
577    pub fn gt(&self, v2: &Val) -> Result<bool, LibISLError> {
578        let v1 = self;
579        let isl_rs_ctx = v1.get_ctx();
580        let v1 = v1.ptr;
581        let v2 = v2.ptr;
582        let isl_rs_result = unsafe { isl_val_gt(v1, v2) };
583        let isl_rs_result = match isl_rs_result {
584            0 => false,
585            1 => true,
586            _ => {
587                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
588            }
589        };
590        let err = isl_rs_ctx.last_error();
591        if err != Error::None_ {
592            let err_msg = isl_rs_ctx.last_error_msg();
593            isl_rs_ctx.reset_error();
594            return Err(LibISLError::new(err, err_msg));
595        }
596        Ok(isl_rs_result)
597    }
598
599    /// Wraps `isl_val_gt_si`.
600    pub fn gt_si(&self, i: i64) -> Result<bool, LibISLError> {
601        let v = self;
602        let isl_rs_ctx = v.get_ctx();
603        let v = v.ptr;
604        let isl_rs_result = unsafe { isl_val_gt_si(v, i) };
605        let isl_rs_result = match isl_rs_result {
606            0 => false,
607            1 => true,
608            _ => {
609                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
610            }
611        };
612        let err = isl_rs_ctx.last_error();
613        if err != Error::None_ {
614            let err_msg = isl_rs_ctx.last_error_msg();
615            isl_rs_ctx.reset_error();
616            return Err(LibISLError::new(err, err_msg));
617        }
618        Ok(isl_rs_result)
619    }
620
621    /// Wraps `isl_val_infty`.
622    pub fn infty(ctx: &Context) -> Result<Val, LibISLError> {
623        let isl_rs_ctx = Context { ptr: ctx.ptr,
624                                   should_free_on_drop: false };
625        let ctx = ctx.ptr;
626        let isl_rs_result = unsafe { isl_val_infty(ctx) };
627        let isl_rs_result = Val { ptr: isl_rs_result,
628                                  should_free_on_drop: true };
629        let err = isl_rs_ctx.last_error();
630        if err != Error::None_ {
631            let err_msg = isl_rs_ctx.last_error_msg();
632            isl_rs_ctx.reset_error();
633            return Err(LibISLError::new(err, err_msg));
634        }
635        Ok(isl_rs_result)
636    }
637
638    /// Wraps `isl_val_int_from_si`.
639    pub fn int_from_si(ctx: &Context, i: i64) -> Result<Val, LibISLError> {
640        let isl_rs_ctx = Context { ptr: ctx.ptr,
641                                   should_free_on_drop: false };
642        let ctx = ctx.ptr;
643        let isl_rs_result = unsafe { isl_val_int_from_si(ctx, i) };
644        let isl_rs_result = Val { ptr: isl_rs_result,
645                                  should_free_on_drop: true };
646        let err = isl_rs_ctx.last_error();
647        if err != Error::None_ {
648            let err_msg = isl_rs_ctx.last_error_msg();
649            isl_rs_ctx.reset_error();
650            return Err(LibISLError::new(err, err_msg));
651        }
652        Ok(isl_rs_result)
653    }
654
655    /// Wraps `isl_val_int_from_ui`.
656    pub fn int_from_ui(ctx: &Context, u: u64) -> Result<Val, LibISLError> {
657        let isl_rs_ctx = Context { ptr: ctx.ptr,
658                                   should_free_on_drop: false };
659        let ctx = ctx.ptr;
660        let isl_rs_result = unsafe { isl_val_int_from_ui(ctx, u) };
661        let isl_rs_result = Val { ptr: isl_rs_result,
662                                  should_free_on_drop: true };
663        let err = isl_rs_ctx.last_error();
664        if err != Error::None_ {
665            let err_msg = isl_rs_ctx.last_error_msg();
666            isl_rs_ctx.reset_error();
667            return Err(LibISLError::new(err, err_msg));
668        }
669        Ok(isl_rs_result)
670    }
671
672    /// Wraps `isl_val_inv`.
673    pub fn inv(self) -> Result<Val, LibISLError> {
674        let v = self;
675        let isl_rs_ctx = v.get_ctx();
676        let mut v = v;
677        v.do_not_free_on_drop();
678        let v = v.ptr;
679        let isl_rs_result = unsafe { isl_val_inv(v) };
680        let isl_rs_result = Val { ptr: isl_rs_result,
681                                  should_free_on_drop: true };
682        let err = isl_rs_ctx.last_error();
683        if err != Error::None_ {
684            let err_msg = isl_rs_ctx.last_error_msg();
685            isl_rs_ctx.reset_error();
686            return Err(LibISLError::new(err, err_msg));
687        }
688        Ok(isl_rs_result)
689    }
690
691    /// Wraps `isl_val_is_divisible_by`.
692    pub fn is_divisible_by(&self, v2: &Val) -> Result<bool, LibISLError> {
693        let v1 = self;
694        let isl_rs_ctx = v1.get_ctx();
695        let v1 = v1.ptr;
696        let v2 = v2.ptr;
697        let isl_rs_result = unsafe { isl_val_is_divisible_by(v1, v2) };
698        let isl_rs_result = match isl_rs_result {
699            0 => false,
700            1 => true,
701            _ => {
702                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
703            }
704        };
705        let err = isl_rs_ctx.last_error();
706        if err != Error::None_ {
707            let err_msg = isl_rs_ctx.last_error_msg();
708            isl_rs_ctx.reset_error();
709            return Err(LibISLError::new(err, err_msg));
710        }
711        Ok(isl_rs_result)
712    }
713
714    /// Wraps `isl_val_is_infty`.
715    pub fn is_infty(&self) -> Result<bool, LibISLError> {
716        let v = self;
717        let isl_rs_ctx = v.get_ctx();
718        let v = v.ptr;
719        let isl_rs_result = unsafe { isl_val_is_infty(v) };
720        let isl_rs_result = match isl_rs_result {
721            0 => false,
722            1 => true,
723            _ => {
724                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
725            }
726        };
727        let err = isl_rs_ctx.last_error();
728        if err != Error::None_ {
729            let err_msg = isl_rs_ctx.last_error_msg();
730            isl_rs_ctx.reset_error();
731            return Err(LibISLError::new(err, err_msg));
732        }
733        Ok(isl_rs_result)
734    }
735
736    /// Wraps `isl_val_is_int`.
737    pub fn is_int(&self) -> Result<bool, LibISLError> {
738        let v = self;
739        let isl_rs_ctx = v.get_ctx();
740        let v = v.ptr;
741        let isl_rs_result = unsafe { isl_val_is_int(v) };
742        let isl_rs_result = match isl_rs_result {
743            0 => false,
744            1 => true,
745            _ => {
746                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
747            }
748        };
749        let err = isl_rs_ctx.last_error();
750        if err != Error::None_ {
751            let err_msg = isl_rs_ctx.last_error_msg();
752            isl_rs_ctx.reset_error();
753            return Err(LibISLError::new(err, err_msg));
754        }
755        Ok(isl_rs_result)
756    }
757
758    /// Wraps `isl_val_is_nan`.
759    pub fn is_nan(&self) -> Result<bool, LibISLError> {
760        let v = self;
761        let isl_rs_ctx = v.get_ctx();
762        let v = v.ptr;
763        let isl_rs_result = unsafe { isl_val_is_nan(v) };
764        let isl_rs_result = match isl_rs_result {
765            0 => false,
766            1 => true,
767            _ => {
768                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
769            }
770        };
771        let err = isl_rs_ctx.last_error();
772        if err != Error::None_ {
773            let err_msg = isl_rs_ctx.last_error_msg();
774            isl_rs_ctx.reset_error();
775            return Err(LibISLError::new(err, err_msg));
776        }
777        Ok(isl_rs_result)
778    }
779
780    /// Wraps `isl_val_is_neg`.
781    pub fn is_neg(&self) -> Result<bool, LibISLError> {
782        let v = self;
783        let isl_rs_ctx = v.get_ctx();
784        let v = v.ptr;
785        let isl_rs_result = unsafe { isl_val_is_neg(v) };
786        let isl_rs_result = match isl_rs_result {
787            0 => false,
788            1 => true,
789            _ => {
790                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
791            }
792        };
793        let err = isl_rs_ctx.last_error();
794        if err != Error::None_ {
795            let err_msg = isl_rs_ctx.last_error_msg();
796            isl_rs_ctx.reset_error();
797            return Err(LibISLError::new(err, err_msg));
798        }
799        Ok(isl_rs_result)
800    }
801
802    /// Wraps `isl_val_is_neginfty`.
803    pub fn is_neginfty(&self) -> Result<bool, LibISLError> {
804        let v = self;
805        let isl_rs_ctx = v.get_ctx();
806        let v = v.ptr;
807        let isl_rs_result = unsafe { isl_val_is_neginfty(v) };
808        let isl_rs_result = match isl_rs_result {
809            0 => false,
810            1 => true,
811            _ => {
812                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
813            }
814        };
815        let err = isl_rs_ctx.last_error();
816        if err != Error::None_ {
817            let err_msg = isl_rs_ctx.last_error_msg();
818            isl_rs_ctx.reset_error();
819            return Err(LibISLError::new(err, err_msg));
820        }
821        Ok(isl_rs_result)
822    }
823
824    /// Wraps `isl_val_is_negone`.
825    pub fn is_negone(&self) -> Result<bool, LibISLError> {
826        let v = self;
827        let isl_rs_ctx = v.get_ctx();
828        let v = v.ptr;
829        let isl_rs_result = unsafe { isl_val_is_negone(v) };
830        let isl_rs_result = match isl_rs_result {
831            0 => false,
832            1 => true,
833            _ => {
834                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
835            }
836        };
837        let err = isl_rs_ctx.last_error();
838        if err != Error::None_ {
839            let err_msg = isl_rs_ctx.last_error_msg();
840            isl_rs_ctx.reset_error();
841            return Err(LibISLError::new(err, err_msg));
842        }
843        Ok(isl_rs_result)
844    }
845
846    /// Wraps `isl_val_is_nonneg`.
847    pub fn is_nonneg(&self) -> Result<bool, LibISLError> {
848        let v = self;
849        let isl_rs_ctx = v.get_ctx();
850        let v = v.ptr;
851        let isl_rs_result = unsafe { isl_val_is_nonneg(v) };
852        let isl_rs_result = match isl_rs_result {
853            0 => false,
854            1 => true,
855            _ => {
856                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
857            }
858        };
859        let err = isl_rs_ctx.last_error();
860        if err != Error::None_ {
861            let err_msg = isl_rs_ctx.last_error_msg();
862            isl_rs_ctx.reset_error();
863            return Err(LibISLError::new(err, err_msg));
864        }
865        Ok(isl_rs_result)
866    }
867
868    /// Wraps `isl_val_is_nonpos`.
869    pub fn is_nonpos(&self) -> Result<bool, LibISLError> {
870        let v = self;
871        let isl_rs_ctx = v.get_ctx();
872        let v = v.ptr;
873        let isl_rs_result = unsafe { isl_val_is_nonpos(v) };
874        let isl_rs_result = match isl_rs_result {
875            0 => false,
876            1 => true,
877            _ => {
878                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
879            }
880        };
881        let err = isl_rs_ctx.last_error();
882        if err != Error::None_ {
883            let err_msg = isl_rs_ctx.last_error_msg();
884            isl_rs_ctx.reset_error();
885            return Err(LibISLError::new(err, err_msg));
886        }
887        Ok(isl_rs_result)
888    }
889
890    /// Wraps `isl_val_is_one`.
891    pub fn is_one(&self) -> Result<bool, LibISLError> {
892        let v = self;
893        let isl_rs_ctx = v.get_ctx();
894        let v = v.ptr;
895        let isl_rs_result = unsafe { isl_val_is_one(v) };
896        let isl_rs_result = match isl_rs_result {
897            0 => false,
898            1 => true,
899            _ => {
900                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
901            }
902        };
903        let err = isl_rs_ctx.last_error();
904        if err != Error::None_ {
905            let err_msg = isl_rs_ctx.last_error_msg();
906            isl_rs_ctx.reset_error();
907            return Err(LibISLError::new(err, err_msg));
908        }
909        Ok(isl_rs_result)
910    }
911
912    /// Wraps `isl_val_is_pos`.
913    pub fn is_pos(&self) -> Result<bool, LibISLError> {
914        let v = self;
915        let isl_rs_ctx = v.get_ctx();
916        let v = v.ptr;
917        let isl_rs_result = unsafe { isl_val_is_pos(v) };
918        let isl_rs_result = match isl_rs_result {
919            0 => false,
920            1 => true,
921            _ => {
922                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
923            }
924        };
925        let err = isl_rs_ctx.last_error();
926        if err != Error::None_ {
927            let err_msg = isl_rs_ctx.last_error_msg();
928            isl_rs_ctx.reset_error();
929            return Err(LibISLError::new(err, err_msg));
930        }
931        Ok(isl_rs_result)
932    }
933
934    /// Wraps `isl_val_is_rat`.
935    pub fn is_rat(&self) -> Result<bool, LibISLError> {
936        let v = self;
937        let isl_rs_ctx = v.get_ctx();
938        let v = v.ptr;
939        let isl_rs_result = unsafe { isl_val_is_rat(v) };
940        let isl_rs_result = match isl_rs_result {
941            0 => false,
942            1 => true,
943            _ => {
944                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
945            }
946        };
947        let err = isl_rs_ctx.last_error();
948        if err != Error::None_ {
949            let err_msg = isl_rs_ctx.last_error_msg();
950            isl_rs_ctx.reset_error();
951            return Err(LibISLError::new(err, err_msg));
952        }
953        Ok(isl_rs_result)
954    }
955
956    /// Wraps `isl_val_is_zero`.
957    pub fn is_zero(&self) -> Result<bool, LibISLError> {
958        let v = self;
959        let isl_rs_ctx = v.get_ctx();
960        let v = v.ptr;
961        let isl_rs_result = unsafe { isl_val_is_zero(v) };
962        let isl_rs_result = match isl_rs_result {
963            0 => false,
964            1 => true,
965            _ => {
966                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
967            }
968        };
969        let err = isl_rs_ctx.last_error();
970        if err != Error::None_ {
971            let err_msg = isl_rs_ctx.last_error_msg();
972            isl_rs_ctx.reset_error();
973            return Err(LibISLError::new(err, err_msg));
974        }
975        Ok(isl_rs_result)
976    }
977
978    /// Wraps `isl_val_le`.
979    pub fn le(&self, v2: &Val) -> Result<bool, LibISLError> {
980        let v1 = self;
981        let isl_rs_ctx = v1.get_ctx();
982        let v1 = v1.ptr;
983        let v2 = v2.ptr;
984        let isl_rs_result = unsafe { isl_val_le(v1, v2) };
985        let isl_rs_result = match isl_rs_result {
986            0 => false,
987            1 => true,
988            _ => {
989                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
990            }
991        };
992        let err = isl_rs_ctx.last_error();
993        if err != Error::None_ {
994            let err_msg = isl_rs_ctx.last_error_msg();
995            isl_rs_ctx.reset_error();
996            return Err(LibISLError::new(err, err_msg));
997        }
998        Ok(isl_rs_result)
999    }
1000
1001    /// Wraps `isl_val_lt`.
1002    pub fn lt(&self, v2: &Val) -> Result<bool, LibISLError> {
1003        let v1 = self;
1004        let isl_rs_ctx = v1.get_ctx();
1005        let v1 = v1.ptr;
1006        let v2 = v2.ptr;
1007        let isl_rs_result = unsafe { isl_val_lt(v1, v2) };
1008        let isl_rs_result = match isl_rs_result {
1009            0 => false,
1010            1 => true,
1011            _ => {
1012                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
1013            }
1014        };
1015        let err = isl_rs_ctx.last_error();
1016        if err != Error::None_ {
1017            let err_msg = isl_rs_ctx.last_error_msg();
1018            isl_rs_ctx.reset_error();
1019            return Err(LibISLError::new(err, err_msg));
1020        }
1021        Ok(isl_rs_result)
1022    }
1023
1024    /// Wraps `isl_val_max`.
1025    pub fn max(self, v2: Val) -> Result<Val, LibISLError> {
1026        let v1 = self;
1027        let isl_rs_ctx = v1.get_ctx();
1028        let mut v1 = v1;
1029        v1.do_not_free_on_drop();
1030        let v1 = v1.ptr;
1031        let mut v2 = v2;
1032        v2.do_not_free_on_drop();
1033        let v2 = v2.ptr;
1034        let isl_rs_result = unsafe { isl_val_max(v1, v2) };
1035        let isl_rs_result = Val { ptr: isl_rs_result,
1036                                  should_free_on_drop: true };
1037        let err = isl_rs_ctx.last_error();
1038        if err != Error::None_ {
1039            let err_msg = isl_rs_ctx.last_error_msg();
1040            isl_rs_ctx.reset_error();
1041            return Err(LibISLError::new(err, err_msg));
1042        }
1043        Ok(isl_rs_result)
1044    }
1045
1046    /// Wraps `isl_val_min`.
1047    pub fn min(self, v2: Val) -> Result<Val, LibISLError> {
1048        let v1 = self;
1049        let isl_rs_ctx = v1.get_ctx();
1050        let mut v1 = v1;
1051        v1.do_not_free_on_drop();
1052        let v1 = v1.ptr;
1053        let mut v2 = v2;
1054        v2.do_not_free_on_drop();
1055        let v2 = v2.ptr;
1056        let isl_rs_result = unsafe { isl_val_min(v1, v2) };
1057        let isl_rs_result = Val { ptr: isl_rs_result,
1058                                  should_free_on_drop: true };
1059        let err = isl_rs_ctx.last_error();
1060        if err != Error::None_ {
1061            let err_msg = isl_rs_ctx.last_error_msg();
1062            isl_rs_ctx.reset_error();
1063            return Err(LibISLError::new(err, err_msg));
1064        }
1065        Ok(isl_rs_result)
1066    }
1067
1068    /// Wraps `isl_val_mod`.
1069    pub fn mod_(self, v2: Val) -> Result<Val, LibISLError> {
1070        let v1 = self;
1071        let isl_rs_ctx = v1.get_ctx();
1072        let mut v1 = v1;
1073        v1.do_not_free_on_drop();
1074        let v1 = v1.ptr;
1075        let mut v2 = v2;
1076        v2.do_not_free_on_drop();
1077        let v2 = v2.ptr;
1078        let isl_rs_result = unsafe { isl_val_mod(v1, v2) };
1079        let isl_rs_result = Val { ptr: isl_rs_result,
1080                                  should_free_on_drop: true };
1081        let err = isl_rs_ctx.last_error();
1082        if err != Error::None_ {
1083            let err_msg = isl_rs_ctx.last_error_msg();
1084            isl_rs_ctx.reset_error();
1085            return Err(LibISLError::new(err, err_msg));
1086        }
1087        Ok(isl_rs_result)
1088    }
1089
1090    /// Wraps `isl_val_mul`.
1091    pub fn mul(self, v2: Val) -> Result<Val, LibISLError> {
1092        let v1 = self;
1093        let isl_rs_ctx = v1.get_ctx();
1094        let mut v1 = v1;
1095        v1.do_not_free_on_drop();
1096        let v1 = v1.ptr;
1097        let mut v2 = v2;
1098        v2.do_not_free_on_drop();
1099        let v2 = v2.ptr;
1100        let isl_rs_result = unsafe { isl_val_mul(v1, v2) };
1101        let isl_rs_result = Val { ptr: isl_rs_result,
1102                                  should_free_on_drop: true };
1103        let err = isl_rs_ctx.last_error();
1104        if err != Error::None_ {
1105            let err_msg = isl_rs_ctx.last_error_msg();
1106            isl_rs_ctx.reset_error();
1107            return Err(LibISLError::new(err, err_msg));
1108        }
1109        Ok(isl_rs_result)
1110    }
1111
1112    /// Wraps `isl_val_mul_ui`.
1113    pub fn mul_ui(self, v2: u64) -> Result<Val, LibISLError> {
1114        let v1 = self;
1115        let isl_rs_ctx = v1.get_ctx();
1116        let mut v1 = v1;
1117        v1.do_not_free_on_drop();
1118        let v1 = v1.ptr;
1119        let isl_rs_result = unsafe { isl_val_mul_ui(v1, v2) };
1120        let isl_rs_result = Val { ptr: isl_rs_result,
1121                                  should_free_on_drop: true };
1122        let err = isl_rs_ctx.last_error();
1123        if err != Error::None_ {
1124            let err_msg = isl_rs_ctx.last_error_msg();
1125            isl_rs_ctx.reset_error();
1126            return Err(LibISLError::new(err, err_msg));
1127        }
1128        Ok(isl_rs_result)
1129    }
1130
1131    /// Wraps `isl_val_n_abs_num_chunks`.
1132    pub fn n_abs_num_chunks(&self, size: usize) -> Result<i32, LibISLError> {
1133        let v = self;
1134        let isl_rs_ctx = v.get_ctx();
1135        let v = v.ptr;
1136        let isl_rs_result = unsafe { isl_val_n_abs_num_chunks(v, size) };
1137        let err = isl_rs_ctx.last_error();
1138        if err != Error::None_ {
1139            let err_msg = isl_rs_ctx.last_error_msg();
1140            isl_rs_ctx.reset_error();
1141            return Err(LibISLError::new(err, err_msg));
1142        }
1143        Ok(isl_rs_result)
1144    }
1145
1146    /// Wraps `isl_val_nan`.
1147    pub fn nan(ctx: &Context) -> Result<Val, LibISLError> {
1148        let isl_rs_ctx = Context { ptr: ctx.ptr,
1149                                   should_free_on_drop: false };
1150        let ctx = ctx.ptr;
1151        let isl_rs_result = unsafe { isl_val_nan(ctx) };
1152        let isl_rs_result = Val { ptr: isl_rs_result,
1153                                  should_free_on_drop: true };
1154        let err = isl_rs_ctx.last_error();
1155        if err != Error::None_ {
1156            let err_msg = isl_rs_ctx.last_error_msg();
1157            isl_rs_ctx.reset_error();
1158            return Err(LibISLError::new(err, err_msg));
1159        }
1160        Ok(isl_rs_result)
1161    }
1162
1163    /// Wraps `isl_val_ne`.
1164    pub fn ne(&self, v2: &Val) -> Result<bool, LibISLError> {
1165        let v1 = self;
1166        let isl_rs_ctx = v1.get_ctx();
1167        let v1 = v1.ptr;
1168        let v2 = v2.ptr;
1169        let isl_rs_result = unsafe { isl_val_ne(v1, v2) };
1170        let isl_rs_result = match isl_rs_result {
1171            0 => false,
1172            1 => true,
1173            _ => {
1174                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
1175            }
1176        };
1177        let err = isl_rs_ctx.last_error();
1178        if err != Error::None_ {
1179            let err_msg = isl_rs_ctx.last_error_msg();
1180            isl_rs_ctx.reset_error();
1181            return Err(LibISLError::new(err, err_msg));
1182        }
1183        Ok(isl_rs_result)
1184    }
1185
1186    /// Wraps `isl_val_neg`.
1187    pub fn neg(self) -> Result<Val, LibISLError> {
1188        let v = self;
1189        let isl_rs_ctx = v.get_ctx();
1190        let mut v = v;
1191        v.do_not_free_on_drop();
1192        let v = v.ptr;
1193        let isl_rs_result = unsafe { isl_val_neg(v) };
1194        let isl_rs_result = Val { ptr: isl_rs_result,
1195                                  should_free_on_drop: true };
1196        let err = isl_rs_ctx.last_error();
1197        if err != Error::None_ {
1198            let err_msg = isl_rs_ctx.last_error_msg();
1199            isl_rs_ctx.reset_error();
1200            return Err(LibISLError::new(err, err_msg));
1201        }
1202        Ok(isl_rs_result)
1203    }
1204
1205    /// Wraps `isl_val_neginfty`.
1206    pub fn neginfty(ctx: &Context) -> Result<Val, LibISLError> {
1207        let isl_rs_ctx = Context { ptr: ctx.ptr,
1208                                   should_free_on_drop: false };
1209        let ctx = ctx.ptr;
1210        let isl_rs_result = unsafe { isl_val_neginfty(ctx) };
1211        let isl_rs_result = Val { ptr: isl_rs_result,
1212                                  should_free_on_drop: true };
1213        let err = isl_rs_ctx.last_error();
1214        if err != Error::None_ {
1215            let err_msg = isl_rs_ctx.last_error_msg();
1216            isl_rs_ctx.reset_error();
1217            return Err(LibISLError::new(err, err_msg));
1218        }
1219        Ok(isl_rs_result)
1220    }
1221
1222    /// Wraps `isl_val_negone`.
1223    pub fn negone(ctx: &Context) -> Result<Val, LibISLError> {
1224        let isl_rs_ctx = Context { ptr: ctx.ptr,
1225                                   should_free_on_drop: false };
1226        let ctx = ctx.ptr;
1227        let isl_rs_result = unsafe { isl_val_negone(ctx) };
1228        let isl_rs_result = Val { ptr: isl_rs_result,
1229                                  should_free_on_drop: true };
1230        let err = isl_rs_ctx.last_error();
1231        if err != Error::None_ {
1232            let err_msg = isl_rs_ctx.last_error_msg();
1233            isl_rs_ctx.reset_error();
1234            return Err(LibISLError::new(err, err_msg));
1235        }
1236        Ok(isl_rs_result)
1237    }
1238
1239    /// Wraps `isl_val_one`.
1240    pub fn one(ctx: &Context) -> Result<Val, LibISLError> {
1241        let isl_rs_ctx = Context { ptr: ctx.ptr,
1242                                   should_free_on_drop: false };
1243        let ctx = ctx.ptr;
1244        let isl_rs_result = unsafe { isl_val_one(ctx) };
1245        let isl_rs_result = Val { ptr: isl_rs_result,
1246                                  should_free_on_drop: true };
1247        let err = isl_rs_ctx.last_error();
1248        if err != Error::None_ {
1249            let err_msg = isl_rs_ctx.last_error_msg();
1250            isl_rs_ctx.reset_error();
1251            return Err(LibISLError::new(err, err_msg));
1252        }
1253        Ok(isl_rs_result)
1254    }
1255
1256    /// Wraps `isl_val_pow2`.
1257    pub fn pow2(self) -> Result<Val, LibISLError> {
1258        let v = self;
1259        let isl_rs_ctx = v.get_ctx();
1260        let mut v = v;
1261        v.do_not_free_on_drop();
1262        let v = v.ptr;
1263        let isl_rs_result = unsafe { isl_val_pow2(v) };
1264        let isl_rs_result = Val { ptr: isl_rs_result,
1265                                  should_free_on_drop: true };
1266        let err = isl_rs_ctx.last_error();
1267        if err != Error::None_ {
1268            let err_msg = isl_rs_ctx.last_error_msg();
1269            isl_rs_ctx.reset_error();
1270            return Err(LibISLError::new(err, err_msg));
1271        }
1272        Ok(isl_rs_result)
1273    }
1274
1275    /// Wraps `isl_val_read_from_str`.
1276    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<Val, LibISLError> {
1277        let isl_rs_ctx = Context { ptr: ctx.ptr,
1278                                   should_free_on_drop: false };
1279        let ctx = ctx.ptr;
1280        let str_ = CString::new(str_).unwrap();
1281        let str_ = str_.as_ptr();
1282        let isl_rs_result = unsafe { isl_val_read_from_str(ctx, str_) };
1283        let isl_rs_result = Val { ptr: isl_rs_result,
1284                                  should_free_on_drop: true };
1285        let err = isl_rs_ctx.last_error();
1286        if err != Error::None_ {
1287            let err_msg = isl_rs_ctx.last_error_msg();
1288            isl_rs_ctx.reset_error();
1289            return Err(LibISLError::new(err, err_msg));
1290        }
1291        Ok(isl_rs_result)
1292    }
1293
1294    /// Wraps `isl_val_set_si`.
1295    pub fn set_si(self, i: i64) -> Result<Val, LibISLError> {
1296        let v = self;
1297        let isl_rs_ctx = v.get_ctx();
1298        let mut v = v;
1299        v.do_not_free_on_drop();
1300        let v = v.ptr;
1301        let isl_rs_result = unsafe { isl_val_set_si(v, i) };
1302        let isl_rs_result = Val { ptr: isl_rs_result,
1303                                  should_free_on_drop: true };
1304        let err = isl_rs_ctx.last_error();
1305        if err != Error::None_ {
1306            let err_msg = isl_rs_ctx.last_error_msg();
1307            isl_rs_ctx.reset_error();
1308            return Err(LibISLError::new(err, err_msg));
1309        }
1310        Ok(isl_rs_result)
1311    }
1312
1313    /// Wraps `isl_val_sgn`.
1314    pub fn sgn(&self) -> Result<i32, LibISLError> {
1315        let v = self;
1316        let isl_rs_ctx = v.get_ctx();
1317        let v = v.ptr;
1318        let isl_rs_result = unsafe { isl_val_sgn(v) };
1319        let err = isl_rs_ctx.last_error();
1320        if err != Error::None_ {
1321            let err_msg = isl_rs_ctx.last_error_msg();
1322            isl_rs_ctx.reset_error();
1323            return Err(LibISLError::new(err, err_msg));
1324        }
1325        Ok(isl_rs_result)
1326    }
1327
1328    /// Wraps `isl_val_sub`.
1329    pub fn sub(self, v2: Val) -> Result<Val, LibISLError> {
1330        let v1 = self;
1331        let isl_rs_ctx = v1.get_ctx();
1332        let mut v1 = v1;
1333        v1.do_not_free_on_drop();
1334        let v1 = v1.ptr;
1335        let mut v2 = v2;
1336        v2.do_not_free_on_drop();
1337        let v2 = v2.ptr;
1338        let isl_rs_result = unsafe { isl_val_sub(v1, v2) };
1339        let isl_rs_result = Val { ptr: isl_rs_result,
1340                                  should_free_on_drop: true };
1341        let err = isl_rs_ctx.last_error();
1342        if err != Error::None_ {
1343            let err_msg = isl_rs_ctx.last_error_msg();
1344            isl_rs_ctx.reset_error();
1345            return Err(LibISLError::new(err, err_msg));
1346        }
1347        Ok(isl_rs_result)
1348    }
1349
1350    /// Wraps `isl_val_sub_ui`.
1351    pub fn sub_ui(self, v2: u64) -> Result<Val, LibISLError> {
1352        let v1 = self;
1353        let isl_rs_ctx = v1.get_ctx();
1354        let mut v1 = v1;
1355        v1.do_not_free_on_drop();
1356        let v1 = v1.ptr;
1357        let isl_rs_result = unsafe { isl_val_sub_ui(v1, v2) };
1358        let isl_rs_result = Val { ptr: isl_rs_result,
1359                                  should_free_on_drop: true };
1360        let err = isl_rs_ctx.last_error();
1361        if err != Error::None_ {
1362            let err_msg = isl_rs_ctx.last_error_msg();
1363            isl_rs_ctx.reset_error();
1364            return Err(LibISLError::new(err, err_msg));
1365        }
1366        Ok(isl_rs_result)
1367    }
1368
1369    /// Wraps `isl_val_to_list`.
1370    pub fn to_list(self) -> Result<ValList, LibISLError> {
1371        let el = self;
1372        let isl_rs_ctx = el.get_ctx();
1373        let mut el = el;
1374        el.do_not_free_on_drop();
1375        let el = el.ptr;
1376        let isl_rs_result = unsafe { isl_val_to_list(el) };
1377        let isl_rs_result = ValList { ptr: isl_rs_result,
1378                                      should_free_on_drop: true };
1379        let err = isl_rs_ctx.last_error();
1380        if err != Error::None_ {
1381            let err_msg = isl_rs_ctx.last_error_msg();
1382            isl_rs_ctx.reset_error();
1383            return Err(LibISLError::new(err, err_msg));
1384        }
1385        Ok(isl_rs_result)
1386    }
1387
1388    /// Wraps `isl_val_to_str`.
1389    pub fn to_str(&self) -> Result<&str, LibISLError> {
1390        let v = self;
1391        let isl_rs_ctx = v.get_ctx();
1392        let v = v.ptr;
1393        let isl_rs_result = unsafe { isl_val_to_str(v) };
1394        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1395        let isl_rs_result = isl_rs_result.to_str().unwrap();
1396        let err = isl_rs_ctx.last_error();
1397        if err != Error::None_ {
1398            let err_msg = isl_rs_ctx.last_error_msg();
1399            isl_rs_ctx.reset_error();
1400            return Err(LibISLError::new(err, err_msg));
1401        }
1402        Ok(isl_rs_result)
1403    }
1404
1405    /// Wraps `isl_val_trunc`.
1406    pub fn trunc(self) -> Result<Val, LibISLError> {
1407        let v = self;
1408        let isl_rs_ctx = v.get_ctx();
1409        let mut v = v;
1410        v.do_not_free_on_drop();
1411        let v = v.ptr;
1412        let isl_rs_result = unsafe { isl_val_trunc(v) };
1413        let isl_rs_result = Val { ptr: isl_rs_result,
1414                                  should_free_on_drop: true };
1415        let err = isl_rs_ctx.last_error();
1416        if err != Error::None_ {
1417            let err_msg = isl_rs_ctx.last_error_msg();
1418            isl_rs_ctx.reset_error();
1419            return Err(LibISLError::new(err, err_msg));
1420        }
1421        Ok(isl_rs_result)
1422    }
1423
1424    /// Wraps `isl_val_zero`.
1425    pub fn zero(ctx: &Context) -> Result<Val, LibISLError> {
1426        let isl_rs_ctx = Context { ptr: ctx.ptr,
1427                                   should_free_on_drop: false };
1428        let ctx = ctx.ptr;
1429        let isl_rs_result = unsafe { isl_val_zero(ctx) };
1430        let isl_rs_result = Val { ptr: isl_rs_result,
1431                                  should_free_on_drop: true };
1432        let err = isl_rs_ctx.last_error();
1433        if err != Error::None_ {
1434            let err_msg = isl_rs_ctx.last_error_msg();
1435            isl_rs_ctx.reset_error();
1436            return Err(LibISLError::new(err, err_msg));
1437        }
1438        Ok(isl_rs_result)
1439    }
1440
1441    /// Does not call isl_val_free() on being dropped. (For internal use only.)
1442    pub fn do_not_free_on_drop(&mut self) {
1443        self.should_free_on_drop = false;
1444    }
1445}
1446
1447impl Drop for Val {
1448    fn drop(&mut self) {
1449        if self.should_free_on_drop {
1450            unsafe {
1451                isl_val_free(self.ptr);
1452            }
1453        }
1454    }
1455}
isl_rs/bindings/val.rs

isl_rs/bindings/
val.rs
