feat: add libuv to provide some asynchronous functionality

.github/workflows/release.yml

@@ -32,6 +32,7 @@ jobs:
             RUSTFLAGS: ""
             libvm: "libvm.a"
             libvm_dylib: "libvm.dylib"
+            libuv_dylib: "libuv.dylib"
           - os: "ubuntu-latest"
             dir: linux64
             debdir: pivot-lang_0.1.0-1_amd64
@@ -40,12 +41,14 @@ jobs:
             RUSTFLAGS: ""
             libvm: "libvm.a"
             libvm_dylib: "libvm.so"
+            libuv_dylib: "libuv.so"
           - os: "windows-latest"
             dir: win64
             artifacts: "plc.exe"
             RUSTFLAGS: "-Dwarnings -Ctarget-feature=+crt-static"
             libvm: "vm.lib"
             libvm_dylib: "vm.dll"
+            libuv_dylib: "uv.dll"
             arch: windows-amd64
     steps:
       - uses: actions/checkout@v4
@@ -127,6 +130,20 @@ jobs:
             dst = os.environ['OUT_DIR'] + "/" + artifact
             shutil.copy(src, dst)
         shell: python
+      - name: Move libuv dylib
+        env:
+          ARTIFACTS: ${{ matrix.config.libuv_dylib }}
+          OUT_DIR: ${{ matrix.config.dir }}
+          OS: ${{ matrix.config.os }}
+        run: |
+          import os
+          import shutil
+          artifacts = os.environ['ARTIFACTS'].split()
+          for artifact in artifacts:
+            src = "target/release/%s" % artifact
+            dst = os.environ['OUT_DIR'] + "/" + artifact
+            shutil.copy(src, dst)
+        shell: python
       - name: Move pllib
         env:
           ARTIFACTS: planglib

.vscode/settings.json

@@ -14,6 +14,7 @@
     "lldb.showDisassembly": "auto",
     "lldb.dereferencePointers": true,
     "lldb.consoleMode": "commands",
+    "makefile.configureOnOpen": true,
     // "rust-analyzer.check.targets": [
     //     "wasm32-unknown-unknown",
     // ],

Makefile

@@ -20,9 +20,11 @@ vmdebug:
 	@cp target/debug/libvm.a target/release/libvm.a
 	@touch target/debug/libvm.so && cp target/debug/libvm.so target/release/libvm.so
 	@touch target/debug/libvm.dylib && cp target/debug/libvm.dylib target/release/libvm.dylib
+	@touch target/debug/libuv.so && cp target/debug/libvm.so target/release/libuv.so
+	@touch target/debug/libuv.dylib && cp target/debug/libuv.dylib target/release/libuv.dylib
 
 install:
-	@cargo install --path=.
+	@cargo install --path=. --locked
 
 fmt:
 	@cargo +stable fmt

pl_linker/src/linker.rs

@@ -100,6 +100,21 @@ fn get_linux_lib_paths() -> Vec<String> {
     paths
 }
 
+// fn get_libgcc_path() -> Result<String, String> {
+//     let base_path = "/usr/lib/gcc/x86_64-linux-gnu";
+//     let entries = std::fs::read_dir(base_path).map_err(|e| format!("Failed to read directory {}: {}", base_path, e))?;
+
+//     for entry in entries {
+//         let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
+//         if entry.path().is_dir() {
+//             let version = entry.file_name().into_string().map_err(|e| format!("Failed to convert OsString to String: {:?}", e))?;
+//             return Ok(format!("{}/{}", base_path, version));
+//         }
+//     }
+
+//     Err("No valid gcc version directory found".to_string())
+// }
+
 impl Linker for LdLinker {
     fn add_object(&mut self, path: &Path) -> Result<(), LinkerError> {
         let path_str = path
@@ -115,9 +130,21 @@ impl Linker for LdLinker {
         paths.iter().for_each(|lib| {
             self.push_args(&format!("-L{}", lib.as_str()));
         });
+        // // Add the path to the libgcc library
+        // match get_libgcc_path() {
+        //     Ok(libgcc_dir) => {
+        //         self.push_args(&format!("-L{}", libgcc_dir));
+        //     }
+        //     Err(e) => {
+        //         return Err(LinkerError::LinkError(format!(
+        //             "Failed to get libgcc path: {}",
+        //             e
+        //         )));
+        //     }
+        // }
         // libs and link args
         [
-            "-pie",
+            "-no-pie",
             "-zrelro",
             "--hash-style=gnu",
             "--build-id",
@@ -133,6 +160,7 @@ impl Linker for LdLinker {
             "-lunwind",
             "--no-as-needed",
             "-ldl",
+            // "-lgcc",
             // "/usr/lib/gcc/x86_64-linux-gnu/<version>/crtendS.o",
             "/lib/x86_64-linux-gnu/crtn.o",
         ]
@@ -318,6 +346,11 @@ impl Linker for MsvcLinker {
         self.push_args("ntdll.lib");
         self.push_args("psapi.lib");
         self.push_args("PowrProf.lib");
+        self.push_args("user32.lib"); // Add user32.lib
+        self.push_args("dbghelp.lib"); // Add dbghelp.lib
+        self.push_args("ole32.lib"); // Add ole32.lib
+        self.push_args("shell32.lib"); // Add shell32.lib
+        self.push_args("iphlpapi.lib"); // Add iphlpapi.lib
 
         self.args.insert(0, "lld-link".to_owned());
         lld_rs::link(lld_rs::LldFlavor::Coff, &self.args)

planglib/core/gc.pi

@@ -1,4 +1,4 @@
-fn DioGC__malloc(size: i64, obj_type: u8, rsp:i64) *u8;
+fn DioGC__malloc(size: i64, obj_type: u8, rsp:i64) *();
 
 pub fn DioGC__collect() void;
 
@@ -10,9 +10,31 @@ pub fn DioGC__enable_auto_collect() void;
 
 pub fn DioGC__get_stw_num() i64;
 
-fn DioGC__stuck_begin(sp:i64) void;
+pub fn DioGC__stuck_begin(sp:i64) void;
 
-fn DioGC__stuck_end() void;
+pub fn DioGC__pin(ptr: * u8) void;
+
+fn DioGC__keep_live_pinned(ptr: *u8) void;
+
+fn DioGC__rm_live_pinned(ptr: *u8) void;
+
+fn DioGC__is_pinned(ptr: *u8) i32;
+
+pub fn is_pinned<T>(ptr: *T) bool {
+    return DioGC__is_pinned(unsafe_cast<u8>(ptr)) == 1;
+}
+
+pub fn keep_alive_pinned<T>(ptr: *T) void {
+    DioGC__keep_live_pinned(unsafe_cast<u8>(ptr));
+    return;
+}
+
+pub fn rm_alive_pinned<T>(ptr: *T) void {
+    DioGC__rm_live_pinned(unsafe_cast<u8>(ptr));
+    return;
+}
+
+pub fn DioGC__stuck_end() void;
 fn DioGC__add_coro_stack(sp:i64, stack:* u8) void;
 fn DioGC__remove_coro_stack(stack:i64) void;
 
@@ -32,6 +54,11 @@ pub fn remove_coro_stack(stack:i64) void {
     return;
 }
 
+pub fn pin<T>(ptr: *T) void {
+    DioGC__pin(unsafe_cast<u8>(ptr));
+    return;
+}
+
 /// # string
 /// 
 /// Built-in string type
@@ -72,8 +99,6 @@ pub fn ptr_to_int(ptr: *u8) i64;
 
 pub fn utf8_count(ptr: *u8, len:i64) i64;
 
-    fn printi64ln(i:i64) void;
-
 impl string {
     pub fn append(str: string) void {
         let old = self.data;
@@ -113,6 +138,13 @@ impl string {
         return arr_from_raw(self.data, self._byte_len);
     }
 
+    pub fn cstr() *u8 {
+        let arr = [u8*self._byte_len + 1;];
+        memcpy(&arr[0], self.data, self._byte_len);
+        arr[self._byte_len] = 0 as u8;
+        return &arr[0];
+    }
+
     pub fn chars() [char] {
         let bytes = arr_from_raw(self.data, self._byte_len);
         let chars = [char*self._len;];
@@ -169,3 +201,27 @@ pub fn string_eq(l:string, r:string) bool {
     }
     return true;
 }
+
+
+/// # malloc
+/// 
+/// Allocate memory using GC
+/// 
+/// The allocated memory is treated as atomic, which means the memory
+/// shall not contain any gc pointer.
+pub fn malloc(size: i64) * () {
+    return DioGC__malloc(size, 0 as u8, asm_sp());
+}
+
+
+/// # malloc_pinned
+/// 
+/// Allocate memory using GC
+/// 
+/// The allocated memory is treated as pinned-atomic, which means the memory
+/// shall not contain any gc pointer, and it will not be moved by gc.
+pub fn malloc_pinned(size: i64) * () {
+    let mem = DioGC__malloc(size, 0 as u8, asm_sp());
+    pin(mem);
+    return mem;
+}

planglib/std/__private.pi

@@ -17,3 +17,9 @@ use std::time;
 use std::string;
 use std::slice;
 use std::task;
+use std::libuv;
+use std::task::reactor;
+use std::task::executor;
+use std::task::helper;
+use std::task::delay;
+use std::task::tcp;