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

#![no_std]


#[doc(hidden)]
pub use core::mem::transmute;

/**
 * Slices (via the Index trait & operation) into fixed size arrays
 *
 * Will panic with the same rules as normal slicing.
 *
 * Will not compile if bounds are not static.
 *
 * Will not compile if end bound proceeds start bound.
 *
 * # Format
 *
 * ```notest
 * index_fixed! ( {&,&mut} <slice> ; .. <end>)
 * index_fixed! ( {&,&mut} <slice> ; <start> , .. <end>)
 * index_fixed! ( {&,&mut} <slice> ; <start> , ... <end>)
 * ```
 *
 * # Examples
 *
 * ```
 * #[macro_use]
 * extern crate index_fixed;
 *
 * fn main() {
 *   let my_slice = [1, 2, 3, 4];
 *   let slice_of_2 = index_fixed!(&my_slice ; .. 2);
 *   assert_eq!(slice_of_2, &my_slice[..2]);
 * }
 * ```
 */
// FIXME example test disabled because index_fixed!() is not defined
#[macro_export]
macro_rules! index_fixed {
    (&mut $s:expr ;  .. $e:expr) => {
        index_fixed!(&mut $s; 0 , .. $e )
    };
    (&mut $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed!(&mut $s; $b , .. ($e + 1))
    };
    (&mut $s:expr ; $b:expr , .. $e:expr) => { {
        unsafe fn conv<T>(a: &mut[T]) -> &mut[T;$e - $b] {
            $crate::transmute::<*mut T, &mut[T;$e - $b]>(a.as_mut_ptr())
        }
        unsafe { conv(&mut $s[$b..$e]) }
    } };
    (& $s:expr ; .. $e:expr) => {
        index_fixed!(& $s ; 0 , .. $e)
    };
    (& $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed!(& $s ; $b , .. ($e + 1))
    };
    (& $s:expr ; $b:expr , .. $e:expr) => { {
        unsafe fn conv<T>(a: &[T]) -> &[T;$e - $b] {
            $crate::transmute::<*const T, &[T;$e - $b]>(a.as_ptr())
        }
        unsafe { conv(& $s[$b..$e]) }
    } };
}