feat(library): 补充 sleep 实现.

修复标准库中错误的异常抛出方式.

Author: xiaoyi1212

lib/system.exf

@@ -5,6 +5,11 @@ function native read();
 
 function native thread(func);
 function native thread_exit();
+function native nano_sleep(time);
+
+function sleep(time) {
+    nano_sleep(time * 1000000);
+}
 
 function println(output) {
     print(output + "\n");

src/compiler/mod.rs

@@ -130,7 +130,7 @@ impl Compiler {
                 Self::dump_lexer_error(&lex_error, file);
                 return;
             }
-            ParserError::Eof | ParserError::Empty => {
+            ParserError::Eof | ParserError::Empty | ParserError::RuntimeError(..) => {
                 return;
             }
             ParserError::IdentifierExpected(token) => {

src/compiler/parser/mod.rs

@@ -23,6 +23,7 @@ use crate::compiler::parser::import::import_eval;
 use crate::compiler::parser::judgment::if_eval;
 use crate::compiler::parser::var::var_eval;
 use crate::compiler::parser::r#while::while_eval;
+use crate::runtime::RuntimeError;
 
 #[derive(Debug)]
 pub enum ParserError {
@@ -44,6 +45,7 @@ pub enum ParserError {
     NoNativeImplement(Token),      // 无本地实现
     NotFoundLibrary(Token),        // 找不到库
     Empty,                         // 占位符
+    RuntimeError(RuntimeError),    // 运行时占位符
     Eof,
 }
 

src/library/system.rs

@@ -1,12 +1,12 @@
-use smol_str::{SmolStr, ToSmolStr};
-use std::io;
-use std::io::Read;
-use std::process::exit;
-
 use crate::compiler::ast::vm_ir::Value;
 use crate::library::{LibModule, ModuleFunc, output_capture::print, register_library};
 use crate::runtime::RuntimeError;
 use crate::runtime::context;
+use smol_str::{SmolStr, ToSmolStr};
+use std::io::Read;
+use std::process::exit;
+use std::time::Duration;
+use std::{io, thread};
 
 fn print_impl(value: Value) {
     match value {
@@ -159,6 +159,33 @@ fn reg_thread_exit() -> ModuleFunc {
     }
 }
 
+#[allow(clippy::unnecessary_wraps)]
+fn system_nano_sleep(args: &[Value]) -> Result<Value, RuntimeError> {
+    let arg_time = args.first().unwrap().clone();
+    let Value::Int(raw_time) = arg_time else {
+        return Err(RuntimeError::TypeException(
+            "nano_sleep: time not a number.".to_smolstr(),
+        ));
+    };
+    let time = if raw_time >= 0 {
+        raw_time as u64
+    } else {
+        return Err(RuntimeError::TypeException(
+            "nano_sleep: time must > 0.".to_smolstr(),
+        ));
+    };
+    thread::sleep(Duration::from_nanos(time));
+    Ok(Value::Null)
+}
+
+fn reg_nano_sleep() -> ModuleFunc {
+    ModuleFunc {
+        name: SmolStr::new("nano_sleep"),
+        arity: 1,
+        func: system_nano_sleep,
+    }
+}
+
 pub fn register_system_lib() {
     let mut system_lib = LibModule {
         name: SmolStr::new("system"),
@@ -169,5 +196,6 @@ pub fn register_system_lib() {
     system_lib.functions.push(reg_read());
     system_lib.functions.push(reg_thread());
     system_lib.functions.push(reg_thread_exit());
+    system_lib.functions.push(reg_nano_sleep());
     register_library(system_lib);
 }

src/runtime/executor.rs

@@ -9,6 +9,7 @@ use crate::runtime::context::SyncTable;
 use crate::runtime::vm_operation::*;
 use crate::runtime::vm_table_opt::*;
 use crate::runtime::{MetadataUnit, RuntimeError, SharedGlobals, SharedSync};
+use crate::runtime::RuntimeError::NoSuchFunctionException;
 
 pub struct StackFrame<'a> {
     pc: usize,
@@ -388,10 +389,9 @@ fn print_and_return(executor: &Executor, failed_status: Option<RuntimeError>) ->
     Value::Null
 }
 
-fn print_error(executor: &Executor, path: SmolStr) {
+fn print_error(executor: &Executor, error: RuntimeError) {
     eprintln!(
-        "RuntimeError: {:?}",
-        RuntimeError::NoSuchFunctionException(path)
+        "RuntimeError: {error:?}",
     );
     for frame in &executor.call_stack {
         let name = frame.get_frame_name();
@@ -456,24 +456,33 @@ pub fn call_function(
                 argument.push(stack_frame.pop_op_stack());
             }
 
-            if let Ok(lib) = find_library(file, |f| {
+            match find_library(file, |f| {
                 if let Some(lib) = f
                     && let Some(func) = lib.find_func(&SmolStr::new(func))
                 {
-                    (func.func)(&argument).map_or(Err(ParserError::Empty), Ok)
+                    match (func.func)(&argument) {
+                        Err(error) => Err(ParserError::RuntimeError(error)),
+                        Ok(ok ) => Ok(ok),
+                    }
                 } else {
-                    Err(ParserError::Empty)
+                    Err(ParserError::RuntimeError(NoSuchFunctionException(path.clone())))
                 }
             }) {
-                let mut frame = executor.call_stack.pop().unwrap();
-                if let Some((unit_index, func_index)) = frame.take_sync_lock() {
-                    sync_table.unlock(unit_index, func_index);
+                Ok(lib) => {
+                    let mut frame = executor.call_stack.pop().unwrap();
+                    if let Some((unit_index, func_index)) = frame.take_sync_lock() {
+                        sync_table.unlock(unit_index, func_index);
+                    }
+                    executor.call_stack.last_mut().unwrap().push_op_stack(lib);
+                    executor.frame_index -= 1;
+                },
+                Err(error) => {
+                    let ParserError::RuntimeError(error) = error else {
+                        unreachable!()
+                    };
+                    print_error(&executor, error);
+                    break;
                 }
-                executor.call_stack.last_mut().unwrap().push_op_stack(lib);
-                executor.frame_index -= 1;
-            } else {
-                print_error(&executor, path);
-                break;
             }
         } else {
             match run_code(units, stack_frame, &globals, &call_cache, &sync_table) {