update

Author: aceinetx

ZenLang

@@ -7,12 +7,43 @@ use zenlang::tokenizer;
 
 static SHELL_ZENLANG_CODE: &'static str = r#"
 mod stdlib;
+mod zenos;
+
+fn execute line {
+    if line == "" {
+        return null;
+    }
+    let splitted = str_split(line, " ");
+
+    let command = splitted[0];
+    if command == "hello" {
+        println("hi there!");
+    } elif command == "ver" {
+        ver();
+    } else {
+        println("unknown command");
+    }
+    return null;
+}
 
 fn main {
     while true {
         print("> ");
         let s = get_string();
+        execute(s);
     }
+    return null;
+}
+"#;
+static ZENOS_ZENLANG_CODE: &'static str = r#"
+mod stdlib;
+fn ver {
+    println("ZenOS nightly");
+    println("ZenLang nightly");
+    println("ZenLang constants:");
+    print("MAX_STACK_SIZE = ");
+    println(_vmcall_ret_unsafe_1(50));
+    return null;
 }
 "#;
 
@@ -42,6 +73,10 @@ fn compile_code_into(code: String, module_name: String, out: String) {
         Ok(bytes) => {
             //
             if let Some(fs) = get_fs() {
+                if let Err(e) = fs.create_file(out.clone()) {
+                    println!("[rom] /bin/shell.zenc: {}", e);
+                    return;
+                }
                 if let Err(e) = fs.write_file(out, bytes) {
                     println!("[rom] write error: {}", e);
                     return;
@@ -62,14 +97,15 @@ pub fn set_rom() {
             println!("[rom] /bin: {}", e);
         }
 
-        if let Err(e) = fs.create_file("/bin/shell.zenc".into()) {
-            println!("[rom] /bin/shell.zenc: {}", e);
-        }
-        println!("{:?}", fs);
         compile_code_into(
             SHELL_ZENLANG_CODE.into(),
             "zenshell".into(),
             "/bin/shell.zenc".into(),
         );
+        compile_code_into(
+            ZENOS_ZENLANG_CODE.into(),
+            "zenos".into(),
+            "/lib/zenos.zenc".into(),
+        );
     }
 }

src/fs/rom.rs

@@ -4,12 +4,12 @@ use alloc::string::*;
 use uefi::println;
 use zenlang::module::Module;
 
-pub fn main() -> Result<(), String> {
-    let mut process_manager = ProcessManager::new();
-
-    // load shell
+pub fn run_zenc_process_manager(
+    process_manager: &mut ProcessManager,
+    path: &str,
+) -> Result<(), String> {
     if let Some(fs) = get_fs() {
-        match fs.read_file("/bin/shell.zenc".into()) {
+        match fs.read_file(path.into()) {
             Ok(bytes) => {
                 let mut module = Module::new();
                 if let Err(e) = module.load(bytes) {
@@ -26,6 +26,7 @@ pub fn main() -> Result<(), String> {
                 }
 
                 process_manager.append_process(process);
+                return Ok(());
             }
             Err(e) => {
                 return Err(e.into());
@@ -34,7 +35,14 @@ pub fn main() -> Result<(), String> {
     } else {
         return Err("get_fs failed".into());
     }
+}
 
+pub fn main() -> Result<(), String> {
+    let mut process_manager = ProcessManager::new();
+
+    if let Err(e) = run_zenc_process_manager(&mut process_manager, "/bin/shell.zenc") {
+        return Err(e);
+    }
     println!("[main] shell loading successful");
 
     // step all processes

src/init/main.rs

@@ -1,10 +1,14 @@
+use crate::fs::global::get_fs;
 use crate::io::get_string;
+use alloc::format;
 use alloc::string::*;
 use alloc::vec::*;
 use uefi::print;
 use zenlang::module::Module;
 use zenlang::platform;
 use zenlang::stdlib::*;
+use zenlang::value::*;
+use zenlang::vm::*;
 
 pub struct Platform {}
 
@@ -27,10 +31,31 @@ impl platform::Platform for Platform {
             let module = compile_stdlib_module();
             return Some(module);
         }
+        if let Some(fs) = get_fs() {
+            if let Ok(bytes) = fs.read_file(format!("/lib/{}.zenc", name)) {
+                let mut module = Module::new();
+                if let Err(_) = module.load(bytes) {
+                    return None;
+                }
+                return Some(module);
+            }
+        }
         return None;
     }
     fn read_file_bytes(&self, _name: String) -> Option<Vec<u8>> {
         return None;
     }
     fn write_file_bytes(&self, _name: String, _bytes: Vec<u8>) {}
+    fn vmcall(&self, vm: &mut VM, index: u8) -> bool {
+        match index {
+            50 => {
+                // get max stack size
+                vm.stack.push(Value::Number(MAX_STACK_SIZE as f64));
+                return true;
+            }
+            _ => {
+                return false;
+            }
+        }
+    }
 }

src/lang/platform.rs

@@ -44,14 +44,16 @@ impl ProcessManager {
                     println!("runtime error at pc = {}:{}", pc.get_low(), pc.get_high(),);
                     println!("-- end runtime error --");
                 } else {
-                    println!("{} returned {}", process.pid, process.vm.ret);
+                    println!("pid {} returned {}", process.pid, process.vm.ret);
                 }
             }
         }
     }
 
     pub fn remove_stalling_processes(&mut self) {
-        for i in 0..self.processes.len() {
+        let mut i: usize = self.processes.len();
+        while i > 0 {
+            i -= 1;
             if self.processes[i].stalling {
                 self.processes.remove(i);
             }