Dev

.vscode/extensions.json

@@ -7,7 +7,8 @@
     "dtsvet.vscode-wasm",
     "vadimcn.vscode-lldb",
     "spmeesseman.vscode-taskexplorer",
-    "serayuzgur.crates",
+    "fill-labs.dependi",
     "denoland.vscode-deno",
-  ]
+    "rioj7.command-variable",
+  ],
 }

.vscode/settings.json

@@ -10,6 +10,7 @@
     "editor.smoothScrolling": true,
     "workbench.editor.labelFormat": "short",
     "workbench.startupEditor": "readme",
+    "rust-analyzer.imports.preferNoStd": "true",
     "files.exclude": {
         "**/ellie_engine": true,
         "**/elliec": true,

ellie_engine/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ellie_engine"
 description = "Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments."
-version = "1.4.13-alpha"
+version = "1.5.20-alpha"
 authors = ["Ahmetcan Aksu <ahmetcanaksu@behemehal.org>", "Behemehal <info@behemehal.org>"]
 edition = "2021"
 license-file = "../LICENSE"
@@ -15,19 +15,19 @@ homepage = "https://www.ellie-lang.org"
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"], optional = true }
 path-absolutize = { version = "3.0.10", optional = true }
-ellie_core = { path = "core", version = "0.7.2", default-features = false }
+ellie_core = { path = "core", version = "0.7.3", default-features = false }
 #ellie_assist = { path = "EllieAssist", version = "*", optional = true }
-ellie_tokenizer = { path = "tokenizer", version = "0.6.2", default-features = false, optional = true }
-ellie_parser = { path = "parser", version = "0.7.2", default-features = false, optional = true }
-ellie_bytecode = { path = "bytecode", version = "0.4.3", optional = true }
-ellie_vm = { path = "vm", version = "0.5.4", optional = true }
-ellie_fmt = { path = "fmt", version = "0.5.2", optional = true }
+ellie_tokenizer = { path = "tokenizer", version = "0.7.3", default-features = false, optional = true }
+ellie_parser = { path = "parser", version = "0.8.3", default-features = false, optional = true }
+ellie_bytecode = { path = "bytecode", version = "0.5.4", optional = true }
+ellie_vm = { path = "vm", version = "0.6.5", optional = true }
+ellie_fmt = { path = "fmt", version = "0.5.3", optional = true }
 ellie_renderer_utils = { path = "renderer_utils", version = "0.3.0", optional = true,  default-features = false }
 
 [features]
 default = ["vm", "compiler", "fmt", "std"]
 compiler = ["ellie_tokenizer", "ellie_parser", "ellie_bytecode", "ellie_core/compiler_utils"]
-vm = ["ellie_vm", "ellie_vm/std"]
+vm = ["ellie_vm"]
 std = ["ellie_vm/std", "ellie_core/std"]
 renderer_utils = ["ellie_renderer_utils"]
 fmt = ["ellie_fmt"]
@@ -37,10 +37,17 @@ cli-utils = ["ellie_renderer_utils/cli-utils"]
 
 [build-dependencies]
 path-absolutize = { version = "3.0.10" }
-toml = "0.8.0"
-regex = { version = "1.1.7" }
+toml = "0.8.19"
+regex = { version = "1.10.6" }
 chrono = "0.4.22"
 
+[dev-dependencies]
+criterion = { version = "0.5.1", features = ["html_reports", "csv_output"] }
+
+[[bench]]
+name = "compile"
+harness = false
+
 [workspace]
-members = [".", "./core", "./tokenizer", "./parser", "./bytecode", "./vm", "./fmt", "./renderer_utils" ]
-default-members = ["."]
+members = [".", "./core", "./tokenizer", "./parser", "./bytecode", "./vm", "./fmt", "./renderer_utils"]
+default-members = ["."]

ellie_engine/benches/codes.rs

@@ -0,0 +1,158 @@
+pub const BENCH_CLASS: &str = r#"
+/// -- Required Types --
+@dont_fix_variant;
+class int {}
+
+@dont_fix_variant;
+class void {}
+
+
+@dont_fix_variant;
+class bool {}
+
+@dont_fix_variant;
+class function {}
+
+@dont_fix_variant;
+class string {}
+
+@dont_fix_variant;
+class nullAble<T> {}
+
+fn println(s: string);
+/// -- Required Types --
+
+class Human  {
+	co(name, age);
+	v name : string;
+	v age : int;
+	fn introduce() : string {
+		ret "Hello my name is " + self.name + ", I born at " + (2023 - self.age);
+	}
+}
+
+
+fn main() {
+	v human = new Human("Ahmetcan", 22);
+	println(human.introduce());
+}
+"#;
+
+pub const BENCH_LOOP: &str = r#"
+/// -- Required Types --
+@dont_fix_variant;
+class int {}
+
+@dont_fix_variant;
+class void {}
+
+
+@dont_fix_variant;
+class bool {}
+
+@dont_fix_variant;
+class function {}
+
+@dont_fix_variant;
+class string {}
+
+@dont_fix_variant;
+class nullAble<T> {}
+
+fn println(s: string);
+/// -- Required Types --
+
+fn main() {
+    v last = 0;
+    v current = 1;
+    v count = 2;
+    v fib = 0;
+
+    loop count <= 10 {
+        fib = last + current;
+        last = current;
+        current = fib;
+        count += 1;
+    }
+
+    println("fib(10) = " + fib);
+}
+"#;
+
+pub const BENCH_FIBONACCI_LOOP: &str = r#"
+/// -- Required Types --
+@dont_fix_variant;
+class int {}
+
+@dont_fix_variant;
+class void {}
+
+
+@dont_fix_variant;
+class bool {}
+
+@dont_fix_variant;
+class function {}
+
+@dont_fix_variant;
+class string {}
+
+@dont_fix_variant;
+class nullAble<T> {}
+
+fn println(s: string);
+/// -- Required Types --
+
+fn main() {
+    v last = 0;
+    v current = 1;
+    v count = 2;
+    v fib = 0;
+
+    loop count <= 10 {
+        fib = last + current;
+        last = current;
+        current = fib;
+        count += 1;
+    }
+
+    println("fib(10) = " + fib);
+}
+"#;
+
+pub const BENCH_FIBONACCI_RECURSION: &str = r#"
+/// -- Required Types --
+@dont_fix_variant;
+class int {}
+
+@dont_fix_variant;
+class void {}
+
+
+@dont_fix_variant;
+class bool {}
+
+@dont_fix_variant;
+class function {}
+
+@dont_fix_variant;
+class string {}
+
+@dont_fix_variant;
+class nullAble<T> {}
+
+fn println(s: string);
+/// -- Required Types --
+
+fn main() {
+    fn fib(n: int) : int {
+        if n <= 1 {
+            ret n;
+        } else {
+            ret fib(n - 1) + fib(n - 2);
+        }
+    }
+
+    println("fib(10) = " + fib(10));
+}
+"#;

ellie_engine/benches/compile.rs

@@ -0,0 +1,80 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ellie_engine::{parseText};
+
+
+pub mod codes;
+pub mod utils;
+
+fn tokenize(c: &mut Criterion) {
+    c.bench_function("class_tokenize", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::tokenize_code(black_box(codes::BENCH_CLASS)));
+        })
+    });
+    c.bench_function("loop_tokenize", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::tokenize_code(black_box(codes::BENCH_LOOP)));
+        })
+    });
+    c.bench_function("fibonacci_loop_tokenize", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::tokenize_code(black_box(codes::BENCH_FIBONACCI_LOOP)));
+        })
+    });
+    c.bench_function("fibonacci_recursion_tokenize", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::tokenize_code(black_box(
+                codes::BENCH_FIBONACCI_RECURSION,
+            )));
+        })
+    });
+}
+
+fn parse(c: &mut Criterion) {
+    let class_tokenized = utils::tokenize_code(codes::BENCH_CLASS);
+    let loop_tokenized = utils::tokenize_code(codes::BENCH_LOOP);
+    let fibonacci_loop_tokenized = utils::tokenize_code(codes::BENCH_FIBONACCI_LOOP);
+    let fibonacci_recursion_tokenized = utils::tokenize_code(codes::BENCH_FIBONACCI_RECURSION);
+
+    c.bench_function("class_parse", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::parse_code(class_tokenized.clone()));
+        })
+    });
+
+    c.bench_function("loop_parse", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::parse_code(loop_tokenized.clone()));
+        })
+    });
+
+    c.bench_function("fibonacci_loop_parse", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::parse_code(fibonacci_loop_tokenized.clone()));
+        })
+    });
+
+    c.bench_function("fibonacci_recursion_parse", |b| {
+        b.iter(|| {
+            let _ = black_box(utils::parse_code(fibonacci_recursion_tokenized.clone()));
+        })
+    });
+}
+
+fn byte_code_assembler(c: &mut Criterion) {
+    let class_parse = parseText!(codes::BENCH_CLASS).expect("should've been successful");
+    let loop_parse = parseText!(codes::BENCH_LOOP).expect("should've been successful");
+    let fibonacci_loop_parse =
+        parseText!(codes::BENCH_FIBONACCI_LOOP).expect("should've been successful");
+    let fibonacci_recursion_parse =
+        parseText!(codes::BENCH_FIBONACCI_RECURSION).expect("should've been successful");
+
+    //c.bench_function("class_byte_code_assembler", |b| {
+    //    b.iter(|| {
+    //        let _ = black_box(compiler::byte_code_assembler(class_parse.clone()));
+    //    })
+    //});
+}
+
+criterion_group!(benches, tokenize, parse);
+criterion_main!(benches);

ellie_engine/benches/utils.rs

@@ -0,0 +1,71 @@
+use core::hash::{Hash, Hasher};
+use std::hash::DefaultHasher;
+
+use ellie_core::{
+    defs::{PlatformArchitecture, Version},
+    utils::PageExport,
+};
+use ellie_engine::{
+    compiler, tokenizer,
+    utils::{CompileOutput, CompilerSettings, MainProgram, ProgramRepository},
+};
+use ellie_tokenizer::tokenizer::{Page, ResolvedImport};
+
+#[derive(Clone)]
+pub struct Repository {
+    pub code: String,
+    pub main_hash: usize,
+}
+
+impl ProgramRepository for Repository {
+    fn read_main(&mut self) -> MainProgram {
+        let mut main_file_hasher = DefaultHasher::new();
+        self.code.hash(&mut main_file_hasher);
+        let first_page_hash = main_file_hasher.finish();
+        self.main_hash = first_page_hash as usize;
+        MainProgram {
+            file_content: self.code.clone(),
+            file_name: "playground.ei".to_string(),
+            file_hash: first_page_hash as usize,
+            start_directory: "<ellie_module_playground>".to_string(),
+        }
+    }
+
+    fn read_module(
+        &mut self,
+        _link_module: bool,
+        _current_path: String,
+        _requested_path: String,
+    ) -> ResolvedImport {
+        panic!("Module resolver is not implemented on tests")
+    }
+}
+
+pub fn tokenize_code(code: &str) -> (usize, PageExport<Page>) {
+    let mut program_repository = Repository {
+        code: code.to_string(),
+        main_hash: 0,
+    };
+    let pages =
+        tokenizer::tokenize_file(&mut program_repository).expect("should've been successful");
+    (program_repository.main_hash, pages)
+}
+
+pub fn parse_code(
+    (main_hash, pages): (usize, PageExport<Page>),
+) -> Result<CompileOutput, Vec<ellie_core::error::Error>> {
+    compiler::parse_pages(
+        main_hash,
+        vec![],
+        pages,
+        CompilerSettings {
+            name: "ellie_bench".to_string(),
+            file_name: String::from("ellie_bench.ei"),
+            is_lib: false,
+            description: String::from("No description"),
+            experimental_features: false,
+            byte_code_architecture: PlatformArchitecture::B32,
+            version: Version::build_from_string(&"0.1.0".to_string()),
+        },
+    )
+}