feat(lib): 增加 type 标准库和与, 或逻辑运算符.

增加 readline 函数.
修复本地函数返回值无法获取问题.

Author: xiaoyi1212

lib/system.exf

@@ -1,7 +1,29 @@
 
 function native print(output);
 function native exit(code);
+function native read();
 
 function println(output) {
     this.print(output + "\n");
 }
+
+function readline() {
+    var line = "";
+    var c = "";
+    var newline = "\n";
+
+    while {
+        c = this.read();
+        if (c == "") {
+            break;
+        }
+        if (c == newline) {
+            break;
+        }
+        if (c == "\r") {
+            continue;
+        }
+        line = line + c;
+    }
+    return line;
+}

lib/type.exf

@@ -0,0 +1,12 @@
+
+function native to_number(auto);
+function native to_float(auto);
+function native check_type(auto);
+
+function to_bool(auto) {
+    return auto == 0 || auto == "true";
+}
+
+function to_string(auto) {
+    return auto + "";
+}

src/library/mod.rs

@@ -11,9 +11,11 @@ use std::fs::File;
 use std::io::Read;
 use std::sync::{LazyLock, RwLock};
 use crate::compiler::ast::vm_ir::Value;
+use crate::library::type_lib::register_type_lib;
 
 mod system;
 pub mod output_capture;
+mod type_lib;
 
 static MODULES: LazyLock<RwLock<BTreeMap<SmolStr, LibModule>>> =
     LazyLock::new(|| RwLock::new(BTreeMap::new()));
@@ -85,6 +87,7 @@ pub fn load_libraries(
     }
 
     register_system_lib();
+    register_type_lib();
 
     compiler.compile().expect("error: library has error.");
     Ok(())

src/library/system.rs

@@ -1,3 +1,5 @@
+use std::io;
+use std::io::Read;
 use crate::library::{output_capture::print, register_library, LibModule, ModuleFunc};
 use crate::runtime::RuntimeError;
 use smol_str::{SmolStr, ToSmolStr};
@@ -59,12 +61,38 @@ fn reg_exit() -> ModuleFunc{
     }
 }
 
+
+#[allow(clippy::unnecessary_wraps)]
+fn system_read(_args:&[Value]) -> Result<Value,RuntimeError> {
+    let mut buffer = [0u8; 1];
+
+    let read = match io::stdin().read_exact(&mut buffer) {
+        Ok(_) => {
+            (buffer[0] as char).to_string()
+        }
+        Err(_) => {
+            String::new() // 可以返回 EOF
+        }
+    };
+
+    Ok(Value::String(read.to_smolstr()))
+}
+
+fn reg_read() -> ModuleFunc{
+    ModuleFunc {
+        name: SmolStr::new("read"),
+        arity: 0,
+        func: system_read,
+    }
+}
+
 pub fn register_system_lib() {
     let mut system_lib = LibModule {
         name: SmolStr::new("system"),
         functions: vec![]
     };
     system_lib.functions.push(reg_println());
     system_lib.functions.push(reg_exit());
+    system_lib.functions.push(reg_read());
     register_library(system_lib);
 }

src/library/type_lib.rs

@@ -0,0 +1,85 @@
+use crate::compiler::ast::vm_ir::Value;
+use crate::library::{register_library, LibModule, ModuleFunc};
+use crate::runtime::RuntimeError;
+use smol_str::{SmolStr, ToSmolStr};
+
+#[allow(clippy::unnecessary_wraps)]
+fn type_to_number(args: &[Value]) -> Result<Value, RuntimeError> {
+    let auto = args.first().unwrap().clone();
+    if let Value::String(raw_str) = auto {
+        let i = raw_str.as_str().parse::<i64>().unwrap();
+        Ok(Value::Int(i))
+    } else if let Value::Float(raw_float) = args.first().unwrap() {
+        let i = raw_float.floor() as i64;
+        Ok(Value::Int(i))
+    } else {
+        Err(RuntimeError::TypeException(
+            "to_number: auto not a string or float.".to_smolstr(),
+        ))
+    }
+}
+
+fn reg_to_number() -> ModuleFunc {
+    ModuleFunc {
+        name: SmolStr::new("to_number"),
+        arity: 1,
+        func: type_to_number,
+    }
+}
+
+#[allow(clippy::unnecessary_wraps)]
+fn type_to_float(args: &[Value]) -> Result<Value, RuntimeError> {
+    let auto = args.first().unwrap().clone();
+    if let Value::String(raw_str) = auto {
+        let i = raw_str.as_str().parse::<f64>().unwrap();
+        Ok(Value::Float(i))
+    } else if let Value::Int(raw_number) = args.first().unwrap() {
+        let i = *raw_number as f64;
+        Ok(Value::Float(i))
+    } else {
+        Err(RuntimeError::TypeException(
+            "to_float: auto not a string or number.".to_smolstr(),
+        ))
+    }
+}
+
+fn reg_to_float() -> ModuleFunc {
+    ModuleFunc {
+        name: SmolStr::new("to_float"),
+        arity: 1,
+        func: type_to_float,
+    }
+}
+
+#[allow(clippy::unnecessary_wraps)]
+fn type_check_type(args: &[Value]) -> Result<Value, RuntimeError> {
+    let auto = args.first().unwrap().clone();
+    match auto {
+        Value::String(_) => Ok(Value::String("string".to_smolstr())),
+        Value::Float(_) => Ok(Value::String("float".to_smolstr())),
+        Value::Int(_) => Ok(Value::String("number".to_smolstr())),
+        Value::Bool(_) => Ok(Value::String("bool".to_smolstr())),
+        Value::Array(..) => Ok(Value::String("array".to_smolstr())),
+        Value::Ref(_) => Ok(Value::String("ref".to_smolstr())),
+        Value::Null => Ok(Value::String("null".to_smolstr())),
+    }
+}
+
+fn reg_check_type() -> ModuleFunc {
+    ModuleFunc {
+        name: SmolStr::new("check_type"),
+        arity: 1,
+        func: type_check_type,
+    }
+}
+
+pub fn register_type_lib() {
+    let mut type_lib = LibModule {
+        name: SmolStr::new("type"),
+        functions: vec![],
+    };
+    type_lib.functions.push(reg_to_number());
+    type_lib.functions.push(reg_to_float());
+    type_lib.functions.push(reg_check_type());
+    register_library(type_lib);
+}

src/runtime/executor.rs

@@ -1,10 +1,7 @@
 use crate::compiler::ast::vm_ir::{ByteCode, Value};
 use crate::compiler::parser::ParserError;
 use crate::library::find_library;
-use crate::runtime::vm_operation::{
-    add_value, big_value, div_value, equ_value, get_ref, less_equ_value, less_value, mul_value,
-    neg_value, not_equ_value, not_value, rmd_value, self_add_value, self_sub_value, sub_value,
-};
+use crate::runtime::vm_operation::{add_value, and_value, big_value, div_value, equ_value, get_ref, less_equ_value, less_value, mul_value, neg_value, not_equ_value, not_value, or_value, rmd_value, self_add_value, self_sub_value, sub_value};
 use crate::runtime::vm_table_opt::{call_func, get_index_array, jump, jump_false, jump_true, load_array_local, load_local, push_stack, set_index_array, store_local};
 use crate::runtime::{MetadataUnit, RuntimeError};
 use smol_str::{SmolStr, ToSmolStr};
@@ -181,6 +178,8 @@ fn run_code<'a>(
             ByteCode::Neg => neg_value(stack_frame)?,
             ByteCode::SAdd => self_add_value(stack_frame)?,
             ByteCode::SSub => self_sub_value(stack_frame)?,
+            ByteCode::And => and_value(stack_frame)?,
+            ByteCode::Or => or_value(stack_frame)?,
             ByteCode::Big => do_bin_op!(stack_frame, big_value),
             ByteCode::Less => do_bin_op!(stack_frame, less_value),
             ByteCode::LesEqu => do_bin_op!(stack_frame, less_equ_value),
@@ -310,8 +309,8 @@ pub fn call_function(
                     Err(ParserError::Empty)
                 }
             }) {
-                executor.call_stack.last_mut().unwrap().push_op_stack(lib);
                 executor.call_stack.pop().unwrap();
+                executor.call_stack.last_mut().unwrap().push_op_stack(lib);
                 executor.frame_index -= 1;
             } else {
                 eprintln!(

src/runtime/vm_operation.rs

@@ -2,7 +2,7 @@ use crate::compiler::ast::vm_ir::Value;
 use crate::compiler::ast::vm_ir::Value::{Bool, Float, Int, String, Null};
 use crate::runtime::executor::StackFrame;
 use crate::runtime::RuntimeError;
-use smol_str::format_smolstr;
+use smol_str::{format_smolstr, ToSmolStr};
 
 pub fn get_ref(stack_frame: &mut StackFrame) {
     let ref1 = stack_frame.pop_op_stack();
@@ -407,3 +407,27 @@ pub fn neg_value(stack_frame: &mut StackFrame) -> Result<(), RuntimeError> {
     stack_frame.next_pc();
     Ok(())
 }
+
+pub fn and_value(stack_frame: &mut StackFrame) -> Result<(), RuntimeError> {
+    let v1 = stack_frame.pop_op_stack();
+    let v2 = stack_frame.pop_op_stack();
+    if let Bool(b1) = v1 && let Bool(b2) = v2 {
+        stack_frame.push_op_stack(Bool(b1 && b2));
+        stack_frame.next_pc();
+        Ok(())
+    }else { 
+        Err(RuntimeError::TypeException("unknown to bool.".to_smolstr()))
+    }
+}
+
+pub fn or_value(stack_frame: &mut StackFrame) -> Result<(), RuntimeError> {
+    let v1 = stack_frame.pop_op_stack();
+    let v2 = stack_frame.pop_op_stack();
+    if let Bool(b1) = v1 && let Bool(b2) = v2 {
+        stack_frame.push_op_stack(Bool(b1 || b2));
+        stack_frame.next_pc();
+        Ok(())
+    }else {
+        Err(RuntimeError::TypeException("unknown to bool.".to_smolstr()))
+    }
+}