Skip to content

Commit ff7719a

Browse files
lucic71lucic71
committed
Call fread both through func ptr and direct func call
1 parent a689a25 commit ff7719a

3 files changed

Lines changed: 250 additions & 116 deletions

File tree

‎tests/unit/fn_ptr_stdlib_compare.cpp‎

Lines changed: 19 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,23 @@ typedef size_t (*fread_alternative_t)(char *, size_t, size_t, void *);
99

1010
size_t my_alternative_fread(char *p, size_t n, size_t m, void *f) { return 22; }
1111

12+
#define CHECK_FREAD(call) \
13+
do { \
14+
FILE *stream = fopen("/dev/zero", "rb"); \
15+
assert(stream != nullptr); \
16+
char buf[16]; \
17+
memset(buf, 'X', sizeof(buf)); \
18+
size_t n = (call)(buf, 1, 10, stream); \
19+
assert(n == 10); \
20+
for (int i = 0; i < 10; ++i) { \
21+
assert(buf[i] == 0); \
22+
} \
23+
for (int i = 10; i < 16; ++i) { \
24+
assert(buf[i] == 'X'); \
25+
} \
26+
fclose(stream); \
27+
} while (0)
28+
1229
int main() {
1330
fread_t fn1 = fread;
1431
assert(fn1 == fread);
@@ -20,19 +37,8 @@ int main() {
2037
fread_t f3 = (fread_t)my_alternative_fread;
2138
assert((*f3)(nullptr, 0, 0, nullptr) == 22);
2239

23-
FILE *stream = fopen("/dev/zero", "rb");
24-
assert(stream != nullptr);
25-
char buf[16];
26-
memset(buf, 'X', sizeof(buf));
27-
size_t n = (*fn1)(buf, 1, 10, stream);
28-
assert(n == 10);
29-
for (int i = 0; i < 10; ++i) {
30-
assert(buf[i] == 0);
31-
}
32-
for (int i = 10; i < 16; ++i) {
33-
assert(buf[i] == 'X');
34-
}
35-
fclose(stream);
40+
CHECK_FREAD(fread);
41+
CHECK_FREAD((*fn1));
3642

3743
return 0;
3844
}

‎tests/unit/out/refcount/fn_ptr_stdlib_compare.rs‎

Lines changed: 109 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -66,57 +66,116 @@ fn main_0() -> i32 {
6666
(*(*f3.borrow()))(_arg0, _arg1, _arg2, _arg3)
6767
}) == 22_u64)
6868
);
69-
let stream: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
70-
match Ptr::from_string_literal("rb").to_rust_string() {
71-
v if v == "rb" => std::fs::OpenOptions::new()
72-
.read(true)
73-
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
74-
.ok()
75-
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
76-
v if v == "wb" => std::fs::OpenOptions::new()
77-
.write(true)
78-
.create(true)
79-
.truncate(true)
80-
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
81-
.ok()
82-
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
83-
_ => panic!("unsupported mode"),
84-
},
85-
));
86-
assert!(!((*stream.borrow()).is_null()));
87-
let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
88-
(0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
89-
));
90-
{
91-
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memset(
92-
(('X' as u8) as i32) as u8,
93-
::std::mem::size_of::<[u8; 16]>() as u64 as usize,
94-
);
95-
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
96-
};
97-
let n: Value<u64> = Rc::new(RefCell::new(
98-
({
99-
let _arg0: AnyPtr = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any();
100-
let _arg1: u64 = 1_u64;
101-
let _arg2: u64 = 10_u64;
102-
let _arg3: Ptr<::std::fs::File> = (*stream.borrow()).clone();
103-
(*(*fn1.borrow()))(_arg0, _arg1, _arg2, _arg3)
104-
}),
105-
));
106-
assert!(((*n.borrow()) == 10_u64));
107-
let i: Value<i32> = Rc::new(RefCell::new(0));
108-
'loop_: while ((*i.borrow()) < 10) {
109-
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == 0));
110-
(*i.borrow_mut()).prefix_inc();
69+
'loop_: loop {
70+
let stream: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
71+
match Ptr::from_string_literal("rb").to_rust_string() {
72+
v if v == "rb" => std::fs::OpenOptions::new()
73+
.read(true)
74+
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
75+
.ok()
76+
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
77+
v if v == "wb" => std::fs::OpenOptions::new()
78+
.write(true)
79+
.create(true)
80+
.truncate(true)
81+
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
82+
.ok()
83+
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
84+
_ => panic!("unsupported mode"),
85+
},
86+
));
87+
assert!(!((*stream.borrow()).is_null()));
88+
let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
89+
(0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
90+
));
91+
{
92+
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memset(
93+
(('X' as u8) as i32) as u8,
94+
::std::mem::size_of::<[u8; 16]>() as u64 as usize,
95+
);
96+
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
97+
};
98+
let n: Value<u64> = Rc::new(RefCell::new(libcc2rs::fread_refcount(
99+
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
100+
1_u64,
101+
10_u64,
102+
(*stream.borrow()).clone(),
103+
)));
104+
assert!(((*n.borrow()) == 10_u64));
105+
let i: Value<i32> = Rc::new(RefCell::new(0));
106+
'loop_: while ((*i.borrow()) < 10) {
107+
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == 0));
108+
(*i.borrow_mut()).prefix_inc();
109+
}
110+
let i: Value<i32> = Rc::new(RefCell::new(10));
111+
'loop_: while ((*i.borrow()) < 16) {
112+
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == (('X' as u8) as i32)));
113+
(*i.borrow_mut()).prefix_inc();
114+
}
115+
{
116+
(*stream.borrow()).delete();
117+
0
118+
};
119+
if !(0 != 0) {
120+
break;
121+
}
111122
}
112-
let i: Value<i32> = Rc::new(RefCell::new(10));
113-
'loop_: while ((*i.borrow()) < 16) {
114-
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == (('X' as u8) as i32)));
115-
(*i.borrow_mut()).prefix_inc();
123+
'loop_: loop {
124+
let stream: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
125+
match Ptr::from_string_literal("rb").to_rust_string() {
126+
v if v == "rb" => std::fs::OpenOptions::new()
127+
.read(true)
128+
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
129+
.ok()
130+
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
131+
v if v == "wb" => std::fs::OpenOptions::new()
132+
.write(true)
133+
.create(true)
134+
.truncate(true)
135+
.open(Ptr::from_string_literal("/dev/zero").to_rust_string())
136+
.ok()
137+
.map_or(Ptr::null(), |f| Ptr::alloc(f)),
138+
_ => panic!("unsupported mode"),
139+
},
140+
));
141+
assert!(!((*stream.borrow()).is_null()));
142+
let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
143+
(0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
144+
));
145+
{
146+
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memset(
147+
(('X' as u8) as i32) as u8,
148+
::std::mem::size_of::<[u8; 16]>() as u64 as usize,
149+
);
150+
((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
151+
};
152+
let n: Value<u64> = Rc::new(RefCell::new(
153+
({
154+
let _arg0: AnyPtr = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any();
155+
let _arg1: u64 = 1_u64;
156+
let _arg2: u64 = 10_u64;
157+
let _arg3: Ptr<::std::fs::File> = (*stream.borrow()).clone();
158+
(*(*fn1.borrow()))(_arg0, _arg1, _arg2, _arg3)
159+
}),
160+
));
161+
assert!(((*n.borrow()) == 10_u64));
162+
let i: Value<i32> = Rc::new(RefCell::new(0));
163+
'loop_: while ((*i.borrow()) < 10) {
164+
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == 0));
165+
(*i.borrow_mut()).prefix_inc();
166+
}
167+
let i: Value<i32> = Rc::new(RefCell::new(10));
168+
'loop_: while ((*i.borrow()) < 16) {
169+
assert!((((*buf.borrow())[(*i.borrow()) as usize] as i32) == (('X' as u8) as i32)));
170+
(*i.borrow_mut()).prefix_inc();
171+
}
172+
{
173+
(*stream.borrow()).delete();
174+
0
175+
};
176+
if !(0 != 0) {
177+
break;
178+
}
116179
}
117-
{
118-
(*stream.borrow()).delete();
119-
0
120-
};
121180
return 0;
122181
}

‎tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs‎

Lines changed: 122 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -50,63 +50,132 @@ unsafe fn main_0() -> i32 {
5050
(f3).unwrap()(_arg0, _arg1, _arg2, _arg3)
5151
}) == (22_u64))
5252
);
53-
let mut stream: *mut ::std::fs::File =
54-
match std::ffi::CStr::from_ptr(b"rb\0".as_ptr() as *const i8)
55-
.to_str()
56-
.expect("invalid c-string")
53+
'loop_: loop {
54+
let mut stream: *mut ::std::fs::File =
55+
match std::ffi::CStr::from_ptr(b"rb\0".as_ptr() as *const i8)
56+
.to_str()
57+
.expect("invalid c-string")
58+
{
59+
v if v == "rb" => std::fs::OpenOptions::new()
60+
.read(true)
61+
.open(
62+
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
63+
.to_str()
64+
.expect("invalid c-string"),
65+
)
66+
.ok()
67+
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
68+
v if v == "wb" => std::fs::OpenOptions::new()
69+
.write(true)
70+
.create(true)
71+
.truncate(true)
72+
.open(
73+
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
74+
.to_str()
75+
.expect("invalid c-string"),
76+
)
77+
.ok()
78+
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
79+
_ => panic!("unsupported mode"),
80+
};
81+
assert!(!((stream).is_null()));
82+
let mut buf: [u8; 16] = [0_u8; 16];
5783
{
58-
v if v == "rb" => std::fs::OpenOptions::new()
59-
.read(true)
60-
.open(
61-
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
62-
.to_str()
63-
.expect("invalid c-string"),
64-
)
65-
.ok()
66-
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
67-
v if v == "wb" => std::fs::OpenOptions::new()
68-
.write(true)
69-
.create(true)
70-
.truncate(true)
71-
.open(
72-
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
73-
.to_str()
74-
.expect("invalid c-string"),
75-
)
76-
.ok()
77-
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
78-
_ => panic!("unsupported mode"),
84+
let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
85+
for offset in 0..::std::mem::size_of::<[u8; 16]>() as u64 {
86+
*byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
87+
}
88+
(buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
7989
};
80-
assert!(!((stream).is_null()));
81-
let mut buf: [u8; 16] = [0_u8; 16];
82-
{
83-
let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
84-
for offset in 0..::std::mem::size_of::<[u8; 16]>() as u64 {
85-
*byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
90+
let mut n: u64 = unsafe {
91+
libcc2rs::fread_unsafe(
92+
(buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut ::std::ffi::c_void,
93+
1_u64,
94+
10_u64,
95+
stream,
96+
)
97+
};
98+
assert!(((n) == (10_u64)));
99+
let mut i: i32 = 0;
100+
'loop_: while ((i) < (10)) {
101+
assert!(((buf[(i) as usize] as i32) == (0)));
102+
i.prefix_inc();
103+
}
104+
let mut i: i32 = 10;
105+
'loop_: while ((i) < (16)) {
106+
assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
107+
i.prefix_inc();
108+
}
109+
{
110+
Box::from_raw(stream);
111+
0
112+
};
113+
if !(0 != 0) {
114+
break;
86115
}
87-
(buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
88-
};
89-
let mut n: u64 = (unsafe {
90-
let _arg0: *mut ::libc::c_void = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void);
91-
let _arg1: u64 = 1_u64;
92-
let _arg2: u64 = 10_u64;
93-
let _arg3: *mut ::std::fs::File = stream;
94-
(fn1).unwrap()(_arg0, _arg1, _arg2, _arg3)
95-
});
96-
assert!(((n) == (10_u64)));
97-
let mut i: i32 = 0;
98-
'loop_: while ((i) < (10)) {
99-
assert!(((buf[(i) as usize] as i32) == (0)));
100-
i.prefix_inc();
101116
}
102-
let mut i: i32 = 10;
103-
'loop_: while ((i) < (16)) {
104-
assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
105-
i.prefix_inc();
117+
'loop_: loop {
118+
let mut stream: *mut ::std::fs::File =
119+
match std::ffi::CStr::from_ptr(b"rb\0".as_ptr() as *const i8)
120+
.to_str()
121+
.expect("invalid c-string")
122+
{
123+
v if v == "rb" => std::fs::OpenOptions::new()
124+
.read(true)
125+
.open(
126+
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
127+
.to_str()
128+
.expect("invalid c-string"),
129+
)
130+
.ok()
131+
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
132+
v if v == "wb" => std::fs::OpenOptions::new()
133+
.write(true)
134+
.create(true)
135+
.truncate(true)
136+
.open(
137+
std::ffi::CStr::from_ptr(b"/dev/zero\0".as_ptr() as *const i8)
138+
.to_str()
139+
.expect("invalid c-string"),
140+
)
141+
.ok()
142+
.map_or(std::ptr::null_mut(), |f| Box::into_raw(Box::new(f))),
143+
_ => panic!("unsupported mode"),
144+
};
145+
assert!(!((stream).is_null()));
146+
let mut buf: [u8; 16] = [0_u8; 16];
147+
{
148+
let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
149+
for offset in 0..::std::mem::size_of::<[u8; 16]>() as u64 {
150+
*byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
151+
}
152+
(buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
153+
};
154+
let mut n: u64 = (unsafe {
155+
let _arg0: *mut ::libc::c_void = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void);
156+
let _arg1: u64 = 1_u64;
157+
let _arg2: u64 = 10_u64;
158+
let _arg3: *mut ::std::fs::File = stream;
159+
(fn1).unwrap()(_arg0, _arg1, _arg2, _arg3)
160+
});
161+
assert!(((n) == (10_u64)));
162+
let mut i: i32 = 0;
163+
'loop_: while ((i) < (10)) {
164+
assert!(((buf[(i) as usize] as i32) == (0)));
165+
i.prefix_inc();
166+
}
167+
let mut i: i32 = 10;
168+
'loop_: while ((i) < (16)) {
169+
assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
170+
i.prefix_inc();
171+
}
172+
{
173+
Box::from_raw(stream);
174+
0
175+
};
176+
if !(0 != 0) {
177+
break;
178+
}
106179
}
107-
{
108-
Box::from_raw(stream);
109-
0
110-
};
111180
return 0;
112181
}

0 commit comments

Comments
 (0)