⚔️ added lexer errors

aym-n · Jan 11, 2024 · 86db225 · 86db225
1 parent b1120cb
commit 86db225
Show file tree

Hide file tree

Showing 6 changed files with 92 additions and 70 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "arc"
-version = "0.1.0"
+version = "1.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

diff --git a/main.arc b/main.arc
@@ -1,9 +1 @@
-class Doughnut {
-  cook() {
-    print "Fry until golden brown.";
-  }
-}
-
-class BostonCream < Doughnut {}
-
-BostonCream().cook();
+print "hello;
diff --git a/src/errors.rs b/src/errors.rs
@@ -2,13 +2,24 @@ use crate::tokens::*;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum Error {
+    LexerError{ lexeme: String , line: String, message: String},
     ParseError { token: Token, message: String },
     RuntimeError { token: Token, message: String },
     SystemError { message: String },
     Return { value: Object },
 }
 
 impl Error {
+    pub fn lexer_error(lexeme: &str, line: &str, message: &str) -> Error {
+        let err = Error::LexerError {
+            lexeme: lexeme.to_string(),
+            line: line.to_string(),
+            message: message.to_string(),
+        };
+        err.report("");
+        err
+    }
+
     pub fn return_value(value: Object) -> Error {
         Error::Return { value }
     }
@@ -41,6 +52,9 @@ impl Error {
 
     pub fn report(&self, _loc: &str) {
         match self {
+            Error::LexerError { lexeme, line, message } => {
+                eprintln!("[line {}] Error {}: {}", line, lexeme, message);
+            }
             Error::ParseError { token, message }
             | Error::RuntimeError { token, message } => {
                 if token.kind == TokenKind::EOF {

diff --git a/src/lexer.rs b/src/lexer.rs
@@ -1,10 +1,11 @@
 use crate::tokens::*;
-
+use crate::errors::*;
 pub struct Lexer {
     input: String,
     start: usize,
     current: usize,
     line: usize,
+    pub had_error: bool,
 }
 
 impl Lexer {
@@ -14,6 +15,7 @@ impl Lexer {
             start: 0,
             current: 0,
             line: 1,
+            had_error: false,
         }
     }
 
@@ -73,7 +75,12 @@ impl Lexer {
         }
 
         if self.is_at_end() {
-            eprintln!("{}: Unterminated string.", self.line);
+            Error::lexer_error(
+                &self.input[self.start..self.current].to_string(),
+                &self.line.to_string(),
+                "unterminated string.",
+            );
+            self.had_error = true;
             return None;
         }
 
@@ -105,9 +112,13 @@ impl Lexer {
     fn is_at_end(&self) -> bool {
         self.current > self.input.len() - 1
     }
+
+    pub fn success(&self) -> bool {
+        !self.had_error
+    }
 }
 
-impl Iterator for Lexer {
+impl<'a> Iterator for &'a mut Lexer {
     type Item = Token;
     fn next(&mut self) -> Option<Self::Item> {
         if self.is_at_end() {
@@ -212,7 +223,12 @@ impl Iterator for Lexer {
             }
 
             _ => {
-                eprintln!("{}: Unexpected character: {}", self.line, self.current_char());
+                Error::lexer_error(
+                    &self.input[self.start..self.current].to_string(),
+                    &self.line.to_string(),
+                    "unexpected character.",
+                );
+                self.had_error = true;
                 None
             }
         }

diff --git a/src/main.rs b/src/main.rs
@@ -1,55 +1,41 @@
-use std::io::Write;
-
-mod lexer;
-use crate::lexer::Lexer;
-
-mod tokens;
-use tokens::*;
-
+mod callable;
+mod enviroment;
 mod errors;
-use crate::errors::*;
-
-// mod ast_printer;
-// use crate::ast_printer::AstPrinter;
-
 mod expr;
-
-mod parser;
-use parser::*;
-
+mod functions;
+mod instance;
 mod interpreter;
-use interpreter::Interpreter;
-
-mod stmt;
-
-mod enviroment;
-
-mod callable;
-
+mod lexer;
 mod native_functions;
-
-mod functions;
-
+mod parser;
 mod resolver;
-use resolver::*;
+mod stmt;
+mod tokens;
 
+use crate::errors::*;
+use crate::lexer::Lexer;
+use interpreter::Interpreter;
+use parser::*;
+use resolver::*;
+use std::io::Write;
 use std::rc::Rc;
-
-mod instance;
+use tokens::*;
 
 fn eval(source: &str) -> Result<(), Error> {
-    let lexer = Lexer::new(source.to_string());
+    let mut lexer = Lexer::new(source.to_string());
     let tokens: Vec<Token> = lexer.collect();
 
-    let mut parser = Parser::new(tokens);
-    let statements = parser.parse();
+    if lexer.success() {
+        let mut parser = Parser::new(tokens);
+        let statements = parser.parse();
 
-    let interpreter = Interpreter::new();
-    let s = Rc::new(statements?);
-    let resolver = Resolver::new(&interpreter);
-    resolver.resolve(&Rc::clone(&s));
-    if resolver.success(){
-        interpreter.interpret(&Rc::clone(&s));
+        let interpreter = Interpreter::new();
+        let s = Rc::new(statements?);
+        let resolver = Resolver::new(&interpreter);
+        resolver.resolve(&Rc::clone(&s));
+        if resolver.success() {
+            interpreter.interpret(&Rc::clone(&s));
+        }
     }
     Ok(())
 }
@@ -58,34 +44,48 @@ fn repl() {
     let interpreter = Interpreter::new();
     loop {
         let mut input = String::new();
-        print!(">");
+        //ascii header
+        println!(
+            r#" 
+            █████╗ ██████╗  ██████╗
+            ██╔══██╗██╔══██╗██╔════╝
+            ███████║██████╔╝██║     
+            ██╔══██║██╔══██╗██║     
+            ██║  ██║██║  ██║╚██████╗
+            ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ 
+                    [v1.1.0]
+            "#
+        );            
+        print!("arc~> ");
         std::io::stdout().flush().unwrap();
         std::io::stdin().read_line(&mut input).unwrap();
-
+        input = input.trim_end_matches('\n').to_string();
         match input.trim() {
             "exit" => std::process::exit(0),
+            "clear" => print!("{}[2J", 27 as char),
             "@" => interpreter.print_env(),
             _ => {
-                let lexer = Lexer::new(input);
+                let mut lexer = Lexer::new(input);
                 let tokens: Vec<Token> = lexer.collect();
 
-                let mut parser = Parser::new(tokens);
-                let statements = parser.parse();
+                if lexer.success() {
+                    let mut parser = Parser::new(tokens);
+                    let statements = parser.parse();
 
-                match statements {
-                    Ok(statements) => {
-                        let s = Rc::new(statements);
-                        let resolver = Resolver::new(&interpreter);
-                        resolver.resolve(&Rc::clone(&s));
+                    match statements {
+                        Ok(statements) => {
+                            let s = Rc::new(statements);
+                            let resolver = Resolver::new(&interpreter);
+                            resolver.resolve(&Rc::clone(&s));
 
-                        if resolver.success() {
-                            if !interpreter.interpret(&Rc::clone(&s)) {
-                                std::process::exit(1);
+                            if resolver.success() {
+                                if !interpreter.interpret(&Rc::clone(&s)) {
+                                    std::process::exit(1);
+                                }
                             }
                         }
-
+                        Err(_) => std::process::exit(2),
                     }
-                    Err(_) => std::process::exit(2),
                 }
             }
         }