extend token::kind

Author: martcpp

src/lexericals/lexer.rs

@@ -35,7 +35,14 @@ impl Lexer {
         //"=+(){},;";
         self.skip_whitespace(); // Skip whitespace characters
         let token = match self.ch {
-            '=' => Token::new(Tokenkind::Assign, self.ch.to_string()),
+            '=' => {
+                self.read_token(); // Read the next character to check for '=='
+                if self.ch == '=' {
+                    Token::new(Tokenkind::Eq, "==".to_string())
+                }else {
+                    Token::new(Tokenkind::Assign, "=".to_string())
+                }
+            },
             '+' => Token::new(Tokenkind::Plus, self.ch.to_string()),
             '-' => Token::new(Tokenkind::Minus, self.ch.to_string()),
             ',' => Token::new(Tokenkind::Comma, self.ch.to_string()),
@@ -44,6 +51,27 @@ impl Lexer {
             '}' => Token::new(Tokenkind::Rbrace, self.ch.to_string()),
             '{' => Token::new(Tokenkind::Lbrace, self.ch.to_string()),
             ';' => Token::new(Tokenkind::Semicolon, self.ch.to_string()),
+            '!' => {
+                self.read_token(); // Read the next character to check for '!='
+                if self.ch == '=' {
+                    Token::new(Tokenkind::NotEq, "!=".to_string())
+                } else {
+                    Token::new(Tokenkind::Bang, "!".to_string())
+                }
+            }
+            '*' => Token::new(Tokenkind::Asterisk, self.ch.to_string()),
+            '/' => Token::new(Tokenkind::Slash, self.ch.to_string()),
+            '%' => Token::new(Tokenkind::Pencentage, self.ch.to_string()),
+            '<' => Token::new(Tokenkind::Lthan, self.ch.to_string()),
+            '>' => Token::new(Tokenkind::Gthan, self.ch.to_string()),
+            '&' => {
+                self.read_token(); // Read the next character to check for '&&'
+                if self.ch == '&' {
+                    Token::new(Tokenkind::And, "&&".to_string())
+                } else {
+                    Token::new(Tokenkind::Illegal, "&".to_string())
+                }
+            }
             '\0' => Token::new(Tokenkind::Eof, String::new()), // End of file token
 
             _ => {
@@ -124,6 +152,7 @@ mod test {
             x + y;
         };
         let result = add(five, ten);
+        ==
         "#;
 
         let expect_token = vec![
@@ -168,6 +197,7 @@ mod test {
             Token::new(Tokenkind::Ident, String::from("ten")),
             Token::new(Tokenkind::Rparen, String::from(")")),
             Token::new(Tokenkind::Semicolon, String::from(";")),
+            Token::new(Tokenkind::Eq, String::from("==")),
             Token::new(Tokenkind::Eof, String::new()),
         ];
         let mut lexer = Lexer::new(input);

src/lexericals/tokenizer.rs

@@ -16,28 +16,42 @@ impl Token {
 #[allow(dead_code, unused_variables)]
 #[derive(Debug, PartialEq)]
 pub enum Tokenkind {
+    // Illegal and End of File and identifiers
     Illegal,
     Eof,
     Ident,
+    
+
+    // Types
     Int,
     Float,
     String,
-    Assign,
+    Char,
+
+    // mathematical Operators
     Plus,
     Minus,
-    Bang,
     Asterisk,
     Slash,
+    Pencentage,
+
+    // special Characters
     Comma,
     Semicolon,
     Lparen,
     Rparen,
     Lbrace,
     Rbrace,
+    Assign,
+
+    // comparison Operators
     Eq,
     NotEq,
     Lthan,
     Gthan,
+    OR,
+    And,
+    Bang,
 
     // Keywords
     Function,
@@ -50,29 +64,45 @@ pub enum Tokenkind {
 impl Display for Tokenkind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            // Illegal and End of File and identifiers
             Tokenkind::Illegal => write!(f, "Illegal"),
             Tokenkind::Eof => write!(f, "Eof"),
             Tokenkind::Ident => write!(f, "Ident"),
+            
+
+            // Types
             Tokenkind::Int => write!(f, "Int"),
             Tokenkind::Float => write!(f, "Float"),
             Tokenkind::String => write!(f, "String"),
-            Tokenkind::Assign => write!(f, "Assign"),
+            Tokenkind::Char => write!(f, "Char"),
+
+            
+
+            // mathematical Operators
             Tokenkind::Plus => write!(f, "Plus"),
             Tokenkind::Minus => write!(f, "Minus"),
-            Tokenkind::Bang => write!(f, "Bang"),
             Tokenkind::Asterisk => write!(f, "Asterisk"),
             Tokenkind::Slash => write!(f, "Slash"),
+            Tokenkind::Pencentage => write!(f, "Percentage"),
+
+            // special Characters
             Tokenkind::Comma => write!(f, "Comma"),
             Tokenkind::Semicolon => write!(f, "Semicolon"),
             Tokenkind::Lparen => write!(f, "Lparen"),
             Tokenkind::Rparen => write!(f, "Rparen"),
             Tokenkind::Lbrace => write!(f, "Lbrace"),
             Tokenkind::Rbrace => write!(f, "Rbrace"),
+            Tokenkind::Assign => write!(f, "Assign"),
+
+            // equality Operators
             Tokenkind::Eq => write!(f, "Eq"),
             Tokenkind::NotEq => write!(f, "NotEq"),
             Tokenkind::Lthan => write!(f, "Lthan"),
             Tokenkind::Gthan => write!(f, "Gthan"),
-
+            Tokenkind::OR => write!(f, "OR"),
+            Tokenkind::And => write!(f, "And"),
+            Tokenkind::Bang => write!(f, "Bang"),
+            
             // Keywords
             Tokenkind::Function => write!(f, "Function"),
             Tokenkind::Let => write!(f, "Let"),
@@ -85,7 +115,7 @@ impl Display for Tokenkind {
 
 impl Tokenkind {
     pub fn lookup_ident(ident: &str) -> Self {
-        match ident as &str {
+        match ident{
             "fn" => Self::Function,
             "let" => Self::Let,
             "if" => Self::If,

src/main.rs

@@ -18,6 +18,7 @@ fn main() {
             x + y;
         };
         let result = add(five, ten);
+        ==
         "#;
 
     let mut lexer = Lexer::new(input);
@@ -109,6 +110,7 @@ fn read() -> Vec<Token> {
         Token::new(Tokenkind::Ident, String::from("ten")),
         Token::new(Tokenkind::Rparen, String::from(")")),
         Token::new(Tokenkind::Semicolon, String::from(";")),
+        Token::new(Tokenkind::Eq, String::from("==")),
         Token::new(Tokenkind::Eof, String::new()),
     ];
     expected_token