Made the backend work for math, working on the frontend

TAGS~

@@ -1,159 +0,0 @@
-
-Cargo.lock,0
-
-Cargo.toml,0
-
-README.md,130
-# ![SkyLang](.images/slang_logo_dark_transparent_not_motto.png)![SkyLang](.images/slang_logo_dark_transparent_not_motto.png)
1,0
-
-src/codegen/fasm.rs,91
-pub fn fasm_codegen(exprs: &Vec<Expr>, not_a_function: bool) -> String {fasm_codegen
3,27
-
-src/codegen/fasmarm.rs,0
-
-src/codegen/mod.rs,23
-pub mod fasm;fasm
1,0
-
-src/lex/mod.rs,47
-pub mod tok;tok
1,0
-pub mod parse;parse
2,13
-
-src/lex/parse.rs,755
-pub fn match_single_char<'a>(word: &'a str) -> Option<Token<'a>> {match_single_char
6,40
-    macro_rules! tok {tok
7,107
-pub fn match_keyword<'a>(word: &'a str) -> Option<Token<'a>> {match_keyword
38,697
-    macro_rules! tok {tok
39,760
-pub fn match_two_char<'a>(word: &'a str) -> Option<Token<'a>> {match_two_char
66,1310
-    macro_rules! tok {tok
67,1374
-pub fn match_string_literal<'a>(word: &'a str) -> Option<Token<'a>> {match_string_literal
85,1681
-    macro_rules! tok {tok
86,1751
-pub fn match_int_literal<'a>(word: &'a str) -> Option<Token<'a>> {match_int_literal
114,2191
-    macro_rules! tok {tok
115,2258
-pub fn match_identifier<'a>(word: &'a str) -> Option<Token<'a>> {match_identifier
134,2562
-    macro_rules! tok {tok
135,2628
-
-src/lex/tok.rs,2268
-pub struct Token<'a> {Token
6,79
-    tt: TokenType,tt
7,102
-    word: &'a str,word
8,121
-pub enum TokenType {TokenType
12,160
-    EOF,EOF
13,181
-    Semicolon,	// ;Semicolon
16,222
-    Equal,	// =Equal
17,242
-    LeftParen,	// (LeftParen
18,258
-    RightParen, // )RightParen
19,278
-    LeftBrace,	// {LeftBrace
20,299
-    RightBrace, // }RightBrace
21,319
-    Comma,	// ,Comma
22,340
-    Dot,	// .Dot
23,356
-    Minus,	// -Minus
24,370
-    Plus,	// +Plus
25,386
-    Slash,	// /Slash
26,401
-    Star,	// *Star
27,417
-    Percent,	// %Percent
28,432
-    Bang,	// !Bang
29,450
-    Colon,	// :Colon
30,465
-    Less,	// <Less
31,481
-    Greater,	// >Greater
32,496
-    Fn,		// fnFn
35,531
-    Let,	// letLet
36,546
-    If,		// ifIf
37,562
-    Else,	// elseElse
38,577
-    While,	// whileWhile
39,595
-    Elif,	// elifElif
40,615
-    Return,	// returnReturn
41,633
-    For,	// forFor
42,655
-    In,		// inIn
43,671
-    Break,	// breakBreak
44,686
-    Continue,	// continueContinue
45,706
-    EqualEqual,		// ==EqualEqual
48,761
-    BangEqual,		// !=BangEqual
49,784
-    LessEqual,		// <=LessEqual
50,806
-    GreaterEqual,	// >=GreaterEqual
51,828
-    String,	// A string literal.String
54,873
-    Number,	// An integer.Number
55,906
-    Identifier, // An identifier.Identifier
56,933
-    True,	// trueTrue
57,967
-    False,	// falseFalse
58,985
-    Null,	// NoneNull
59,1005
-    Error, // A syntax error.Error
62,1037
-pub struct Lexer<'a> {Lexer
66,1087
-    source: &'a str,source
67,1110
-    tokens: Vec<Token<'a>>,tokens
68,1131
-    current: usize,current
69,1159
-    after: &'a strafter
70,1179
-impl<'a> Lexer<'a> {Lexer
73,1201
-    pub fn new() -> Self {new
74,1222
-impl<'a> std::iter::Iterator for Lexer<'a> {Lexer
84,1386
-    type Item = Option<char>;Item
85,1431
-    fn next(&mut self) -> Option<Self::Item> {next
87,1462
-impl<'a> From<&'a str> for Lexer<'a> {Lexer
92,1579
-    fn from(value: &'a str) -> Self {from
93,1618
-impl<'a> From<&'a std::string::String> for Lexer<'a> {Lexer
103,1800
-    fn from(value: &'a std::string::String) -> Self {from
104,1855
-impl<'a> Token<'a> {Token
114,2057
-    pub fn new(tt: TokenType, word: &'a str) -> Self {new
115,2078
-    pub fn empty() -> Self {empty
122,2171
-
-src/main.rs,102
-pub mod lex;lex
3,21
-pub mod codegen;codegen
4,34
-pub mod parse;parse
7,106
-fn main() {main
9,122
-
-src/parse/ast.rs,2125
-pub enum Expr<'a> {Expr
2,17
-    MathExpr(Math<'a>),MathExpr
3,37
-    FunCall(FunCall<'a>),FunCall
4,61
-    FunDefinition(FunDefinition<'a>),FunDefinition
5,87
-    VarDefinition(VarDefinition<'a>),VarDefinition
6,125
-    Return(Value<'a>),Return
7,163
-    If(IfStatement<'a>),If
8,186
-    BreakpointBreakpoint
9,211
-pub struct Math<'a> {Math
15,279
-    pub left: &'a Value<'a>,left
16,301
-    pub right: &'a Value<'a>,right
17,330
-    pub operator: MathOperatoroperator
18,360
-pub enum MathOperator {MathOperator
22,424
-    OP_ADD,	// AdditionOP_ADD
23,448
-    OP_SUB,	// SubtractionOP_SUB
24,472
-    OP_DIV,	// DivisionOP_DIV
25,499
-    OP_MULT,	// MultiplicationOP_MULT
26,523
-    OP_MOD,	// ModuloOP_MOD
27,554
-pub struct FunCall<'a> {FunCall
33,610
-    pub name: &'a str,name
34,635
-    pub params: Vec<Value<'a>>,params
35,658
-pub struct FunDefinition<'a> {FunDefinition
39,710
-    pub name: &'a str,name
40,741
-    pub contents: Vec<Expr<'a>>,contents
41,764
-pub struct FunParamDef<'a> {FunParamDef
45,817
-    name: &'a str,name
46,846
-    number: u64,number
47,865
-pub struct FunParamCall<'a> {FunParamCall
51,902
-    pub value: Value<'a>,value
52,932
-pub struct VarDefinition<'a> {VarDefinition
58,992
-    pub name: &'a str,name
59,1023
-    pub value: Value<'a>,value
60,1046
-pub struct VarReference<'a> {VarReference
65,1106
-    pub name: &'a str,name
66,1136
-pub struct ParamReference {ParamReference
70,1192
-    pub param_number: u64,param_number
71,1220
-pub enum Value<'a> {Value
75,1280
-    Var(VarReference<'a>),Var
76,1301
-    Param(ParamReference),Param
77,1328
-    Number(u64),Number
78,1355
-pub struct IfStatement<'a> {IfStatement
82,1392
-    pub condition: Condition<'a>,condition
83,1421
-    pub if_true: Vec<Expr<'a>>,if_true
84,1455
-pub struct Condition<'a> {Condition
88,1507
-    pub left: Value<'a>,left
89,1534
-    pub right: Value<'a>,right
90,1559
-    pub between: COND_OP,between
91,1585
-pub enum COND_OP {COND_OP
95,1631
-    EQ,EQ
96,1650
-    NE,NE
97,1658
-impl<'a> Value<'a> {Value
100,1669
-    pub fn unwrap(&self) -> String {unwrap
101,1690
-
-src/parse/mod.rs,21
-pub mod ast;ast
1,0

src/codegen/fasm.rs

@@ -2,35 +2,14 @@ use crate::parse::ast::*;
 use skylang::temp;
 use std::rc::Rc;
 
-const REGISTERS: [&str; 9] = ["r10", "r11", "r12", "r13", "r14", "rsp", "rbp", "rdp", "rdi"];
 #[derive(Debug)]
-pub struct FasmCodegen {
-    register_counter: usize,
-    operation_queue: Vec<OperationQueue>,
-    use_queue: bool,
-}
-
-#[derive(Debug)]
-enum OperationQueue {
-    RegisterCounter(usize),
-    Instruction(String),
-}
-
-impl Default for FasmCodegen {
-    fn default() -> Self {
-        Self::new()
-    }
-}
+pub struct FasmCodegen;
 
 impl FasmCodegen {
     pub fn new() -> Self {
-	FasmCodegen {
-	    register_counter: 0,
-	    operation_queue: Vec::new(),
-	    use_queue: false
-	}
+	FasmCodegen
     }
-
+    
     pub fn fasm_codegen(&mut self, exprs: &Vec<Expr>, not_a_function: bool) -> String {
 	macro_rules! fasm_codegen {
 	    // Macro to make calling fasm_codegen function easier.
@@ -71,46 +50,27 @@ impl FasmCodegen {
 	    match expr {
 		// If the expression is a math expression.
 		Expr::MathExpr(e) => {
-		    if let Expr::MathExpr(_m) = e.right.as_ref() {
-			self.register_counter += 1;
-
-			self.operation_queue.push(OperationQueue::RegisterCounter(self.register_counter));
-			self.use_queue = true;
-		    } else {
-			self.use_queue = false;
-		    }
-		    let mut register_counter = &self.register_counter;
-		    if self.use_queue {
-			println!("self.use_queue");
-			if let Some(OperationQueue::RegisterCounter(q)) = self.operation_queue.pop() {
-			    register_counter = &q;
-			}
-		    }
-		    
-
-		    dbg!(*register_counter, self.register_counter, self.use_queue);
-		    unwrap!(e.left);
-		    self.register_counter += 1;
-		    dbg!(*register_counter, self.register_counter, self.use_queue);
-		    asm_start.push_str(format!("\tmov {}, rax\n", REGISTERS[*register_counter]).as_str());
 		    unwrap!(e.right);
-		    self.register_counter += 1;
-		    dbg!(*register_counter, self.register_counter, self.use_queue);
-		    asm_start.push_str(format!("\tmov {}, rax\n", REGISTERS[*register_counter]).as_str());
-		    self.register_counter += 1;
+		    asm_start.push_str("\tpush rax\n");
+		    unwrap!(e.left);
+		    asm_start.push_str("\tpush rax\n");
 		    match e.operator {
 			// If the operator is addition.
 			MathOperator::OP_ADD  => {
-			    asm_start.push_str(format!("\tadd {}, {}\n", REGISTERS[*register_counter - 1], REGISTERS[*register_counter]).as_str());
-			    asm_start.push_str(format!("\tmov rax, {}\n", REGISTERS[*register_counter - 1]).as_str());
+			    asm_start.push_str("\tpop r10\n");
+			    asm_start.push_str("\tpop r11\n");
+			    asm_start.push_str("\tadd r10, r11\n");
+			    asm_start.push_str("\tmov rax, r10\n");
 
 			    // r10 ← r10 + r11; rax ← r10;
 			    // The sum will now be stored in the %rax register.
 			},
 			// If the operator is multiplication.
 			MathOperator::OP_MULT => {
-			    asm_start.push_str(format!("\timul {}, {}\n", REGISTERS[*register_counter - 1], REGISTERS[*register_counter]).as_str());
-			    asm_start.push_str(format!("\tmov rax, {}\n", REGISTERS[*register_counter - 1]).as_str());
+			    asm_start.push_str("\tpop r10\n");
+			    asm_start.push_str("\tpop r11\n");
+			    asm_start.push_str("\timul r10, r11\n");
+			    asm_start.push_str("\tmov rax, r10\n");
 
 			    // r10 ← r10 * r11; rax ← r10;
 			    // The product will now be stored in the %rax register.

src/lex/tok.rs

@@ -5,7 +5,7 @@ use core::iter::Peekable;
 
 pub use Token::*;
 
-#[derive(Debug, Logos, PartialEq, Eq)]
+#[derive(Debug, Logos, PartialEq, Eq, Clone)]
 #[logos(skip r"[ \t\n\f]+")]
 pub enum Token {
     // SINGLE CHARACTER TOKENS

src/main.rs

@@ -52,7 +52,7 @@ fn main() {
     // println!("{}", fc);
     let parsed = "3*10+5";
 
-    let lexer = Token::lexer(parsed);
+    let mut lexer = Token::lexer(parsed);
     
     println!("\"{}\"", parsed);
     arrow!("    ");

src/parse/parse.rs

@@ -11,17 +11,16 @@ macro_rules! unwrap {
 }
 
 pub fn parse_math(mut tokens: Lexer<Token>) -> Option<Expr> {
-    // Is it a Value? → Is it an operator? → Is it a value?
-
-    if let Some(Ok(Number(left))) = tokens.next() {
-	if let Some(op) = match_operator(&mut tokens) {
-	    if let Some(right) = parse_math(tokens) {
-		return Some(Expr::MathExpr(Math {left: Rc::new(Expr::Number(left)), right: Rc::new(right), operator: op}));
+    if let Some(left) = parse_math(tokens) {
+	if let Some(op) = match_operator(tokens) {
+	    if let Some(Ok(Number(right))) = tokens.next() {
+		return Some(Expr::MathExpr(Math {left: Rc::new(left), right: Rc::new(Expr::Number(right)), operator: op}));
 	    }
 	} else {
-	    return Some(Expr::Number(left));
+	    
 	}
     }
+
     None
 }
 
@@ -41,7 +40,7 @@ pub fn parse_global_declaration(mut tokens: Lexer<Token>) -> Option<Expr> {
     tok
 }
 
-pub fn match_operator(tokens: &mut Lexer<Token>) -> Option<MathOperator> {
+pub fn match_operator(mut tokens: Lexer<Token>) -> Option<MathOperator> {
     if let Some(Ok(token)) = tokens.next() {
 	return match token {
 	    Plus    => Some(MathOperator::OP_ADD),