Intermediate representation

README.md

@@ -65,12 +65,6 @@ print(c)
 // This prints `99`
 printf(c)
 
-// Raw Brainfuck
-// This should only be used in the standard library, e.g. input(), not in user code
-// If this project succeeds it's ultimate goal, basm will be the only function from
-// the compiler except math, and all other functions will be written in alkoholiq
-basm("<>+-")
-
 // Iterators work like in Rust
 // For simplicity, if the iterator is a single number it is still ran
 for ch in input_array {

examples/basic.🍺

@@ -2,51 +2,4 @@
 
 x = 1
 y = 2
-
-fn + a b {
-    ret = 0
-    copy a ret
-    copy b ret
-    return ret
-}
-
-z = +( x y)
-goto(z)
-basm(".")
-
-
----
-
-
-set x
-> (alloc) + (add)
-
-set y
-> (alloc) ++ (add)
-
-
-function call
-allocate z
-> (alloc)
-new stack
->
-
-set a
-> (alloc) (copy)
-
-set b
-> (alloc) (copy)
-
-copy a
-copy b
-return ret
-(move ret to z)
-
-pop stack
-(zero b)
-(zero a)
-
-goto z
-< (goto z)
-print
-.
+z = + x y

src/ast.rs

@@ -38,7 +38,6 @@ pub enum Expression {
     //     /// Right side
     //     rhs: Box<Expression>,
     // },
-
     /// Variable assignment
     Assignment {
         /// Name of the variable
@@ -84,6 +83,12 @@ pub enum Expression {
         /// Body
         body: Box<Expression>,
     },
+
+    // Return
+    Return {
+        // Name of return value
+        name: String,
+    },
 }
 
 // Not used right now because maths are functions

src/codegen.rs

@@ -1,17 +1,13 @@
+use crate::ast::Expression;
 use std::collections::HashMap;
 use std::str::from_utf8;
-use crate::ast::Expression;
 
 // Codegen notes for myself:
 // - Make the codegen also do comments, they will get removed in the optimization step
 // - Functions: https://brainfuck.org/function_tutorial.b
-// - 
+// -
 
-
-/// Because we do not yet know the length of functions, we need to make a list of all the 
+/// Because we do not yet know the length of functions, we need to make a list of all the
 /// basic instructions and their purpose. This will be used to generate the code after initial
 /// analysis.
-enum AbstractInstruction {
-
-}
-
+enum AbstractInstruction {}

src/ir.rs

@@ -0,0 +1,129 @@
+use crate::ast::Expression;
+use std::collections::HashMap;
+
+
+/// Intermediate representation
+/// The main purpuse of this is to convert the nested expression into a linear flat instruction list
+/// that is more similar to the way brainfuck works
+///
+/// Resources:
+/// - https://andreabergia.com/series/stack-based-virtual-machines/
+#[derive(Clone, Debug)]
+pub enum IR {
+    /// Push a single byte on the stack
+    Push(u8),
+    /// Pop a value from the stack (zero it out)
+    Pop,
+
+    /// Add the two top most values
+    ADD,
+    /// Subtract the two topmost values
+    SUB,
+    /// Multiply the two topmost values
+    MUL,
+    /// Check for equality of the two topmost values
+    EQ,
+
+    /// Duplicate the topmost value
+    DUP,
+
+    /// Push topmost byte to variable storage
+    STORE(String),
+    /// Retrieve a named value
+    /// This removes the variable from the storage
+    LOAD(String),
+    /// Start if block
+    START_IF,
+    /// End if block
+    CLOSE_IF,
+
+    // TODO Else blocks
+    // TODO Functions and frames
+}
+
+#[derive(Clone, Debug)]
+pub struct IRGenerator {
+    ir: Vec<IR>,
+    variables: HashMap<String, usize>
+}
+
+impl IRGenerator {
+    pub fn new() -> IRGenerator {
+        Self {
+            ir: vec![],
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn generate(&mut self, ast: Vec<Expression>) -> Vec<IR> {
+        for expr in ast {
+            self.generate_expression(expr);
+        }
+
+        self.ir.clone()
+    }
+
+    fn load(&mut self, expr: Expression) {
+        match expr {
+            Expression::Number(n) => {
+                self.ir.push(IR::Push(n));
+            }
+
+            Expression::Path(path) => {
+                // Duplicate the value
+                self.ir.push(IR::LOAD(path.clone()));
+                self.ir.push(IR::DUP);
+                self.ir.push(IR::STORE(path));
+            }
+
+            _ => {
+                todo!("Not implemented: {:?}", expr);
+            }
+        }
+    }
+
+    fn generate_expression(&mut self, expression: Expression) {
+        match expression {
+            Expression::Number(n) => {
+                self.ir.push(IR::Push(n));
+            }
+
+            Expression::Closure {body} => {
+                for expr in body {
+                    self.generate_expression(expr);
+                }
+            }
+
+            Expression::Assignment {name, value} => {
+                self.generate_expression(*value);
+
+                self.variables.insert(name.clone(), 0);
+                self.ir.push(IR::STORE(name));
+            }
+
+            Expression::Call {name, args} => {
+                // Load all arguments
+                for arg in args {
+                    self.load(arg);
+                }
+
+                if name == "+" {
+                    self.ir.push(IR::ADD);
+                } else if name == "-" {
+                    self.ir.push(IR::SUB);
+                } else if name == "*" {
+                    self.ir.push(IR::MUL);
+                } else if name == "==" {
+                    self.ir.push(IR::EQ);
+                } else {
+                    todo!("Not implemented: {:?}", name);
+                }
+            }
+
+            _ => {
+                dbg!("Not implemented:", expression);
+            }
+        }
+    }
+}
+

src/lexer.rs

@@ -20,11 +20,7 @@ pub fn tokenize_indexed(input: &str) -> Vec<IndexedToken> {
                     line_number,
                 },
                 Err(_) => {
-                    eprintln!(
-                        "Failed lexing `{}` on line {}:",
-                        &input[span],
-                        line_number
-                    );
+                    eprintln!("Failed lexing `{}` on line {}:", &input[span], line_number);
                     eprintln!("{}{}", line_text_before, line_text_after);
                     eprintln!("{}^", " ".repeat(line_text_before.len() - 1));
                     std::process::exit(1)

src/main.rs

@@ -1,11 +1,12 @@
 use std::io::Read;
 
 mod ast;
+mod codegen;
+mod ir;
 mod lexer;
 mod parser;
 mod tokens;
 mod utils;
-mod codegen;
 
 fn main() {
     let input = std::env::args().nth(1).map_or_else(
@@ -34,6 +35,6 @@ fn main() {
     #[cfg(debug_assertions)]
     dbg!(&ast);
 
-    let code = codegen::Codegen::new().generate(ast);
-    println!("{}", code);
+    let ir = ir::IRGenerator::new().generate(ast);
+    dbg!(ir);
 }

src/parser.rs

@@ -11,10 +11,7 @@ pub struct Parser {
 
 impl Parser {
     pub fn new(tokens: Vec<IndexedToken>, _input: String) -> Self {
-        Parser {
-            tokens,
-            current: 0,
-        }
+        Parser { tokens, current: 0 }
     }
 
     fn next(&mut self) -> Option<&IndexedToken> {
@@ -35,13 +32,11 @@ impl Parser {
     }
 
     fn peek(&self) -> Option<Token> {
-        self.tokens
-            .get(self.current).map(|x| x.clone().token)
+        self.tokens.get(self.current).map(|x| x.clone().token)
     }
 
     fn ipeek(&self) -> Option<IndexedToken> {
-        self.tokens
-            .get(self.current).cloned()
+        self.tokens.get(self.current).cloned()
     }
 
     fn check(&self, token: Token) -> bool {
@@ -57,18 +52,22 @@ impl Parser {
 
         while !self.is_at_end() {
             if let Some(expr) = self.parse_expression() {
-                // Check if the new expression is valid
-                if !self.valid(&expressions, &expr) {
-                    let last_parsed_token = self.tokens[self.current - 1].clone();
-                    eprintln!("Unexpected expression {:?} on line {}:", expr, last_parsed_token.line_number);
-                    eprintln!("{}", last_parsed_token.line);
-                    eprintln!(
-                        "{}{}",
-                        " ".repeat(last_parsed_token.chars_before - last_parsed_token.range.len()),
-                        "^".repeat(last_parsed_token.range.len())
-                    );
-                    panic!();
-                }
+                // Will be done in the IR generation
+                // // Check if the new expression is valid
+                // if !self.valid(&expressions, &expr) {
+                //     let last_parsed_token = self.tokens[self.current - 1].clone();
+                //     eprintln!(
+                //         "Unexpected expression {:?} on line {}:",
+                //         expr, last_parsed_token.line_number
+                //     );
+                //     eprintln!("{}", last_parsed_token.line);
+                //     eprintln!(
+                //         "{}{}",
+                //         " ".repeat(last_parsed_token.chars_before - last_parsed_token.range.len()),
+                //         "^".repeat(last_parsed_token.range.len())
+                //     );
+                //     panic!();
+                // }
 
                 expressions.push(expr);
             } else {
@@ -258,7 +257,27 @@ impl Parser {
                     args,
                     body: Box::new(body),
                 })
-            },
+            }
+
+            // Return
+            Token::Return => {
+                self.advance();
+                let name = self.next()?.token.inner_string()?;
+
+                Some(Expression::Return { name })
+            }
+
+            // Math operations
+            Token::Add => {
+                // + a b
+                self.advance();
+                let a = self.parse_expression()?;
+                let b = self.parse_expression()?;
+                Some(Expression::Call {
+                    name: "+".to_string(),
+                    args: vec![a, b],
+                })
+            }
 
             _ => None,
         }
@@ -268,26 +287,10 @@ impl Parser {
         Some(match lit {
             Token::Integer(num) => Expression::Number(num),
             Token::Char(num) => Expression::Number(num),
-            Token::String(s) => {
-                Expression::Array(s.bytes().map(Expression::Number).collect())
-            }
+            Token::String(s) => Expression::Array(s.bytes().map(Expression::Number).collect()),
             Token::True => Expression::Number(1),
             Token::False => Expression::Number(0),
             _ => return None,
         })
     }
-
-    fn valid(&self, expressions: &Vec<Expression>, new: &Expression) -> bool {
-        match new {
-            Expression::Path(_) => {
-                // Check if the previous expression was also a path
-                if let Some(Expression::Path(_)) = expressions.last() {
-                    return false;
-                }
-
-                true
-            },
-            _ => true,
-        }
-    }
 }