Skip to content

Commit 1db0d81

Browse files
filmorfilmor
committed
Replace mem::uninitialized by MaybeUninit
1 parent 1bf64e0 commit 1db0d81

File tree

11 files changed

+79
-97
lines changed

11 files changed

+79
-97
lines changed

‎rustler/src/types/binary.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use crate::wrapper::binary::{alloc, realloc, ErlNifBinary};
22
use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
33

4+
use std::mem::MaybeUninit;
45
use std::borrow::{Borrow, BorrowMut};
56
use std::io::Write;
67
use std::ops::{Deref, DerefMut};
@@ -114,7 +115,7 @@ impl DerefMut for OwnedBinary {
114115
impl Drop for OwnedBinary {
115116
fn drop(&mut self) {
116117
if self.release {
117-
unsafe { rustler_sys::enif_release_binary(self.inner.as_c_arg()) };
118+
unsafe { rustler_sys::enif_release_binary(&mut self.inner) };
118119
}
119120
}
120121
}
@@ -123,7 +124,6 @@ unsafe impl Send for OwnedBinary {}
123124

124125
// Borrowed
125126

126-
#[derive(Copy, Clone)]
127127
pub struct Binary<'a> {
128128
inner: ErlNifBinary,
129129
term: Term<'a>,
@@ -137,7 +137,7 @@ impl<'a> Binary<'a> {
137137
let term = unsafe {
138138
Term::new(
139139
env,
140-
rustler_sys::enif_make_binary(env.as_c_arg(), bin.inner.as_c_arg()),
140+
rustler_sys::enif_make_binary(env.as_c_arg(), &mut bin.inner),
141141
)
142142
};
143143
Binary {
@@ -151,37 +151,37 @@ impl<'a> Binary<'a> {
151151
}
152152

153153
pub fn from_term(term: Term<'a>) -> Result<Self, Error> {
154-
let mut binary = unsafe { ErlNifBinary::new_empty() };
154+
let mut binary = MaybeUninit::uninit();
155155
if unsafe {
156156
rustler_sys::enif_inspect_binary(
157157
term.get_env().as_c_arg(),
158158
term.as_c_arg(),
159-
binary.as_c_arg(),
159+
binary.as_mut_ptr(),
160160
)
161161
} == 0
162162
{
163163
return Err(Error::BadArg);
164164
}
165165
Ok(Binary {
166-
inner: binary,
166+
inner: unsafe { binary.assume_init() },
167167
term,
168168
})
169169
}
170170

171171
pub fn from_iolist(term: Term<'a>) -> Result<Self, Error> {
172-
let mut binary = unsafe { ErlNifBinary::new_empty() };
172+
let mut binary = MaybeUninit::uninit();
173173
if unsafe {
174174
rustler_sys::enif_inspect_iolist_as_binary(
175175
term.get_env().as_c_arg(),
176176
term.as_c_arg(),
177-
binary.as_c_arg(),
177+
binary.as_mut_ptr(),
178178
)
179179
} == 0
180180
{
181181
return Err(Error::BadArg);
182182
}
183183
Ok(Binary {
184-
inner: binary,
184+
inner: unsafe { binary.assume_init() },
185185
term,
186186
})
187187
}

‎rustler/src/types/pid.rs‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use crate::wrapper::{pid, ErlNifPid};
22
use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
3-
use std::mem;
3+
use std::mem::MaybeUninit;
44

55
#[derive(Clone)]
66
pub struct Pid {
@@ -36,10 +36,12 @@ impl<'a> Env<'a> {
3636
/// environment is to use `OwnedEnv`. The `Env` that Rustler passes to NIFs when they're
3737
/// called is always associated with the calling Erlang process.)
3838
pub fn pid(self) -> Pid {
39-
let mut pid: ErlNifPid = unsafe { mem::uninitialized() };
40-
if unsafe { rustler_sys::enif_self(self.as_c_arg(), &mut pid) }.is_null() {
39+
let mut pid = MaybeUninit::uninit();
40+
if unsafe { rustler_sys::enif_self(self.as_c_arg(), pid.as_mut_ptr()) }.is_null() {
4141
panic!("environment is process-independent");
4242
}
43-
Pid { c: pid }
43+
Pid {
44+
c: unsafe { pid.assume_init() },
45+
}
4446
}
4547
}

‎rustler/src/wrapper.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,6 @@ pub type size_t = usize;
3030

3131
pub type NIF_ENV = *mut rustler_sys::ErlNifEnv;
3232
pub type NIF_TERM = size_t;
33-
pub type NIF_BINARY = *mut rustler_sys::ErlNifBinary;
3433
pub type NIF_RESOURCE_TYPE = *const rustler_sys::ErlNifResourceType;
3534

3635
pub fn get_nif_resource_type_init_size() -> usize {

‎rustler/src/wrapper/binary.rs‎

Lines changed: 7 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,37 +1,17 @@
1-
use crate::wrapper::{c_void, size_t, NIF_BINARY};
2-
use std::mem::uninitialized;
3-
4-
#[repr(C)]
5-
#[derive(Copy, Clone)]
6-
pub struct ErlNifBinary {
7-
pub size: size_t,
8-
pub data: *mut u8,
9-
_internal: [*mut c_void; 3],
10-
}
11-
12-
impl ErlNifBinary {
13-
pub unsafe fn new_empty() -> Self {
14-
ErlNifBinary {
15-
size: uninitialized(),
16-
data: uninitialized(),
17-
_internal: uninitialized(),
18-
}
19-
}
20-
pub fn as_c_arg(&mut self) -> NIF_BINARY {
21-
(self as *mut ErlNifBinary) as NIF_BINARY
22-
}
23-
}
1+
use crate::wrapper::size_t;
2+
pub(in crate) use rustler_sys::ErlNifBinary;
3+
use std::mem::MaybeUninit;
244

255
pub unsafe fn alloc(size: size_t) -> Option<ErlNifBinary> {
26-
let mut binary = ErlNifBinary::new_empty();
27-
let success = rustler_sys::enif_alloc_binary(size, binary.as_c_arg());
6+
let mut binary = MaybeUninit::uninit();
7+
let success = rustler_sys::enif_alloc_binary(size, binary.as_mut_ptr());
288
if success == 0 {
299
return None;
3010
}
31-
Some(binary)
11+
Some(binary.assume_init())
3212
}
3313

3414
pub unsafe fn realloc(binary: &mut ErlNifBinary, size: size_t) -> bool {
35-
let success = rustler_sys::enif_realloc_binary(binary.as_c_arg(), size);
15+
let success = rustler_sys::enif_realloc_binary(binary, size);
3616
success != 0
3717
}

‎rustler/src/wrapper/env.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,28 +1,28 @@
11
use crate::wrapper::binary::ErlNifBinary;
22
use crate::wrapper::{ERL_NIF_BIN2TERM_SAFE, NIF_ENV, NIF_TERM};
3-
use std::mem;
3+
use std::mem::MaybeUninit;
44

55
pub unsafe fn binary_to_term(env: NIF_ENV, data: &[u8], safe: bool) -> Option<(NIF_TERM, usize)> {
66
let opts = if safe { ERL_NIF_BIN2TERM_SAFE } else { 0 };
77

8-
let mut result: NIF_TERM = mem::uninitialized();
8+
let mut result = MaybeUninit::uninit();
99
let read_count =
10-
rustler_sys::enif_binary_to_term(env, data.as_ptr(), data.len(), &mut result, opts);
10+
rustler_sys::enif_binary_to_term(env, data.as_ptr(), data.len(), result.as_mut_ptr(), opts);
1111

1212
if read_count == 0 {
1313
return None;
1414
}
1515

16-
Some((result, read_count))
16+
Some((result.assume_init(), read_count))
1717
}
1818

1919
pub unsafe fn term_to_binary(env: NIF_ENV, term: NIF_TERM) -> Option<ErlNifBinary> {
20-
let mut binary = ErlNifBinary::new_empty();
21-
let success = rustler_sys::enif_term_to_binary(env, term, binary.as_c_arg());
20+
let mut binary = MaybeUninit::uninit();
21+
let success = rustler_sys::enif_term_to_binary(env, term, binary.as_mut_ptr());
2222

2323
if success == 0 {
2424
return None;
2525
}
2626

27-
Some(binary)
27+
Some(binary.assume_init())
2828
}

‎rustler/src/wrapper/list.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
11
use crate::wrapper::{NIF_ENV, NIF_TERM};
2-
use std::mem;
2+
use std::mem::MaybeUninit;
33

44
pub unsafe fn get_list_cell(env: NIF_ENV, list: NIF_TERM) -> Option<(NIF_TERM, NIF_TERM)> {
5-
let mut head: NIF_TERM = mem::uninitialized();
6-
let mut tail: NIF_TERM = mem::uninitialized();
7-
let success = rustler_sys::enif_get_list_cell(env, list, &mut head, &mut tail);
5+
let mut head = MaybeUninit::uninit();
6+
let mut tail = MaybeUninit::uninit();
7+
let success = rustler_sys::enif_get_list_cell(env, list, head.as_mut_ptr(), tail.as_mut_ptr());
88

99
if success != 1 {
1010
return None;
1111
}
12-
Some((head, tail))
12+
Some((head.assume_init(), tail.assume_init()))
1313
}
1414

1515
pub unsafe fn get_list_length(env: NIF_ENV, list: NIF_TERM) -> Option<usize> {
@@ -31,11 +31,11 @@ pub unsafe fn make_list_cell(env: NIF_ENV, head: NIF_TERM, tail: NIF_TERM) -> NI
3131
}
3232

3333
pub unsafe fn make_reverse_list(env: NIF_ENV, list: NIF_TERM) -> Option<NIF_TERM> {
34-
let mut list_out: NIF_TERM = mem::uninitialized();
35-
let success = rustler_sys::enif_make_reverse_list(env, list, &mut list_out);
34+
let mut list_out = MaybeUninit::uninit();
35+
let success = rustler_sys::enif_make_reverse_list(env, list, list_out.as_mut_ptr());
3636

3737
if success != 1 {
3838
return None;
3939
}
40-
Some(list_out)
40+
Some(list_out.assume_init())
4141
}

‎rustler/src/wrapper/map.rs‎

Lines changed: 27 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,25 @@
11
pub use crate::wrapper::ErlNifMapIterator;
22
use crate::wrapper::{ErlNifMapIteratorEntry, NIF_ENV, NIF_TERM};
3-
use std::mem;
3+
use std::mem::MaybeUninit;
44

55
pub unsafe fn get_map_value(env: NIF_ENV, map: NIF_TERM, key: NIF_TERM) -> Option<NIF_TERM> {
6-
let mut result: NIF_TERM = mem::uninitialized();
7-
let success = rustler_sys::enif_get_map_value(env, map, key, &mut result);
6+
let mut result = MaybeUninit::uninit();
7+
let success = rustler_sys::enif_get_map_value(env, map, key, result.as_mut_ptr());
88

99
if success != 1 {
1010
return None;
1111
}
12-
Some(result)
12+
Some(result.assume_init())
1313
}
1414

1515
pub unsafe fn get_map_size(env: NIF_ENV, map: NIF_TERM) -> Option<usize> {
16-
let mut size: rustler_sys::size_t = mem::uninitialized();
17-
let success = rustler_sys::enif_get_map_size(env, map, &mut size);
16+
let mut size = MaybeUninit::uninit();
17+
let success = rustler_sys::enif_get_map_size(env, map, size.as_mut_ptr());
1818

1919
if success != 1 {
2020
return None;
2121
}
22-
Some(size)
22+
Some(size.assume_init())
2323
}
2424

2525
pub unsafe fn map_new(env: NIF_ENV) -> NIF_TERM {
@@ -32,23 +32,23 @@ pub unsafe fn map_put(
3232
key: NIF_TERM,
3333
value: NIF_TERM,
3434
) -> Option<NIF_TERM> {
35-
let mut result: NIF_TERM = mem::uninitialized();
36-
let success = rustler_sys::enif_make_map_put(env, map, key, value, &mut result);
35+
let mut result = MaybeUninit::uninit();
36+
let success = rustler_sys::enif_make_map_put(env, map, key, value, result.as_mut_ptr());
3737

3838
if success != 1 {
3939
return None;
4040
}
41-
Some(result)
41+
Some(result.assume_init())
4242
}
4343

4444
pub unsafe fn map_remove(env: NIF_ENV, map: NIF_TERM, key: NIF_TERM) -> Option<NIF_TERM> {
45-
let mut result: NIF_TERM = mem::uninitialized();
46-
let success = rustler_sys::enif_make_map_remove(env, map, key, &mut result);
45+
let mut result = MaybeUninit::uninit();
46+
let success = rustler_sys::enif_make_map_remove(env, map, key, result.as_mut_ptr());
4747

4848
if success != 1 {
4949
return None;
5050
}
51-
Some(result)
51+
Some(result.assume_init())
5252
}
5353

5454
pub unsafe fn map_update(
@@ -57,27 +57,27 @@ pub unsafe fn map_update(
5757
key: NIF_TERM,
5858
new_value: NIF_TERM,
5959
) -> Option<NIF_TERM> {
60-
let mut result: NIF_TERM = mem::uninitialized();
61-
let success = rustler_sys::enif_make_map_update(env, map, key, new_value, &mut result);
60+
let mut result = MaybeUninit::uninit();
61+
let success = rustler_sys::enif_make_map_update(env, map, key, new_value, result.as_mut_ptr());
6262

6363
if success != 1 {
6464
return None;
6565
}
66-
Some(result)
66+
Some(result.assume_init())
6767
}
6868

6969
pub unsafe fn map_iterator_create(env: NIF_ENV, map: NIF_TERM) -> Option<ErlNifMapIterator> {
70-
let mut iter = mem::uninitialized();
70+
let mut iter = MaybeUninit::uninit();
7171
let success = rustler_sys::enif_map_iterator_create(
7272
env,
7373
map,
74-
&mut iter,
74+
iter.as_mut_ptr(),
7575
ErlNifMapIteratorEntry::ERL_NIF_MAP_ITERATOR_HEAD,
7676
);
7777
if success == 0 {
7878
None
7979
} else {
80-
Some(iter)
80+
Some(iter.assume_init())
8181
}
8282
}
8383

@@ -89,12 +89,13 @@ pub unsafe fn map_iterator_get_pair(
8989
env: NIF_ENV,
9090
iter: &mut ErlNifMapIterator,
9191
) -> Option<(NIF_TERM, NIF_TERM)> {
92-
let mut key: NIF_TERM = mem::uninitialized();
93-
let mut value: NIF_TERM = mem::uninitialized();
94-
if rustler_sys::enif_map_iterator_get_pair(env, iter, &mut key, &mut value) == 0 {
92+
let mut key = MaybeUninit::uninit();
93+
let mut value = MaybeUninit::uninit();
94+
if rustler_sys::enif_map_iterator_get_pair(env, iter, key.as_mut_ptr(), value.as_mut_ptr()) == 0
95+
{
9596
None
9697
} else {
97-
Some((key, value))
98+
Some((key.assume_init(), value.assume_init()))
9899
}
99100
}
100101

@@ -108,17 +109,17 @@ pub unsafe fn make_map_from_arrays(
108109
keys: &[NIF_TERM],
109110
values: &[NIF_TERM],
110111
) -> Option<NIF_TERM> {
111-
let mut map = mem::uninitialized();
112+
let mut map = MaybeUninit::uninit();
112113
if rustler_sys::enif_make_map_from_arrays(
113114
env,
114115
keys.as_ptr(),
115116
values.as_ptr(),
116117
keys.len() as usize,
117-
&mut map,
118+
map.as_mut_ptr(),
118119
) == 0
119120
{
120121
return None;
121122
}
122123

123-
Some(map)
124+
Some(map.assume_init())
124125
}

‎rustler/src/wrapper/pid.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
11
use crate::wrapper::{ErlNifPid, NIF_ENV, NIF_TERM};
2-
use std::mem;
2+
use std::mem::MaybeUninit;
33

44
pub unsafe fn get_local_pid(env: NIF_ENV, term: NIF_TERM) -> Option<ErlNifPid> {
5-
let mut pid: ErlNifPid = mem::uninitialized();
6-
if rustler_sys::enif_get_local_pid(env, term, &mut pid) == 0 {
5+
let mut pid = MaybeUninit::uninit();
6+
if rustler_sys::enif_get_local_pid(env, term, pid.as_mut_ptr()) == 0 {
77
return None;
88
}
9-
Some(pid)
9+
Some(pid.assume_init())
1010
}
1111

1212
// pub unsafe fn is_process_alive(env: NIF_ENV, pid: &ErlNifPid) -> bool {

0 commit comments

Comments
 (0)