Add vaarg func pointer test

Author: lucic71

tests/unit/out/refcount/va_arg_fn_ptr.rs

@@ -0,0 +1,81 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn square_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return ((*x.borrow()) * (*x.borrow()));
+}
+pub fn negate_1(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return -(*x.borrow());
+}
+pub fn add_2(a: i32, b: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    return ((*a.borrow()) + (*b.borrow()));
+}
+pub fn apply_unary_3(x: i32, args: &[VaArg]) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let fn_: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
+        ((*ap.borrow_mut()).arg::<FnPtr<fn(i32) -> i32>>()).clone(),
+    ));
+    let result: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _arg0: i32 = (*x.borrow());
+            (*(*fn_.borrow()))(_arg0)
+        }),
+    ));
+    return (*result.borrow());
+}
+pub fn apply_binary_4(a: i32, b: i32, args: &[VaArg]) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let fn_: Value<FnPtr<fn(i32, i32) -> i32>> = Rc::new(RefCell::new(
+        ((*ap.borrow_mut()).arg::<FnPtr<fn(i32, i32) -> i32>>()).clone(),
+    ));
+    let result: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _arg0: i32 = (*a.borrow());
+            let _arg1: i32 = (*b.borrow());
+            (*(*fn_.borrow()))(_arg0, _arg1)
+        }),
+    ));
+    return (*result.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (((({
+            let _x: i32 = 5;
+            apply_unary_3(_x, &[FnPtr::<fn(i32) -> i32>::new(square_0).into()])
+        }) == 25) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _x: i32 = 7;
+            apply_unary_3(_x, &[FnPtr::<fn(i32) -> i32>::new(negate_1).into()])
+        }) == -7_i32) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _a: i32 = 3;
+            let _b: i32 = 4;
+            apply_binary_4(_a, _b, &[FnPtr::<fn(i32, i32) -> i32>::new(add_2).into()])
+        }) == 7) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/va_arg_fn_ptr.rs

@@ -0,0 +1,93 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub unsafe fn square_0(mut x: i32) -> i32 {
+    return ((x) * (x));
+}
+pub unsafe fn negate_1(mut x: i32) -> i32 {
+    return -x;
+}
+pub unsafe fn add_2(mut a: i32, mut b: i32) -> i32 {
+    return ((a) + (b));
+}
+pub unsafe fn apply_unary_3(mut x: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = VaList::default();
+    ap = VaList::new(args);
+    let mut fn_: Option<unsafe fn(i32) -> i32> = std::mem::transmute::<
+        *mut ::libc::c_void,
+        Option<unsafe fn(i32) -> i32>,
+    >(ap.arg::<*mut ::libc::c_void>());
+    let mut result: i32 = (unsafe {
+        let _arg0: i32 = x;
+        (fn_).unwrap()(_arg0)
+    });
+    return result;
+}
+pub unsafe fn apply_binary_4(mut a: i32, mut b: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = VaList::default();
+    ap = VaList::new(args);
+    let mut fn_: Option<unsafe fn(i32, i32) -> i32> = std::mem::transmute::<
+        *mut ::libc::c_void,
+        Option<unsafe fn(i32, i32) -> i32>,
+    >(ap.arg::<*mut ::libc::c_void>());
+    let mut result: i32 = (unsafe {
+        let _arg0: i32 = a;
+        let _arg1: i32 = b;
+        (fn_).unwrap()(_arg0, _arg1)
+    });
+    return result;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!(
+        ((((unsafe {
+            let _x: i32 = 5;
+            apply_unary_3(
+                _x,
+                &[
+                    (Some(square_0).map_or(::std::ptr::null_mut(), |f| f as *mut ::libc::c_void))
+                        .into(),
+                ],
+            )
+        }) == (25)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _x: i32 = 7;
+            apply_unary_3(
+                _x,
+                &[
+                    (Some(negate_1).map_or(::std::ptr::null_mut(), |f| f as *mut ::libc::c_void))
+                        .into(),
+                ],
+            )
+        }) == (-7_i32)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _a: i32 = 3;
+            let _b: i32 = 4;
+            apply_binary_4(
+                _a,
+                _b,
+                &[
+                    (Some(add_2).map_or(::std::ptr::null_mut(), |f| f as *mut ::libc::c_void))
+                        .into(),
+                ],
+            )
+        }) == (7)) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/va_arg_fn_ptr.c

@@ -0,0 +1,34 @@
+#include <assert.h>
+#include <stdarg.h>
+
+typedef int (*unary)(int);
+typedef int (*binary)(int, int);
+
+int square(int x) { return x * x; }
+int negate(int x) { return -x; }
+int add(int a, int b) { return a + b; }
+
+int apply_unary(int x, ...) {
+  va_list ap;
+  va_start(ap, x);
+  unary fn = va_arg(ap, unary);
+  int result = fn(x);
+  va_end(ap);
+  return result;
+}
+
+int apply_binary(int a, int b, ...) {
+  va_list ap;
+  va_start(ap, b);
+  binary fn = va_arg(ap, binary);
+  int result = fn(a, b);
+  va_end(ap);
+  return result;
+}
+
+int main() {
+  assert(apply_unary(5, square) == 25);
+  assert(apply_unary(7, negate) == -7);
+  assert(apply_binary(3, 4, add) == 7);
+  return 0;
+}