clex 0.1.0

Fast C-lang lexer (library)
Documentation 
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

/// Keyword token
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum Keyword {
    /// auto
    Auto,
    /// break
    Break,
    /// case
    Case,
    /// char
    Char,
    /// const
    Const,
    /// continue
    Continue,
    /// default
    Default,
    /// do
    Do,
    /// double
    Double,
    /// else
    Else,
    /// enum
    Enum,
    /// extern
    Extern,
    /// float
    Float,
    /// for
    For,
    /// goto
    Goto,
    /// if
    If,
    /// inline
    Inline,
    /// int
    Int,
    /// long
    Long,
    /// register
    Register,
    /// restrict
    Restrict,
    /// return
    Return,
    /// short
    Short,
    /// signed
    Signed,
    /// sizeof
    SizeOf,
    /// static
    Static,
    /// struct
    Struct,
    /// switch
    Switch,
    /// typedef
    TypeDef,
    /// union
    Union,
    /// unsigned
    Unsigned,
    /// void
    Void,
    /// volatile
    Volatile,
    /// while
    While,
    /// _Alignas
    AlignAs,
    /// _Alignof
    AlignOf,
    /// _Atomic
    Atomic,
    /// _Bool
    Bool,
    /// _Complex
    Complex,
    /// _Generic
    Generic,
    /// _Imaginary
    Imaginary,
    /// _Noreturn
    NoReturn,
    /// _Static_assert
    StaticAssert,
    /// _Thread_local
    ThreadLocal,
    /// __func__
    FuncName,
}

impl std::str::FromStr for Keyword {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        KEYWORDS.get(s).copied().ok_or(())
    }
}

static KEYWORDS: phf::Map<&'static str, Keyword> = phf::phf_map! {
    "auto" => Keyword::Auto,
    "break" => Keyword::Break,
    "case" => Keyword::Case,
    "char" => Keyword::Char,
    "const" => Keyword::Const,
    "continue" => Keyword::Continue,
    "default" => Keyword::Default,
    "do" => Keyword::Do,
    "double" => Keyword::Double,
    "else" => Keyword::Else,
    "enum" => Keyword::Enum,
    "extern" => Keyword::Extern,
    "float" => Keyword::Float,
    "for" => Keyword::For,
    "goto" => Keyword::Goto,
    "if" => Keyword::If,
    "inline" => Keyword::Inline,
    "int" => Keyword::Int,
    "long" => Keyword::Long,
    "register" => Keyword::Register,
    "restrict" => Keyword::Restrict,
    "return" => Keyword::Return,
    "short" => Keyword::Short,
    "signed" => Keyword::Signed,
    "sizeof" => Keyword::SizeOf,
    "static" => Keyword::Static,
    "struct" => Keyword::Struct,
    "switch" => Keyword::Switch,
    "typedef" => Keyword::TypeDef,
    "union" => Keyword::Union,
    "unsigned" => Keyword::Unsigned,
    "void" => Keyword::Void,
    "volatile" => Keyword::Volatile,
    "while" => Keyword::While,
    "_Alignas" => Keyword::AlignAs,
    "_Alignof" => Keyword::AlignOf,
    "_Atomic" => Keyword::Atomic,
    "_Bool" => Keyword::Bool,
    "_Complex" => Keyword::Complex,
    "_Generic" => Keyword::Generic,
    "_Imaginary" => Keyword::Imaginary,
    "_Noreturn" => Keyword::NoReturn,
    "_Static_assert" => Keyword::StaticAssert,
    "_Thread_local" => Keyword::ThreadLocal,
    "__func__" => Keyword::FuncName,
};

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn keyword() {
        assert_eq!("auto".parse::<Keyword>(), Ok(Keyword::Auto));
        assert_eq!("extern".parse::<Keyword>(), Ok(Keyword::Extern));
        assert_eq!("do".parse::<Keyword>(), Ok(Keyword::Do));
        assert_eq!("__func__".parse::<Keyword>(), Ok(Keyword::FuncName));
    }

    #[test]
    fn not_a_keyword() {
        assert_eq!("123".parse::<Keyword>(), Err(()));
        assert_eq!("done".parse::<Keyword>(), Err(()));
    }
}