isl_rs/bindings/
ast_node.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{ASTExpr, ASTNodeList, ASTNodeType, Context, Error, Id, LibISLError, Printer};
5use libc::uintptr_t;
6use std::ffi::CStr;
7use std::os::raw::c_char;
8
9/// Wraps `isl_ast_node`.
10pub struct ASTNode {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_ast_node_alloc_user(expr: uintptr_t) -> uintptr_t;
18
19    fn isl_ast_node_block_from_children(list: uintptr_t) -> uintptr_t;
20
21    fn isl_ast_node_block_get_children(node: uintptr_t) -> uintptr_t;
22
23    fn isl_ast_node_copy(node: uintptr_t) -> uintptr_t;
24
25    fn isl_ast_node_dump(node: uintptr_t) -> ();
26
27    fn isl_ast_node_for_get_body(node: uintptr_t) -> uintptr_t;
28
29    fn isl_ast_node_for_get_cond(node: uintptr_t) -> uintptr_t;
30
31    fn isl_ast_node_for_get_inc(node: uintptr_t) -> uintptr_t;
32
33    fn isl_ast_node_for_get_init(node: uintptr_t) -> uintptr_t;
34
35    fn isl_ast_node_for_get_iterator(node: uintptr_t) -> uintptr_t;
36
37    fn isl_ast_node_for_is_degenerate(node: uintptr_t) -> i32;
38
39    fn isl_ast_node_free(node: uintptr_t) -> uintptr_t;
40
41    fn isl_ast_node_get_annotation(node: uintptr_t) -> uintptr_t;
42
43    fn isl_ast_node_get_ctx(node: uintptr_t) -> uintptr_t;
44
45    fn isl_ast_node_get_type(node: uintptr_t) -> i32;
46
47    fn isl_ast_node_if_get_cond(node: uintptr_t) -> uintptr_t;
48
49    fn isl_ast_node_if_get_else(node: uintptr_t) -> uintptr_t;
50
51    fn isl_ast_node_if_get_else_node(node: uintptr_t) -> uintptr_t;
52
53    fn isl_ast_node_if_get_then(node: uintptr_t) -> uintptr_t;
54
55    fn isl_ast_node_if_get_then_node(node: uintptr_t) -> uintptr_t;
56
57    fn isl_ast_node_if_has_else(node: uintptr_t) -> i32;
58
59    fn isl_ast_node_if_has_else_node(node: uintptr_t) -> i32;
60
61    fn isl_ast_node_mark_get_id(node: uintptr_t) -> uintptr_t;
62
63    fn isl_ast_node_mark_get_node(node: uintptr_t) -> uintptr_t;
64
65    fn isl_ast_node_print_macros(node: uintptr_t, p: uintptr_t) -> uintptr_t;
66
67    fn isl_ast_node_set_annotation(node: uintptr_t, annotation: uintptr_t) -> uintptr_t;
68
69    fn isl_ast_node_to_C_str(node: uintptr_t) -> *const c_char;
70
71    fn isl_ast_node_to_list(el: uintptr_t) -> uintptr_t;
72
73    fn isl_ast_node_to_str(node: uintptr_t) -> *const c_char;
74
75    fn isl_ast_node_user_from_expr(expr: uintptr_t) -> uintptr_t;
76
77    fn isl_ast_node_user_get_expr(node: uintptr_t) -> uintptr_t;
78
79}
80
81impl ASTNode {
82    /// Wraps `isl_ast_node_alloc_user`.
83    pub fn alloc_user(expr: ASTExpr) -> Result<ASTNode, LibISLError> {
84        let isl_rs_ctx = expr.get_ctx();
85        let mut expr = expr;
86        expr.do_not_free_on_drop();
87        let expr = expr.ptr;
88        let isl_rs_result = unsafe { isl_ast_node_alloc_user(expr) };
89        let isl_rs_result = ASTNode { ptr: isl_rs_result,
90                                      should_free_on_drop: true };
91        let err = isl_rs_ctx.last_error();
92        if err != Error::None_ {
93            let err_msg = isl_rs_ctx.last_error_msg();
94            isl_rs_ctx.reset_error();
95            return Err(LibISLError::new(err, err_msg));
96        }
97        Ok(isl_rs_result)
98    }
99
100    /// Wraps `isl_ast_node_block_from_children`.
101    pub fn block_from_children(list: ASTNodeList) -> Result<ASTNode, LibISLError> {
102        let isl_rs_ctx = list.get_ctx();
103        let mut list = list;
104        list.do_not_free_on_drop();
105        let list = list.ptr;
106        let isl_rs_result = unsafe { isl_ast_node_block_from_children(list) };
107        let isl_rs_result = ASTNode { ptr: isl_rs_result,
108                                      should_free_on_drop: true };
109        let err = isl_rs_ctx.last_error();
110        if err != Error::None_ {
111            let err_msg = isl_rs_ctx.last_error_msg();
112            isl_rs_ctx.reset_error();
113            return Err(LibISLError::new(err, err_msg));
114        }
115        Ok(isl_rs_result)
116    }
117
118    /// Wraps `isl_ast_node_block_get_children`.
119    pub fn block_get_children(&self) -> Result<ASTNodeList, LibISLError> {
120        let node = self;
121        let isl_rs_ctx = node.get_ctx();
122        let node = node.ptr;
123        let isl_rs_result = unsafe { isl_ast_node_block_get_children(node) };
124        let isl_rs_result = ASTNodeList { ptr: isl_rs_result,
125                                          should_free_on_drop: true };
126        let err = isl_rs_ctx.last_error();
127        if err != Error::None_ {
128            let err_msg = isl_rs_ctx.last_error_msg();
129            isl_rs_ctx.reset_error();
130            return Err(LibISLError::new(err, err_msg));
131        }
132        Ok(isl_rs_result)
133    }
134
135    /// Wraps `isl_ast_node_copy`.
136    pub fn copy(&self) -> Result<ASTNode, LibISLError> {
137        let node = self;
138        let isl_rs_ctx = node.get_ctx();
139        let node = node.ptr;
140        let isl_rs_result = unsafe { isl_ast_node_copy(node) };
141        let isl_rs_result = ASTNode { ptr: isl_rs_result,
142                                      should_free_on_drop: true };
143        let err = isl_rs_ctx.last_error();
144        if err != Error::None_ {
145            let err_msg = isl_rs_ctx.last_error_msg();
146            isl_rs_ctx.reset_error();
147            return Err(LibISLError::new(err, err_msg));
148        }
149        Ok(isl_rs_result)
150    }
151
152    /// Wraps `isl_ast_node_dump`.
153    pub fn dump(&self) -> Result<(), LibISLError> {
154        let node = self;
155        let isl_rs_ctx = node.get_ctx();
156        let node = node.ptr;
157        let isl_rs_result = unsafe { isl_ast_node_dump(node) };
158        let err = isl_rs_ctx.last_error();
159        if err != Error::None_ {
160            let err_msg = isl_rs_ctx.last_error_msg();
161            isl_rs_ctx.reset_error();
162            return Err(LibISLError::new(err, err_msg));
163        }
164        Ok(isl_rs_result)
165    }
166
167    /// Wraps `isl_ast_node_for_get_body`.
168    pub fn for_get_body(&self) -> Result<ASTNode, LibISLError> {
169        let node = self;
170        let isl_rs_ctx = node.get_ctx();
171        let node = node.ptr;
172        let isl_rs_result = unsafe { isl_ast_node_for_get_body(node) };
173        let isl_rs_result = ASTNode { ptr: isl_rs_result,
174                                      should_free_on_drop: true };
175        let err = isl_rs_ctx.last_error();
176        if err != Error::None_ {
177            let err_msg = isl_rs_ctx.last_error_msg();
178            isl_rs_ctx.reset_error();
179            return Err(LibISLError::new(err, err_msg));
180        }
181        Ok(isl_rs_result)
182    }
183
184    /// Wraps `isl_ast_node_for_get_cond`.
185    pub fn for_get_cond(&self) -> Result<ASTExpr, LibISLError> {
186        let node = self;
187        let isl_rs_ctx = node.get_ctx();
188        let node = node.ptr;
189        let isl_rs_result = unsafe { isl_ast_node_for_get_cond(node) };
190        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
191                                      should_free_on_drop: true };
192        let err = isl_rs_ctx.last_error();
193        if err != Error::None_ {
194            let err_msg = isl_rs_ctx.last_error_msg();
195            isl_rs_ctx.reset_error();
196            return Err(LibISLError::new(err, err_msg));
197        }
198        Ok(isl_rs_result)
199    }
200
201    /// Wraps `isl_ast_node_for_get_inc`.
202    pub fn for_get_inc(&self) -> Result<ASTExpr, LibISLError> {
203        let node = self;
204        let isl_rs_ctx = node.get_ctx();
205        let node = node.ptr;
206        let isl_rs_result = unsafe { isl_ast_node_for_get_inc(node) };
207        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
208                                      should_free_on_drop: true };
209        let err = isl_rs_ctx.last_error();
210        if err != Error::None_ {
211            let err_msg = isl_rs_ctx.last_error_msg();
212            isl_rs_ctx.reset_error();
213            return Err(LibISLError::new(err, err_msg));
214        }
215        Ok(isl_rs_result)
216    }
217
218    /// Wraps `isl_ast_node_for_get_init`.
219    pub fn for_get_init(&self) -> Result<ASTExpr, LibISLError> {
220        let node = self;
221        let isl_rs_ctx = node.get_ctx();
222        let node = node.ptr;
223        let isl_rs_result = unsafe { isl_ast_node_for_get_init(node) };
224        let isl_rs_result = ASTExpr { 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_ast_node_for_get_iterator`.
236    pub fn for_get_iterator(&self) -> Result<ASTExpr, LibISLError> {
237        let node = self;
238        let isl_rs_ctx = node.get_ctx();
239        let node = node.ptr;
240        let isl_rs_result = unsafe { isl_ast_node_for_get_iterator(node) };
241        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
242                                      should_free_on_drop: true };
243        let err = isl_rs_ctx.last_error();
244        if err != Error::None_ {
245            let err_msg = isl_rs_ctx.last_error_msg();
246            isl_rs_ctx.reset_error();
247            return Err(LibISLError::new(err, err_msg));
248        }
249        Ok(isl_rs_result)
250    }
251
252    /// Wraps `isl_ast_node_for_is_degenerate`.
253    pub fn for_is_degenerate(&self) -> Result<bool, LibISLError> {
254        let node = self;
255        let isl_rs_ctx = node.get_ctx();
256        let node = node.ptr;
257        let isl_rs_result = unsafe { isl_ast_node_for_is_degenerate(node) };
258        let isl_rs_result = match isl_rs_result {
259            0 => false,
260            1 => true,
261            _ => {
262                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
263            }
264        };
265        let err = isl_rs_ctx.last_error();
266        if err != Error::None_ {
267            let err_msg = isl_rs_ctx.last_error_msg();
268            isl_rs_ctx.reset_error();
269            return Err(LibISLError::new(err, err_msg));
270        }
271        Ok(isl_rs_result)
272    }
273
274    /// Wraps `isl_ast_node_free`.
275    pub fn free(self) -> Result<ASTNode, LibISLError> {
276        let node = self;
277        let isl_rs_ctx = node.get_ctx();
278        let mut node = node;
279        node.do_not_free_on_drop();
280        let node = node.ptr;
281        let isl_rs_result = unsafe { isl_ast_node_free(node) };
282        let isl_rs_result = ASTNode { ptr: isl_rs_result,
283                                      should_free_on_drop: true };
284        let err = isl_rs_ctx.last_error();
285        if err != Error::None_ {
286            let err_msg = isl_rs_ctx.last_error_msg();
287            isl_rs_ctx.reset_error();
288            return Err(LibISLError::new(err, err_msg));
289        }
290        Ok(isl_rs_result)
291    }
292
293    /// Wraps `isl_ast_node_get_annotation`.
294    pub fn get_annotation(&self) -> Result<Id, LibISLError> {
295        let node = self;
296        let isl_rs_ctx = node.get_ctx();
297        let node = node.ptr;
298        let isl_rs_result = unsafe { isl_ast_node_get_annotation(node) };
299        let isl_rs_result = Id { ptr: isl_rs_result,
300                                 should_free_on_drop: true };
301        let err = isl_rs_ctx.last_error();
302        if err != Error::None_ {
303            let err_msg = isl_rs_ctx.last_error_msg();
304            isl_rs_ctx.reset_error();
305            return Err(LibISLError::new(err, err_msg));
306        }
307        Ok(isl_rs_result)
308    }
309
310    /// Wraps `isl_ast_node_get_ctx`.
311    pub fn get_ctx(&self) -> Context {
312        let node = self;
313        let node = node.ptr;
314        let isl_rs_result = unsafe { isl_ast_node_get_ctx(node) };
315        let isl_rs_result = Context { ptr: isl_rs_result,
316                                      should_free_on_drop: false };
317        isl_rs_result
318    }
319
320    /// Wraps `isl_ast_node_get_type`.
321    pub fn get_type(&self) -> Result<ASTNodeType, LibISLError> {
322        let node = self;
323        let isl_rs_ctx = node.get_ctx();
324        let node = node.ptr;
325        let isl_rs_result = unsafe { isl_ast_node_get_type(node) };
326        let isl_rs_result = ASTNodeType::from_i32(isl_rs_result);
327        let err = isl_rs_ctx.last_error();
328        if err != Error::None_ {
329            let err_msg = isl_rs_ctx.last_error_msg();
330            isl_rs_ctx.reset_error();
331            return Err(LibISLError::new(err, err_msg));
332        }
333        Ok(isl_rs_result)
334    }
335
336    /// Wraps `isl_ast_node_if_get_cond`.
337    pub fn if_get_cond(&self) -> Result<ASTExpr, LibISLError> {
338        let node = self;
339        let isl_rs_ctx = node.get_ctx();
340        let node = node.ptr;
341        let isl_rs_result = unsafe { isl_ast_node_if_get_cond(node) };
342        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
343                                      should_free_on_drop: true };
344        let err = isl_rs_ctx.last_error();
345        if err != Error::None_ {
346            let err_msg = isl_rs_ctx.last_error_msg();
347            isl_rs_ctx.reset_error();
348            return Err(LibISLError::new(err, err_msg));
349        }
350        Ok(isl_rs_result)
351    }
352
353    /// Wraps `isl_ast_node_if_get_else`.
354    pub fn if_get_else(&self) -> Result<ASTNode, LibISLError> {
355        let node = self;
356        let isl_rs_ctx = node.get_ctx();
357        let node = node.ptr;
358        let isl_rs_result = unsafe { isl_ast_node_if_get_else(node) };
359        let isl_rs_result = ASTNode { ptr: isl_rs_result,
360                                      should_free_on_drop: true };
361        let err = isl_rs_ctx.last_error();
362        if err != Error::None_ {
363            let err_msg = isl_rs_ctx.last_error_msg();
364            isl_rs_ctx.reset_error();
365            return Err(LibISLError::new(err, err_msg));
366        }
367        Ok(isl_rs_result)
368    }
369
370    /// Wraps `isl_ast_node_if_get_else_node`.
371    pub fn if_get_else_node(&self) -> Result<ASTNode, LibISLError> {
372        let node = self;
373        let isl_rs_ctx = node.get_ctx();
374        let node = node.ptr;
375        let isl_rs_result = unsafe { isl_ast_node_if_get_else_node(node) };
376        let isl_rs_result = ASTNode { ptr: isl_rs_result,
377                                      should_free_on_drop: true };
378        let err = isl_rs_ctx.last_error();
379        if err != Error::None_ {
380            let err_msg = isl_rs_ctx.last_error_msg();
381            isl_rs_ctx.reset_error();
382            return Err(LibISLError::new(err, err_msg));
383        }
384        Ok(isl_rs_result)
385    }
386
387    /// Wraps `isl_ast_node_if_get_then`.
388    pub fn if_get_then(&self) -> Result<ASTNode, LibISLError> {
389        let node = self;
390        let isl_rs_ctx = node.get_ctx();
391        let node = node.ptr;
392        let isl_rs_result = unsafe { isl_ast_node_if_get_then(node) };
393        let isl_rs_result = ASTNode { ptr: isl_rs_result,
394                                      should_free_on_drop: true };
395        let err = isl_rs_ctx.last_error();
396        if err != Error::None_ {
397            let err_msg = isl_rs_ctx.last_error_msg();
398            isl_rs_ctx.reset_error();
399            return Err(LibISLError::new(err, err_msg));
400        }
401        Ok(isl_rs_result)
402    }
403
404    /// Wraps `isl_ast_node_if_get_then_node`.
405    pub fn if_get_then_node(&self) -> Result<ASTNode, LibISLError> {
406        let node = self;
407        let isl_rs_ctx = node.get_ctx();
408        let node = node.ptr;
409        let isl_rs_result = unsafe { isl_ast_node_if_get_then_node(node) };
410        let isl_rs_result = ASTNode { ptr: isl_rs_result,
411                                      should_free_on_drop: true };
412        let err = isl_rs_ctx.last_error();
413        if err != Error::None_ {
414            let err_msg = isl_rs_ctx.last_error_msg();
415            isl_rs_ctx.reset_error();
416            return Err(LibISLError::new(err, err_msg));
417        }
418        Ok(isl_rs_result)
419    }
420
421    /// Wraps `isl_ast_node_if_has_else`.
422    pub fn if_has_else(&self) -> Result<bool, LibISLError> {
423        let node = self;
424        let isl_rs_ctx = node.get_ctx();
425        let node = node.ptr;
426        let isl_rs_result = unsafe { isl_ast_node_if_has_else(node) };
427        let isl_rs_result = match isl_rs_result {
428            0 => false,
429            1 => true,
430            _ => {
431                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
432            }
433        };
434        let err = isl_rs_ctx.last_error();
435        if err != Error::None_ {
436            let err_msg = isl_rs_ctx.last_error_msg();
437            isl_rs_ctx.reset_error();
438            return Err(LibISLError::new(err, err_msg));
439        }
440        Ok(isl_rs_result)
441    }
442
443    /// Wraps `isl_ast_node_if_has_else_node`.
444    pub fn if_has_else_node(&self) -> Result<bool, LibISLError> {
445        let node = self;
446        let isl_rs_ctx = node.get_ctx();
447        let node = node.ptr;
448        let isl_rs_result = unsafe { isl_ast_node_if_has_else_node(node) };
449        let isl_rs_result = match isl_rs_result {
450            0 => false,
451            1 => true,
452            _ => {
453                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
454            }
455        };
456        let err = isl_rs_ctx.last_error();
457        if err != Error::None_ {
458            let err_msg = isl_rs_ctx.last_error_msg();
459            isl_rs_ctx.reset_error();
460            return Err(LibISLError::new(err, err_msg));
461        }
462        Ok(isl_rs_result)
463    }
464
465    /// Wraps `isl_ast_node_mark_get_id`.
466    pub fn mark_get_id(&self) -> Result<Id, LibISLError> {
467        let node = self;
468        let isl_rs_ctx = node.get_ctx();
469        let node = node.ptr;
470        let isl_rs_result = unsafe { isl_ast_node_mark_get_id(node) };
471        let isl_rs_result = Id { ptr: isl_rs_result,
472                                 should_free_on_drop: true };
473        let err = isl_rs_ctx.last_error();
474        if err != Error::None_ {
475            let err_msg = isl_rs_ctx.last_error_msg();
476            isl_rs_ctx.reset_error();
477            return Err(LibISLError::new(err, err_msg));
478        }
479        Ok(isl_rs_result)
480    }
481
482    /// Wraps `isl_ast_node_mark_get_node`.
483    pub fn mark_get_node(&self) -> Result<ASTNode, LibISLError> {
484        let node = self;
485        let isl_rs_ctx = node.get_ctx();
486        let node = node.ptr;
487        let isl_rs_result = unsafe { isl_ast_node_mark_get_node(node) };
488        let isl_rs_result = ASTNode { ptr: isl_rs_result,
489                                      should_free_on_drop: true };
490        let err = isl_rs_ctx.last_error();
491        if err != Error::None_ {
492            let err_msg = isl_rs_ctx.last_error_msg();
493            isl_rs_ctx.reset_error();
494            return Err(LibISLError::new(err, err_msg));
495        }
496        Ok(isl_rs_result)
497    }
498
499    /// Wraps `isl_ast_node_print_macros`.
500    pub fn print_macros(&self, p: Printer) -> Result<Printer, LibISLError> {
501        let node = self;
502        let isl_rs_ctx = node.get_ctx();
503        let node = node.ptr;
504        let mut p = p;
505        p.do_not_free_on_drop();
506        let p = p.ptr;
507        let isl_rs_result = unsafe { isl_ast_node_print_macros(node, p) };
508        let isl_rs_result = Printer { ptr: isl_rs_result,
509                                      should_free_on_drop: true };
510        let err = isl_rs_ctx.last_error();
511        if err != Error::None_ {
512            let err_msg = isl_rs_ctx.last_error_msg();
513            isl_rs_ctx.reset_error();
514            return Err(LibISLError::new(err, err_msg));
515        }
516        Ok(isl_rs_result)
517    }
518
519    /// Wraps `isl_ast_node_set_annotation`.
520    pub fn set_annotation(self, annotation: Id) -> Result<ASTNode, LibISLError> {
521        let node = self;
522        let isl_rs_ctx = node.get_ctx();
523        let mut node = node;
524        node.do_not_free_on_drop();
525        let node = node.ptr;
526        let mut annotation = annotation;
527        annotation.do_not_free_on_drop();
528        let annotation = annotation.ptr;
529        let isl_rs_result = unsafe { isl_ast_node_set_annotation(node, annotation) };
530        let isl_rs_result = ASTNode { ptr: isl_rs_result,
531                                      should_free_on_drop: true };
532        let err = isl_rs_ctx.last_error();
533        if err != Error::None_ {
534            let err_msg = isl_rs_ctx.last_error_msg();
535            isl_rs_ctx.reset_error();
536            return Err(LibISLError::new(err, err_msg));
537        }
538        Ok(isl_rs_result)
539    }
540
541    /// Wraps `isl_ast_node_to_C_str`.
542    pub fn to_C_str(&self) -> Result<&str, LibISLError> {
543        let node = self;
544        let isl_rs_ctx = node.get_ctx();
545        let node = node.ptr;
546        let isl_rs_result = unsafe { isl_ast_node_to_C_str(node) };
547        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
548        let isl_rs_result = isl_rs_result.to_str().unwrap();
549        let err = isl_rs_ctx.last_error();
550        if err != Error::None_ {
551            let err_msg = isl_rs_ctx.last_error_msg();
552            isl_rs_ctx.reset_error();
553            return Err(LibISLError::new(err, err_msg));
554        }
555        Ok(isl_rs_result)
556    }
557
558    /// Wraps `isl_ast_node_to_list`.
559    pub fn to_list(self) -> Result<ASTNodeList, LibISLError> {
560        let el = self;
561        let isl_rs_ctx = el.get_ctx();
562        let mut el = el;
563        el.do_not_free_on_drop();
564        let el = el.ptr;
565        let isl_rs_result = unsafe { isl_ast_node_to_list(el) };
566        let isl_rs_result = ASTNodeList { ptr: isl_rs_result,
567                                          should_free_on_drop: true };
568        let err = isl_rs_ctx.last_error();
569        if err != Error::None_ {
570            let err_msg = isl_rs_ctx.last_error_msg();
571            isl_rs_ctx.reset_error();
572            return Err(LibISLError::new(err, err_msg));
573        }
574        Ok(isl_rs_result)
575    }
576
577    /// Wraps `isl_ast_node_to_str`.
578    pub fn to_str(&self) -> Result<&str, LibISLError> {
579        let node = self;
580        let isl_rs_ctx = node.get_ctx();
581        let node = node.ptr;
582        let isl_rs_result = unsafe { isl_ast_node_to_str(node) };
583        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
584        let isl_rs_result = isl_rs_result.to_str().unwrap();
585        let err = isl_rs_ctx.last_error();
586        if err != Error::None_ {
587            let err_msg = isl_rs_ctx.last_error_msg();
588            isl_rs_ctx.reset_error();
589            return Err(LibISLError::new(err, err_msg));
590        }
591        Ok(isl_rs_result)
592    }
593
594    /// Wraps `isl_ast_node_user_from_expr`.
595    pub fn user_from_expr(expr: ASTExpr) -> Result<ASTNode, LibISLError> {
596        let isl_rs_ctx = expr.get_ctx();
597        let mut expr = expr;
598        expr.do_not_free_on_drop();
599        let expr = expr.ptr;
600        let isl_rs_result = unsafe { isl_ast_node_user_from_expr(expr) };
601        let isl_rs_result = ASTNode { ptr: isl_rs_result,
602                                      should_free_on_drop: true };
603        let err = isl_rs_ctx.last_error();
604        if err != Error::None_ {
605            let err_msg = isl_rs_ctx.last_error_msg();
606            isl_rs_ctx.reset_error();
607            return Err(LibISLError::new(err, err_msg));
608        }
609        Ok(isl_rs_result)
610    }
611
612    /// Wraps `isl_ast_node_user_get_expr`.
613    pub fn user_get_expr(&self) -> Result<ASTExpr, LibISLError> {
614        let node = self;
615        let isl_rs_ctx = node.get_ctx();
616        let node = node.ptr;
617        let isl_rs_result = unsafe { isl_ast_node_user_get_expr(node) };
618        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
619                                      should_free_on_drop: true };
620        let err = isl_rs_ctx.last_error();
621        if err != Error::None_ {
622            let err_msg = isl_rs_ctx.last_error_msg();
623            isl_rs_ctx.reset_error();
624            return Err(LibISLError::new(err, err_msg));
625        }
626        Ok(isl_rs_result)
627    }
628
629    /// Does not call isl_ast_node_free() on being dropped. (For internal use
630    /// only.)
631    pub fn do_not_free_on_drop(&mut self) {
632        self.should_free_on_drop = false;
633    }
634}
635
636impl Drop for ASTNode {
637    fn drop(&mut self) {
638        if self.should_free_on_drop {
639            unsafe {
640                isl_ast_node_free(self.ptr);
641            }
642        }
643    }
644}
isl_rs/bindings/ast_node.rs

isl_rs/bindings/
ast_node.rs
