1use std::fmt;
2#[derive(Debug, Clone, PartialEq)]
3pub struct Token {
4 pub kind: TokenKind,
5 pub lexeme: String,
6 pub line: usize,
7 pub column: usize,
8}
9
10impl Token {
11 pub fn new(kind: TokenKind, lexeme: String, line: usize, column: usize) -> Self {
12 Self {
13 kind,
14 lexeme,
15 line,
16 column,
17 }
18 }
19}
20
21#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
22pub enum TokenKind {
23 Integer,
24 Float,
25 String,
26 True,
27 False,
28 Identifier,
29 Local,
30 Mut,
31 Function,
32 Return,
33 If,
34 Then,
35 Else,
36 Elseif,
37 End,
38 While,
39 Do,
40 For,
41 In,
42 Break,
43 Continue,
44 Struct,
45 Enum,
46 Trait,
47 Impl,
48 Match,
49 Case,
50 As,
51 Is,
52 Extern,
53 Unsafe,
54 Pub,
55 Use,
56 Module,
57 Const,
58 Static,
59 Type,
60 Plus,
61 Minus,
62 Star,
63 Slash,
64 Percent,
65 Caret,
66 DoubleDot,
67 Concat,
68 Equal,
69 DoubleEqual,
70 NotEqual,
71 Less,
72 LessEqual,
73 Greater,
74 GreaterEqual,
75 And,
76 Or,
77 Not,
78 PlusEqual,
79 MinusEqual,
80 StarEqual,
81 SlashEqual,
82 Ampersand,
83 Pipe,
84 Question,
85 LeftParen,
86 RightParen,
87 LeftBrace,
88 RightBrace,
89 LeftBracket,
90 RightBracket,
91 Comma,
92 Colon,
93 DoubleColon,
94 Semicolon,
95 Dot,
96 Arrow,
97 FatArrow,
98 Comment,
99 Whitespace,
100 Newline,
101 Eof,
102}
103
104impl fmt::Display for TokenKind {
105 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
106 match self {
107 TokenKind::Integer => write!(f, "integer"),
108 TokenKind::Float => write!(f, "float"),
109 TokenKind::String => write!(f, "string"),
110 TokenKind::True => write!(f, "true"),
111 TokenKind::False => write!(f, "false"),
112 TokenKind::Identifier => write!(f, "identifier"),
113 TokenKind::Local => write!(f, "local"),
114 TokenKind::Mut => write!(f, "mut"),
115 TokenKind::Function => write!(f, "function"),
116 TokenKind::Return => write!(f, "return"),
117 TokenKind::If => write!(f, "if"),
118 TokenKind::Then => write!(f, "then"),
119 TokenKind::Else => write!(f, "else"),
120 TokenKind::Elseif => write!(f, "elseif"),
121 TokenKind::End => write!(f, "end"),
122 TokenKind::While => write!(f, "while"),
123 TokenKind::Do => write!(f, "do"),
124 TokenKind::For => write!(f, "for"),
125 TokenKind::In => write!(f, "in"),
126 TokenKind::Break => write!(f, "break"),
127 TokenKind::Continue => write!(f, "continue"),
128 TokenKind::Struct => write!(f, "struct"),
129 TokenKind::Enum => write!(f, "enum"),
130 TokenKind::Trait => write!(f, "trait"),
131 TokenKind::Impl => write!(f, "impl"),
132 TokenKind::Match => write!(f, "match"),
133 TokenKind::Case => write!(f, "case"),
134 TokenKind::As => write!(f, "as"),
135 TokenKind::Is => write!(f, "is"),
136 TokenKind::Extern => write!(f, "extern"),
137 TokenKind::Unsafe => write!(f, "unsafe"),
138 TokenKind::Pub => write!(f, "pub"),
139 TokenKind::Use => write!(f, "use"),
140 TokenKind::Module => write!(f, "module"),
141 TokenKind::Const => write!(f, "const"),
142 TokenKind::Static => write!(f, "static"),
143 TokenKind::Type => write!(f, "type"),
144 TokenKind::Plus => write!(f, "+"),
145 TokenKind::Minus => write!(f, "-"),
146 TokenKind::Star => write!(f, "*"),
147 TokenKind::Slash => write!(f, "/"),
148 TokenKind::Percent => write!(f, "%"),
149 TokenKind::Caret => write!(f, "^"),
150 TokenKind::DoubleDot => write!(f, ".."),
151 TokenKind::Concat => write!(f, ".."),
152 TokenKind::Equal => write!(f, "="),
153 TokenKind::DoubleEqual => write!(f, "=="),
154 TokenKind::NotEqual => write!(f, "~="),
155 TokenKind::Less => write!(f, "<"),
156 TokenKind::LessEqual => write!(f, "<="),
157 TokenKind::Greater => write!(f, ">"),
158 TokenKind::GreaterEqual => write!(f, ">="),
159 TokenKind::And => write!(f, "and"),
160 TokenKind::Or => write!(f, "or"),
161 TokenKind::Not => write!(f, "not"),
162 TokenKind::PlusEqual => write!(f, "+="),
163 TokenKind::MinusEqual => write!(f, "-="),
164 TokenKind::StarEqual => write!(f, "*="),
165 TokenKind::SlashEqual => write!(f, "/="),
166 TokenKind::Ampersand => write!(f, "&"),
167 TokenKind::Pipe => write!(f, "|"),
168 TokenKind::Question => write!(f, "?"),
169 TokenKind::LeftParen => write!(f, "("),
170 TokenKind::RightParen => write!(f, ")"),
171 TokenKind::LeftBrace => write!(f, "{{"),
172 TokenKind::RightBrace => write!(f, "}}"),
173 TokenKind::LeftBracket => write!(f, "["),
174 TokenKind::RightBracket => write!(f, "]"),
175 TokenKind::Comma => write!(f, ","),
176 TokenKind::Colon => write!(f, ":"),
177 TokenKind::DoubleColon => write!(f, "::"),
178 TokenKind::Semicolon => write!(f, ";"),
179 TokenKind::Dot => write!(f, "."),
180 TokenKind::Arrow => write!(f, "->"),
181 TokenKind::FatArrow => write!(f, "=>"),
182 TokenKind::Comment => write!(f, "comment"),
183 TokenKind::Whitespace => write!(f, "whitespace"),
184 TokenKind::Newline => write!(f, "newline"),
185 TokenKind::Eof => write!(f, "EOF"),
186 }
187 }
188}
189
190impl TokenKind {
191 pub fn keyword(s: &str) -> Option<TokenKind> {
192 match s {
193 "local" => Some(TokenKind::Local),
194 "mut" => Some(TokenKind::Mut),
195 "function" => Some(TokenKind::Function),
196 "return" => Some(TokenKind::Return),
197 "if" => Some(TokenKind::If),
198 "then" => Some(TokenKind::Then),
199 "else" => Some(TokenKind::Else),
200 "elseif" => Some(TokenKind::Elseif),
201 "end" => Some(TokenKind::End),
202 "while" => Some(TokenKind::While),
203 "do" => Some(TokenKind::Do),
204 "for" => Some(TokenKind::For),
205 "in" => Some(TokenKind::In),
206 "break" => Some(TokenKind::Break),
207 "continue" => Some(TokenKind::Continue),
208 "struct" => Some(TokenKind::Struct),
209 "enum" => Some(TokenKind::Enum),
210 "trait" => Some(TokenKind::Trait),
211 "impl" => Some(TokenKind::Impl),
212 "match" => Some(TokenKind::Match),
213 "case" => Some(TokenKind::Case),
214 "as" => Some(TokenKind::As),
215 "is" => Some(TokenKind::Is),
216 "true" => Some(TokenKind::True),
217 "false" => Some(TokenKind::False),
218 "and" => Some(TokenKind::And),
219 "or" => Some(TokenKind::Or),
220 "not" => Some(TokenKind::Not),
221 "extern" => Some(TokenKind::Extern),
222 "unsafe" => Some(TokenKind::Unsafe),
223 "pub" => Some(TokenKind::Pub),
224 "use" => Some(TokenKind::Use),
225 "module" => Some(TokenKind::Module),
226 "const" => Some(TokenKind::Const),
227 "static" => Some(TokenKind::Static),
228 "type" => Some(TokenKind::Type),
229 _ => None,
230 }
231 }
232}