Fix default for 2D array (#242)

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -1897,7 +1897,9 @@ ConverterRefCount::GetArrayDefaultAsString(clang::QualType qual_type) {
     const auto &size = array_type->getSize();
     auto size_as_string = GetNumAsString(size);
     auto element_type = array_type->getElementType();
-    PushConversionKind push(*this, ConversionKind::Unboxed);
+    PushConversionKind push(*this, element_type->isArrayType()
+                                       ? ConversionKind::FullRefCount
+                                       : ConversionKind::Unboxed);
     auto element_type_as_string = ToString(element_type);
     auto default_as_string = GetDefaultAsString(element_type);
     return std::format("(0..{}).map(|_| {}).collect::<Box<[{}]>>()",

tests/unit/array_2d_default.c

@@ -0,0 +1,20 @@
+#include <assert.h>
+
+static void fill_row(char *row, char c) {
+  row[0] = c;
+  row[1] = '\0';
+}
+
+int main(void) {
+  char grid[3][6];
+  for (int i = 0; i < 3; i++) {
+    fill_row(grid[i], (char)('a' + i));
+  }
+  assert(grid[0][0] == 'a');
+  assert(grid[1][0] == 'b');
+  assert(grid[2][0] == 'c');
+  assert(grid[1][1] == '\0');
+  grid[2][5] = 'z';
+  assert(grid[2][5] == 'z');
+  return 0;
+}

tests/unit/out/refcount/array_2d_default.rs

@@ -0,0 +1,66 @@
+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 fill_row_0(row: Ptr<u8>, c: u8) {
+    let row: Value<Ptr<u8>> = Rc::new(RefCell::new(row));
+    let c: Value<u8> = Rc::new(RefCell::new(c));
+    let __rhs = (*c.borrow());
+    (*row.borrow()).offset((0) as isize).write(__rhs);
+    (*row.borrow())
+        .offset((1) as isize)
+        .write((('\0' as i32) as u8));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let grid: Value<Box<[Value<Box<[u8]>>]>> = Rc::new(RefCell::new(
+        (0..3)
+            .map(|_| {
+                Rc::new(RefCell::new(
+                    (0..6).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+                ))
+            })
+            .collect::<Box<[Value<Box<[u8]>>]>>(),
+    ));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((((*i.borrow()) < 3) as i32) != 0) {
+        ({
+            let _row: Ptr<u8> = (((grid.as_pointer() as Ptr<Value<Box<[u8]>>>)
+                .offset((*i.borrow()))
+                .read()
+                .as_pointer()) as Ptr<u8>);
+            let _c: u8 = ((('a' as i32) + (*i.borrow())) as u8);
+            fill_row_0(_row, _c)
+        });
+        (*i.borrow_mut()).postfix_inc();
+    }
+    assert!(
+        (((((*grid.borrow())[(0) as usize].borrow()[(0) as usize] as i32) == ('a' as i32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*grid.borrow())[(1) as usize].borrow()[(0) as usize] as i32) == ('b' as i32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*grid.borrow())[(2) as usize].borrow()[(0) as usize] as i32) == ('c' as i32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*grid.borrow())[(1) as usize].borrow()[(1) as usize] as i32) == ('\0' as i32))
+            as i32)
+            != 0)
+    );
+    (*grid.borrow())[(2) as usize].borrow_mut()[(5) as usize] = (('z' as i32) as u8);
+    assert!(
+        (((((*grid.borrow())[(2) as usize].borrow()[(5) as usize] as i32) == ('z' as i32)) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/array_2d_default.rs

@@ -0,0 +1,36 @@
+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 fill_row_0(mut row: *mut libc::c_char, mut c: libc::c_char) {
+    (*row.offset((0) as isize)) = c;
+    (*row.offset((1) as isize)) = (('\0' as i32) as libc::c_char);
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut grid: [[libc::c_char; 6]; 3] = [[(0 as libc::c_char); 6]; 3];
+    let mut i: i32 = 0;
+    'loop_: while ((((i) < (3)) as i32) != 0) {
+        (unsafe {
+            let _row: *mut libc::c_char = grid[(i) as usize].as_mut_ptr();
+            let _c: libc::c_char = ((('a' as i32) + (i)) as libc::c_char);
+            fill_row_0(_row, _c)
+        });
+        i.postfix_inc();
+    }
+    assert!(((((grid[(0) as usize][(0) as usize] as i32) == ('a' as i32)) as i32) != 0));
+    assert!(((((grid[(1) as usize][(0) as usize] as i32) == ('b' as i32)) as i32) != 0));
+    assert!(((((grid[(2) as usize][(0) as usize] as i32) == ('c' as i32)) as i32) != 0));
+    assert!(((((grid[(1) as usize][(1) as usize] as i32) == ('\0' as i32)) as i32) != 0));
+    grid[(2) as usize][(5) as usize] = (('z' as i32) as libc::c_char);
+    assert!(((((grid[(2) as usize][(5) as usize] as i32) == ('z' as i32)) as i32) != 0));
+    return 0;
+}