1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#![no_std]
#[doc(hidden)]
pub extern crate core as __core;
#[allow(unused_imports)]
use core::mem::MaybeUninit;
#[doc(hidden)]
pub struct __ArrayVec<T> {
start: *mut T,
length: usize,
}
impl<T> __ArrayVec<T> {
pub fn new(start: *mut T) -> Self {
Self { start, length: 0 }
}
pub fn start(&self) -> *mut T {
self.start
}
pub fn length(&mut self) -> *mut usize {
&mut self.length
}
}
impl<T> Drop for __ArrayVec<T> {
fn drop(&mut self) {
for i in 0..self.length {
unsafe {
core::ptr::drop_in_place(self.start.add(i));
}
}
}
}
#[macro_export(local_inner_macros)]
macro_rules! array {
[@INTERNAL $callback:expr; $count:expr] => {{
const COUNT: usize = $count;
#[allow(unsafe_code)]
fn create_arr<T>(mut callback: impl FnMut(usize) -> T) -> [T; COUNT] {
let mut arr = $crate::__core::mem::MaybeUninit::uninit();
let mut vec = $crate::__ArrayVec::<T>::new((&mut arr).as_mut_ptr() as *mut T);
unsafe {
for i in 0..COUNT {
*(&mut vec).length() = i;
$crate::__core::ptr::write((&vec).start().add(i), callback(i));
}
$crate::__core::mem::forget(vec);
arr.assume_init()
}
}
create_arr($callback)
}};
[| $($rest:tt)*] => {
array![@INTERNAL | $($rest)*]
};
[move $($rest:tt)*] => {
array![@INTERNAL move $($rest)*]
};
[$expr:expr; $count:expr] => {
array![|_| $expr; $count]
};
}