m o r e r e f a c t o r i n g

Author: LynithDev

packages/engine/src/cursor.rs

@@ -67,24 +67,3 @@ impl Cursor {
         self.2
     } 
 }
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct WithCursor<T> {
-    pub value: T,
-    pub start: Cursor,
-    pub end: Cursor,
-}
-
-impl<T> WithCursor<T> {
-    pub fn create(value: T) -> Self {
-        Self::create_with(Cursor::create(), Cursor::create(), value)
-    }
-
-    pub fn create_with(start: Cursor, end: Cursor, value: T) -> Self {
-        Self {
-            start,
-            end,
-            value,
-        }
-    }
-}

packages/engine/src/engine.rs

@@ -0,0 +1,68 @@
+use std::path::PathBuf;
+use crate::component::ComponentErrors;
+use crate::error::{EngineErrorKind, EngineResult};
+use crate::lexer::Lexer;
+use crate::parser::Parser;
+
+pub struct Engine {}
+
+impl Engine {
+    pub fn create() -> Self {
+        debug!("created engine");
+        Self {}
+    }
+
+    pub fn exec_file(&mut self, file: &PathBuf) -> EngineResult<i32> {
+        debug!("executing file {file:?}");
+
+        let code = if file.is_file() && (file.is_absolute() || file.is_relative()) {
+            std::fs::read_to_string(file).map_err(|_| EngineErrorKind::UnknownError)?
+        } else {
+            return Err(EngineErrorKind::UnknownError);
+        };
+
+        let mut lexer = Lexer::create(
+            &code,
+            #[cfg(feature = "cli")]
+            Some(file.clone()),
+        );
+        self.exec_post(&mut lexer)
+    }
+
+    pub fn exec(&mut self, code: &str) -> EngineResult<i32> {
+        debug!("executing script");
+
+        let mut lexer = Lexer::create(
+            code,
+            #[cfg(feature = "cli")]
+            None,
+        );
+        self.exec_post(&mut lexer)
+    }
+
+    fn exec_post(&mut self, lexer: &mut Lexer) -> EngineResult<i32> {
+        #[cfg(feature = "cli")]
+        let source_file = lexer.source().clone();
+        
+        lexer.tokens();  
+        if lexer.has_errors() {
+            lexer.print_errors();
+            return Ok(1);
+        }
+
+        let mut parser = Parser::create(
+            lexer.tokens(),
+            #[cfg(feature = "cli")]
+            source_file,
+        );
+
+        parser.parse();
+        parser.print_errors();
+
+        // let mut transpiler = Transpiler::create(&transpiler::TranspilerTarget::Bash, parser.parse());
+        // println!("---START---\n{}\n---END---", transpiler.transpile());
+
+
+        Ok(0)
+    }
+}

packages/engine/src/lib.rs

@@ -6,79 +6,21 @@
 #[macro_use]
 extern crate log;
 
-use std::path::PathBuf;
-use component::ComponentErrors;
-use error::EngineResult;
-use lexer::Lexer;
-use parser::Parser;
-
 pub mod component;
 pub mod constants;
 pub mod cursor;
 pub mod error;
 pub mod lexer;
 pub mod parser;
 pub mod transpiler;
-
-pub struct Engine {}
-
-impl Engine {
-    pub fn create() -> Self {
-        debug!("created engine");
-        Self {}
-    }
-
-    pub fn exec_file(&mut self, file: &PathBuf) -> EngineResult<i32> {
-        debug!("executing file {file:?}");
-
-        let code = if file.is_file() && (file.is_absolute() || file.is_relative()) {
-            std::fs::read_to_string(file).map_err(|_| error::EngineErrorKind::UnknownError)?
-        } else {
-            return Err(error::EngineErrorKind::UnknownError);
-        };
-
-        let mut lexer = Lexer::create(
-            &code,
-            #[cfg(feature = "cli")]
-            Some(file.clone()),
-        );
-        self.exec_post(&mut lexer)
-    }
-
-    pub fn exec(&mut self, code: &str) -> EngineResult<i32> {
-        debug!("executing script");
-
-        let mut lexer = Lexer::create(
-            code,
-            #[cfg(feature = "cli")]
-            None,
-        );
-        self.exec_post(&mut lexer)
-    }
-
-    fn exec_post(&mut self, lexer: &mut Lexer) -> EngineResult<i32> {
-        #[cfg(feature = "cli")]
-        let source_file = lexer.source().clone();
-        
-        lexer.tokens();  
-        if lexer.has_errors() {
-            lexer.print_errors();
-            return Ok(1);
+pub mod engine;
+
+#[macro_export]
+macro_rules! ok_or_none {
+    ($expr:expr) => {
+        match $expr {
+            Some(val) => val,
+            None => return Ok(None),
         }
-
-        let mut parser = Parser::create(
-            lexer.tokens(),
-            #[cfg(feature = "cli")]
-            source_file,
-        );
-
-        parser.parse();
-        parser.print_errors();
-
-        // let mut transpiler = Transpiler::create(&transpiler::TranspilerTarget::Bash, parser.parse());
-        // println!("---START---\n{}\n---END---", transpiler.transpile());
-
-
-        Ok(0)
-    }
-}
+    };
+}

packages/engine/src/parser/ast.rs

@@ -21,11 +21,18 @@ macro_rules! parseable {
 }
 
 #[macro_export]
-macro_rules! parse {
+macro_rules! parse_expr {
     ($parser:expr, $expr:ident = $name:ty) => {
-        let Some($expr) = <$name>::parse($parser)? else {
-            return Ok(None);
+        let start = $parser.cursor;
+        let kind = $crate::ok_or_none!(<$name>::parse($parser)?);
+        let end = $parser.cursor;
+        
+        let kind = {
+            use $crate::parser::ast::ToExpressionKind;
+            kind.as_expr_kind()
         };
+
+        let $expr = $crate::parser::expr::Expression::new(start, kind, end);
     };
 }
 

packages/engine/src/parser/expr/bin_op/and_op.rs

@@ -1,4 +1,4 @@
-use crate::{to_expr_kind, ast, parse, parse_bin_op, parseable, parser::{ast::ToExpressionKind, expr::{bin_op::BinOp, Expression, Or}}};
+use crate::{ast, parse_bin_op, parse_expr, parseable, parser::expr::{Expression, Or}, to_expr_kind};
 
 ast!(And(Expression, Expression));
 to_expr_kind!(And);
@@ -17,28 +17,30 @@ parse_bin_op! {
 
 parseable! {
     And = |parser| {
-        parse!(parser, lhs = Or);
-        parse!(parser, rhs = Or);
-        Ok(Some(And(lhs.as_expr_kind(), rhs.as_expr_kind())))
+        parse_expr!(parser, lhs = Or);
+        parse_expr!(parser, rhs = Or);
+        Ok(Some(And(lhs, rhs)))
     }
 }
 
-// let_expr!(mut lhs = self.expr_logic_and()?);
+    // fn expr_logic_and(&mut self) -> ParserResult<Option<WithCursor<ExpressionKind>>> {
+    //     let_expr!(mut lhs = self.expr_cmp_equality()?);
 
-// while let Some(token_or) = self.next_if_eq(&&LexerTokenKind::Or) {
-//     let_expr!(rhs = self.expr_logic_and()?);
+    //     while let Some(token_and) = self.next_if_eq(&&LexerTokenKind::And) {
+    //         let_expr!(rhs = self.expr_cmp_equality()?);
 
-//     let operator: LogicalOperator = LogicalOperator::Or;
+    //         let operator: LogicalOperator = LogicalOperator::And;
 
-//     lhs = WithCursor::create_with(
-//         lhs.start,
-//         rhs.end,
-//         ExpressionKind::Logic(Box::from((
-//             lhs,
-//             WithCursor::create_with(token_or.start, token_or.end, operator),
-//             rhs,
-//         ))),
-//     );
-// }
+    //         lhs = WithCursor::create_with(
+    //             lhs.start,
+    //             rhs.end,
+    //             ExpressionKind::Logic(Box::from((
+    //                 lhs,
+    //                 WithCursor::create_with(token_and.start, token_and.end, operator),
+    //                 rhs,
+    //             ))),
+    //         );
+    //     }
 
-// Ok(Some(lhs))
+    //     Ok(Some(lhs))
+    // }

packages/engine/src/parser/expr/arithmetic_expr.rs renamed to packages/engine/src/parser/expr/expr_arithmetic.rs

@@ -1,4 +1,4 @@
-use crate::{to_expr_kind, ast, parseable, parser::stmt::Statement};
+use crate::{ast, ok_or_none, parseable, parser::stmt::Statement, to_expr_kind};
 
 ast!(Block(Vec<Statement>)); 
 to_expr_kind!(Block);
@@ -15,7 +15,7 @@ parseable! {
                 break;
             }
 
-            let statement = parser.parse_statement(token)?;
+            let statement = ok_or_none!(parser.statement(token)?);
             statements.push(statement);
 
             parser.next();

packages/engine/src/parser/expr/assignment_expr.rs renamed to packages/engine/src/parser/expr/expr_assignment.rs

@@ -1,4 +1,4 @@
-use crate::{to_expr_kind, ast, parseable};
+use crate::{ast, ok_or_none, parseable, to_expr_kind};
 
 use super::{Expression, Identifier};
 
@@ -7,7 +7,7 @@ to_expr_kind!(FunctionCall);
 
 parseable! {
     FunctionCall = |parser| {
-        let expr = parser.expr_primary()?;
+        let expr = ok_or_none!(Identifier::);
 
         let ExpressionKind::Identifier(identifier) = &expr.value else {
             return Ok(None);

packages/engine/src/parser/expr/block_expr.rs renamed to packages/engine/src/parser/expr/expr_block.rs

@@ -1,4 +1,4 @@
-use crate::{to_expr_kind, ast, parseable};
+use crate::{ast, ok_or_none, parseable, to_expr_kind};
 
 use super::Expression;
 
@@ -7,12 +7,10 @@ to_expr_kind!(Group);
 
 parseable! {
     Group = |parser| {
-        let mut expr = parser.expression()?;
+        let expr = ok_or_none!(parser.expression()?);
 
         parser.expect_token(&LexerTokenKind::RParen)?;
 
-        expr.value = ExpressionKind::Group(expr.value);
-
-        Ok(expr)
+        Ok(Some(Group(expr)))
     }
 }