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

use std::convert::TryFrom;

pub mod codegen;
pub mod lexer;
pub mod llvm;
pub mod parser;

/// Fixed size of [`SmallCStr`] including the trailing `\0` byte.
pub const SMALL_STR_SIZE: usize = 16;

/// Small C string on the stack with fixed size [`SMALL_STR_SIZE`].
///
/// This is specially crafted to interact with the LLVM C API and get rid of some heap allocations.
#[derive(Debug, PartialEq)]
pub struct SmallCStr([u8; SMALL_STR_SIZE]);

impl SmallCStr {
    /// Create a new C string from `src`.
    /// Returns [`None`] if `src` exceeds the fixed size or contains any `\0` bytes.
    pub fn new<T: AsRef<[u8]>>(src: &T) -> Option<SmallCStr> {
        let src = src.as_ref();
        let len = src.len();

        // Check for \0 bytes.
        let contains_null = unsafe { !libc::memchr(src.as_ptr().cast(), 0, len).is_null() };

        if contains_null || len > SMALL_STR_SIZE - 1 {
            None
        } else {
            let mut dest = [0; SMALL_STR_SIZE];
            dest[..len].copy_from_slice(src);
            Some(SmallCStr(dest))
        }
    }

    /// Return pointer to C string.
    pub const fn as_ptr(&self) -> *const libc::c_char {
        self.0.as_ptr().cast()
    }
}

impl TryFrom<&str> for SmallCStr {
    type Error = ();

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        SmallCStr::new(&value).ok_or(())
    }
}

/// Either type, for APIs accepting two types.
pub enum Either<A, B> {
    A(A),
    B(B),
}

#[cfg(test)]
mod test {
    use super::{SmallCStr, SMALL_STR_SIZE};
    use std::convert::TryInto;

    #[test]
    fn test_create() {
        let src = "\x30\x31\x32\x33";
        let scs = SmallCStr::new(&src).unwrap();
        assert_eq!(&scs.0[..5], &[0x30, 0x31, 0x32, 0x33, 0x00]);

        let src = b"abcd1234";
        let scs = SmallCStr::new(&src).unwrap();
        assert_eq!(
            &scs.0[..9],
            &[0x61, 0x62, 0x63, 0x64, 0x31, 0x32, 0x33, 0x34, 0x00]
        );
    }

    #[test]
    fn test_contain_null() {
        let src = "\x30\x00\x32\x33";
        let scs = SmallCStr::new(&src);
        assert_eq!(scs, None);

        let src = "\x30\x31\x32\x33\x00";
        let scs = SmallCStr::new(&src);
        assert_eq!(scs, None);
    }

    #[test]
    fn test_too_large() {
        let src = (0..SMALL_STR_SIZE).map(|_| 'a').collect::<String>();
        let scs = SmallCStr::new(&src);
        assert_eq!(scs, None);

        let src = (0..SMALL_STR_SIZE + 10).map(|_| 'a').collect::<String>();
        let scs = SmallCStr::new(&src);
        assert_eq!(scs, None);
    }

    #[test]
    fn test_try_into() {
        let src = "\x30\x31\x32\x33";
        let scs: Result<SmallCStr, ()> = src.try_into();
        assert!(scs.is_ok());

        let src = (0..SMALL_STR_SIZE).map(|_| 'a').collect::<String>();
        let scs: Result<SmallCStr, ()> = src.as_str().try_into();
        assert!(scs.is_err());

        let src = (0..SMALL_STR_SIZE + 10).map(|_| 'a').collect::<String>();
        let scs: Result<SmallCStr, ()> = src.as_str().try_into();
        assert!(scs.is_err());
    }
}