Enumération des types de token

Infos de base d'un token

src/main.rs

@@ -2,10 +2,10 @@ use std::env;
 use std::fs;
 use std::io;
 use std::io::Write;
-use crate::rlox::RLox;
 use std::process;
 
-pub mod rlox;
+mod rlox;
+use crate::rlox::RLox;
 
 // Exit codes from #include <sysexits.h>
 const EX_OK: i32 = 0;
@@ -54,10 +54,15 @@ fn run_prompt() -> i32 {
     exit_code
 }
 
-fn run( script: String ) -> i32 {
+fn run( _script: String ) -> i32 {
     let rlox_interpreter = RLox { had_error: false };
 
 
     if rlox_interpreter.had_error { EX_DATAERR } else { EX_OK }
 }
 
+// Implémentations de référence :
+// https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations#rust
+
+// Pause :
+// http://www.craftinginterpreters.com/scanning.html#regular-languages-and-expressions

src/rlox.rs

@@ -1,4 +1,5 @@
-
+mod token_type;
+mod token;
 
 pub struct RLox {
     pub had_error: bool,

src/rlox/token.rs

@@ -0,0 +1,15 @@
+use super::token_type::TokenType;
+
+#[derive(Debug)]
+struct Token {
+    token_type: TokenType,
+    lexeme: String,
+    literal: String,
+    line: u32,
+}
+
+impl std::fmt::Display for Token {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{0} {1} {2}",self.token_type, self.lexeme, self.literal)
+    }
+}

src/rlox/token_type.rs

@@ -0,0 +1,105 @@
+
+#[derive(Debug)]
+pub enum TokenType {
+    // Single-character tokens.
+    LeftParen,
+    RightParen,
+    LeftBrace,
+    RightBrace,
+    Comma,
+    Dot,
+    Minus,
+    Plus,
+    Semicolon,
+    Slash,
+    Star,
+
+    // One or two character tokens.
+    Bang,
+    BangEqual,
+    Equal,
+    EqualEqual,
+    Greater,
+    GreaterEqual,
+    Less,
+    LessEqual,
+
+    // Literals.
+    Identifier,
+    String,
+    Number,
+
+    // Keywords.
+    And,
+    Class,
+    Else,
+    False,
+    Fun,
+    For,
+    If,
+    Nil,
+    Or,
+    Print,
+    Return,
+    Super,
+    This,
+    True,
+    Var,
+    While,
+
+    Eof,
+}
+
+impl std::fmt::Display for crate::rlox::token_type::TokenType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            // Single-character tokens.
+            TokenType::LeftParen=> write!(f, "LEFT_PAREN"),
+            TokenType::RightParen=> write!(f, "RIGHT_PAREN"),
+            TokenType::LeftBrace=> write!(f, "LEFT_BRACE"),
+            TokenType::RightBrace=> write!(f, "RIGHT_BRACE"),
+            TokenType::Comma=> write!(f, "COMMA"),
+            TokenType::Dot=> write!(f, "DOT"),
+            TokenType::Minus=> write!(f, "MINUS"),
+            TokenType::Plus=> write!(f, "PLUS"),
+            TokenType::Semicolon=> write!(f, "SEMICOLON"),
+            TokenType::Slash=> write!(f, "SLASH"),
+            TokenType::Star=> write!(f, "STAR"),
+
+            // One or two character tokens.
+            TokenType::Bang=> write!(f, "BANG"),
+            TokenType::BangEqual=> write!(f, "BANG_EQUAL"),
+            TokenType::Equal=> write!(f, "EQUAL"),
+            TokenType::EqualEqual=> write!(f, "EQUAL_EQUAL"),
+            TokenType::Greater=> write!(f, "GREATER"),
+            TokenType::GreaterEqual=> write!(f, "GREATER_EQUAL"),
+            TokenType::Less=> write!(f, "LESS"),
+            TokenType::LessEqual=> write!(f, "LESS_EQUAL"),
+
+            // Literals.
+            TokenType::Identifier=> write!(f, "IDENTIFIER"),
+            TokenType::String=> write!(f, "STRING"),
+            TokenType::Number=> write!(f, "NUMBER"),
+
+            // Keywords.
+            TokenType::And=> write!(f, "AND"),
+            TokenType::Class=> write!(f, "CLASS"),
+            TokenType::Else=> write!(f, "ELSE"),
+            TokenType::False=> write!(f, "FALSE"),
+            TokenType::Fun=> write!(f, "FUN"),
+            TokenType::For=> write!(f, "FOR"),
+            TokenType::If=> write!(f, "IF"),
+            TokenType::Nil=> write!(f, "NIL"),
+            TokenType::Or=> write!(f, "OR"),
+            TokenType::Print=> write!(f, "PRINT"),
+            TokenType::Return=> write!(f, "RETURN"),
+            TokenType::Super=> write!(f, "SUPER"),
+            TokenType::This=> write!(f, "THIS"),
+            TokenType::True=> write!(f, "TRUE"),
+            TokenType::Var=> write!(f, "VAR"),
+            TokenType::While=> write!(f, "WHILE"),
+
+            TokenType::Eof=> write!(f, "EOF"),
+        }
+    }
+}