Add generic pointer implementation for VaArg and VaArgGet (#82)

lucic71 · web-flow · commit 2ade29a43d62 · 2026-05-13T10:01:33.000+01:00
This allows passing pointers to user defined structs and to
non-primitive objects to variadic functions.
diff --git a/libcc2rs/src/va_args.rs b/libcc2rs/src/va_args.rs
@@ -27,21 +27,23 @@ macro_rules! impl_va_arg_from {
             fn from(v: $ty) -> Self { VaArg::$variant(v as $cast) }
         }
     )*};
-    (ptr: $($ty:ty),*) => {$(
-        impl From<*mut $ty> for VaArg {
-            fn from(v: *mut $ty) -> Self { VaArg::RawPtr(v as *mut c_void) }
-        }
-        impl From<*const $ty> for VaArg {
-            fn from(v: *const $ty) -> Self { VaArg::RawPtr(v as *mut c_void) }
-        }
-    )*};
 }
 
 impl_va_arg_from!(direct: i32 => Int, u32 => UInt, i64 => Long, u64 => ULong, f64 => Double, AnyPtr => Ptr);
 impl_va_arg_from!(promote: i8 => Int as i32, i16 => Int as i32, u8 => UInt as u32, u16 => UInt as u32, f32 => Double as f64);
-impl_va_arg_from!(ptr: c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
 
-impl<T: Clone + crate::reinterpret::ByteRepr + 'static> From<crate::rc::Ptr<T>> for VaArg {
+impl<T> From<*mut T> for VaArg {
+    fn from(v: *mut T) -> Self {
+        VaArg::RawPtr(v as *mut c_void)
+    }
+}
+impl<T> From<*const T> for VaArg {
+    fn from(v: *const T) -> Self {
+        VaArg::RawPtr(v as *mut c_void)
+    }
+}
+
+impl<T: crate::reinterpret::ByteRepr + 'static> From<crate::rc::Ptr<T>> for VaArg {
     fn from(v: crate::rc::Ptr<T>) -> Self {
         VaArg::Ptr(v.to_any())
     }
@@ -95,23 +97,27 @@ macro_rules! impl_va_arg_get {
             }
         }
     )*};
-    (ptr: $($ty:ty),*) => {$(
-        impl VaArgGet for *mut $ty {
-            fn get(v: &VaArg) -> Self {
-                match v { VaArg::RawPtr(p) => *p as Self, _ => panic!("VaArgGet: expected pointer") }
-            }
-        }
-        impl VaArgGet for *const $ty {
-            fn get(v: &VaArg) -> Self {
-                match v { VaArg::RawPtr(p) => *p as Self, _ => panic!("VaArgGet: expected pointer") }
-            }
-        }
-    )*};
 }
 
 impl_va_arg_get!(int: i8, i16, i32, i64, u8, u16, u32, u64);
 impl_va_arg_get!(float: f32, f64);
-impl_va_arg_get!(ptr: c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
+
+impl<T> VaArgGet for *mut T {
+    fn get(v: &VaArg) -> Self {
+        match v {
+            VaArg::RawPtr(p) => *p as Self,
+            _ => panic!("VaArgGet: expected pointer"),
+        }
+    }
+}
+impl<T> VaArgGet for *const T {
+    fn get(v: &VaArg) -> Self {
+        match v {
+            VaArg::RawPtr(p) => *p as Self,
+            _ => panic!("VaArgGet: expected pointer"),
+        }
+    }
+}
 
 impl<T: 'static> VaArgGet for crate::rc::Ptr<T> {
     fn get(v: &VaArg) -> Self {
diff --git a/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs b/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
@@ -0,0 +1,131 @@
+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};
+#[derive(Default)]
+pub struct node {
+    pub data: Value<i32>,
+    pub next: Value<Ptr<node>>,
+}
+impl ByteRepr for node {}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum opt {
+    #[default]
+    OPT_STRING_OUT = 0,
+    OPT_FILE = 1,
+    OPT_NODE = 2,
+    OPT_NODE_OUT = 3,
+}
+impl From<i32> for opt {
+    fn from(n: i32) -> opt {
+        match n {
+            0 => opt::OPT_STRING_OUT,
+            1 => opt::OPT_FILE,
+            2 => opt::OPT_NODE,
+            3 => opt::OPT_NODE_OUT,
+            _ => panic!("invalid opt value: {}", n),
+        }
+    }
+}
+pub fn dispatch_0(option: i32, __args: &[VaArg]) -> i32 {
+    let option: Value<i32> = Rc::new(RefCell::new(option));
+    let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
+    (*ap.borrow_mut()) = VaList::new(__args);
+    let result: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*option.borrow());
+        match __match_cond {
+            v if v == (opt::OPT_STRING_OUT as i32) => {
+                let out: Value<Ptr<Ptr<u8>>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<Ptr<u8>>>()).clone(),
+                ));
+                (*out.borrow()).write(Ptr::from_string_literal("hello"));
+                (*result.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == (opt::OPT_FILE as i32) => {
+                let f: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<::std::fs::File>>()).clone(),
+                ));
+                (*result.borrow_mut()) = ((!((*f.borrow()).is_null())) as i32).clone();
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE as i32) => {
+                let n: Value<Ptr<node>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<node>>()).clone(),
+                ));
+                (*result.borrow_mut()) = (*(*(*n.borrow()).upgrade().deref()).data.borrow());
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE_OUT as i32) => {
+                let out: Value<Ptr<Ptr<node>>> = Rc::new(RefCell::new(
+                    ((*ap.borrow_mut()).arg::<Ptr<Ptr<node>>>()).clone(),
+                ));
+                (*out.borrow()).write(Ptr::<node>::null());
+                (*result.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return (*result.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::<u8>::null()));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_STRING_OUT as i32);
+            dispatch_0(_option, &[(s.as_pointer()).into()])
+        }) == 1) as i32)
+            != 0)
+    );
+    assert!((((!((*s.borrow()).is_null())) as i32) != 0));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(_option, &[libcc2rs::cout().into()])
+        }) == 1) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(
+                _option,
+                &[(AnyPtr::default())
+                    .cast::<::std::fs::File>()
+                    .expect("ub:wrong type")
+                    .into()],
+            )
+        }) == 0) as i32)
+            != 0)
+    );
+    let head: Value<node> = Rc::new(RefCell::new(node {
+        data: Rc::new(RefCell::new(42)),
+        next: Rc::new(RefCell::new(Ptr::<node>::null())),
+    }));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_NODE as i32);
+            dispatch_0(_option, &[(head.as_pointer()).into()])
+        }) == 42) as i32)
+            != 0)
+    );
+    let outp: Value<Ptr<node>> = Rc::new(RefCell::new((head.as_pointer())));
+    assert!(
+        (((({
+            let _option: i32 = (opt::OPT_NODE_OUT as i32);
+            dispatch_0(_option, &[(outp.as_pointer()).into()])
+        }) == 2) as i32)
+            != 0)
+    );
+    assert!(((((*outp.borrow()).is_null()) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs b/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
@@ -0,0 +1,121 @@
+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;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct node {
+    pub data: i32,
+    pub next: *mut node,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum opt {
+    #[default]
+    OPT_STRING_OUT = 0,
+    OPT_FILE = 1,
+    OPT_NODE = 2,
+    OPT_NODE_OUT = 3,
+}
+impl From<i32> for opt {
+    fn from(n: i32) -> opt {
+        match n {
+            0 => opt::OPT_STRING_OUT,
+            1 => opt::OPT_FILE,
+            2 => opt::OPT_NODE,
+            3 => opt::OPT_NODE_OUT,
+            _ => panic!("invalid opt value: {}", n),
+        }
+    }
+}
+pub unsafe fn dispatch_0(mut option: i32, __args: &[VaArg]) -> i32 {
+    let mut ap: VaList = VaList::default();
+    ap = VaList::new(__args);
+    let mut result: i32 = 0;
+    'switch: {
+        let __match_cond = option;
+        match __match_cond {
+            v if v == (opt::OPT_STRING_OUT as i32) => {
+                let mut out: *mut *const u8 = ap.arg::<*mut *const u8>();
+                (*out) = b"hello\0".as_ptr().cast_mut().cast_const();
+                result = 1;
+                break 'switch;
+            }
+            v if v == (opt::OPT_FILE as i32) => {
+                let mut f: *mut ::std::fs::File = ap.arg::<*mut ::std::fs::File>();
+                result = ((!((f).is_null())) as i32).clone();
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE as i32) => {
+                let mut n: *mut node = ap.arg::<*mut node>();
+                result = (*n).data;
+                break 'switch;
+            }
+            v if v == (opt::OPT_NODE_OUT as i32) => {
+                let mut out: *mut *mut node = ap.arg::<*mut *mut node>();
+                (*out) = std::ptr::null_mut();
+                result = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return result;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut s: *const u8 = std::ptr::null();
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_STRING_OUT as i32);
+            dispatch_0(_option, &[(&mut s as *mut *const u8).into()])
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!((((!((s).is_null())) as i32) != 0));
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(_option, &[libcc2rs::cout_unsafe().into()])
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_FILE as i32);
+            dispatch_0(
+                _option,
+                &[((0 as *mut ::libc::c_void) as *mut ::std::fs::File).into()],
+            )
+        }) == (0)) as i32)
+            != 0)
+    );
+    let mut head: node = node {
+        data: 42,
+        next: std::ptr::null_mut(),
+    };
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_NODE as i32);
+            dispatch_0(_option, &[(&mut head as *mut node).into()])
+        }) == (42)) as i32)
+            != 0)
+    );
+    let mut outp: *mut node = (&mut head as *mut node);
+    assert!(
+        ((((unsafe {
+            let _option: i32 = (opt::OPT_NODE_OUT as i32);
+            dispatch_0(_option, &[(&mut outp as *mut *mut node).into()])
+        }) == (2)) as i32)
+            != 0)
+    );
+    assert!(((((outp).is_null()) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/va_arg_non_primitive_ptrs.c b/tests/unit/va_arg_non_primitive_ptrs.c
@@ -0,0 +1,65 @@
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+struct node {
+  int data;
+  struct node *next;
+};
+
+enum opt {
+  OPT_STRING_OUT,
+  OPT_FILE,
+  OPT_NODE,
+  OPT_NODE_OUT,
+};
+
+int dispatch(int option, ...) {
+  va_list ap;
+  va_start(ap, option);
+  int result = 0;
+  switch (option) {
+  case OPT_STRING_OUT: {
+    const char **out = va_arg(ap, const char **);
+    *out = "hello";
+    result = 1;
+    break;
+  }
+  case OPT_FILE: {
+    FILE *f = va_arg(ap, FILE *);
+    result = (f != NULL);
+    break;
+  }
+  case OPT_NODE: {
+    struct node *n = va_arg(ap, struct node *);
+    result = n->data;
+    break;
+  }
+  case OPT_NODE_OUT: {
+    struct node **out = va_arg(ap, struct node **);
+    *out = NULL;
+    result = 2;
+    break;
+  }
+  }
+  va_end(ap);
+  return result;
+}
+
+int main() {
+  const char *s = NULL;
+  assert(dispatch(OPT_STRING_OUT, &s) == 1);
+  assert(s != NULL);
+
+  assert(dispatch(OPT_FILE, stdout) == 1);
+  assert(dispatch(OPT_FILE, (FILE *)NULL) == 0);
+
+  struct node head = {42, NULL};
+  assert(dispatch(OPT_NODE, &head) == 42);
+
+  struct node *outp = &head;
+  assert(dispatch(OPT_NODE_OUT, &outp) == 2);
+  assert(outp == NULL);
+
+  return 0;
+}
