diff --git a/docs/src/runtime/iterators.md b/docs/src/runtime/iterators.md index c1c56feb8..421fcb3ba 100644 --- a/docs/src/runtime/iterators.md +++ b/docs/src/runtime/iterators.md @@ -27,14 +27,6 @@ for x in v.as_pointer() as Ptr { } ``` -`PtrValueIter` yields copies of the elements instead of pointers to them; rule -bodies use it to feed a range of C memory to Rust iterator adaptors: - -```rust -// std::accumulate(first, last, init) -let count = (last - first) as usize; -PtrValueIter::new(&first, count).fold(init, |acc, x| acc + x) -``` ## Stable iterators diff --git a/libcc2rs/src/rc.rs b/libcc2rs/src/rc.rs index f97408a46..f0742fe5f 100644 --- a/libcc2rs/src/rc.rs +++ b/libcc2rs/src/rc.rs @@ -1229,43 +1229,6 @@ impl Iterator for Ptr { } } -// Ptr iterator that yields values instead of pointers. -// It's more efficient and it's useful to implement idiomatic iterator patterns -pub struct PtrValueIter { - ptr: Ptr, - n: usize, -} - -impl PtrValueIter { - pub fn new(ptr: &Ptr, n: usize) -> Self { - Self { - ptr: ptr.clone(), - n, - } - } -} - -impl Iterator for PtrValueIter { - type Item = T; - - fn next(&mut self) -> Option { - if self.n > 0 { - let value = self.ptr.read(); - self.ptr += 1; - self.n -= 1; - Some(value) - } else { - None - } - } - - fn size_hint(&self) -> (usize, Option) { - (self.n, Some(self.n)) - } -} - -impl ExactSizeIterator for PtrValueIter {} - impl Sub for Ptr { type Output = isize; fn sub(self, other: Self) -> Self::Output { diff --git a/rules/algorithm/src.cpp b/rules/algorithm/src.cpp index bfed13eaa..f67220ef8 100644 --- a/rules/algorithm/src.cpp +++ b/rules/algorithm/src.cpp @@ -40,9 +40,8 @@ void f12(T1 first, T1 last, const T2 &value) { return std::fill(first, last, value); } -std::ostream_iterator f13(std::string::iterator a0, - std::string::iterator a1, - std::ostream_iterator a2) { +template +std::ostream_iterator f13(T1 a0, T1 a1, std::ostream_iterator a2) { return std::copy(a0, a1, a2); } diff --git a/rules/algorithm/tgt_refcount.rs b/rules/algorithm/tgt_refcount.rs index 545449a96..2374d6825 100644 --- a/rules/algorithm/tgt_refcount.rs +++ b/rules/algorithm/tgt_refcount.rs @@ -122,10 +122,14 @@ fn f12, T2: Clone + ByteRepr>(a0: T1, a1: T1, a2: T2) { } } -fn f13(a0: Ptr, a1: Ptr, a2: &mut ::std::fs::File) -> ::std::fs::File { - a0.with_slice(a1.get_offset() - a0.get_offset(), |__s| { - CChar::with_u8_slice(__s, |__b| a2.write_all(__b)) - }); +fn f13>(a0: T1, a1: T1, a2: &mut ::std::fs::File) -> ::std::fs::File { + let mut __bytes: Vec = Vec::new(); + let mut __it = a0; + while __it != a1 { + __bytes.push(__it.iter_deref().read() as u8); + __it.iter_inc(); + } + a2.write_all(&__bytes); a2.try_clone().unwrap() } diff --git a/rules/algorithm/tgt_unsafe.rs b/rules/algorithm/tgt_unsafe.rs index f07c3004f..169ec1d20 100644 --- a/rules/algorithm/tgt_unsafe.rs +++ b/rules/algorithm/tgt_unsafe.rs @@ -112,15 +112,18 @@ unsafe fn f12, T2: Clone>(a0: T1, a1: T1, a2: T2) } } -unsafe fn f13( - a0: *const libc::c_char, - a1: *const libc::c_char, +unsafe fn f13>( + a0: T1, + a1: T1, a2: &mut ::std::fs::File, ) -> ::std::fs::File { - let __start = a0 as *const u8; - let __end = a1 as *const u8; - let __len = __end.offset_from(__start) as usize; - a2.write_all(::std::slice::from_raw_parts(__start, __len)); + let mut __bytes: Vec = Vec::new(); + let mut __it = a0; + while __it != a1 { + __bytes.push(*__it.iter_deref() as u8); + __it.iter_inc(); + } + a2.write_all(&__bytes); a2.try_clone().unwrap() } diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs index bc7832ffa..351a9d057 100644 --- a/rules/iterator_category/shim.rs +++ b/rules/iterator_category/shim.rs @@ -338,14 +338,6 @@ macro_rules! random_access_iterator { Vec($ptr), } - impl $name { - pub fn vec_ptr(&self) -> $ptr { - match self { - Self::Vec(p) => p.clone(), - } - } - } - impl Default for $name { fn default() -> Self { Self::Vec($null) @@ -354,7 +346,9 @@ macro_rules! random_access_iterator { impl Clone for $name { fn clone(&self) -> Self { - Self::Vec(self.vec_ptr()) + match self { + Self::Vec(p) => Self::Vec(p.clone()), + } } } @@ -442,6 +436,14 @@ random_access_iterator!( Ptr::null() ); +impl RandomAccessIterator { + pub fn index(&self) -> usize { + match self { + Self::Vec(p) => p.get_offset(), + } + } +} + random_access_iterator!( UnsafeRandomAccessIterator, *mut T, diff --git a/rules/string/src.cpp b/rules/string/src.cpp index a61569193..2ebae94da 100644 --- a/rules/string/src.cpp +++ b/rules/string/src.cpp @@ -6,7 +6,6 @@ #include using t1 = std::string; -using t2 = std::string::iterator; typedef std::string::size_type t3; std::string f1(const std::string &s, std::size_t pos, std::size_t count) { @@ -57,10 +56,6 @@ bool f18(const std::string &a, const char *b) { return a == b; } std::size_t f19(const std::string &s) { return s.length(); } -std::string::iterator f20(std::string::iterator it, std::size_t n) { - return it + n; -} - std::string &f21(std::string &s, std::size_t n, char c) { return s.append(n, c); } diff --git a/rules/string/tgt_refcount.rs b/rules/string/tgt_refcount.rs index 4d96960d2..3b94acee5 100644 --- a/rules/string/tgt_refcount.rs +++ b/rules/string/tgt_refcount.rs @@ -9,10 +9,6 @@ fn t1() -> Vec { vec![0] } -fn t2() -> Ptr { - Ptr::null() -} - fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len().saturating_sub(1))].to_vec(); @@ -62,8 +58,8 @@ fn f11(a0: Ptr) -> Ptr { a0 } -fn f12(a0: Ptr) -> Ptr { - a0 +fn f12(a0: Ptr) -> RandomAccessIterator { + RandomAccessIterator::Vec(a0) } fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr> { @@ -80,8 +76,8 @@ fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr) -> Ptr { - a0.to_last() +fn f15(a0: Ptr) -> RandomAccessIterator { + RandomAccessIterator::Vec(a0.to_last()) } fn f16(a0: Vec, a1: Ptr) -> usize { @@ -106,10 +102,6 @@ fn f18(a0: Vec, a1: Ptr) -> bool { a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] == *__s) } -fn f20(a0: Ptr, a1: usize) -> Ptr { - a0.offset(a1 as isize) -} - // TODO: This should return a0 fn f21(a0: &mut Vec, a1: usize, a2: i8) -> Vec { a0.pop(); diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index a7b7966de..32cacd28c 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -1,14 +1,12 @@ // Copyright (c) 2022-present INESC-ID. // Distributed under the MIT license that can be found in the LICENSE file. +use libcc2rs::*; + fn t1() -> Vec { vec![0] } -fn t2() -> *mut libc::c_char { - ::std::ptr::null_mut() -} - fn t3() -> usize { 0_usize } @@ -80,8 +78,8 @@ unsafe fn f10(a0: *const libc::c_char) -> Vec { unsafe fn f11(a0: Vec) -> *const libc::c_char { a0.as_ptr() } -unsafe fn f12(a0: &mut Vec) -> *mut libc::c_char { - a0.as_mut_ptr() +unsafe fn f12(a0: &mut Vec) -> UnsafeRandomAccessIterator { + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr()) } unsafe fn f13(a0: &mut Vec, a1: usize) { a0.pop(); @@ -100,8 +98,8 @@ unsafe fn f14( ::std::slice::from_raw_parts(a3, a4 as usize).to_vec(), ); } -unsafe fn f15(a0: &mut Vec) -> *mut libc::c_char { - a0.as_mut_ptr().add(a0.len() - 1) +unsafe fn f15(a0: &mut Vec) -> UnsafeRandomAccessIterator { + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len() - 1)) } unsafe fn f16(a0: Vec, a1: *const libc::c_char) -> usize { match a0.iter().rposition(|&c| { @@ -134,9 +132,6 @@ unsafe fn f18(a0: Vec, a1: *const libc::c_char) -> bool { unsafe fn f19(a0: Vec) -> usize { (a0.len() - 1) } -unsafe fn f20(a0: *mut libc::c_char, a1: usize) -> *mut libc::c_char { - a0.add(a1 as usize) -} unsafe fn f21(a0: &mut Vec, a1: usize, a2: libc::c_char) { a0.splice( a0.len() - 1..a0.len() - 1, diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp index 684733efe..e6d62263b 100644 --- a/rules/vector/src.cpp +++ b/rules/vector/src.cpp @@ -136,18 +136,13 @@ void f80(std::vector &o, const T1 &value) { return o.push_back(value); } -template > -std::vector f90(const T1 *first, const T1 *last) { - return std::vector(first, last); -} - template > std::vector f91(const std::initializer_list &a0) { return std::vector(a0); } template , typename T3> -std::vector f92(T3 *first, T3 *last) { +std::vector f92(T3 first, T3 last) { return std::vector(first, last); } @@ -181,10 +176,10 @@ const T1 &f99(const std::vector &o) { return o.back(); } -template > +template , typename T3> typename std::vector::iterator f101(std::vector &o, typename std::vector::const_iterator pos, - const T1 *first, const T1 *last) { + T3 first, T3 last) { return o.insert(pos, first, last); } @@ -231,3 +226,17 @@ auto f114(std::vector &o, Init &&...args) -> decltype(o.emplace_back(std::forward(args)...)) { return o.emplace_back(std::forward(args)...); } + +template > +typename std::vector::iterator +f115(std::vector &o, typename std::vector::const_iterator pos, + std::size_t n, const T1 &value) { + return o.insert(pos, n, value); +} + +template > +typename std::vector::iterator +f116(std::vector &o, typename std::vector::const_iterator pos, + std::initializer_list l) { + return o.insert(pos, l); +} diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 111566a2a..bdb48977e 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -10,9 +10,9 @@ fn f40(a0: Ptr) -> Ptr { } fn f60(a0: Ptr>, a1: RandomAccessIterator) -> RandomAccessIterator { - let idx = a1.vec_ptr().get_offset(); - a0.with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec(a0.decay()) + let __off = a1.index(); + a0.with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec(a0.decay() + __off) } fn f65(a0: Ptr) -> Ptr { @@ -40,27 +40,25 @@ fn f76(a0: Ptr) -> RandomAccessIterator { } fn f77(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.index(); a0.insert(__off, a2); a1 } fn f79(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.index(); a0.insert(__off, a2); a1 } -fn f90(a0: Ptr, a1: Ptr) -> Vec { - let __count = a1.get_offset() - a0.get_offset(); - PtrValueIter::new(&a0, __count).collect::>() -} - -fn f92, T2: Clone + ByteRepr>(a0: Ptr, a1: Ptr) -> Vec { - let __count = a1.get_offset() - a0.get_offset(); - PtrValueIter::new(&a0, __count) - .map(|item| T1::try_from(item).ok().unwrap()) - .collect::>() +fn f92, T2: Clone + ByteRepr, T3: CppInputIterator>(a0: T3, a1: T3) -> Vec { + let mut __v = Vec::new(); + let mut __it = a0; + while __it != a1 { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v } fn f93(a0: Ptr) -> Ptr { @@ -87,15 +85,19 @@ fn f99(a0: Ptr) -> Ptr { a0.to_last() } -fn f101( +fn f101>( a0: Ptr>, a1: RandomAccessIterator, - a2: Ptr, - a3: Ptr, + a2: T3, + a3: T3, ) -> RandomAccessIterator { - let start_idx = a1.vec_ptr().get_offset(); - let count = a3.get_offset() - a2.get_offset(); - let temp_vec: Vec = PtrValueIter::new(&a2, count).collect(); + let start_idx = a1.index(); + let mut temp_vec: Vec = Vec::new(); + let mut __it = a2; + while __it != a3 { + temp_vec.push(__it.iter_deref().read()); + __it.iter_inc(); + } a0.with_mut(|v: &mut Vec| { v.splice(start_idx..start_idx, temp_vec); }); @@ -113,3 +115,15 @@ fn f104(a0: Ptr) -> RandomAccessIterator { fn f105(a0: Ptr>, a1: Vec) { a0.write(a1) } + +fn f115(a0: &mut Vec, a1: RandomAccessIterator, a2: usize, a3: T1) -> RandomAccessIterator { + let __off = a1.index(); + a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + a1 +} + +fn f116(a0: &mut Vec, a1: RandomAccessIterator, a2: Vec) -> RandomAccessIterator { + let __off = a1.index(); + a0.splice(__off..__off, a2); + a1 +} diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index ffcb4fccd..386dbc7af 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -24,7 +24,7 @@ unsafe fn f47(a0: Vec) -> Vec { } unsafe fn f60(a0: &mut Vec, a1: UnsafeRandomAccessIterator) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.remove(pos); a1 } @@ -101,7 +101,7 @@ unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.insert(pos, a2); a1 } @@ -111,7 +111,7 @@ unsafe fn f78(a0: usize, a1: T1) -> Vec { } unsafe fn f79(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.insert(pos, a2); a1 } @@ -121,19 +121,18 @@ unsafe fn f80(a0: &mut Vec, a1: T1) { a0.push(a0_clone) } -unsafe fn f90(a0: *const T1, a1: *const T1) -> Vec { - core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize).to_vec() -} - unsafe fn f91(a0: Vec) -> Vec { a0 } -unsafe fn f92, T2: Clone>(a0: *mut T2, a1: *mut T2) -> Vec { - core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize) - .iter() - .map(|x| T1::try_from(x.clone()).ok().unwrap()) - .collect() +unsafe fn f92, T2: Clone, T3: UnsafeCppInputIterator>(a0: T3, a1: T3) -> Vec { + let mut __v = Vec::new(); + let mut __it = a0; + while __it != a1 { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v } unsafe fn f93(a0: &mut Vec) -> *const T1 { @@ -164,18 +163,20 @@ unsafe fn f99(a0: &Vec) -> &T1 { ((a0).last().unwrap()) } -unsafe fn f101( +unsafe fn f101>( a0: &mut Vec, a1: UnsafeRandomAccessIterator, - a2: *const T1, - a3: *const T1, + a2: T3, + a3: T3, ) -> UnsafeRandomAccessIterator { - let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; - let count = a3.offset_from(a2) as usize; - a0.splice( - __off..__off, - std::slice::from_raw_parts(a2, count).iter().cloned(), - ); + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + let mut __tmp = Vec::new(); + let mut __it = a2; + while __it != a3 { + __tmp.push((*__it.iter_deref()).clone()); + __it.iter_inc(); + } + a0.splice(__off..__off, __tmp); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } @@ -212,3 +213,15 @@ unsafe fn f114(a0: &mut Vec, init: T1) { let __init = init; a0.push(__init) } + +unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) +} + +unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; + a0.splice(__off..__off, a2); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) +} diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs index b73fc34d8..b5904e411 100644 --- a/tests/unit/out/refcount/push_emplace_back.rs +++ b/tests/unit/out/refcount/push_emplace_back.rs @@ -48,13 +48,13 @@ pub fn push_local_from_field_1(mut jpg: Ptr, mut cond: bool) { } { let __a1 = { - let __count = (head.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (head.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(head.as_pointer() as Ptr), __count) - .map(|item| u8::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (head.as_pointer() as Ptr); + while __it != (head.as_pointer() as Ptr).offset((3) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; dest.with_mut(|__v: &mut Vec>| __v.push(__a1)) }; @@ -79,13 +79,13 @@ pub fn emplace_local_from_field_4(mut jpg: Ptr, mut cond: bool) { } { let __init = { - let __count = (head.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (head.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(head.as_pointer() as Ptr), __count) - .map(|item| u8::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (head.as_pointer() as Ptr); + while __it != (head.as_pointer() as Ptr).offset((3) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; dest.with_mut(|__v: &mut Vec>| __v.push(__init)) }; diff --git a/tests/unit/out/refcount/stdcopy_ostream.rs b/tests/unit/out/refcount/stdcopy_ostream.rs index 162408ad4..4ba7ca44a 100644 --- a/tests/unit/out/refcount/stdcopy_ostream.rs +++ b/tests/unit/out/refcount/stdcopy_ostream.rs @@ -25,11 +25,13 @@ fn main_0() -> i32 { .expect("Failed to open file"), )); { - (str.as_pointer() as Ptr).with_slice( - (str.as_pointer() as Ptr).to_last().get_offset() - - (str.as_pointer() as Ptr).get_offset(), - |__s| CChar::with_u8_slice(__s, |__b| (*ofs.borrow_mut()).write_all(__b)), - ); + let mut __bytes: Vec = Vec::new(); + let mut __it = RandomAccessIterator::Vec((str.as_pointer() as Ptr)); + while __it != RandomAccessIterator::Vec((str.as_pointer() as Ptr).to_last()) { + __bytes.push(__it.iter_deref().read() as u8); + __it.iter_inc(); + } + (*ofs.borrow_mut()).write_all(&__bytes); (*ofs.borrow_mut()).try_clone().unwrap() }; } diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index 653ea8d23..450485c99 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs @@ -13,43 +13,47 @@ pub fn main() { fn main_0() -> i32 { let src: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v1: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v1.len() == 3_usize)); assert!(((v1[0_usize] == 1_u32) && (v1[1_usize] == 2_u32)) && (v1[2_usize] == 3_u32)); let mut v2: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u64::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v2.len() == 3_usize)); assert!(((v2[0_usize] == 1_u64) && (v2[1_usize] == 2_u64)) && (v2[2_usize] == 3_u64)); let mut v3: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| i32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v3.len() == 3_usize)); assert!(((v3[0_usize] == 1) && (v3[1_usize] == 2)) && (v3[2_usize] == 3)); let src1: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v4: Vec = { - let __count = (src1.as_pointer() as Ptr).to_end().get_offset() - - (src1.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src1.as_pointer() as Ptr), __count).collect::>() + let mut __v = Vec::new(); + let mut __it = (src1.as_pointer() as Ptr); + while __it != (src1.as_pointer() as Ptr).to_end() { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v4.len() == 3_usize)); assert!(((v4[0_usize] == 1_u32) && (v4[1_usize] == 2_u32)) && (v4[2_usize] == 3_u32)); @@ -58,11 +62,113 @@ fn main_0() -> i32 { let mut start: Ptr = (buf.as_pointer() as Ptr); let mut len: usize = 5_usize; let mut v5: Vec = { - let __count = start.offset((len) as isize).get_offset() - start.get_offset(); - PtrValueIter::new(&start, __count).collect::>() + let mut __v = Vec::new(); + let mut __it = (start).clone(); + while __it != start.offset((len) as isize) { + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v5.len() == 5_usize)); assert!(((v5[0_usize] as i32) == 10) && ((v5[4_usize] as i32) == 50)); + let m: Value, Value)>> = Rc::new(RefCell::new(Map::new())); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(1.clone(), || { + ( + Rc::new(RefCell::new(1)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(10); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(2.clone(), || { + ( + Rc::new(RefCell::new(2)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(20); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(3.clone(), || { + ( + Rc::new(RefCell::new(3)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(30); + let v6: Value, Value)>> = Rc::new(RefCell::new({ + let mut __v = Vec::new(); + let mut __it = (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()); + while __it + != (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()) + { + __v.push( + <(Value, Value)>::try_from(__it.iter_deref().read()) + .ok() + .unwrap(), + ); + __it.iter_inc(); + } + __v + })); + assert!(((*v6.borrow()).len() == 3_usize)); + assert!( + ((*(*v6.borrow())[0_usize].0.borrow()) == 1) + && ((*(*v6.borrow())[0_usize].1.borrow()) == 10) + ); + assert!( + ((*(*v6.borrow())[2_usize].0.borrow()) == 3) + && ((*(*v6.borrow())[2_usize].1.borrow()) == 30) + ); + { + let start_idx = , Value)>>::from( + RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value, Value)>)) + .iter_add(1_isize), + ) + .index(); + let mut temp_vec: Vec<(Value, Value)> = Vec::new(); + let mut __it = (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()); + while __it + != (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()) + { + temp_vec.push(__it.iter_deref().read()); + __it.iter_inc(); + } + (v6.as_pointer() as Ptr, Value)>>).with_mut( + |v: &mut Vec<(Value, Value)>| { + v.splice(start_idx..start_idx, temp_vec); + }, + ); + RandomAccessIterator::Vec( + (v6.as_pointer() as Ptr, Value)>>).decay() + start_idx, + ) + }; + assert!(((*v6.borrow()).len() == 6_usize)); + assert!( + (((*(*v6.borrow())[1_usize].0.borrow()) == 1) + && ((*(*v6.borrow())[3_usize].0.borrow()) == 3)) + && ((*(*v6.borrow())[4_usize].0.borrow()) == 2) + ); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs index 22ed160a4..6a5ccdbc8 100644 --- a/tests/unit/out/unsafe/push_emplace_back.rs +++ b/tests/unit/out/unsafe/push_emplace_back.rs @@ -38,13 +38,15 @@ pub unsafe fn push_local_from_field_1(mut jpg: *mut JPEGData, mut cond: bool) { dest = (&mut (*jpg).app_data as *mut Vec>); } { - let __a1 = core::slice::from_raw_parts( - head.as_mut_ptr(), - (head.as_mut_ptr().offset((3) as isize)).offset_from(head.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u8::try_from(x.clone()).ok().unwrap()) - .collect(); + let __a1 = { + let mut __v = Vec::new(); + let mut __it = head.as_mut_ptr(); + while __it != head.as_mut_ptr().offset((3) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; (*dest).push(__a1) }; } @@ -66,13 +68,15 @@ pub unsafe fn emplace_local_from_field_4(mut jpg: *mut JPEGData, mut cond: bool) dest = (&mut (*jpg).app_data as *mut Vec>); } { - let __init = core::slice::from_raw_parts( - head.as_mut_ptr(), - (head.as_mut_ptr().offset((3) as isize)).offset_from(head.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u8::try_from(x.clone()).ok().unwrap()) - .collect(); + let __init = { + let mut __v = Vec::new(); + let mut __it = head.as_mut_ptr(); + while __it != head.as_mut_ptr().offset((3) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; (*dest).push(__init) }; } diff --git a/tests/unit/out/unsafe/stdcopy_ostream.rs b/tests/unit/out/unsafe/stdcopy_ostream.rs index f298bd329..999710e31 100644 --- a/tests/unit/out/unsafe/stdcopy_ostream.rs +++ b/tests/unit/out/unsafe/stdcopy_ostream.rs @@ -23,10 +23,13 @@ unsafe fn main_0() -> i32 { ::std::fs::File::create(::std::ffi::CStr::from_ptr(file.as_ptr()).to_str().unwrap()) .unwrap(); { - let __start = str.as_mut_ptr() as *const u8; - let __end = str.as_mut_ptr().add(str.len() - 1) as *const u8; - let __len = __end.offset_from(__start) as usize; - ofs.write_all(::std::slice::from_raw_parts(__start, __len)); + let mut __bytes: Vec = Vec::new(); + let mut __it = UnsafeRandomAccessIterator::Vec(str.as_mut_ptr()); + while __it != UnsafeRandomAccessIterator::Vec(str.as_mut_ptr().add(str.len() - 1)) { + __bytes.push(*__it.iter_deref() as u8); + __it.iter_inc(); + } + ofs.write_all(&__bytes); ofs.try_clone().unwrap() }; } diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index a9c316f52..b7fef3955 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs @@ -14,45 +14,55 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut src: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v1: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v1: Vec = { + let mut __v = Vec::new(); + let mut __it = src.as_mut_ptr(); + while __it != src.as_mut_ptr().offset((3) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; assert!(((v1.len()) == (3_usize))); assert!( (((v1[(0_usize)]) == (1_u32)) && ((v1[(1_usize)]) == (2_u32))) && ((v1[(2_usize)]) == (3_u32)) ); - let mut v2: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u64::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v2: Vec = { + let mut __v = Vec::new(); + let mut __it = src.as_mut_ptr(); + while __it != src.as_mut_ptr().offset((3) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; assert!(((v2.len()) == (3_usize))); assert!( (((v2[(0_usize)]) == (1_u64)) && ((v2[(1_usize)]) == (2_u64))) && ((v2[(2_usize)]) == (3_u64)) ); - let mut v3: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| i32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v3: Vec = { + let mut __v = Vec::new(); + let mut __it = src.as_mut_ptr(); + while __it != src.as_mut_ptr().offset((3) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; assert!(((v3.len()) == (3_usize))); assert!((((v3[(0_usize)]) == (1)) && ((v3[(1_usize)]) == (2))) && ((v3[(2_usize)]) == (3))); let src1: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v4: Vec = core::slice::from_raw_parts( - src1.as_ptr(), - (src1.as_ptr().add(src1.len())).offset_from(src1.as_ptr()) as usize, - ) - .to_vec(); + let mut v4: Vec = { + let mut __v = Vec::new(); + let mut __it = src1.as_ptr(); + while __it != src1.as_ptr().add(src1.len()) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; assert!(((v4.len()) == (3_usize))); assert!( (((v4[(0_usize)]) == (1_u32)) && ((v4[(1_usize)]) == (2_u32))) @@ -61,13 +71,56 @@ unsafe fn main_0() -> i32 { let mut buf: [u8; 5] = [10_u8, 20_u8, 30_u8, 40_u8, 50_u8]; let mut start: *const u8 = (buf.as_mut_ptr()).cast_const(); let mut len: usize = 5_usize; - let mut v5: Vec = core::slice::from_raw_parts( - start, - (start.offset((len) as isize)).offset_from(start) as usize, - ) - .to_vec(); + let mut v5: Vec = { + let mut __v = Vec::new(); + let mut __it = start; + while __it != start.offset((len) as isize) { + __v.push(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v + }; assert!(((v5.len()) == (5_usize))); assert!(((v5[(0_usize)] as i32) == (10)) && ((v5[(4_usize)] as i32) == (50))); + let mut m: UnsafeMap = UnsafeMap::new(); + (*&mut (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 10; + (*&mut (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 20; + (*&mut (*m.get_or_insert_with(3.clone(), || (3, ::default()))).1) = 30; + let mut v6: Vec<(i32, i32)> = { + let mut __v = Vec::new(); + let mut __it = m.begin(); + while __it != m.end() { + __v.push( + <(i32, i32)>::try_from((*__it.iter_deref()).clone()) + .ok() + .unwrap(), + ); + __it.iter_inc(); + } + __v + }; + assert!(((v6.len()) == (3_usize))); + assert!(((v6[(0_usize)].0) == (1)) && ((v6[(0_usize)].1) == (10))); + assert!(((v6[(2_usize)].0) == (3)) && ((v6[(2_usize)].1) == (30))); + { + let __off = >::from( + UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr()).iter_add(1_isize), + ) + .iter_distance(&UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr())) + as usize; + let mut __tmp = Vec::new(); + let mut __it = m.begin(); + while __it != m.end() { + __tmp.push((*__it.iter_deref()).clone()); + __it.iter_inc(); + } + v6.splice(__off..__off, __tmp); + UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr().add(__off)) + }; + assert!(((v6.len()) == (6_usize))); + assert!( + (((v6[(1_usize)].0) == (1)) && ((v6[(3_usize)].0) == (3))) && ((v6[(4_usize)].0) == (2)) + ); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/vector.cpp b/tests/unit/vector.cpp index b908ae949..82935676c 100644 --- a/tests/unit/vector.cpp +++ b/tests/unit/vector.cpp @@ -39,6 +39,40 @@ int main() { assert(v2[0] == 100); assert(v2[1] == 2); assert(v2[2] == 3); + int x = 7; + v2.insert(v2.begin() + 1, x); + assert(v2.size() == 4); + assert(v2[0] == 100); + assert(v2[1] == 7); + assert(v2[2] == 2); + v2.insert(v2.end(), 2, 9); + assert(v2.size() == 6); + assert(v2[4] == 9); + assert(v2[5] == 9); + v2.insert(v2.begin() + 2, {11, 12, 13}); + assert(v2.size() == 9); + assert(v2[1] == 7); + assert(v2[2] == 11); + assert(v2[3] == 12); + assert(v2[4] == 13); + assert(v2[5] == 2); + assert(v2[8] == 9); + std::vector src{21, 22}; + v2.insert(v2.begin(), src.begin(), src.end()); + assert(v2.size() == 11); + assert(v2[0] == 21); + assert(v2[1] == 22); + assert(v2[2] == 100); + v2.erase(v2.begin()); + v2.erase(v2.begin()); + for (int i = 0; i < 4; ++i) + v2.erase(v2.begin() + 1); + v2.pop_back(); + v2.pop_back(); + assert(v2.size() == 3); + assert(v2[0] == 100); + assert(v2[1] == 2); + assert(v2[2] == 3); auto s2 = v2.size(); std::vector v3(100, 1); assert(v3.size() == 100); diff --git a/tests/unit/vector_iter_range_ctor.cpp b/tests/unit/vector_iter_range_ctor.cpp index 84d113c1e..03a7868a4 100644 --- a/tests/unit/vector_iter_range_ctor.cpp +++ b/tests/unit/vector_iter_range_ctor.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include int main() { @@ -33,5 +34,17 @@ int main() { assert(v5.size() == 5); assert(v5[0] == 10 && v5[4] == 50); + std::map m; + m[1] = 10; + m[2] = 20; + m[3] = 30; + std::vector> v6(m.begin(), m.end()); + assert(v6.size() == 3); + assert(v6[0].first == 1 && v6[0].second == 10); + assert(v6[2].first == 3 && v6[2].second == 30); + v6.insert(v6.begin() + 1, m.begin(), m.end()); + assert(v6.size() == 6); + assert(v6[1].first == 1 && v6[3].first == 3 && v6[4].first == 2); + return 0; }