Add test to reinterpret NULL as integer pointer in va_arg

Author: lucic71

tests/unit/out/refcount/va_arg_null_int_ptr.rs

@@ -0,0 +1,64 @@
+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 first_nonnull_0(count: i32, args: &[VaArg]) -> i32 {
+    let count: Value<i32> = Rc::new(RefCell::new(count));
+    let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
+    (*ap.borrow_mut()) = VaList::new(args);
+    let result: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((((*i.borrow()) < (*count.borrow())) as i32) != 0) {
+        let p: Value<Ptr<i32>> =
+            Rc::new(RefCell::new(((*ap.borrow_mut()).arg::<Ptr<i32>>()).clone()));
+        if (((!((*p.borrow()).is_null())) as i32) != 0) {
+            let __rhs = ((*p.borrow()).read());
+            (*result.borrow_mut()) = __rhs;
+            break;
+        }
+        (*i.borrow_mut()).postfix_inc();
+    }
+    return (*result.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(42));
+    assert!(
+        (((({
+            let _count: i32 = 2;
+            first_nonnull_0(
+                _count,
+                &[(AnyPtr::default()).into(), (x.as_pointer()).into()],
+            )
+        }) == 42) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _count: i32 = 3;
+            first_nonnull_0(
+                _count,
+                &[
+                    (AnyPtr::default()).into(),
+                    (AnyPtr::default()).into(),
+                    (x.as_pointer()).into(),
+                ],
+            )
+        }) == 42) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _count: i32 = 1;
+            first_nonnull_0(_count, &[(AnyPtr::default()).into()])
+        }) == -1_i32) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/va_arg_null_int_ptr.rs

@@ -0,0 +1,66 @@
+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 first_nonnull_0(mut count: i32, args: &[VaArg]) -> i32 {
+    let mut ap: VaList = VaList::default();
+    ap = VaList::new(args);
+    let mut result: i32 = -1_i32;
+    let mut i: i32 = 0;
+    'loop_: while ((((i) < (count)) as i32) != 0) {
+        let mut p: *mut i32 = ap.arg::<*mut i32>();
+        if (((!((p).is_null())) as i32) != 0) {
+            result = (*p);
+            break;
+        }
+        i.postfix_inc();
+    }
+    return result;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut x: i32 = 42;
+    assert!(
+        ((((unsafe {
+            let _count: i32 = 2;
+            first_nonnull_0(
+                _count,
+                &[
+                    (0 as *mut ::libc::c_void).into(),
+                    (&mut x as *mut i32).into(),
+                ],
+            )
+        }) == (42)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _count: i32 = 3;
+            first_nonnull_0(
+                _count,
+                &[
+                    (0 as *mut ::libc::c_void).into(),
+                    (0 as *mut ::libc::c_void).into(),
+                    (&mut x as *mut i32).into(),
+                ],
+            )
+        }) == (42)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            let _count: i32 = 1;
+            first_nonnull_0(_count, &[(0 as *mut ::libc::c_void).into()])
+        }) == (-1_i32)) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/va_arg_null_int_ptr.c

@@ -0,0 +1,26 @@
+#include <assert.h>
+#include <stdarg.h>
+#include <stddef.h>
+
+int first_nonnull(int count, ...) {
+  va_list ap;
+  va_start(ap, count);
+  int result = -1;
+  for (int i = 0; i < count; i++) {
+    int *p = va_arg(ap, int *);
+    if (p != NULL) {
+      result = *p;
+      break;
+    }
+  }
+  va_end(ap);
+  return result;
+}
+
+int main() {
+  int x = 42;
+  assert(first_nonnull(2, NULL, &x) == 42);
+  assert(first_nonnull(3, NULL, NULL, &x) == 42);
+  assert(first_nonnull(1, NULL) == -1);
+  return 0;
+}