/rust/registry/src/index.crates.io-1949cf8c6b5b557f/alloc-no-stdlib-2.0.4/src/init.rs

Source
#[macro_export]
macro_rules! static_array {
    (@accum (0, $($_ignored:expr),*) -> ($($body:tt)*))
        => {static_array!(@as_expr [$($body)*])};
    (@accum (1, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (0, $($expr),*) -> ($($body)* $($expr,)*))};
    (@accum (2, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (0, $($expr),*) -> ($($body)* $($expr,)* $($expr,)*))};
    (@accum (4, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (2, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (8, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (4, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (16, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (8, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (32, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (16, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (64, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (32, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (128, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (64, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (256, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (128, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (512, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (256, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (1024, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (512, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (2048, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (1024, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (4096, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (2048, $($expr,)* $($expr),*) -> ($($body)*))};
    (@accum (8192, $($expr:expr),*) -> ($($body:tt)*))
        => {static_array!(@accum (4096, $($expr,)* $($expr),*) -> ($($body)*))};

    (@as_expr $expr:expr) => {$expr};

    ($expr:expr; $n:tt) => { static_array!(@accum ($n, $expr) -> ()) };
}


#[macro_export]
macro_rules! define_stack_allocator_traits(
    ($name : ident, global) => {
        impl<'a, T: 'a> Default for $name<'a, T> {
            fn default() -> Self {
                return $name::<'a, T>{freelist : &mut[],};
            }
        }
        define_stack_allocator_traits!($name, generic);
    };
    ($name : ident, $freelist_size : tt, stack) => {
        impl<'a, T: 'a> Default for $name<'a, T> {
            fn default() -> Self {
                return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
            }
        }
        define_stack_allocator_traits!($name, generic);
    };
    ($name : ident, heap) => {
        impl<'a, T: 'a> Default for $name<'a, T> {
            fn default() -> Self {
                let v : Vec<&mut [T]> = Vec::new();
                let b = v.into_boxed_slice();
                return $name::<'a, T>{freelist : b};
            }
        }
        define_stack_allocator_traits!($name, generic);
    };
    ($name : ident, $freelist_size : tt, malloc) => {
        define_stack_allocator_traits!($name, calloc);
    };
    ($name : ident, $freelist_size : tt, calloc) => {
    
        impl<'a, T: 'a> Default for $name<'a, T> {
            fn default() -> Self {
                return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
            }
        }
        define_stack_allocator_traits!($name, generic);
    };
    ($name : ident, generic) => {
        impl<'a, T: 'a> SliceWrapper<&'a mut[T]> for $name<'a, T> {
            fn slice(& self) -> & [&'a mut[T]] {
                return & self.freelist;
            }
        }
        impl<'a, T: 'a> SliceWrapperMut<&'a mut [T]> for $name<'a, T> {
            fn slice_mut(& mut self) ->&mut [&'a mut [T]] {
                return &mut self.freelist;
            }
        }
        impl<'a, T: 'a> ops::Index<usize> for $name<'a, T> {
            type Output = [T];
            fn index<'b> (&'b self, _index : usize) -> &'b [T] {
                return &self.freelist[_index];
            }
        }

        impl<'a, T: 'a> ops::IndexMut<usize> for $name<'a, T> {
            fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut [T] {
                return &mut self.freelist[_index];
            }
        }
    };
);

#[macro_export]
macro_rules! declare_stack_allocator_struct(
    (@as_expr $expr : expr) => {$expr};
    (@new_method $name : ident, $freelist_size : tt) => {
        impl<'a, T: 'a> $name<'a, T> {
          fn new_allocator(global_buffer : &'a mut [T],
                           initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
              let mut retval = StackAllocator::<T, $name<T> > {
                  nop : &mut [],
                  system_resources : $name::<T>::default(),
                  free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
                  free_list_overflow_count : 0,
                  initialize : initializer,
              };
              retval.free_cell(AllocatedStackMemory::<T>{mem:global_buffer});
              return retval;
          }
        }
    };

    (@new_calloc_method $name : ident, $freelist_size : tt) => {
        impl<'a, T: 'a> $name<'a, T> {
          fn new_allocator(mut global_buffer : &'a mut [T],
                           initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
              let mut retval = StackAllocator::<T, $name<T> > {
                  nop : &mut [],
                  system_resources : $name::<T>::default(),
                  free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
                  free_list_overflow_count : 0,
                  initialize : initializer,
              };
              retval.free_cell(AllocatedStackMemory::<T>{mem:core::mem::replace(&mut global_buffer, &mut[])});
              return retval;
          }
        }
    };
    ($name :ident, $freelist_size : tt, malloc) => {
        declare_stack_allocator_struct!($name, $freelist_size, calloc);
    };
    ($name :ident, $freelist_size : tt, calloc) => {
        struct $name<'a, T : 'a> {
            freelist : [&'a mut [T]; declare_stack_allocator_struct!(@as_expr $freelist_size)],
        }
        define_stack_allocator_traits!($name,
                                       $freelist_size,
                                       calloc);
        declare_stack_allocator_struct!( @new_calloc_method $name, $freelist_size);
    };
    ($name :ident, $freelist_size : tt, stack) => {
        struct $name<'a, T : 'a> {
            freelist : [&'a mut [T];declare_stack_allocator_struct!(@as_expr $freelist_size)],
            // can't borrow here: make it on stack-- heap : core::cell::RefCell<[T; $heap_size]>
        }
        define_stack_allocator_traits!($name,
                                       $freelist_size,
                                       stack);
        declare_stack_allocator_struct!( @new_method $name, $freelist_size);
    };
    ($name :ident, $freelist_size : expr, global) => {
       struct $name <'a, T: 'a> {freelist : &'a mut [&'a mut [T]]}
       define_stack_allocator_traits!($name, global);
       impl<'a, T: 'a> $name<'a, T> {
          fn new_allocator(initializer : fn (&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
              return StackAllocator::<T, $name<T> > {
                  nop : &mut [],
                  system_resources : $name::<T>::default(),
                  free_list_start : 0,
                  free_list_overflow_count : 0,
                  initialize : initializer,
              };
          }
       }
    };
);
#[macro_export]
macro_rules! bind_global_buffers_to_allocator(
    ($allocator : expr, $buffer : ident, $T : ty) => {
        $allocator.free_list_start = $buffer::FREELIST.len();
        $allocator.system_resources.freelist = &mut $buffer::FREELIST;
        $allocator.free_cell(AllocatedStackMemory::<$T>{mem:&mut $buffer::HEAP});
    };
);

#[macro_export]
macro_rules! define_allocator_memory_pool(
    (@as_expr $expr:expr) => {$expr};


    ($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc) => {
      alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, true);
    };
    ($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc_no_free) => {
       alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, false);
    };
    ($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc) => {
      alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, true);
    };
    ($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc_no_free) => {
       alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, false);
    };
    ($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], heap) => {
       (vec![$default_value; $heap_size]).into_boxed_slice();
    };
    ($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], stack) => {
       [$default_value; $heap_size];
    };
    ($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], global, $name : ident) => {
       pub mod $name {
           pub static mut FREELIST : [&'static mut [$T];
                                  define_allocator_memory_pool!(@as_expr $freelist_size)]
               = static_array!(&mut[]; $freelist_size);
           pub static mut HEAP : [$T; $heap_size] = [$default_value; $heap_size];
       }
    };

);



Coverage Report

Created: 2025-11-16 07:09

Line	Count	Source
1		#[macro_export]
2		macro_rules! static_array {
3		(@accum (0, $($_ignored:expr),) -> ($($body:tt)))
4		=> {static_array!(@as_expr [$($body)*])};
5		(@accum (1, $($expr:expr),) -> ($($body:tt)))
6		=> {static_array!(@accum (0, $($expr),) -> ($($body) $($expr,)*))};
7		(@accum (2, $($expr:expr),) -> ($($body:tt)))
8		=> {static_array!(@accum (0, $($expr),) -> ($($body) $($expr,)* $($expr,)*))};
9		(@accum (4, $($expr:expr),) -> ($($body:tt)))
10		=> {static_array!(@accum (2, $($expr,)* $($expr),) -> ($($body)))};
11		(@accum (8, $($expr:expr),) -> ($($body:tt)))
12		=> {static_array!(@accum (4, $($expr,)* $($expr),) -> ($($body)))};
13		(@accum (16, $($expr:expr),) -> ($($body:tt)))
14		=> {static_array!(@accum (8, $($expr,)* $($expr),) -> ($($body)))};
15		(@accum (32, $($expr:expr),) -> ($($body:tt)))
16		=> {static_array!(@accum (16, $($expr,)* $($expr),) -> ($($body)))};
17		(@accum (64, $($expr:expr),) -> ($($body:tt)))
18		=> {static_array!(@accum (32, $($expr,)* $($expr),) -> ($($body)))};
19		(@accum (128, $($expr:expr),) -> ($($body:tt)))
20		=> {static_array!(@accum (64, $($expr,)* $($expr),) -> ($($body)))};
21		(@accum (256, $($expr:expr),) -> ($($body:tt)))
22		=> {static_array!(@accum (128, $($expr,)* $($expr),) -> ($($body)))};
23		(@accum (512, $($expr:expr),) -> ($($body:tt)))
24		=> {static_array!(@accum (256, $($expr,)* $($expr),) -> ($($body)))};
25		(@accum (1024, $($expr:expr),) -> ($($body:tt)))
26		=> {static_array!(@accum (512, $($expr,)* $($expr),) -> ($($body)))};
27		(@accum (2048, $($expr:expr),) -> ($($body:tt)))
28		=> {static_array!(@accum (1024, $($expr,)* $($expr),) -> ($($body)))};
29		(@accum (4096, $($expr:expr),) -> ($($body:tt)))
30		=> {static_array!(@accum (2048, $($expr,)* $($expr),) -> ($($body)))};
31		(@accum (8192, $($expr:expr),) -> ($($body:tt)))
32		=> {static_array!(@accum (4096, $($expr,)* $($expr),) -> ($($body)))};
33
34		(@as_expr $expr:expr) => {$expr};
35
36		($expr:expr; $n:tt) => { static_array!(@accum ($n, $expr) -> ()) };
37		}
38
39
40		#[macro_export]
41		macro_rules! define_stack_allocator_traits(
42		($name : ident, global) => {
43		impl<'a, T: 'a> Default for $name<'a, T> {
44		fn default() -> Self {
45		return $name::<'a, T>{freelist : &mut[],};
46		}
47		}
48		define_stack_allocator_traits!($name, generic);
49		};
50		($name : ident, $freelist_size : tt, stack) => {
51		impl<'a, T: 'a> Default for $name<'a, T> {
52		fn default() -> Self {
53		return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
54		}
55		}
56		define_stack_allocator_traits!($name, generic);
57		};
58		($name : ident, heap) => {
59		impl<'a, T: 'a> Default for $name<'a, T> {
60		fn default() -> Self {
61		let v : Vec<&mut [T]> = Vec::new();
62		let b = v.into_boxed_slice();
63		return $name::<'a, T>{freelist : b};
64		}
65		}
66		define_stack_allocator_traits!($name, generic);
67		};
68		($name : ident, $freelist_size : tt, malloc) => {
69		define_stack_allocator_traits!($name, calloc);
70		};
71		($name : ident, $freelist_size : tt, calloc) => {
72
73		impl<'a, T: 'a> Default for $name<'a, T> {
74		fn default() -> Self {
75		return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
76		}
77		}
78		define_stack_allocator_traits!($name, generic);
79		};
80		($name : ident, generic) => {
81		impl<'a, T: 'a> SliceWrapper<&'a mut[T]> for $name<'a, T> {
82	0	fn slice(& self) -> & [&'a mut[T]] {
83	0	return & self.freelist;
84	0	} Unexecuted instantiation: <brotli_decompressor::MemPool<brotli_decompressor::huffman::HuffmanCode> as alloc_no_stdlib::allocated_memory::SliceWrapper<&mut [brotli_decompressor::huffman::HuffmanCode]>>::slice Unexecuted instantiation: <brotli_decompressor::MemPool<u8> as alloc_no_stdlib::allocated_memory::SliceWrapper<&mut [u8]>>::slice Unexecuted instantiation: <brotli_decompressor::MemPool<u32> as alloc_no_stdlib::allocated_memory::SliceWrapper<&mut [u32]>>::slice
85		}
86		impl<'a, T: 'a> SliceWrapperMut<&'a mut [T]> for $name<'a, T> {
87	0	fn slice_mut(& mut self) ->&mut [&'a mut [T]] {
88	0	return &mut self.freelist;
89	0	} Unexecuted instantiation: <brotli_decompressor::MemPool<brotli_decompressor::huffman::HuffmanCode> as alloc_no_stdlib::allocated_memory::SliceWrapperMut<&mut [brotli_decompressor::huffman::HuffmanCode]>>::slice_mut Unexecuted instantiation: <brotli_decompressor::MemPool<u8> as alloc_no_stdlib::allocated_memory::SliceWrapperMut<&mut [u8]>>::slice_mut Unexecuted instantiation: <brotli_decompressor::MemPool<u32> as alloc_no_stdlib::allocated_memory::SliceWrapperMut<&mut [u32]>>::slice_mut
90		}
91		impl<'a, T: 'a> ops::Index<usize> for $name<'a, T> {
92		type Output = [T];
93	0	fn index<'b> (&'b self, _index : usize) -> &'b [T] {
94	0	return &self.freelist[_index];
95	0	}
96		}
97
98		impl<'a, T: 'a> ops::IndexMut<usize> for $name<'a, T> {
99	0	fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut [T] {
100	0	return &mut self.freelist[_index];
101	0	}
102		}
103		};
104		);
105
106		#[macro_export]
107		macro_rules! declare_stack_allocator_struct(
108		(@as_expr $expr : expr) => {$expr};
109		(@new_method $name : ident, $freelist_size : tt) => {
110		impl<'a, T: 'a> $name<'a, T> {
111		fn new_allocator(global_buffer : &'a mut [T],
112		initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
113		let mut retval = StackAllocator::<T, $name<T> > {
114		nop : &mut [],
115		system_resources : $name::<T>::default(),
116		free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
117		free_list_overflow_count : 0,
118		initialize : initializer,
119		};
120		retval.free_cell(AllocatedStackMemory::<T>{mem:global_buffer});
121		return retval;
122		}
123		}
124		};
125
126		(@new_calloc_method $name : ident, $freelist_size : tt) => {
127		impl<'a, T: 'a> $name<'a, T> {
128		fn new_allocator(mut global_buffer : &'a mut [T],
129		initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
130		let mut retval = StackAllocator::<T, $name<T> > {
131		nop : &mut [],
132		system_resources : $name::<T>::default(),
133		free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
134		free_list_overflow_count : 0,
135		initialize : initializer,
136		};
137		retval.free_cell(AllocatedStackMemory::<T>{mem:core::mem::replace(&mut global_buffer, &mut[])});
138		return retval;
139		}
140		}
141		};
142		($name :ident, $freelist_size : tt, malloc) => {
143		declare_stack_allocator_struct!($name, $freelist_size, calloc);
144		};
145		($name :ident, $freelist_size : tt, calloc) => {
146		struct $name<'a, T : 'a> {
147		freelist : [&'a mut [T]; declare_stack_allocator_struct!(@as_expr $freelist_size)],
148		}
149		define_stack_allocator_traits!($name,
150		$freelist_size,
151		calloc);
152		declare_stack_allocator_struct!( @new_calloc_method $name, $freelist_size);
153		};
154		($name :ident, $freelist_size : tt, stack) => {
155		struct $name<'a, T : 'a> {
156		freelist : [&'a mut [T];declare_stack_allocator_struct!(@as_expr $freelist_size)],
157		// can't borrow here: make it on stack-- heap : core::cell::RefCell<[T; $heap_size]>
158		}
159		define_stack_allocator_traits!($name,
160		$freelist_size,
161		stack);
162		declare_stack_allocator_struct!( @new_method $name, $freelist_size);
163		};
164		($name :ident, $freelist_size : expr, global) => {
165		struct $name <'a, T: 'a> {freelist : &'a mut [&'a mut [T]]}
166		define_stack_allocator_traits!($name, global);
167		impl<'a, T: 'a> $name<'a, T> {
168		fn new_allocator(initializer : fn (&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
169		return StackAllocator::<T, $name<T> > {
170		nop : &mut [],
171		system_resources : $name::<T>::default(),
172		free_list_start : 0,
173		free_list_overflow_count : 0,
174		initialize : initializer,
175		};
176		}
177		}
178		};
179		);
180		#[macro_export]
181		macro_rules! bind_global_buffers_to_allocator(
182		($allocator : expr, $buffer : ident, $T : ty) => {
183		$allocator.free_list_start = $buffer::FREELIST.len();
184		$allocator.system_resources.freelist = &mut $buffer::FREELIST;
185		$allocator.free_cell(AllocatedStackMemory::<$T>{mem:&mut $buffer::HEAP});
186		};
187		);
188
189		#[macro_export]
190		macro_rules! define_allocator_memory_pool(
191		(@as_expr $expr:expr) => {$expr};
192
193
194		($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc) => {
195		alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, true);
196		};
197		($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc_no_free) => {
198		alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, false);
199		};
200		($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc) => {
201		alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, true);
202		};
203		($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc_no_free) => {
204		alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, false);
205		};
206		($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], heap) => {
207		(vec![$default_value; $heap_size]).into_boxed_slice();
208		};
209		($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], stack) => {
210		[$default_value; $heap_size];
211		};
212		($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], global, $name : ident) => {
213		pub mod $name {
214		pub static mut FREELIST : [&'static mut [$T];
215		define_allocator_memory_pool!(@as_expr $freelist_size)]
216		= static_array!(&mut[]; $freelist_size);
217		pub static mut HEAP : [$T; $heap_size] = [$default_value; $heap_size];
218		}
219		};
220
221		);
222
223