doc/grammar.bnf

@@ -1,21 +1,8 @@
 MODULE ::= INSTR*
-INSTR ::=
-| EXPR semicolon
-| ASSIGN semicolon
-| ASSIGN_IF semicolon
-| ASSIGN_ADD semicolon
-ASSIGN ::= ident assign EXPR
-ASSIGN_IF ::= ident assign_if EXPR
-ASSIGN_ADD ::= ident assign_add EXPR
-EXPR ::= LITERAL
-LITERAL ::= 
-| BUILTIN 
-| ARRAY 
-| ident
+INSTR ::= EXPR semicolon
+EXPR ::= BUILTIN
 BUILTIN ::= 
 | bool 
 | float 
 | int
 | string
-
-ARRAY ::= osquare EXPR* csquare

src/ast/lexer.rs

@@ -19,8 +19,7 @@ impl Lexer {
             line: 1,
             text: String::from(""),
             separators: vec![
-                ';', '[', ']',
-                '=', '?', '+'
+                ';'
             ]
         }
     }
@@ -39,71 +38,21 @@ impl Lexer {
         self.line = 1;
     }
 
-    pub fn peek(&mut self, lookahead: i32) -> Option<Node> {
-        let cursor = self.cursor;
-        let line = self.line;
-
-        let mut node: Option<Node> = None;
-
-        for _ in 0..=lookahead {
-            node = self.next();
-        }
-        
-        self.cursor = cursor;
-        self.line = line;
-        node
-    }
-
-    fn is_char_sep(&self, c: char) -> bool {
-        let el = self.separators.iter().find(|&&x| x == c);
-
-        if el.is_some() {
-            return true;
-        }
-
-        return c.is_whitespace();
-    }
-
     fn is_sep(&self, pos: usize) -> bool {
         if let Some(c) = self.text.chars().nth(pos) {
-            return self.is_char_sep(c);
+
+            let el = self.separators.iter().find(|&&x| x == c);
+
+            if el.is_some() {
+                return true;
+            }
+
+            return c.is_whitespace();
         }
 
         false
     }
 
-    fn scan_identifier(&mut self) -> Option<Token> {
-        let mut value = String::from("");
-        let mut first = true;
-
-        for c in self.text.chars().skip(self.cursor) {
-            if self.is_char_sep(c) {
-                break;
-            }
-
-            if first && c.is_digit(10) {
-                break;
-            }
-
-            if !c.is_ascii_alphabetic() && c != '_' 
-            && !c.is_digit(10) {
-                break;
-            }
-
-            value.push(c);
-            first = false;
-        }
-
-        if value.len() > 0 {
-            return Some(Token {
-                position: self.cursor + value.len(),
-                value
-            });
-        }
-
-        None
-    }
-
     fn scan_string(&mut self) -> Option<Token> {
         let mut value : String;
         let mut length = 1;
@@ -282,21 +231,6 @@ impl Lexer {
             self.cursor += 1;
         }
     }
-
-    fn skip_comments(&mut self) {
-        while let Some('#') = self.text.chars().nth(self.cursor) {
-            loop {
-                if let Some('\n')
-                = self.text.chars().nth(self.cursor) {
-                    break;
-                }
-
-                self.cursor += 1;
-            }
-
-            self.skip_spaces();
-        }
-    }
 }
 
 impl Iterator for Lexer {
@@ -304,32 +238,6 @@ impl Iterator for Lexer {
 
     fn next(&mut self) -> Option<Self::Item> {
         self.skip_spaces();
-        self.skip_comments();
-
-        if let Some(token) = self.scan_text("+=") {
-            self.cursor = token.position;
-            return Some(Node::AssignAdd);
-        }
-
-        if let Some(token) = self.scan_text("?=") {
-            self.cursor = token.position;
-            return Some(Node::AssignIf);
-        }
-
-        if let Some(token) = self.scan_text("=") {
-            self.cursor = token.position;
-            return Some(Node::Assign);
-        }
-
-        if let Some(token) = self.scan_text("[") {
-            self.cursor = token.position;
-            return Some(Node::OSquare);
-        }
-
-        if let Some(token) = self.scan_text("]") {
-            self.cursor = token.position;
-            return Some(Node::CSquare);
-        }
 
         if let Some(token) = self.scan_keyword("true") {
             self.cursor = token.position;
@@ -365,11 +273,6 @@ impl Iterator for Lexer {
             }
         }
 
-        if let Some(token) = self.scan_identifier() {
-            self.cursor = token.position;
-            return Some(Node::Ident(token.value.clone()));
-        }
-
         None
     }
 }
@@ -421,12 +324,13 @@ mod test {
     }
 
     #[test]
-    fn test_identifier() {
+    fn test_wrong_ident() {
         let mut lex = Lexer::new();
-        let res = lexer_run(&mut lex, " truea atrue ").unwrap();
-        assert_eq!(2, res.len());
-        assert_eq!(Node::Ident(String::from("truea")), *res.get(0).unwrap());
-        assert_eq!(Node::Ident(String::from("atrue")), *res.get(1).unwrap());
+        let res = lexer_run(&mut lex, " truea ");
+        assert!(res.is_err());
+        let mut lex = Lexer::new();
+        let res = lexer_run(&mut lex, " atrue ");
+        assert!(res.is_err());
     }
 
     #[test]
@@ -484,48 +388,4 @@ mod test {
         
         Ok(())
     }
-
-    #[test]
-    fn test_comments() -> Result<(), error::AstError> {
-        let mut lex = Lexer::new();
-
-        let res = lexer_run(&mut lex,
-            " # aze \n 4 ")?;
-
-        assert_eq!(1, res.len());
-        assert_eq!(Node::Int(4),
-            *res.get(0).unwrap());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_arrays() -> Result<(), error::AstError> {
-        let mut lex = Lexer::new();
-
-        let res = lexer_run(&mut lex,
-            " [ ] ")?;
-
-        assert_eq!(2, res.len());
-        assert_eq!(Node::OSquare, *res.get(0).unwrap());
-        assert_eq!(Node::CSquare, *res.get(1).unwrap());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_variables() -> Result<(), error::AstError> {
-        let mut lex = Lexer::new();
-
-        let res = lexer_run(&mut lex,
-            " = ?= += ananas ")?;
-
-        assert_eq!(4, res.len());
-        assert_eq!(Node::Assign, *res.get(0).unwrap());
-        assert_eq!(Node::AssignIf, *res.get(1).unwrap());
-        assert_eq!(Node::AssignAdd, *res.get(2).unwrap());
-        assert_eq!(Node::Ident(String::from("ananas")), *res.get(3).unwrap());
-
-        Ok(())
-    }
 }

src/ast/node.rs

@@ -6,16 +6,6 @@ pub enum Node {
     Int(i32),
     Float(f64),
     String(String),
-    OSquare,
-    CSquare,
-    Array(Vec<Node>),
-    Assign,
-    AssignIf,
-    AssignAdd,
-    AssignInstr(Box<Node>, Vec<Node>),
-    AssignIfInstr(Box<Node>, Vec<Node>),
-    AssignAddInstr(Box<Node>, Vec<Node>),
-    Ident(String),
     Semicolon
 }
 

src/ast/parser.rs

@@ -45,143 +45,51 @@ impl Parser {
         Ok(Some(n))
     }
 
-    fn ensure_semicolon(&mut self, result: ParseResult)
-        -> ParseResult {
-        match self.lexer.next() {
-            Some(Node::Semicolon) => result,
-            _ => Err(error::AstError {
-                msg: String::from("missing semicolon"),
-                line: self.lexer.line()})
-        }
-    }
-
     fn parse_instr(&mut self) -> ParseResult {
-        match self.lexer.peek(1) {
-            Some(Node::Assign) => {
-                    let assign = self.parse_assign();
-                    self.ensure_semicolon(assign)
-            },
-
-            Some(Node::AssignIf) => {
-                    let assign = self.parse_assign_if();
-                    self.ensure_semicolon(assign)
-            },
-
-            Some(Node::AssignAdd) => {
-                    let assign = self.parse_assign_add();
-                    self.ensure_semicolon(assign)
-            },
-
-            _ =>
-                match self.parse_expr() {
-                    Ok(Some(expr)) =>
-                        self.ensure_semicolon(Ok(Some(expr))),
-                    Err(err) => { Err(err) },
-                    Ok(None) => Ok(None)
+        match self.parse_expr() {
+            Ok(Some(expr)) => {
+                match self.lexer.next() {
+                    Some(Node::Semicolon) => Ok(Some(expr)),
+                    None => Ok(None),
+                    _ => Err(error::AstError {
+                        msg: String::from("missing semicolon"),
+                        line: self.lexer.line()})
                 }
-        }
-    }
-
-    fn assign_helper(&mut self)
-            -> Result<(Box<Node>, Vec<Node>), error::AstError> {
-        let mut rhs: Vec<Node> = vec![];
-
-        if let Some(Node::Ident(value)) = self.lexer.next() {
-            let _assign = self.lexer.next();
-
-            loop {
-                match self.lexer.peek(0) {
-                    Some(Node::Semicolon) | None => {
-                        break;
-                    },
-
-                    Some(v) => { self.lexer.next(); rhs.push(v); }
-                }
-            }
-
-            Ok((Box::new(Node::Ident(value)), rhs))
-
-        } else {
-            Err(error::AstError {
-                msg: String::from("cannot assign value to node"),
-                line: self.lexer.line()
-            })
-        }
-    }
-
-    fn parse_assign(&mut self) -> ParseResult {
-        match self.assign_helper() {
-            Ok((lhs, rhs)) 
-                => Ok(Some(Node::AssignInstr(lhs, rhs))),
-            Err(err) => Err(err)
-        }
-    }
-
-    fn parse_assign_if(&mut self) -> ParseResult {
-        match self.assign_helper() {
-            Ok((lhs, rhs)) 
-                => Ok(Some(Node::AssignIfInstr(lhs, rhs))),
-            Err(err) => Err(err)
-        }
-    }
-
-    fn parse_assign_add(&mut self) -> ParseResult {
-        match self.assign_helper() {
-            Ok((lhs, rhs)) 
-                => Ok(Some(Node::AssignAddInstr(lhs, rhs))),
-            Err(err) => Err(err)
+            },
+            Err(err) => { Err(err) },
+            Ok(None) => Ok(None)
         }
     }
 
     fn parse_expr(&mut self) -> ParseResult {
-        self.parse_literal()
+        self.parse_builtin()
     }
 
-    fn parse_literal(&mut self) -> ParseResult {
-        match self.lexer.peek(0) {
-            Some(Node::Ident(id)) 
-                => { self.lexer.next(); Ok(Some(Node::Ident(id))) },
-            Some(Node::OSquare) => self.parse_array(),
-            Some(_) => self.parse_builtin(),
-            None => { self.lexer.next(); Ok(None) }
-        }
-    }
 
     fn parse_builtin(&mut self) -> ParseResult {
-        let node = self.lexer.next().unwrap();
-        match node {
-            Node::Int(value)
+        match self.lexer.next() {
+            Some(Node::Int(value))
                 => Ok(Some(Node::Int(value))),
 
-            Node::Float(value)
+            Some(Node::Float(value))
                 => Ok(Some(Node::Float(value))),
 
-            Node::Bool(value)
+            Some(Node::Bool(value))
                 => Ok(Some(Node::Bool(value))),
 
-            Node::String(value)
+            Some(Node::String(value))
                 => Ok(Some(Node::String(value))),
 
-            _ => {
+            Some(other) => {
                 Err(error::AstError {
-                    msg: String::from(format!("unexpected {:?}", node)),
+                    msg: String::from(format!("unexpected {:?}", other)),
                     line: self.lexer.line()
                 })
             }
+
+            None => Ok(None)
         }
     }
-
-    fn parse_array(&mut self) -> ParseResult {
-        let mut elements: Vec<Node> = vec![];
-
-        let _osquare = self.lexer.next();
-
-        while let Ok(Some(expr)) = self.parse_expr() {
-            elements.push(expr);
-        }
-
-        Ok(Some(Node::Array(elements)))
-    }
 }
 
 #[cfg(test)]
@@ -271,59 +179,4 @@ mod test {
 
         Ok(())
     }
-
-    #[test]
-    fn assign_variables() -> TestResult {
-        test_parser(
-            Node::Module("mod".to_owned(), vec![
-                Node::AssignInstr(
-                    Box::new(Node::Ident(String::from("HELLO"))),
-                    vec![Node::Int(4), Node::Bool(true)]
-                )
-            ]),
-            " HELLO = 4 true; "
-        )?;
-
-        test_parser(
-            Node::Module("mod".to_owned(), vec![
-                Node::AssignIfInstr(
-                    Box::new(Node::Ident(String::from("HELLO_2"))),
-                    vec![Node::Int(4)]
-                )
-            ]),
-            " HELLO_2 ?= 4; "
-        )?;
-
-        test_parser(
-            Node::Module("mod".to_owned(), vec![
-                Node::AssignAddInstr(
-                    Box::new(Node::Ident(
-                        String::from("HELLO_WORLD"))
-                    ),
-                    vec![
-                        Node::Int(4),
-                        Node::Int(1),
-                        Node::Int(2)
-                    ]
-                )
-            ]),
-            " HELLO_WORLD += 4 1 2; "
-        )?;
-        Ok(())
-    }
-    #[test]
-    fn arrays() -> TestResult {
-        test_parser(
-            Node::Module("mod".to_owned(), vec![
-                Node::Array(vec![
-                    Node::Int(2),
-                    Node::Float(3.2),
-                    Node::Bool(true)
-                ])
-            ]),
-            " [2 3.2 true]; "
-        )?;
-
-        Ok(())
-    }
 }

src/eval/evaluator.rs

@@ -2,13 +2,12 @@ use crate::{
     ast::node::Node,
     eval::{
         value::Value,
-        error::EvalError,
-        symtable::SymTable
+        error::EvalError
     }
 };
 
 pub struct Evaluator {
-    table: SymTable
+
 }
 
 type EvalResult = Result<Option<Value>, EvalError>;
@@ -16,7 +15,6 @@ type EvalResult = Result<Option<Value>, EvalError>;
 impl Evaluator {
     pub fn new() -> Self {
         Self {
-            table: SymTable::new()
         }
     }
 
@@ -32,157 +30,14 @@ impl Evaluator {
                 Ok(res)
             },
             
-            Node::Ident(name) => {
-                match self.table.get(name) {
-                    Some(val) => {
-                        Ok(Some(val))
-                    },
-
-                    None => Err(EvalError {
-                        msg: format!("cannot find <{}>", name),
-                        line: 0
-                    })
-                }
-            },
-
-            Node::AssignAddInstr(target, values) => {
-                match &**target {
-                    Node::Ident(name) => {
-                        let mut val_array: Vec<Value> = vec![];
-
-                        match self.table.get(name) {
-                            Some(Value::Array(existing_arr)) => {
-                                val_array = existing_arr;
-                            },
-                            Some(val) => {
-                                val_array.push(val);
-                            },
-                            None => {
-                            }
-                        }
-
-                        for node_val in values {
-                            let val = self.run(node_val)?;
-                            if let Some(v) = val {
-                                val_array.push(v);
-                            }
-                        }
-
-                        let value = Value::Array(val_array);
-                        self.table.set(name, value);
-                    },
-                    _ => {
-                        return Err(EvalError {
-                            msg: format!(
-                                "cannot assign to target <{:?}>",
-                                target
-                            ),
-                            line: 0
-                        });
-                    }
-                }
-
-                Ok(None)
-            },
-
-            Node::AssignIfInstr(target, values) => {
-                match &**target {
-                    Node::Ident(name) => {
-                        match self.table.get(name) {
-                            Some(_) => {},
-                            None => {
-                                if let Some(value)
-                                    = self.nodes_to_value(values)? {
-                                    self.table.set(name, value);
-                                }
-                            }
-                        }
-                    },
-                    _ => {
-                        return Err(EvalError {
-                            msg: format!(
-                                "cannot assign to target <{:?}>",
-                                target
-                            ),
-                            line: 0
-                        });
-                    }
-                }
-
-                Ok(None)
-            },
-
-            Node::AssignInstr(target, values) => {
-                match &**target {
-                    Node::Ident(name) => {
-                        if let Some(value) = self.nodes_to_value(values)? {
-                            self.table.set(name, value);
-                        }
-                    },
-                    _ => {
-                        return Err(EvalError {
-                            msg: format!(
-                                "cannot assign to target <{:?}>",
-                                target
-                            ),
-                            line: 0
-                        });
-                    }
-                }
-
-                Ok(None)
-            },
-
             Node::Bool(value) => Ok(Some(Value::Bool(*value))),
             Node::Int(value) => Ok(Some(Value::Int(*value))),
             Node::Float(value) => Ok(Some(Value::Float(*value))),
-            Node::String(value)
-                => Ok(Some(Value::String(value.clone()))),
-            Node::Array(nodes) => {
-                let mut values: Vec<Value> = vec![];
-
-                for node in nodes {
-                    match self.run(node) {
-                        Ok(Some(value)) => {
-                            values.push(value);
-                        },
-
-                        _ => {
-                            return Err(EvalError {
-                                msg: String::from("invalid array element"),
-                                line: 0
-                            });
-                        }
-                    }
-                }
-
-                Ok(Some(Value::Array(values)))
-            }
+            Node::String(value) => Ok(Some(Value::String(value.clone()))),
 
             _ => Ok(None)
         }
     }
-
-    fn nodes_to_value(&mut self, nodes: &Vec<Node>) -> EvalResult {
-        let mut val_array: Vec<Value> = vec![];
-
-        for node in nodes {
-            match self.run(node) {
-                Ok(Some(val)) => val_array.push(val),
-                Ok(None) => {},
-                Err(err) => { return Err(err); }
-            }
-        }
-
-        if val_array.len() == 0 {
-            Ok(None)
-        } else if val_array.len() == 1 {
-            let val = val_array.get(0).unwrap();
-            Ok(Some(val.clone()))
-        } else {
-            Ok(Some(Value::Array(val_array)))
-        }
-    }
 }
 
 #[cfg(test)]
@@ -225,24 +80,6 @@ mod test {
         }
     }
 
-    fn test_eval_fail(source: &str) -> TestResult {
-        let mut lex = Lexer::new();
-        lex.prepare(source);
-
-        let mut parser = Parser::new("mod", lex);
-        let root = parser.run()?.unwrap();
-
-        let mut evaluator = Evaluator::new();
-
-        match evaluator.run(&root) {
-            Err(_) => Ok(()),
-            _ => Err(Box::new(EvalError {
-                msg: format!("\"{}\" should fail", source),
-                line: 0
-            }))
-        }
-    }
-
     #[test]
     fn simple_boolean() -> TestResult {
         test_eval_value(Value::Bool(true), " true; false; true; ")?;
@@ -266,93 +103,4 @@ mod test {
 
         Ok(())
     }
-
-    #[test]
-    fn arrays() -> TestResult {
-        test_eval_value(
-            Value::Array(
-                vec![
-                    Value::Int(2),
-                    Value::Int(4),
-                    Value::Float(6.1)
-                ]
-            ),
-            " [2 4 6.1]; ")?;
-
-        Ok(())
-    }
-
-    #[test]
-    fn simple_variable() -> TestResult {
-        test_eval_fail("X = V;")?;
-
-        test_eval_value(
-            Value::Int(4),
-            " X = 4; X; ")?;
-
-        test_eval_value(
-            Value::Float(7.2),
-            " X = 4; X = 7.2; X; ")?;
-
-        test_eval_value(
-            Value::Array(
-                vec![
-                    Value::Int(4),
-                    Value::Int(9),
-                    Value::Float(5.2),
-                ]
-            ),
-            " X = 4 9 5.2; X; ")?;
-
-        Ok(())
-    }
-
-    #[test]
-    fn variable_assign_if() -> TestResult {
-        test_eval_fail(" X ?= V; ")?;
-
-        test_eval_value(
-            Value::Int(4),
-            " X ?= 4; X; ")?;
-
-        test_eval_value(
-            Value::Int(4),
-            " X ?= 4; X ?= 9; X; ")?;
-
-        Ok(())
-    }
-
-    #[test]
-    fn variable_assign_add() -> TestResult {
-        test_eval_fail("X += V; ")?;
-
-        test_eval_value(
-            Value::Array(
-                vec![
-                    Value::Int(4),
-                ]
-            ),
-            " X += 4; X; ")?;
-
-        test_eval_value(
-            Value::Array(
-                vec![
-                    Value::Int(4),
-                    Value::Float(3.3)
-                ]
-            ),
-            " X = 4; X += 3.3; X; ")?;
-
-        test_eval_value(
-            Value::Array(
-                vec![
-                    Value::Int(4),
-                    Value::Int(1),
-                    Value::Float(3.3)
-                ]
-            ),
-            " X = 4 1; X += 3.3; X; ")?;
-
-        Ok(())
-    }
 }

src/eval/mod.rs

@@ -1,4 +1,3 @@
 pub mod value;
 pub mod evaluator;
 pub mod error;
-pub mod symtable;

src/eval/symtable.rs

@@ -1,42 +0,0 @@
-use crate::eval::value::Value;
-use std::collections::HashMap;
-
-struct Sym {
-    value: Value
-}
-
-pub struct SymTable {
-    table: HashMap<String, Sym>
-}
-
-impl SymTable {
-    pub fn new() -> Self {
-        Self {
-            table: HashMap::new()
-        }
-    }
-
-    pub fn set(&mut self, name: &str, value: Value) {
-        self.table.insert(name.to_owned(), Sym { value });
-    }
-
-    pub fn get(&mut self, name: &str) -> Option<Value> {
-        match self.table.get(name) {
-            Some(sym) => Some(sym.value.clone()),
-            None => None
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn declare_new_value() {
-        let mut sym = SymTable::new();
-        assert!(sym.get("hello").is_none());
-        sym.set("hello", Value::Int(34));
-        assert_eq!(Value::Int(34), sym.get("hello").unwrap());
-    }
-}

src/eval/value.rs

@@ -1,11 +1,9 @@
 #[derive(PartialEq)]
 #[derive(Debug)]
-#[derive(Clone)]
 pub enum Value {
     Bool(bool),
     Int(i32),
     Float(f64),
-    String(String),
-    Array(Vec<Value>)
+    String(String)
 }