1use std::{
2 collections::HashMap,
3 fmt::{self, Display},
4};
5
6#[derive(Debug, Clone, PartialEq)]
7pub enum Token {
8 Eof,
9 Newline,
10 Indent,
11 Dedent,
12 Name(String),
13 Integer(num_bigint::BigUint),
14 Float(f64),
15 Imaginary(f64),
16 String(String),
17 FormattedString(String),
18 Bytes(Vec<u8>),
19
20 ParenOpen,
24 ParenClose,
26 BracketOpen,
28 BracketClose,
30 BraceOpen,
32 BraceClose,
34 Colon,
36 Comma,
38 Semi,
40 Plus,
42 Minus,
44 Star,
46 Slash,
48 Pipe,
50 Amper,
52 Less,
54 Greater,
56 Equal,
58 Dot,
60 Percent,
62 EqEqual,
64 NotEqual,
66 LessEqual,
68 GreaterEqual,
70 Tilde,
72 Caret,
74 LeftShift,
76 RightShift,
78 DoubleStar,
80 PlusEqual,
82 MinEqual,
84 StarEqual,
86 SlashEqual,
88 PercentEqual,
90 AmperEqual,
92 PipeEqual,
94 CaretEqual,
96 LeftShiftEqual,
98 RightShiftEqual,
100 DoubleStarEqual,
102 DoubleSlash,
104 DoubleSlashEqual,
106 At,
108 AtEqual,
110 Rarrow,
112 Ellipsis,
114
115 False,
119 None,
121 True,
123 And,
125 As,
127 Assert,
129 Break,
131 Class,
133 Continue,
135 Def,
137 Del,
139 Elif,
141 Else,
143 Except,
145 Finally,
147 For,
149 From,
151 Global,
153 If,
155 Import,
157 In,
159 Is,
161 Lambda,
163 Nonlocal,
165 Not,
167 Or,
169 Pass,
171 Raise,
173 Return,
175 Try,
177 While,
179 With,
181 Yield,
183 Await,
185 Async,
187
188 #[doc(hidden)]
190 Module,
191 #[doc(hidden)]
192 Interactive,
193 #[doc(hidden)]
194 Eval,
195}
196
197impl Display for Token {
198 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
199 use Token::*;
200 match self {
201 Eof => write!(f, "EOF"),
202 Newline => write!(f, "newline"),
203 Indent => write!(f, "indent"),
204 Dedent => write!(f, "dedent"),
205 Name(name) => write!(f, "name {}", name),
206 Integer(n) => write!(f, "integer {}", n),
207 Float(n) => write!(f, "float {}", n),
208 Imaginary(n) => write!(f, "complex {}", n),
209 String(_) => write!(f, "string"),
210 FormattedString(_) => write!(f, "formatted string"),
211 Bytes(_) => write!(f, "bytes"),
212 ParenOpen => write!(f, r#"symbol "(""#),
213 ParenClose => write!(f, r#"symbol ")"#),
214 BracketOpen => write!(f, r#"symbol "[""#),
215 BracketClose => write!(f, r#"symbol "]""#),
216 BraceOpen => write!(f, r#"symbol "{{""#),
217 BraceClose => write!(f, r#"symbol \"}}"#),
218 Colon => write!(f, r#"symbol ":""#),
219 Comma => write!(f, r#"symbol ",""#),
220 Semi => write!(f, r#"symbol ";""#),
221 Plus => write!(f, r#"symbol "+""#),
222 Minus => write!(f, r#"symbol "-""#),
223 Star => write!(f, r#"symbol "*""#),
224 Slash => write!(f, r#"symbol "/""#),
225 Pipe => write!(f, r#"symbol "|""#),
226 Amper => write!(f, r#"symbol "&""#),
227 Less => write!(f, r#"symbol "<""#),
228 Greater => write!(f, r#"symbol ">""#),
229 Equal => write!(f, r#"symbol "=""#),
230 Dot => write!(f, r#"symbol ".""#),
231 Percent => write!(f, r#"symbol "%""#),
232 EqEqual => write!(f, r#"symbol "==""#),
233 NotEqual => write!(f, r#"symbol "!=""#),
234 LessEqual => write!(f, r#"symbol "<=""#),
235 GreaterEqual => write!(f, r#"symbol ">=""#),
236 Tilde => write!(f, r#"symbol "~""#),
237 Caret => write!(f, r#"symbol "^""#),
238 LeftShift => write!(f, r#"symbol "<<""#),
239 RightShift => write!(f, r#"symbol ">>""#),
240 DoubleStar => write!(f, r#"symbol "**""#),
241 PlusEqual => write!(f, r#"symbol "+=""#),
242 MinEqual => write!(f, r#"symbol "-=""#),
243 StarEqual => write!(f, r#"symbol "*=""#),
244 SlashEqual => write!(f, r#"symbol "/=""#),
245 PercentEqual => write!(f, r#"symbol "%=""#),
246 AmperEqual => write!(f, r#"symbol "&=""#),
247 PipeEqual => write!(f, r#"symbol "|=""#),
248 CaretEqual => write!(f, r#"symbol "^=""#),
249 LeftShiftEqual => write!(f, r#"symbol """#),
250 RightShiftEqual => write!(f, r#"symbol ">>=""#),
251 DoubleStarEqual => write!(f, r#"symbol "**=""#),
252 DoubleSlash => write!(f, r#"symbol "//""#),
253 DoubleSlashEqual => write!(f, r#"symbol "//=""#),
254 At => write!(f, r#"symbol "@""#),
255 AtEqual => write!(f, r#"symbol "@=""#),
256 Rarrow => write!(f, r#"symbol "->""#),
257 Ellipsis => write!(f, r#"symbol "...""#),
258 False => write!(f, r#"keyword "False""#),
259 None => write!(f, r#"keyword "None""#),
260 True => write!(f, r#"keyword "True""#),
261 And => write!(f, r#"keyword "and""#),
262 As => write!(f, r#"keyword "as""#),
263 Assert => write!(f, r#"keyword "assert""#),
264 Break => write!(f, r#"keyword "break""#),
265 Class => write!(f, r#"keyword "class""#),
266 Continue => write!(f, r#"keyword "continue""#),
267 Def => write!(f, r#"keyword "def""#),
268 Del => write!(f, r#"keyword "del""#),
269 Elif => write!(f, r#"keyword "elif""#),
270 Else => write!(f, r#"keyword "else""#),
271 Except => write!(f, r#"keyword "except""#),
272 Finally => write!(f, r#"keyword "finally""#),
273 For => write!(f, r#"keyword "for""#),
274 From => write!(f, r#"keyword "from""#),
275 Global => write!(f, r#"keyword "global""#),
276 If => write!(f, r#"keyword "if""#),
277 Import => write!(f, r#"keyword "import""#),
278 In => write!(f, r#"keyword "in""#),
279 Is => write!(f, r#"keyword "is""#),
280 Lambda => write!(f, r#"keyword "lambda""#),
281 Nonlocal => write!(f, r#"keyword "nonlocal""#),
282 Not => write!(f, r#"keyword "not""#),
283 Or => write!(f, r#"keyword "or""#),
284 Pass => write!(f, r#"keyword "pass""#),
285 Raise => write!(f, r#"keyword "raise""#),
286 Return => write!(f, r#"keyword "return""#),
287 Try => write!(f, r#"keyword "try""#),
288 While => write!(f, r#"keyword "while""#),
289 With => write!(f, r#"keyword "with""#),
290 Yield => write!(f, r#"keyword "yield""#),
291 Await => write!(f, r#"keyword "await""#),
292 Async => write!(f, r#"keyword "async""#),
293
294 Module => write!(f, "module"),
295 Interactive => write!(f, "interactive"),
296 Eval => write!(f, "eval"),
297 }
298 }
299}
300
301lazy_static::lazy_static! {
302 pub(crate) static ref SYMBOLS: HashMap<&'static str, Token> = {
303 let mut m = HashMap::new();
304 m.insert("(", Token::ParenOpen);
305 m.insert(")", Token::ParenClose);
306 m.insert("[", Token::BracketOpen);
307 m.insert("]", Token::BracketClose);
308 m.insert("{", Token::BraceOpen);
309 m.insert("}", Token::BraceClose);
310 m.insert(":", Token::Colon);
311 m.insert(",", Token::Comma);
312 m.insert(";", Token::Semi);
313 m.insert("+", Token::Plus);
314 m.insert("-", Token::Minus);
315 m.insert("*", Token::Star);
316 m.insert("/", Token::Slash);
317 m.insert("|", Token::Pipe);
318 m.insert("&", Token::Amper);
319 m.insert("<", Token::Less);
320 m.insert(">", Token::Greater);
321 m.insert("=", Token::Equal);
322 m.insert(".", Token::Dot);
323 m.insert("%", Token::Percent);
324 m.insert("==", Token::EqEqual);
325 m.insert("!=", Token::NotEqual);
326 m.insert("<=", Token::LessEqual);
327 m.insert(">=", Token::GreaterEqual);
328 m.insert("~", Token::Tilde);
329 m.insert("^", Token::Caret);
330 m.insert("<<", Token::LeftShift);
331 m.insert(">>", Token::RightShift);
332 m.insert("**", Token::DoubleStar);
333 m.insert("+=", Token::PlusEqual);
334 m.insert("-=", Token::MinEqual);
335 m.insert("*=", Token::StarEqual);
336 m.insert("/=", Token::SlashEqual);
337 m.insert("%=", Token::PercentEqual);
338 m.insert("&=", Token::AmperEqual);
339 m.insert("|=", Token::PipeEqual);
340 m.insert("^=", Token::CaretEqual);
341 m.insert("<<=", Token::LeftShiftEqual);
342 m.insert(">>=", Token::RightShiftEqual);
343 m.insert("**=", Token::DoubleStarEqual);
344 m.insert("//", Token::DoubleSlash);
345 m.insert("//=", Token::DoubleSlashEqual);
346 m.insert("@", Token::At);
347 m.insert("@=", Token::AtEqual);
348 m.insert("->", Token::Rarrow);
349 m.insert("...", Token::Ellipsis);
350 m
351 };
352 pub(crate) static ref KEYWORDS: HashMap<&'static str, Token> = {
353 let mut m = HashMap::new();
354 m.insert("False", Token::False);
355 m.insert("None", Token::None);
356 m.insert("True", Token::True);
357 m.insert("and", Token::And);
358 m.insert("as", Token::As);
359 m.insert("assert", Token::Assert);
360 m.insert("break", Token::Break);
361 m.insert("class", Token::Class);
362 m.insert("continue", Token::Continue);
363 m.insert("def", Token::Def);
364 m.insert("del", Token::Del);
365 m.insert("elif", Token::Elif);
366 m.insert("else", Token::Else);
367 m.insert("except", Token::Except);
368 m.insert("finally", Token::Finally);
369 m.insert("for", Token::For);
370 m.insert("from", Token::From);
371 m.insert("global", Token::Global);
372 m.insert("if", Token::If);
373 m.insert("import", Token::Import);
374 m.insert("in", Token::In);
375 m.insert("is", Token::Is);
376 m.insert("lambda", Token::Lambda);
377 m.insert("nonlocal", Token::Nonlocal);
378 m.insert("not", Token::Not);
379 m.insert("or", Token::Or);
380 m.insert("pass", Token::Pass);
381 m.insert("raise", Token::Raise);
382 m.insert("return", Token::Return);
383 m.insert("try", Token::Try);
384 m.insert("while", Token::While);
385 m.insert("with", Token::With);
386 m.insert("yield", Token::Yield);
387 m.insert("await", Token::Await);
388 m.insert("async", Token::Async);
389 m
390 };
391}