Update union generated files

Author: lucic71

tests/unit/out/refcount/union_addrof_external.rs

@@ -0,0 +1,118 @@
+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};
+#[repr(C)]
+#[derive()]
+pub struct record {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub hi: Value<u32>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl ByteRepr for record {}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Container_anon_15_3 {
+    pub h: Value<record>,
+    pub raw_: Value<Box<[u8]>>,
+}
+impl Default for Container_anon_15_3 {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct Container {
+    pub view: Value<Container_anon_15_3>,
+}
+impl ByteRepr for Container {}
+pub fn fill_0(out: AnyPtr, cap: u64) {
+    let out: Value<AnyPtr> = Rc::new(RefCell::new(out));
+    let cap: Value<u64> = Rc::new(RefCell::new(cap));
+    let src: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    (*src.borrow_mut())[(0) as usize] = 2_u8;
+    (*src.borrow_mut())[(1) as usize] = 0_u8;
+    (*src.borrow_mut())[(2) as usize] = 0_u8;
+    (*src.borrow_mut())[(3) as usize] = 80_u8;
+    (*src.borrow_mut())[(4) as usize] = 127_u8;
+    (*src.borrow_mut())[(5) as usize] = 0_u8;
+    (*src.borrow_mut())[(6) as usize] = 0_u8;
+    (*src.borrow_mut())[(7) as usize] = 1_u8;
+    let n: Value<u64> = Rc::new(RefCell::new(
+        if ((::std::mem::size_of::<[u8; 16]>() as u64) < (*cap.borrow())) {
+            ::std::mem::size_of::<[u8; 16]>() as u64
+        } else {
+            (*cap.borrow())
+        },
+    ));
+    {
+        (*out.borrow()).memcpy(
+            &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+            (*n.borrow()) as usize,
+        );
+        (*out.borrow()).clone()
+    };
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>).to_any().memset(
+            (0) as u8,
+            ::std::mem::size_of::<Container>() as u64 as usize,
+        );
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    ({
+        let _out: AnyPtr = (((*c.borrow()).view.as_pointer()).to_strong().as_pointer() as AnyPtr);
+        let _cap: u64 = ::std::mem::size_of::<Container_anon_15_3>() as u64;
+        fill_0(_out, _cap)
+    });
+    assert!((((*(*(*(*c.borrow()).view.borrow()).h.borrow()).code.borrow()) as i32) == (2)));
+    assert!(
+        ((((((*(*(*c.borrow()).view.borrow()).h.borrow()).lo.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((0) as isize)
+            .read()) as i32)
+            == (0))
+    );
+    assert!(
+        ((((((*(*(*c.borrow()).view.borrow()).h.borrow()).lo.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((1) as isize)
+            .read()) as i32)
+            == (80))
+    );
+    assert!((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(0) as usize] as i32) == (2)));
+    assert!(
+        ((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(3) as usize] as u8) as i32) == (80))
+    );
+    return 0;
+}

tests/unit/out/refcount/union_basic.rs

@@ -7,10 +7,15 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 #[derive(Default)]
-pub struct basic {
+pub union basic {
     pub i: Value<i32>,
     pub f: Value<f32>,
 }
+impl Default for basic {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
 impl ByteRepr for basic {}
 pub fn main() {
     std::process::exit(main_0());

tests/unit/out/refcount/union_cross_arm_cast.rs

@@ -0,0 +1,108 @@
+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()]
+pub struct shape_a {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl Default for shape_a {
+    fn default() -> Self {
+        shape_a {
+            code: <Value<u16>>::default(),
+            pad: Rc::new(RefCell::new(
+                (0..14).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+        }
+    }
+}
+impl ByteRepr for shape_a {}
+#[derive()]
+pub struct shape_b {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub mid: Value<u32>,
+    pub fill: Value<Box<[u8]>>,
+    pub tail: Value<u32>,
+}
+impl Default for shape_b {
+    fn default() -> Self {
+        shape_b {
+            code: <Value<u16>>::default(),
+            lo: <Value<u16>>::default(),
+            mid: <Value<u32>>::default(),
+            fill: Rc::new(RefCell::new(
+                (0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+            tail: <Value<u32>>::default(),
+        }
+    }
+}
+impl ByteRepr for shape_b {}
+#[derive()]
+pub union Container_anon_22_3 {
+    pub a: Value<shape_a>,
+    pub b: Value<shape_b>,
+    pub raw_: Value<Box<[u8]>>,
+}
+impl Default for Container_anon_22_3 {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+impl ByteRepr for Container_anon_22_3 {}
+#[derive(Default)]
+pub struct Container {
+    pub len: Value<u32>,
+    pub u: Value<Container_anon_22_3>,
+}
+impl ByteRepr for Container {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>).to_any().memset(
+            (0) as u8,
+            ::std::mem::size_of::<Container>() as u64 as usize,
+        );
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    (*(*(*(*c.borrow()).u.borrow()).a.borrow()).code.borrow_mut()) = 10_u16;
+    (*(*c.borrow()).len.borrow_mut()) = (::std::mem::size_of::<shape_b>() as u64 as u32);
+    (*(*((((*(*c.borrow()).u.borrow()).a.as_pointer())
+        .to_strong()
+        .as_pointer() as AnyPtr)
+        .cast::<shape_b>()
+        .expect("ub:wrong type"))
+    .upgrade()
+    .deref())
+    .tail
+    .borrow_mut()) = 3735928559_u32;
+    assert!(((*(*(*(*c.borrow()).u.borrow()).b.borrow()).tail.borrow()) == 3735928559_u32));
+    assert!((((*(*(*(*c.borrow()).u.borrow()).b.borrow()).code.borrow()) as i32) == 10));
+    (*(*(*(*c.borrow()).u.borrow()).b.borrow()).lo.borrow_mut()) = 8080_u16;
+    assert!(
+        ((((((*(*c.borrow()).u.borrow()).raw_.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((2) as isize)
+            .read()) as i32)
+            == 144)
+    );
+    assert!(
+        ((((((*(*c.borrow()).u.borrow()).raw_.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((3) as isize)
+            .read()) as i32)
+            == 31)
+    );
+    return 0;
+}

tests/unit/out/refcount/union_field_alignment.rs

@@ -0,0 +1,35 @@
+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()]
+pub union node_anon_10_3 {
+    pub bytes: Value<Box<[u8]>>,
+    pub aligner: Value<AnyPtr>,
+}
+impl Default for node_anon_10_3 {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+impl ByteRepr for node_anon_10_3 {}
+#[derive(Default)]
+pub struct node {
+    pub next: Value<Ptr<node>>,
+    pub x: Value<node_anon_10_3>,
+}
+impl ByteRepr for node {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<node> = <Value<node>>::default();
+    (*(*n.borrow()).next.borrow_mut()) = Default::default();
+    (*(*(*n.borrow()).x.borrow()).bytes.borrow_mut())[(0) as usize] = 171_u8;
+    assert!((((*(*(*n.borrow()).x.borrow()).bytes.borrow())[(0) as usize] as i32) == 171));
+    return 0;
+}

tests/unit/out/refcount/union_flex_array_member.rs

@@ -0,0 +1,78 @@
+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()]
+pub union node_anon_10_3 {
+    pub bytes: Value<Box<[u8]>>,
+    pub aligner: Value<AnyPtr>,
+}
+impl Default for node_anon_10_3 {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+impl ByteRepr for node_anon_10_3 {}
+#[derive(Default)]
+pub struct node {
+    pub len: Value<u64>,
+    pub x: Value<node_anon_10_3>,
+}
+impl ByteRepr for node {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let tail_size: Value<u64> = Rc::new(RefCell::new(32_u64));
+    let n: Value<Ptr<node>> = Rc::new(RefCell::new(
+        ({
+            let ___size: u64 =
+                (::std::mem::size_of::<node>() as u64 as u64).wrapping_add((*tail_size.borrow()));
+            malloc_0(___size)
+        })
+        .cast::<node>()
+        .expect("ub:wrong type"),
+    ));
+    (*(*(*n.borrow()).upgrade().deref()).len.borrow_mut()) = (*tail_size.borrow());
+    let i: Value<u64> = Rc::new(RefCell::new(0_u64));
+    'loop_: while ((*i.borrow()) < (*tail_size.borrow())) {
+        let __rhs = ((((*i.borrow()) & 255_u64) as u64) as u8);
+        (*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .borrow_mut())[(*i.borrow()) as usize] = __rhs;
+        (*i.borrow_mut()).postfix_inc();
+    }
+    let i: Value<u64> = Rc::new(RefCell::new(0_u64));
+    'loop_: while ((*i.borrow()) < (*tail_size.borrow())) {
+        assert!({
+            let _lhs = ((*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+                .bytes
+                .borrow())[(*i.borrow()) as usize] as i32);
+            _lhs == (((((*i.borrow()) & 255_u64) as u64) as u8) as i32)
+        });
+        (*i.borrow_mut()).postfix_inc();
+    }
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(
+        (((*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .as_pointer() as Ptr<u8>)
+            .offset(10 as isize)),
+    ));
+    assert!(((((*p.borrow()).read()) as i32) == 10));
+    (*p.borrow()).write(170_u8);
+    assert!(
+        (((*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .borrow())[(10) as usize] as i32)
+            == 170)
+    );
+    ({
+        let ___ptr: AnyPtr = ((*n.borrow()).clone() as Ptr<node>).to_any();
+        free_1(___ptr)
+    });
+    return 0;
+}