Feat: Implemented compiler

Haato3o · Haato3o · commit cb5f3df21e28 · 2021-10-23T14:55:33.000-03:00
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -0,0 +1,64 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in library 'lucy'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--lib",
+                    "--package=lucy"
+                ],
+                "filter": {
+                    "name": "lucy",
+                    "kind": "lib"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'lucy-cli'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=lucy-cli",
+                    "--package=lucy-cli"
+                ],
+                "filter": {
+                    "name": "lucy-cli",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'lucy-cli'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=lucy-cli",
+                    "--package=lucy-cli"
+                ],
+                "filter": {
+                    "name": "lucy-cli",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}
diff --git a/lucy-cli/src/main.rs b/lucy-cli/src/main.rs
@@ -1,27 +1,32 @@
+use lucy::logger::log::{Log, Logger};
 use lucy::parser::pretokenizer::PreTokenizer;
-use lucy::parser::tokenizer::{Tokenizer};
+use lucy::parser::tokenizer::Tokenizer;
+use lucy::compiler::compiler::LucyCompiler;
 
 fn main() {
     let input = 
     "
-        mov eax, 10
-        mov ebx, 20
-        mov edx, 0b0010101
-        mov ecx, 0x10 ;should be 16
-        add eax, ebx
-        inc ebx
-        add eax, ebx
-        dmp eax
-        dmp 'c'
-        ret
-        mov ebx, \"Hello World\" ; This is a comment!
+        jmp main
+        dmp \"Hello world!\"
+        :main
+        mov edi, 0
+        :loop
+        
     ";
 
     let mut pretokenizer = PreTokenizer::new(String::from(input));
     let _ = pretokenizer.parse();
     let mut tokenizer = Tokenizer::new(pretokenizer);
+    let tokens = tokenizer.tokenize();
 
-    for string in tokenizer.tokenize() {
-        println!("{}", string);
+    // for tkn in tokens {
+    //     Log::info(format!("{}", tkn));
+    // }
+
+    let compiled = LucyCompiler::compile(tokens);
+
+    for c in compiled {
+        Log::info(format!("{:?} {:?}", c.instruction, c.arguments[0].typ));
     }
+
 }
diff --git a/lucy/src/compiler.rs b/lucy/src/compiler.rs
@@ -0,0 +1 @@
+pub mod compiler;
diff --git a/lucy/src/compiler/compiler.rs b/lucy/src/compiler/compiler.rs
@@ -0,0 +1,133 @@
+use std::{collections::HashMap, collections::VecDeque};
+use crate::{core::{data::{AnyData, DataType}, instructions::Operations}, logger::log::{Log, Logger}, parser::token::TokenType};
+
+type Program = Vec<LucyInstruction>;
+
+pub struct OperationParameter {
+    pub typ: DataType,
+    pub data: AnyData
+}
+
+pub struct LucyInstruction {
+    pub instruction: Operations,
+    pub arguments: Vec<OperationParameter>
+}
+
+pub struct LucyCompiler {}
+
+impl LucyCompiler {
+    pub fn compile(tokens: &Vec<TokenType>) -> Program {
+        
+        let checkpoints = LucyCompiler::index_checkpoints(tokens);
+        let mut program: Program = Program::new();
+        let mut args: VecDeque<OperationParameter> = VecDeque::new();
+        let mut queued_instruction: Operations = Operations::COUNT;
+
+        for token in tokens {
+            match token {
+                TokenType::CHECKPOINT(_) => continue,
+                TokenType::COMMENT(_) => continue,
+                TokenType::GOTO(checkpoint) => {
+                    match checkpoints.get(checkpoint) {
+                        Some(i) => {
+                            args.push_back(
+                                OperationParameter { typ: DataType::Int64, data: AnyData::from(*i as i64) }
+                            );
+                            
+                        },
+                        None => {},
+                    }
+                },
+                TokenType::DATA(typ, data) => {
+                    unsafe {
+                        match typ {
+                            DataType::Uint32 => args.push_back(
+                                OperationParameter { typ: DataType::Uint32, data: AnyData::from(data.uint32) }
+                            ),
+                            DataType::Uint64 => args.push_back(
+                                OperationParameter { typ: DataType::Uint64, data: AnyData::from(data.uint64) }
+                            ),
+                            DataType::Int32 => args.push_back(
+                                OperationParameter { typ: DataType::Int32, data: AnyData::from(data.int32) }
+                            ),
+                            DataType::Int64 => args.push_back(
+                                OperationParameter { typ: DataType::Int64, data: AnyData::from(data.int64) }
+                            ),
+                            DataType::Float => args.push_back(
+                                OperationParameter { typ: DataType::Float, data: AnyData::from(data.float) }
+                            ),
+                            DataType::Double => args.push_back(
+                                OperationParameter { typ: DataType::Double, data: AnyData::from(data.double) }
+                            ),
+                            DataType::String => args.push_back(
+                                OperationParameter { typ: DataType::String, data: AnyData::from(&data.string.to_string()) }
+                            ),
+                            DataType::Char => args.push_back(
+                                OperationParameter { typ: DataType::Char, data: AnyData::from(data.char) }
+                            ),
+                            DataType::Register => args.push_back(
+                                OperationParameter { typ: DataType::Register, data: AnyData::from(data.register) }
+                            ),
+                        }
+                    }
+                },
+                TokenType::REGISTER(reg) => args.push_back(
+                    OperationParameter { typ: DataType::Register, data: AnyData::from(*reg) }
+                ),
+                TokenType::INSTRUCTION(ins) => {
+                    if queued_instruction != Operations::COUNT {
+                        let mut vec: Vec<OperationParameter> = Vec::with_capacity(args.len());
+
+                        while args.len() > 0 {
+                            vec.push(args.pop_front().unwrap());
+                        }
+
+                        program.push(
+                            LucyInstruction { instruction: queued_instruction, arguments: vec }
+                        );
+                    }
+                    queued_instruction = *ins;
+                },
+            }
+        }
+        
+        if args.len() > 0 {
+            let mut vec: Vec<OperationParameter> = Vec::with_capacity(args.len());
+
+            while args.len() > 0 {
+                vec.push(args.pop_front().unwrap());
+            }
+
+            program.push(
+                LucyInstruction { instruction: queued_instruction, arguments: vec }
+            );
+
+            queued_instruction = Operations::COUNT;
+        }
+
+        program
+    }
+
+    fn index_checkpoints(tokens: &Vec<TokenType>) -> HashMap<String, usize> {
+        let mut idx: usize = 0;
+        let mut checkpoints: HashMap<String, usize> = HashMap::new();
+
+        for tkn in tokens {
+            match tkn {
+                TokenType::CHECKPOINT(cp) => {
+                    let mut chars= cp.chars();
+                    chars.next();
+                    
+                    checkpoints.insert(String::from(chars.as_str()), idx);
+                },
+                TokenType::INSTRUCTION(_) => {
+                    idx += 1;
+                    continue;
+                },
+                _ => continue
+            }
+        }
+
+        checkpoints
+    }
+}
diff --git a/lucy/src/core/data.rs b/lucy/src/core/data.rs
@@ -35,6 +35,22 @@ impl From<u32> for AnyData {
     }
 }
 
+impl From<u64> for AnyData {
+    fn from(val: u64) -> Self {
+        AnyData {
+            uint64: val
+        }
+    }
+}
+
+impl From<i32> for AnyData {
+    fn from(val: i32) -> Self {
+        AnyData {
+            int32: val
+        }
+    }
+}
+
 impl From<i64> for AnyData {
     fn from(val: i64) -> Self {
         AnyData {
@@ -43,6 +59,22 @@ impl From<i64> for AnyData {
     }
 }
 
+impl From<f32> for AnyData {
+    fn from(val: f32) -> Self {
+        AnyData {
+            float: val
+        }
+    }
+}
+
+impl From<f64> for AnyData {
+    fn from(val: f64) -> Self {
+        AnyData {
+            double: val
+        }
+    }
+}
+
 impl From<&String> for AnyData {
     fn from(val: &String) -> Self {
         let str = String::from(val);
@@ -53,6 +85,22 @@ impl From<&String> for AnyData {
     }
 }
 
+impl From<char> for AnyData {
+    fn from(val: char) -> Self {
+        AnyData {
+            char: val
+        }
+    }
+}
+
+impl From<Register> for AnyData {
+    fn from(val: Register) -> Self {
+        AnyData {
+            register: val
+        }
+    }
+}
+
 pub union Address {
     pub uint64: i64,
     pub register: Register
diff --git a/lucy/src/core/instructions.rs b/lucy/src/core/instructions.rs
@@ -5,7 +5,7 @@ use num_traits::FromPrimitive;
 
 pub type Any = AnyData;
 
-#[derive(Debug, FromPrimitive)]
+#[derive(Debug, FromPrimitive, Clone, Copy, PartialEq)]
 pub enum Operations {
     MOV,
     PUSH,
@@ -49,6 +49,24 @@ impl Operations {
 
         instruction.contains(&primitive)
     }
+
+    pub fn from_string(name: &String) -> Option<Operations> {
+        let mut instruction: Vec<String> = Vec::with_capacity(Operations::COUNT as usize);
+
+        for inst in 0..(Operations::COUNT as i32) {
+            let op: Operations = FromPrimitive::from_i32(inst).unwrap();
+
+            instruction.push(format!("{:?}", op))
+        }
+
+        let primitive = name.to_uppercase();
+
+        let i = instruction.iter().position(|ins| &primitive == ins);
+        match i {
+            Some(idx) => FromPrimitive::from_usize(idx),
+            None => None,
+        }
+    }
 }
 
 pub trait OperationImpl {
diff --git a/lucy/src/lib.rs b/lucy/src/lib.rs
@@ -1,3 +1,4 @@
 pub mod parser;
 pub mod core;
-pub mod logger;
+pub mod logger;
+pub mod compiler;
diff --git a/lucy/src/logger/log.rs b/lucy/src/logger/log.rs
@@ -1,4 +1,4 @@
-trait Logger {
+pub trait Logger {
     fn debug(message: String);
     fn info(message: String);
     fn warn(message: String);
diff --git a/lucy/src/parser/tokenizer.rs b/lucy/src/parser/tokenizer.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-trait Logger {`
	`1`	`+pub trait Logger {`
`2`	`2`	`fn debug(message: String);`
`3`	`3`	`fn info(message: String);`
`4`	`4`	`fn warn(message: String);`